Bikey-Wagon Learnings

src/faebryk/core/node.py

@@ -42,6 +42,8 @@
 logger = logging.getLogger(__name__)
 
 
+# TODO: should this be a FaebrykException?
+# TODO: should this include node and field information?
 class FieldError(Exception):
     pass
 
@@ -110,6 +112,13 @@ def __init__(self, node: "Node", *args: object) -> None:
         self.node = node
 
 
+class FieldConstructionError(FaebrykException):
+    def __init__(self, node: "Node", field: str, *args: object) -> None:
+        super().__init__(*args)
+        self.node = node
+        self.field = field
+
+
 class NodeAlreadyBound(NodeException):
     def __init__(self, node: "Node", other: "Node", *args: object) -> None:
         super().__init__(
@@ -291,7 +300,7 @@ def append(name, inst):
 
             return inst
 
-        def setup_field(name, obj):
+        def _setup_field(name, obj):
             def setup_gen_alias(name, obj):
                 origin = get_origin(obj)
                 assert origin
@@ -321,6 +330,16 @@ def setup_gen_alias(name, obj):
 
             raise NotImplementedError()
 
+        def setup_field(name, obj):
+            try:
+                _setup_field(name, obj)
+            except Exception as e:
+                raise FieldConstructionError(
+                    self,
+                    name,
+                    f'An exception occurred while constructing field "{name}"',
+                ) from e
+
         nonrt, rt = partition(lambda x: isinstance(x[1], rt_field), clsfields.items())
         for name, obj in nonrt:
             setup_field(name, obj)

src/faebryk/exporters/visualize/interactive_graph.py

@@ -8,10 +8,16 @@
 from faebryk.core.graphinterface import GraphInterface
 from faebryk.core.link import Link
 from faebryk.core.node import Node
-from faebryk.exporters.visualize.util import IDSet, generate_pastel_palette
+from faebryk.exporters.visualize.util import (
+    generate_pastel_palette,
+    offer_missing_install,
+)
+from faebryk.libs.util import FuncSet
 
 
 def interactive_graph(G: Graph):
+    offer_missing_install("dash_cytoscape")
+    offer_missing_install("dash")
     import dash_cytoscape as cyto
     from dash import Dash, html
 
@@ -48,7 +54,7 @@ def _node(node: Node):
         return {"data": data}
 
     link_types: set[str] = set()
-    links_touched = IDSet[Link]()
+    links_touched = FuncSet[Link]()
 
     def _link(link: Link):
         if link in links_touched:
@@ -105,17 +111,42 @@ def _not_none(x):
         },
     ]
 
-    def _pastels(iterable):
-        return zip(iterable, generate_pastel_palette(len(iterable)))
+    def _pastels(iterable, offset=0, spare=0):
+        return zip(
+            iterable,
+            generate_pastel_palette(len(iterable) + offset + spare)[
+                offset : -spare or None
+            ],
+        )
 
-    for node_type, color in _pastels(node_types):
+    print("Node types:")
+    for node_type, color in _pastels(node_types, spare=len(node_types)):
         stylesheet.append(
             {
                 "selector": f'node[type = "{node_type}"]',
                 "style": {"background-color": color},
             }
         )
 
+        colored_text = rich.text.Text(f"{node_type}: {color}")
+        colored_text.stylize(f"on {color}")
+        rich.print(colored_text)
+    print("\n")
+
+    print("Link types:")
+    for link_type, color in _pastels(link_types, offset=len(node_types)):
+        stylesheet.append(
+            {
+                "selector": f'edge[type = "{link_type}"]',
+                "style": {"line-color": color, "target-arrow-color": color},
+            }
+        )
+
+        colored_text = rich.text.Text(f"{link_type}: {color}")
+        colored_text.stylize(f"on {color}")
+        rich.print(colored_text)
+    print("\n")
+
     stylesheet.append(
         {
             "selector": 'node[type = "group"]',
@@ -128,14 +159,6 @@ def _pastels(iterable):
         }
     )
 
-    for link_type, color in _pastels(link_types):
-        stylesheet.append(
-            {
-                "selector": f'edge[type = "{link_type}"]',
-                "style": {"line-color": color, "target-arrow-color": color},
-            }
-        )
-
     container_style = {
         "position": "fixed",
         "display": "flex",
@@ -193,19 +216,4 @@ def _pastels(iterable):
         ],
     )
 
-    # print the color palette
-    print("Node types:")
-    for node_type, color in _pastels(node_types):
-        colored_text = rich.text.Text(f"{node_type}: {color}")
-        colored_text.stylize(f"on {color}")
-        rich.print(colored_text)
-    print("\n")
-
-    print("Link types:")
-    for link_type, color in _pastels(link_types):
-        colored_text = rich.text.Text(f"{link_type}: {color}")
-        colored_text.stylize(f"on {color}")
-        rich.print(colored_text)
-    print("\n")
-
     app.run()

src/faebryk/exporters/visualize/util.py

@@ -1,5 +1,49 @@
 import colorsys
-from typing import Iterable, Sequence, Set
+import importlib
+import subprocess
+import sys
+from types import ModuleType
+
+from rich.prompt import Confirm
+
+
+class InstallationError(Exception):
+    """Raised when there's a problem installing a module."""
+
+
+def offer_install(module_name, install_name=None, ex=None) -> ModuleType | None:
+    """
+    Offer to install a missing module using pip.
+    """
+    cmd = [sys.executable, "-m", "pip", "install", install_name or module_name]
+
+    print(f"The module '{module_name}' is not installed.")
+
+    if Confirm.ask(
+        f"Do you want to run the install command [cyan mono]`{' '.join(cmd)}`[/]"
+    ):
+        try:
+            # Attempt to install the module using pip
+            subprocess.check_call(cmd)
+
+        except subprocess.CalledProcessError:
+            print(f"Failed to install {module_name}. Please install it manually.")
+            raise ex or InstallationError(f"Failed to install {module_name}")
+
+        print(f"Successfully installed {module_name}")
+        return importlib.import_module(module_name)
+
+
+def offer_missing_install(
+    module_name: str, install_name: str = None
+) -> ModuleType | None:
+    """
+    Offer to install a missing module using pip.
+    """
+    try:
+        return importlib.import_module(module_name)
+    except ModuleNotFoundError:
+        return offer_install(module_name, install_name)
 
 
 def generate_pastel_palette(num_colors: int) -> list[str]:
@@ -32,21 +76,3 @@ def generate_pastel_palette(num_colors: int) -> list[str]:
         palette.append(hex_color)
 
     return palette
-
-
-# TODO: this belongs elsewhere
-class IDSet[T](Set[T]):
-    def __init__(self, data: Sequence[T] | None = None):
-        self._data = set(data) if data is not None else set()
-
-    def add(self, item: T):
-        self._data.add(id(item))
-
-    def __contains__(self, item: T):
-        return id(item) in self._data
-
-    def __iter__(self) -> Iterable[T]:
-        return iter(self._data)
-
-    def __len__(self) -> int:
-        return len(self._data)

src/faebryk/library/KicadFootprint.py

@@ -9,6 +9,10 @@
 class KicadFootprint(F.Footprint):
     def __init__(self, kicad_identifier: str, pin_names: list[str]) -> None:
         super().__init__()
+        assert ":" in kicad_identifier, (
+            'kicad_identifier must be in the format "library:footprint".'
+            " If not, it'll cause downstream problems"
+        )
 
         unique_pin_names = sorted(set(pin_names))
         self.pin_names_sorted = list(enumerate(unique_pin_names))

src/faebryk/library/NetTie.py

@@ -0,0 +1,51 @@
+# This file is part of the faebryk project
+# SPDX-License-Identifier: MIT
+
+import logging
+from enum import Enum
+
+import faebryk.library._F as F
+from faebryk.core.module import Module
+from faebryk.core.moduleinterface import ModuleInterface
+from faebryk.library.Electrical import Electrical
+from faebryk.library.KicadFootprint import KicadFootprint
+from faebryk.libs.picker.picker import has_part_picked_remove
+
+logger = logging.getLogger(__name__)
+
+
+class NetTie[T: ModuleInterface](Module):
+    class Size(float, Enum):
+        _2_0MM = 2.0
+        _0_5MM = 0.5
+
+    unnamed: list[T]
+
+    def __init__(
+        self,
+        width: Size,
+        interface_type: type[T] = Electrical,
+    ) -> None:
+        super().__init__()
+
+        # dynamically construct the interfaces
+        self.unnamed = self.add([interface_type(), interface_type()], "unnamed")
+
+        # add dem trairs
+        self.add(F.can_bridge_defined(*self.unnamed))
+
+        width_mm = NetTie.Size(width).value
+
+        self.add(F.can_attach_to_footprint_symmetrically())
+        self.add(F.has_designator_prefix_defined("H"))
+        # TODO: "removed" isn't really true, but seems to work
+        self.add(has_part_picked_remove())
+
+        # TODO: generate the kicad footprint instead of loading it
+        self.add(
+            F.has_footprint_defined(
+                KicadFootprint(
+                    f"NetTie:NetTie-2_SMD_Pad{width_mm:.1f}mm", pin_names=["1", "2"]
+                )
+            )
+        )

src/faebryk/library/_F.py

@@ -114,6 +114,7 @@
 from faebryk.library.Capacitor import Capacitor
 from faebryk.library.Fuse import Fuse
 from faebryk.library.Inductor import Inductor
+from faebryk.library.NetTie import NetTie
 from faebryk.library.Resistor import Resistor
 from faebryk.library.Switch import Switch
 from faebryk.library.B4B_ZR_SM4_TF import B4B_ZR_SM4_TF

src/faebryk/library/has_multi_picker.py

@@ -4,13 +4,13 @@
 
 import logging
 from abc import abstractmethod
-from typing import Callable, Mapping
+from typing import Callable, Mapping, Self
 
 import faebryk.library._F as F
 from faebryk.core.module import Module
 from faebryk.core.node import Node
 from faebryk.core.trait import TraitImpl
-from faebryk.libs.picker.picker import PickError
+from faebryk.libs.picker.picker import PickError, has_part_picked_remove
 
 logger = logging.getLogger(__name__)
 
@@ -84,3 +84,19 @@ def handle_duplicate(self, other: TraitImpl, node: Node) -> bool:
         other.pickers.extend(self.pickers)
         other.pickers.sort(key=lambda x: x[0])
         return False
+
+    @classmethod
+    def remove_if[T: Module](
+        cls, m: T, condition: Callable[[T], bool], prio: int = -10
+    ) -> Self:
+        def replace(module: Module):
+            assert module is m
+
+            if condition(module):
+                module.add_trait(has_part_picked_remove())
+
+            raise PickError("", m)
+
+        m.add(has_multi_picker(prio, has_multi_picker.FunctionPicker(replace)))
+
+        return m