mif fixes step 1

.gitignore

@@ -98,3 +98,5 @@ _local
 
 # OS stuff
 .DS_Store
+
+.envrc

src/faebryk/core/core.py

@@ -10,11 +10,6 @@
 
 logger = logging.getLogger(__name__)
 
-LINK_TB = ConfigFlag(
-    "LINK_TB",
-    False,
-    "Save stack trace for each link. Warning: Very slow! Just use for debug",
-)
 ID_REPR = ConfigFlag("ID_REPR", False, "Add object id to repr")
 
 

src/faebryk/core/cpp/__init__.py

@@ -130,4 +130,4 @@ def cleanup():
     set_leak_warnings(bool(LEAK_WARNINGS))
 
 
-at_exit(cleanup)
+at_exit(cleanup, on_exception=False)

src/faebryk/core/cpp/__init__.pyi

@@ -30,6 +30,7 @@ class GraphInterface:
     def __repr__(self) -> str: ...
     def get_graph(self) -> Graph: ...
     def get_gif_edges(self) -> set[GraphInterface]: ...
+    def get_direct_connections(self) -> set[GraphInterface]: ...
     @property
     def edges(self) -> dict[GraphInterface, Link]: ...
     @property

src/faebryk/core/cpp/src/main.cpp

@@ -51,6 +51,8 @@ PYMOD(m) {
                 .def("__repr__", &GI::repr)
                 .def("get_graph", &GI::get_graph)
                 .def("get_gif_edges", &GI::get_gif_edges)
+                // TODO deprecate
+                .def("get_direct_connections", &GI::get_gif_edges)
                 .def_prop_ro("edges", &GI::get_edges)
                 .def_prop_rw("node", &GI::get_node, &GI::set_node)
                 .def("is_connected", &GI::is_connected)

src/faebryk/core/moduleinterface.py

@@ -4,25 +4,24 @@
 from typing import (
     Iterable,
     Sequence,
+    cast,
 )
 
 from typing_extensions import Self
 
-from faebryk.core.core import LINK_TB
 from faebryk.core.graphinterface import (
     GraphInterface,
     GraphInterfaceHierarchical,
 )
 from faebryk.core.link import (
     Link,
     LinkDirect,
-    LinkDirectShallow,
+    LinkDirectConditional,
     LinkFilteredException,
-    _TLinkDirectShallow,
 )
-from faebryk.core.node import Node
+from faebryk.core.node import CNode, Node
 from faebryk.core.trait import Trait
-from faebryk.libs.util import cast_assert, once, print_stack
+from faebryk.libs.util import cast_assert, once
 
 logger = logging.getLogger(__name__)
 
@@ -41,12 +40,12 @@ def _resolve_link_transitive(links: Iterable[type[Link]]) -> type[Link]:
     if len(uniq) == 1:
         return next(iter(uniq))
 
-    if is_type_set_subclasses(uniq, {_TLinkDirectShallow}):
+    if is_type_set_subclasses(uniq, {LinkDirectConditional}):
         # TODO this only works if the filter is identical
         raise NotImplementedError()
 
-    if is_type_set_subclasses(uniq, {LinkDirect, _TLinkDirectShallow}):
-        return [u for u in uniq if issubclass(u, _TLinkDirectShallow)][0]
+    if is_type_set_subclasses(uniq, {LinkDirect, LinkDirectConditional}):
+        return [u for u in uniq if issubclass(u, LinkDirectConditional)][0]
 
     raise NotImplementedError()
 
@@ -61,8 +60,8 @@ def _resolve_link_duplicate(links: Iterable[type[Link]]) -> type[Link]:
     if len(uniq) == 1:
         return next(iter(uniq))
 
-    if is_type_set_subclasses(uniq, {LinkDirect, _TLinkDirectShallow}):
-        return [u for u in uniq if not issubclass(u, _TLinkDirectShallow)][0]
+    if is_type_set_subclasses(uniq, {LinkDirect, LinkDirectConditional}):
+        return [u for u in uniq if not issubclass(u, LinkDirectConditional)][0]
 
     raise NotImplementedError()
 
@@ -116,20 +115,27 @@ class TraitT(Trait): ...
     specialized: GraphInterface
     connected: GraphInterfaceModuleConnection
 
-    # TODO rename
-    @classmethod
-    @once
-    def LinkDirectShallow(cls):
+    class _LinkDirectShallow(LinkDirectConditional):
         """
         Make link that only connects up but not down
         """
 
-        def test(node: Node):
-            return not any(isinstance(p[0], cls) for p in node.get_hierarchy()[:-1])
+        def test(self, node: CNode):
+            return not any(
+                isinstance(p[0], self.type_test) for p in node.get_hierarchy()[:-1]
+            )
+
+        def __init__(self, type_test: type["ModuleInterface"]):
+            self.type_test = type_test
+            super().__init__(lambda src, dst: self.test(dst.node))
 
-        class _LinkDirectShallowMif(
-            LinkDirectShallow(lambda link, gif: test(gif.node))
-        ): ...
+    # TODO rename
+    @classmethod
+    @once
+    def LinkDirectShallow(cls):
+        class _LinkDirectShallowMif(ModuleInterface._LinkDirectShallow):
+            def __init__(self):
+                super().__init__(cls)
 
         return _LinkDirectShallowMif
 
@@ -278,16 +284,14 @@ def _connect_across_hierarchies(
             resolved = _resolve_link_duplicate([type(existing_link), linkcls])
             if resolved is type(existing_link):
                 return
-            if LINK_TB:
-                print(print_stack(existing_link.tb))
             raise NotImplementedError(
                 "Overriding existing links not implemented, tried to override "
                 + f"{existing_link} with {resolved}"
             )
 
         # level 0 connect
         try:
-            self.connected.connect(other.connected, linkcls=linkcls)
+            self.connected.connect(other.connected, linkcls())
         except LinkFilteredException:
             return
 
@@ -360,4 +364,4 @@ def specialize[T: ModuleInterface](self, special: T) -> T:
         # Establish sibling relationship
         self.specialized.connect(special.specializes)
 
-        return special
+        return cast(T, special)

src/faebryk/libs/app/erc.py

@@ -11,7 +11,7 @@
 from faebryk.core.moduleinterface import ModuleInterface
 from faebryk.library.Operation import Operation
 from faebryk.libs.picker.picker import has_part_picked
-from faebryk.libs.util import groupby, print_stack
+from faebryk.libs.util import groupby
 
 logger = logging.getLogger(__name__)
 
@@ -26,14 +26,8 @@ class ERCFaultShort(ERCFault):
     def __init__(self, faulting_ifs: Sequence[ModuleInterface], *args: object) -> None:
         link = faulting_ifs[0].is_connected_to(faulting_ifs[1])
         assert link
-        from faebryk.core.core import LINK_TB
-
-        stack = ""
-        if LINK_TB:
-            stack = print_stack(link.tb)
 
         super().__init__(faulting_ifs, *args)
-        print(stack)
 
 
 class ERCFaultElectricPowerUndefinedVoltage(ERCFault):

src/faebryk/libs/util.py

@@ -646,15 +646,16 @@ def __call__(self, *args, **kwargs) -> Any:
         return self.f(*args, **kwargs)
 
 
-def at_exit(func: Callable):
+def at_exit(func: Callable, on_exception: bool = True):
     import atexit
     import sys
 
     f = CallOnce(func)
 
     atexit.register(f)
     hook = sys.excepthook
-    sys.excepthook = lambda *args: (f(), hook(*args))
+    if on_exception:
+        sys.excepthook = lambda *args: (f(), hook(*args))
 
     # get main thread
     import threading

test/core/cpp/test_importcpp.py

@@ -41,6 +41,17 @@ class SubNode(Node):
     print(sn.a)
 
 
+def test_derived_pynodes():
+    from faebryk.core.moduleinterface import ModuleInterface
+
+    mif1 = ModuleInterface()
+    mif2 = ModuleInterface()
+
+    mif1.connect(mif2)
+
+    print(mif1)
+
+
 def test_cobject():
     from faebryk.core.cpp import (
         GraphInterface,
@@ -70,4 +81,5 @@ def test_cobject():
     # test_add()
     # test_cobject()
     # test_cnodes()
-    test_pynode()
+    # test_pynode()
+    test_derived_pynodes()