add capacitor and refactor units definitions

Author: dragoncoder047

schemascii/components/__init__.py

@@ -1,8 +1,34 @@
+from __future__ import annotations
 import typing
 from dataclasses import dataclass
 
 import schemascii.component as _c
 import schemascii.errors as _errors
+import schemascii.utils as _utils
+
+
+class SimpleComponent:
+    """Component mixin class that simplifies the formatting
+    of the various values and their units into the id_text.
+    """
+
+    value_format: typing.ClassVar[list[tuple[str, str]
+                                       | tuple[str, str, bool]
+                                       | tuple[str, str, bool, bool]]]
+
+    def format_id_text(self: _c.Component | SimpleComponent,
+                       textpoint: complex, **options):
+        val_fmt = []
+        for valsch in self.value_format:
+            val_fmt.append((options[valsch[0]], *valsch[1:]))
+        try:
+            id_text = _utils.id_text(self.rd.name, self.terminals,
+                                     val_fmt, textpoint, **options)
+        except ValueError as e:
+            raise _errors.BOMError(
+                f"{self.rd.name}: Range of values not allowed "
+                "on fixed-value component") from e
+        return id_text
 
 
 @dataclass
@@ -21,8 +47,10 @@ def __post_init__(self):
 
 
 class TwoTerminalComponent(NTerminalComponent):
-    """Shortcut to define a component with two terminals."""
-    n_terminals: typing.Final = 2
+    """Shortcut to define a component with two terminals, and one primary
+    value, that may or may not be variable."""
+    n_terminals: typing.Final[int] = 2
+    is_variable: typing.ClassVar[bool] = False
 
 
 @dataclass
@@ -44,3 +72,7 @@ def __post_init__(self):
         if self.terminals[1].flag == "+":
             # swap first and last
             self.terminals.insert(0, self.terminals.pop(-1))
+
+    @property
+    def is_polarized(self) -> bool:
+        return any(t.flag == "+" for t in self.terminals)

schemascii/components/capacitor.py

@@ -0,0 +1,47 @@
+from cmath import phase, rect
+
+import schemascii.components as _c
+import schemascii.data_consumer as _dc
+import schemascii.utils as _utils
+
+
+class Capacitor(_c.PolarizedTwoTerminalComponent, _c.SimpleComponent,
+                ids=("C",), namespaces=(":capacitor",)):
+    options = [
+        "inherit",
+        _dc.Option("value", str, "Capacitance in farads"),
+        _dc.Option("voltage", str, "Maximum voltage tolerance in volts", None)
+    ]
+
+    @property
+    def value_format(self):
+        return [("value", "F", True, self.is_variable),
+                ("voltage", "V", False)]
+
+    def render(self, **options) -> str:
+        t1, t2 = self.terminals[0].pt, self.terminals[1].pt
+        mid = (t1 + t2) / 2
+        angle = phase(t1 - t2)
+        lines = [
+            (t1, mid + rect(1/4, angle)),
+            (t2, mid + rect(-1/4, angle)),
+            *_utils.deep_transform([
+                (complex(2/5, 1/4), complex(-2/5, 1/4)),
+                (complex(2/5, -1/4), complex(-2/5, -1/4)),
+            ], mid, angle)
+        ]
+        return (_utils.bunch_o_lines(lines, **options)
+                + (_utils.make_plus(self.terminals, mid, angle, **options)
+                   if self.is_polarized else "")
+                + self.format_id_text(
+                    _utils.make_text_point(t1, t2, **options), **options))
+
+
+class VariableCapacitor(Capacitor, ids=("VC", "CV")):
+    is_variable = True
+
+    def render(self, **options):
+        t1, t2 = self.terminals[0].pt, self.terminals[1].pt
+        return (super().render(**options)
+                + _utils.make_variable(
+                    (t1 + t2) / 2, phase(t1 - t2), **options))

schemascii/components/resistor.py

@@ -3,9 +3,8 @@
 import schemascii.components as _c
 import schemascii.data_consumer as _dc
 import schemascii.utils as _utils
-import schemascii.errors as _errors
 
-# TODO: IEC rectangular symbol
+# TODO: IEC rectangular symbol, other variable markings?
 # see here: https://eepower.com/resistor-guide/resistor-standards-and-codes/resistor-symbols/  # noqa: E501
 
 
@@ -22,30 +21,26 @@ def _ansi_resistor_squiggle(t1: complex, t2: complex) -> list[complex]:
     return points
 
 
-class Resistor(_c.TwoTerminalComponent, ids=("R",), namespaces=(":resistor",)):
+class Resistor(_c.TwoTerminalComponent, _c.SimpleComponent,
+               ids=("R",), namespaces=(":resistor",)):
     options = [
         "inherit",
         _dc.Option("value", str, "Resistance in ohms"),
         _dc.Option("power", str, "Maximum power dissipation in watts "
                    "(i.e. size of the resistor)", None)
     ]
 
-    is_variable = False
+    @property
+    def value_format(self):
+        return [("value", "Ω", False, self.is_variable),
+                ("power", "W", False)]
 
-    def render(self, value: str, power: str, **options) -> str:
+    def render(self, **options) -> str:
         t1, t2 = self.terminals[0].pt, self.terminals[1].pt
         points = _ansi_resistor_squiggle(t1, t2)
-        try:
-            id_text = _utils.id_text(self.rd.name, self.terminals,
-                                     ((value, "Ω", False, self.is_variable),
-                                      (power, "W", False)),
-                                     _utils.make_text_point(t1, t2, **options),
-                                     **options)
-        except ValueError as e:
-            raise _errors.BOMError(
-                f"{self.rd.name}: Range of values not allowed "
-                "on fixed resistor") from e
-        return _utils.polylinegon(points, **options) + id_text
+        return (_utils.polylinegon(points, **options)
+                + self.format_id_text(
+                    _utils.make_text_point(t1, t2, **options), **options))
 
 
 class VariableResistor(Resistor, ids=("VR", "RV")):
@@ -58,7 +53,3 @@ def render(self, **options):
                     (t1 + t2) / 2, phase(t1 - t2), **options))
 
 # TODO: potentiometers
-
-
-if __name__ == "__main__":
-    print(Resistor.all_components)

schemascii/components_render.py

@@ -54,8 +54,7 @@ def n_check(
             if len(terminals) != n_terminals:
                 raise TerminalsError(
                     f"{box.type}{box.id} component can only "
-                    f"have {n_terminals} terminals"
-                )
+                    f"have {n_terminals} terminals")
             return func(box, terminals, bom_data, **options)
 
         return n_check
@@ -90,54 +89,16 @@ def sort_terminals(
             bom_data: list[BOMData], **options):
         if len(terminals) != 2:
             raise TerminalsError(
-                f"{box.type}{box.id} component can only " f"have 2 terminals"
-            )
+                f"{box.type}{box.id} component can only have 2 terminals")
         if terminals[1].flag == "+":
             terminals[0], terminals[1] = terminals[1], terminals[0]
         return func(box, terminals, bom_data, **options)
 
-    sort_terminals.__doc__ = func.__doc__
     return sort_terminals
 
 
-@component("C", "CV", "VC")
-@n_terminal(2)
-@no_ambiguous
-def capacitor(box: Cbox, terminals: list[Terminal],
-              bom_data: BOMData, **options):
-    """Draw a capacitor, variable capacitor, etc.
-    bom:farads[,volts]
-    flags:+=positive"""
-    t1, t2 = terminals[0].pt, terminals[1].pt
-    mid = (t1 + t2) / 2
-    angle = phase(t1 - t2)
-    lines = [
-        (t1, mid + rect(0.25, angle)),
-        (t2, mid + rect(-0.25, angle)),
-    ] + deep_transform(
-        [
-            (complex(0.4, 0.25), complex(-0.4, 0.25)),
-            (complex(0.4, -0.25), complex(-0.4, -0.25)),
-        ],
-        mid,
-        angle,
-    )
-    return (
-        bunch_o_lines(lines, **options)
-        + make_plus(terminals, mid, angle, **options)
-        + make_variable(mid, angle, "V" in box.type, **options)
-        + id_text(
-            box,
-            bom_data,
-            terminals,
-            (("F", True), ("V", False)),
-            make_text_point(t1, t2, **options),
-            **options,
-        )
-    )
-
-
 @component("L", "VL", "LV")
+@n_terminal(2)
 @no_ambiguous
 def inductor(box: Cbox, terminals: list[Terminal],
              bom_data: BOMData, **options):