formatting

Author: dragoncoder047

schemascii/__init__.py

@@ -1,17 +1,17 @@
 import importlib
 import os
 
-import schemascii.components as _comp
+import schemascii.components as _c
 import schemascii.drawing as _drawing
 
 __version__ = "0.3.2"
 
 
 def import_all_components():
-    for f in os.scandir(os.path.dirname(_comp.__file__)):
+    for f in os.scandir(os.path.dirname(_c.__file__)):
         if f.is_file():
             importlib.import_module(
-                f"{_comp.__package__}.{f.name.removesuffix('.py')}")
+                f"{_c.__package__}.{f.name.removesuffix('.py')}")
 
 
 import_all_components()
@@ -24,9 +24,5 @@ def render(filename: str, text: str | None = None, **options) -> str:
 
 
 if __name__ == "__main__":
-    print(render(
-        "test_data/test_resistors.txt",
-        scale=20,
-        padding=20,
-        stroke_width=2,
-        stroke="black"))
+    import schemascii.component as _comp
+    print(_comp.Component.all_components)

schemascii/__main__.py

@@ -1,26 +1,25 @@
 import argparse
 import sys
 import warnings
-from . import render, __version__
-from .errors import Error
-from .configs import add_config_arguments
+
+import schemascii
+import schemascii.errors as _errors
 
 
 def cli_main():
     ap = argparse.ArgumentParser(
-        prog="schemascii", description="Render ASCII-art schematics into SVG."
-    )
+        prog="schemascii", description="Render ASCII-art schematics into SVG.")
     ap.add_argument(
-        "-V", "--version", action="version", version="%(prog)s " + __version__
-    )
+        "-V", "--version", action="version",
+        version="%(prog)s " + schemascii.__version__)
     ap.add_argument("in_file", help="File to process.")
     ap.add_argument(
         "-o",
         "--out",
         default=None,
         dest="out_file",
-        help="Output SVG file. (default input file plus .svg)",
-    )
+        help="Output SVG file. (default input file plus .svg)")
+    # TODO: implement this
     add_config_arguments(ap)
     args = ap.parse_args()
     if args.out_file is None:
@@ -31,8 +30,8 @@ def cli_main():
         args.in_file = "<stdin>"
     try:
         with warnings.catch_warnings(record=True) as captured_warnings:
-            result_svg = render(args.in_file, text, **vars(args))
-    except Error as err:
+            result_svg = schemascii.render(args.in_file, text, **vars(args))
+    except _errors.Error as err:
         print(type(err).__name__ + ":", err, file=sys.stderr)
         sys.exit(1)
     if captured_warnings:

schemascii/component.py

@@ -16,6 +16,7 @@
 @dataclass
 class Component(_dc.DataConsumer, namespaces=(":component",)):
     """An icon representing a single electronic component."""
+
     all_components: typing.ClassVar[dict[str, type[Component]]] = {}
 
     options = [
@@ -132,9 +133,12 @@ def __init_subclass__(cls, ids: tuple[str, ...] = None,
             if not (id_letters.isalpha() and id_letters.upper() == id_letters):
                 raise ValueError(
                     f"invalid reference designator letters: {id_letters!r}")
-            if id_letters in cls.all_components:
+            if (id_letters in cls.all_components
+                    and cls.all_components[id_letters] is not cls):
                 raise ValueError(
-                    f"duplicate reference designator letters: {id_letters!r}")
+                    f"duplicate reference designator letters: {id_letters!r} "
+                    f"(trying to register {cls!r}, already "
+                    f"occupied by {cls.all_components[id_letters]!r})")
             cls.all_components[id_letters] = cls
 
     @property

schemascii/utils.py

@@ -419,7 +419,7 @@ def id_text(
     if nolabels:
         return ""
     if not point:
-        point = sum(t.pt for t in terminals) / len(terminals)
+        point = centroid(t.pt for t in terminals)
     data = ""
     if isinstance(value, str):
         data = value
@@ -441,12 +441,9 @@ def id_text(
     if len(terminals) > 1:
         textach = (
             "start"
-            if (
-                any(Side.BOTTOM == t.side for t in terminals)
-                or any(Side.TOP == t.side for t in terminals)
-            )
-            else "middle"
-        )
+            if (any(Side.BOTTOM == t.side for t in terminals)
+                or any(Side.TOP == t.side for t in terminals))
+            else "middle")
     else:
         textach = "middle" if terminals[0].side in (
             Side.TOP, Side.BOTTOM) else "start"
@@ -472,22 +469,15 @@ def make_text_point(t1: complex, t2: complex, **options) -> complex:
     return text_pt
 
 
-def make_plus(terminals: list[Terminal], center: complex,
-              theta: float, **options) -> str:
-    """Make a + sign if the terminals indicate the component is polarized."""
-    if all(t.flag != "+" for t in terminals):
-        return ""
+def make_plus(center: complex, theta: float, **options) -> str:
+    """Make a '+' sign for indicating polarity."""
     return XML.g(
         bunch_o_lines(
             deep_transform(
                 deep_transform([(0.125, -0.125), (0.125j, -0.125j)], 0, theta),
-                center + deep_transform(0.33 + 0.75j, 0, theta),
-                0,
-            ),
-            **options,
-        ),
-        class_="plus",
-    )
+                center + deep_transform(0.33 + 0.75j, 0, theta), 0),
+            **options),
+        class_="plus")
 
 
 def arrow_points(p1: complex, p2: complex) -> list[tuple[complex, complex]]:
@@ -497,16 +487,16 @@ def arrow_points(p1: complex, p2: complex) -> list[tuple[complex, complex]]:
     return [
         (p2, p1),
         (p2, p2 - rect(tick_len, angle + pi / 5)),
-        (p2, p2 - rect(tick_len, angle - pi / 5)),
-    ]
+        (p2, p2 - rect(tick_len, angle - pi / 5))]
 
 
 def make_variable(center: complex, theta: float, **options) -> str:
-    """Draw a 'variable' arrow across the component."""
-    return bunch_o_lines(deep_transform(arrow_points(-1, 1),
-                                        center,
-                                        (theta % pi) + pi / 4),
-                         **options)
+    """Draw a "variable" arrow across the component."""
+    return XML.g(bunch_o_lines(deep_transform(arrow_points(-1, 1),
+                                              center,
+                                              (theta % pi) + pi / 4),
+                               **options),
+                 class_="variable")
 
 
 def light_arrows(center: complex, theta: float, out: bool, **options):
@@ -516,13 +506,13 @@ def light_arrows(center: complex, theta: float, out: bool, **options):
     a, b = 1j, 0.3 + 0.3j
     if out:
         a, b = b, a
-    return bunch_o_lines(
+    return XML.g(bunch_o_lines(
         deep_transform(arrow_points(a, b),
                        center, theta - pi / 2)
         + deep_transform(arrow_points(a - 0.5, b - 0.5),
                          center, theta - pi / 2),
-        **options
-    )
+        **options),
+        class_="light-emitting" if out else "light-dependent")
 
 
 def sort_terminals_counterclockwise(