annotate(): dedup path components so sibling-call nesting doesn't double

Sibling functions within one subsystem call each other, each re-pushing its label onto the annotate ContextVar, which accumulated a/b/a/b paths (measured: 48% of the doom render graph carried a repeated component). annotate now appends only components not already active: distinct labels still nest (proj/paint) while dups collapse (paint/paint -> paint; pmrk/R_CheckPlane/pmrk/R_CheckPlane -> pmrk/R_CheckPlane). Graph topology is unaffected (annotation is metadata only). New tests/graph/test_annotate.py covers it.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: physicsrob

tests/graph/test_annotate.py

@@ -0,0 +1,74 @@
+"""``annotate`` / ``annotated`` — hierarchical provenance labels with dedup.
+
+The dedup behavior matters in practice: sibling functions within one
+subsystem call each other, each re-pushing its label, which without dedup
+accumulates ``a/b/a/b`` paths. ``annotate`` collapses a component that is
+already active in the path while still nesting *distinct* labels.
+"""
+
+from torchwright.graph import annotate, annotated
+from torchwright.graph import node as _node
+
+
+def _cur():
+    return _node._current_annotation.get()
+
+
+def test_basic_nesting():
+    assert _cur() is None
+    with annotate("render"):
+        assert _cur() == "render"
+        with annotate("texture"):
+            assert _cur() == "render/texture"
+        assert _cur() == "render"
+    assert _cur() is None
+
+
+def test_distinct_labels_still_nest():
+    with annotate("proj"):
+        with annotate("paint"):
+            assert _cur() == "proj/paint"
+
+
+def test_dedup_consecutive_same_label():
+    with annotate("paint"):
+        with annotate("paint"):
+            with annotate("paint"):
+                assert _cur() == "paint"
+
+
+def test_dedup_compound_label():
+    with annotate("pmrk/R_CheckPlane"):
+        with annotate("pmrk/R_CheckPlane"):
+            assert _cur() == "pmrk/R_CheckPlane"
+
+
+def test_dedup_interleaved_components():
+    # the A/B/A/B shape produced by sibling functions calling each other
+    with annotate("stor/R_StoreWallRange"):
+        with annotate("pix/R_DrawColumn"):
+            with annotate("pix/R_DrawColumn"):
+                with annotate("tex"):
+                    assert _cur() == "stor/R_StoreWallRange/pix/R_DrawColumn/tex"
+
+
+def test_reset_on_exit_even_on_error():
+    try:
+        with annotate("x"):
+            raise ValueError("boom")
+    except ValueError:
+        pass
+    assert _cur() is None
+
+
+def test_annotated_decorator_dedup():
+    @annotated("bsp")
+    def outer():
+        @annotated("bsp")
+        def inner():
+            return _cur()
+
+        return inner()
+
+    assert outer() == "bsp"
+    assert _cur() is None

torchwright/graph/node.py

@@ -44,14 +44,28 @@ def _verify_tensor_against_value_type(node: "Node", tensor: torch.Tensor) -> Non
 def annotate(label: str):
     """Tag all nodes created inside this block with a hierarchical label.
 
-    Nesting builds a ``/``-separated path::
+    Nesting builds a ``/``-separated path. A component already active in the
+    path is NOT repeated — so sibling functions in one subsystem calling each
+    other (a natural pattern) stay ``a/b`` instead of accumulating
+    ``a/b/a/b``::
 
         with annotate("render"):
             with annotate("texture"):
                 # nodes get annotation = "render/texture"
+            with annotate("render"):
+                # still "render" — re-entering an active scope is a no-op
+
+    ``label`` may itself be a ``/``-separated path (e.g. ``"pmrk/R_CheckPlane"``);
+    each component is deduped independently.
     """
     current = _current_annotation.get()
-    new = f"{current}/{label}" if current else label
+    parts = current.split("/") if current else []
+    seen = set(parts)
+    for comp in label.split("/"):
+        if comp and comp not in seen:
+            parts.append(comp)
+            seen.add(comp)
+    new = "/".join(parts) if parts else current
     token = _current_annotation.set(new)
     try:
         yield