ENH(net,+1TC): check Node-type CLASHES

Author: ankostis

graphtik/planning.py

@@ -51,6 +51,8 @@
 #: is augmented with children's details.
 log = logging.getLogger(__name__)
 
+NODE_TYPE = {0: "dependency", 1: "operation"}
+
 
 def yield_datanodes(nodes) -> List[str]:
     """May scan dag nodes."""
@@ -497,16 +499,34 @@ def append_subdoc_chain(doc_parts):
             doc_chain = [p for p in doc_chain if p]
             graph.add_edges_from(unseen_subdoc_edges(pairwise(doc_chain)))
 
+        node_types = graph.nodes(data="typ")  # a view to check for collisions
+
+        def check_node_collision(
+            node, node_type: int, dep_op=None, dep_kind: str = None
+        ):
+            """The dep_op/dep_kind are given only for data-nodes."""
+            if node in node_types and node_types[node] != node_type:
+                assert not (bool(dep_op) ^ bool(dep_kind)), locals()
+                graph_type = NODE_TYPE[node_types[node]]
+                given_node = (
+                    f"{dep_kind}({node!r})" if dep_op else f"operation({node.name})"
+                )
+                dep_op = f"\n  +--owning op: {dep_op}" if dep_op else ""
+                raise ValueError(
+                    f"Name of {given_node} clashed with a same-named {graph_type} in graph!{dep_op}"
+                )
+
         ## Needs
         #
         needs = []
         needs_edges = []
         for n in operation.needs:
             json_path = get_jsonp(n)
+            check_node_collision(n, 0, operation, "needs")
             if json_path:
                 append_subdoc_chain(json_path)
 
-            nkw, ekw = {}, {}  # node, edge props
+            nkw, ekw = {"typ": 0}, {}  # node, edge props
             if is_optional(n):
                 ekw["optional"] = True
             if is_sfx(n):
@@ -520,7 +540,8 @@ def append_subdoc_chain(doc_parts):
             needs_edges.append((n, operation, ekw))
         graph.add_nodes_from(needs)
         node_props = getattr(operation, "node_props", None) or {}
-        graph.add_node(operation, **node_props)
+        check_node_collision(operation, 1)
+        graph.add_node(operation, typ=1, **node_props)
         graph.add_edges_from(needs_edges)
 
         ## Prepare inversed-aliases index, used
@@ -533,20 +554,21 @@ def append_subdoc_chain(doc_parts):
         #
         for n in operation.provides:
             json_path = get_jsonp(n)
+            check_node_collision(n, 0, operation, "provides")
             if json_path:
                 append_subdoc_chain(json_path)
 
-            kw = {}
+            nkw, ekw = {"typ": 0}, {}
             if is_sfx(n):
-                kw["sideffect"] = True
-                graph.add_node(n, sideffect=True)
+                ekw["sideffect"] = nkw["sideffect"] = True
             if is_implicit(n):
-                kw["implicit"] = True
+                ekw["implicit"] = True
 
             if n in alias_destinations:
-                kw["alias_of"] = alias_destinations[n]
+                ekw["alias_of"] = alias_destinations[n]
 
-            graph.add_edge(operation, n, **kw)
+            graph.add_node(n, **nkw)
+            graph.add_edge(operation, n, **ekw)
 
     def _apply_graph_predicate(self, graph, predicate):
         to_del = []

test/test_op.py

@@ -302,7 +302,10 @@ def test_pipeline_node_props():
     op2 = operation(lambda: None, name="b", node_props={"a": 3, "c": 4})
     pipeline = compose("n", op1, op2, node_props={"bb": 22, "c": 44})
 
-    exp = {"a": {"a": 11, "b": 0, "bb": 22, "c": 44}, "b": {"a": 3, "bb": 22, "c": 44}}
+    exp = {
+        "a": {"typ": 1, "a": 11, "b": 0, "bb": 22, "c": 44},
+        "b": {"typ": 1, "a": 3, "bb": 22, "c": 44},
+    }
     node_props = _collect_op_props(pipeline)
     assert node_props == exp
 
@@ -322,17 +325,20 @@ def test_pipeline_merge_node_props():
     pipeline = compose(
         "n", pipeline1, pipeline2, node_props={"bb": 22, "c": 44}, nest=False
     )
-    exp = {"a": {"a": 1, "bb": 22, "c": 44}, "b": {"a": 3, "bb": 22, "c": 44}}
+    exp = {
+        "a": {"typ": 1, "a": 1, "bb": 22, "c": 44},
+        "b": {"typ": 1, "a": 3, "bb": 22, "c": 44},
+    }
     node_props = _collect_op_props(pipeline)
     assert node_props == exp
 
     pipeline = compose(
         "n", pipeline1, pipeline2, node_props={"bb": 22, "c": 44}, nest=True
     )
     exp = {
-        "n1.a": {"a": 1, "bb": 22, "c": 44},
-        "n2.a": {"a": 11, "b": 0, "bb": 22, "c": 44},
-        "n2.b": {"a": 3, "bb": 22, "c": 44},
+        "n1.a": {"typ": 1, "a": 1, "bb": 22, "c": 44},
+        "n2.a": {"typ": 1, "a": 11, "b": 0, "bb": 22, "c": 44},
+        "n2.b": {"typ": 1, "a": 3, "bb": 22, "c": 44},
     }
     node_props = _collect_op_props(pipeline)
     assert node_props == exp

test/test_planning.py

@@ -6,13 +6,15 @@
 import pytest
 from networkx.readwrite.edgelist import parse_edgelist
 
+from graphtik import operation
 from graphtik.planning import (
     yield_also_chaindocs,
     yield_also_subdocs,
     yield_also_superdocs,
     yield_chaindocs,
     yield_subdocs,
     yield_superdocs,
+    Network,
 )
 
 
@@ -142,3 +144,45 @@ def test_yield_chained_docs_root(g):
         "d21",
         "d211",
     ]
+
+
+@pytest.mark.parametrize(
+    "ops, err",
+    [
+        (
+            [operation(str, "BOOM", provides="BOOM")],
+            r"Name of provides\('BOOM'\) clashed with a same-named operation",
+        ),
+        (
+            [operation(str, "BOOM", needs="BOOM")],
+            r"Name of operation\(BOOM\) clashed with a same-named dependency",
+        ),
+        (
+            [operation(str, "BOOM", provides="a", aliases=("a", "BOOM"))],
+            r"Name of provides\('BOOM'\) clashed with a same-named operation",
+        ),
+        (
+            [operation(str, "op1", provides="BOOM"), operation(str, "BOOM")],
+            r"Name of operation\(BOOM\) clashed with a same-named dependency",
+        ),
+        ## x2 ops
+        (
+            [operation(str, "BOOM"), operation(str, "op2", "BOOM")],
+            r"Name of needs\('BOOM'\) clashed with a same-named operation",
+        ),
+        (
+            [operation(str, "op1", needs="BOOM"), operation(str, "BOOM")],
+            r"Name of operation\(BOOM\) clashed with a same-named dependency",
+        ),
+        (
+            [
+                operation(str, "op1", provides="a", aliases=("a", "BOOM")),
+                operation(str, "BOOM"),
+            ],
+            r"Name of operation\(BOOM\) clashed with a same-named dependency",
+        ),
+    ],
+)
+def test_node_clashes(ops, err):
+    with pytest.raises(ValueError, match=err):
+        Network(*ops)