fix some typing and stuff

Author: dragoncoder047

schemascii/__main__.py

@@ -19,6 +19,16 @@ def cli_main():
         default=None,
         dest="out_file",
         help="Output SVG file. (default input file plus .svg)")
+    ap.add_argument(
+        "-w",
+        "--warnings-are-errors",
+        action="store_true",
+        help="Treat warnings as errors. (default: False)")
+    ap.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Print verbose logging output. (default: False)")
     # TODO: implement this
     add_config_arguments(ap)
     args = ap.parse_args()
@@ -35,13 +45,18 @@ def cli_main():
         print(type(err).__name__ + ":", err, file=sys.stderr)
         sys.exit(1)
     if captured_warnings:
-        for warn in captured_warnings:
-            print("warning:", warn.message, file=sys.stderr)
+        for warning in captured_warnings:
+            print("Warning:", warning.message, file=sys.stderr)
+        if args.warnings_are_errors:
+            print("Error: warnings were treated as errors", file=sys.stderr)
+            sys.exit(1)
     if args.out_file == "-":
         print(result_svg)
     else:
         with open(args.out_file, "w", encoding="utf-8") as out:
             out.write(result_svg)
+        if args.verbose:
+            print("Wrote SVG to", args.out_file)
 
 
 if __name__ == "__main__":

schemascii/annoline.py

@@ -73,7 +73,7 @@ def is_annoline_character(cls, ch: str) -> bool:
     def find_all(cls, grid: _grid.Grid) -> list[AnnotationLine]:
         """Return all of the annotation lines found in the grid."""
         seen_points: set[complex] = set()
-        all_lines: list[cls] = []
+        all_lines: list[AnnotationLine] = []
 
         for y, line in enumerate(grid.lines):
             for x, ch in enumerate(line):

schemascii/annotation.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import html
 import re
 from dataclasses import dataclass
@@ -24,9 +26,9 @@ class Annotation(_dc.DataConsumer, namespaces=(":annotation",)):
     css_class = "annotation"
 
     @classmethod
-    def find_all(cls, grid: _grid.Grid):
+    def find_all(cls, grid: _grid.Grid) -> list[Annotation]:
         """Return all of the text annotations present in the grid."""
-        out: list[cls] = []
+        out: list[Annotation] = []
         for y, line in enumerate(grid.lines):
             for match in ANNOTATION_RE.finditer(line):
                 x = match.span()[0]

schemascii/data.py

@@ -28,14 +28,14 @@ class Section(dict):
     """Section of data relevant to one portion of the drawing."""
 
     header: str
-    data: dict
+    data: dict[str, typing.Any]
 
-    def __getitem__(self, key):
+    def __getitem__(self, key: str):
         return self.data[key]
 
-    def matches(self, name) -> bool:
+    def matches(self, name: str) -> bool:
         """True if self.header matches the name."""
-        return fnmatch.fnmatch(name, self.header)
+        return fnmatch.fnmatch(name.lower(), self.header.lower())
 
 
 @dataclass
@@ -80,22 +80,22 @@ def parse_from_string(cls, text: str, startline=1, filename="") -> Data:
         def complain(msg):
             raise _errors.DiagramSyntaxError(
                 f"{filename} line {line+startline}: {msg}\n"
-                f"  {lines[line]}\n"
-                f"  {' ' * col}{'^'*len(look())}".lstrip())
+                f"{line} | {lines[line]}\n"
+                f"{' ' * len(str(line))} | {' ' * col}{'^'*len(look())}")
 
         def complain_eof():
             restore(lastsig)
             skip_space(True)
             if index >= len(tokens):
                 complain("unexpected EOF")
-            complain("cannot parse after this")
+            complain("unknown parse error")
 
-        def look():
+        def look() -> str:
             if index >= len(tokens):
                 return "\0"
             return tokens[index]
 
-        def eat():
+        def eat() -> str:
             nonlocal line
             nonlocal col
             nonlocal index
@@ -150,7 +150,7 @@ def skip_i(newlines: bool = True):
                     if not skip_space():
                         return
 
-        def expect(expected: set[str]):
+        def expect_and_eat(expected: set[str]):
             got = look()
             if got in expected:
                 eat()
@@ -169,15 +169,15 @@ def parse_section() -> Section:
             # print("** starting section", repr(name))
             mark_used()
             skip_i()
-            expect({"{"})
+            expect_and_eat({"{"})
             data = {}
             while look() != "}":
                 data |= parse_kv_pair()
             eat()  # the "}"
             skip_i()
             return Section(name, data)
 
-        def parse_kv_pair() -> dict:
+        def parse_kv_pair() -> dict[str, int | float | str]:
             skip_i()
             if look() == "}":
                 # handle case of ";}"
@@ -187,7 +187,7 @@ def parse_kv_pair() -> dict:
             key = eat()
             mark_used()
             skip_i()
-            expect({"="})
+            expect_and_eat({"="})
             skip_space()
             expect_not(SPECIAL)
             value = ""
@@ -214,7 +214,7 @@ def parse_kv_pair() -> dict:
                     pass
             # don't eat the ending "}"
             if look() != "}":
-                expect({"\n", ";"})
+                expect_and_eat({"\n", ";"})
             # print("*** got KV", repr(key), repr(value))
             return {key: value}
 
@@ -263,4 +263,3 @@ def __or__(self, other: Data | dict[str, typing.Any] | typing.Any) -> Data:
     my_data = Data.parse_from_string(text)
     pprint.pprint(my_data)
     pprint.pprint(my_data.get_values_for("R1"))
-    print(my_data.getopt("R1", "foo"))

schemascii/grid.py

@@ -75,7 +75,7 @@ def clip(self, p1: complex, p2: complex):
 
     def shrink(self):
         """Shrinks self so that there is not any space between the edges and
-        the next non-printing character. Takes masks into account.
+        the next non-whitespace character. Takes masks into account.
         """
         # clip the top lines
         while all(self.get(complex(x, 0)).isspace()
@@ -95,6 +95,7 @@ def shrink(self):
             this_indent = len(line) - len(line.lstrip())
             min_indent = min(min_indent, this_indent)
         # chop the space
+        # TODO: for left and right, need to take into account the mask array
         if min_indent > 0:
             self.width -= min_indent
             for line in self.data:

schemascii/net.py

@@ -21,7 +21,7 @@ def find_all(cls, grid: _grid.Grid) -> list[Net]:
         """Return a list of all the wire nets found on the grid.
         """
         seen_points: set[complex] = set()
-        all_nets: list[cls] = []
+        all_nets: list[Net] = []
         all_tags = _wt.WireTag.find_all(grid)
 
         for y, line in enumerate(grid.lines):

schemascii/refdes.py

@@ -56,6 +56,8 @@ def short_name(self) -> str:
         U3A
                     Q1G1
                     R.Heater
+                    ^
+                    this one is invalid; only the "R" and "H" are gotten
     GND
 """)
     rds = RefDes.find_all(gg)

schemascii/utils.py

@@ -70,6 +70,8 @@ def from_phase(cls, pt: complex) -> Side:
         """Return the side that is closest to pt, if it is interpreted as
         a vector originating from the origin.
         """
+        # TODO: fix this so it compares the components,
+        # instead of this distance mess
         ops = {
             -pi: Side.LEFT,
             pi: Side.LEFT,

schemascii/wire_tag.py

@@ -33,7 +33,7 @@ class WireTag(_dc.DataConsumer, namespaces=(":wire-tag",)):
     @classmethod
     def find_all(cls, grid: _grid.Grid) -> list[WireTag]:
         """Find all of the wire tags present in the grid."""
-        out: list[cls] = []
+        out: list[WireTag] = []
         for y, line in enumerate(grid.lines):
             for match in WIRE_TAG_PAT.finditer(line):
                 left_grp, right_grp = match.groups()