thundergraph-model 1.2.1__tar.gz → 1.2.3__tar.gz

{thundergraph_model-1.2.1 → thundergraph_model-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thundergraph-model
-Version: 1.2.1
+Version: 1.2.3
 Summary: Executable systems modeling in Python
 License-File: LICENSE
 Requires-Python: >=3.11

{thundergraph_model-1.2.1 → thundergraph_model-1.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "thundergraph-model"
-version = "1.2.1"
+version = "1.2.3"
 description = "Executable systems modeling in Python"
 readme = "PYPI.md"
 requires-python = ">=3.11"

{thundergraph_model-1.2.1 → thundergraph_model-1.2.3}/tg_model/execution/configured_model.py

@@ -262,7 +262,7 @@ def instantiate(root_type: type) -> ConfiguredModel:
         requirement_value_slots,
     )
 
-    connections = _instantiate_connections(compiled, root_instance, path_registry, root_type)
+    connections = _instantiate_all_connections(root_instance, path_registry, root_type)
     allocations = _instantiate_allocations(compiled, root_instance, path_registry, root_type)
     references = _instantiate_all_references(root_instance, path_registry, root_type) + ref_accumulator
 
@@ -535,12 +535,29 @@ def _wire_requirement_block_references(
     path_registry: dict[str, ElementInstance | ValueSlot],
     out: list[ReferenceBinding],
 ) -> None:
-    """Bind ``references`` edges authored inside a :class:`~tg_model.model.elements.Requirement` package."""
+    """Bind ``references`` edges authored inside a :class:`~tg_model.model.elements.Requirement` package.
+
+    Source refs from ``parameter()`` / ``attribute()`` inside a Requirement carry
+    the block's ``symbol_path_prefix`` baked into ``ref.path`` (so they can flow
+    through ``allocate(inputs=...)``). Citation refs do not (they keep
+    ``self.owner_type`` so they're locally scoped). Strip ``_symbol_path_prefix``
+    from each edge endpoint so the result is a clean local-relative path before
+    prepending the runtime ``block_instance_path``.
+    """
+    symbol_prefix: tuple[str, ...] = tuple(compiled.get("_symbol_path_prefix") or ())
+
+    def _instance_path(raw_path: tuple[str, ...]) -> tuple[str, ...]:
+        if symbol_prefix and raw_path[: len(symbol_prefix)] == symbol_prefix:
+            local = raw_path[len(symbol_prefix):]
+        else:
+            local = raw_path
+        return block_instance_path + local
+
     for edge in compiled.get("edges", []):
         if edge.get("kind") != "references":
             continue
-        src_path = block_instance_path + tuple(edge["source"]["path"])
-        tgt_path = block_instance_path + tuple(edge["target"]["path"])
+        src_path = _instance_path(tuple(edge["source"]["path"]))
+        tgt_path = _instance_path(tuple(edge["target"]["path"]))
         src_key = ".".join(src_path)
         tgt_key = ".".join(tgt_path)
         src = path_registry.get(src_key)
@@ -566,43 +583,63 @@ def _wire_requirement_block_references(
         )
 
 
-def _instantiate_connections(
-    compiled: dict[str, Any],
+def _instantiate_all_connections(
     root: PartInstance,
     path_registry: dict[str, ElementInstance | ValueSlot],
     root_type: type,
 ) -> list[ConnectionBinding]:
-    """Resolve compiled connection edges into ConnectionBindings."""
-    connections: list[ConnectionBinding] = []
+    """Resolve ``connect`` edges from every part type in the instance tree.
 
-    for edge in compiled.get("edges", []):
-        if edge["kind"] != "connect":
-            continue
+    Mirrors :func:`_instantiate_all_references`. Connections are no longer required
+    to be authored on the configured root — composed sub-Parts may declare their own
+    internal port wiring via ``model.connect(...)``. Each part contributes the
+    connect edges from its own ``definition_type.compile()`` artifact, and the
+    source/target port paths are resolved against that part's ``instance_path``.
+    """
+    out: list[ConnectionBinding] = []
+    stack: list[PartInstance] = [root]
+    while stack:
+        part = stack.pop()
+        compiled = part.definition_type.compile()
+        for edge in compiled.get("edges", []):
+            if edge["kind"] != "connect":
+                continue
 
-        src_path = root.instance_path + tuple(edge["source"]["path"])
-        tgt_path = root.instance_path + tuple(edge["target"]["path"])
-        src_key = ".".join(src_path)
-        tgt_key = ".".join(tgt_path)
+            src_path = part.instance_path + tuple(edge["source"]["path"])
+            tgt_path = part.instance_path + tuple(edge["target"]["path"])
+            src_key = ".".join(src_path)
+            tgt_key = ".".join(tgt_path)
 
-        src = path_registry.get(src_key)
-        tgt = path_registry.get(tgt_key)
+            src = path_registry.get(src_key)
+            tgt = path_registry.get(tgt_key)
 
-        if not isinstance(src, PortInstance):
-            raise ValueError(f"Connection source '{src_key}' is not a PortInstance")
-        if not isinstance(tgt, PortInstance):
-            raise ValueError(f"Connection target '{tgt_key}' is not a PortInstance")
+            if not isinstance(src, PortInstance):
+                raise ValueError(f"Connection source '{src_key}' is not a PortInstance")
+            if not isinstance(tgt, PortInstance):
+                raise ValueError(f"Connection target '{tgt_key}' is not a PortInstance")
 
-        conn_id = derive_declaration_id(root_type, "connect", *edge["source"]["path"], *edge["target"]["path"])
-        connections.append(
-            ConnectionBinding(
-                stable_id=conn_id,
-                source=src,
-                target=tgt,
-                carrying=edge.get("carrying"),
+            # Include the part's own instance path in the id so connects authored
+            # inside different sub-parts of the same root remain unique.
+            owner_segments = part.instance_path[1:]  # skip the root_type name itself
+            conn_id = derive_declaration_id(
+                root_type,
+                "connect",
+                *owner_segments,
+                *edge["source"]["path"],
+                *edge["target"]["path"],
             )
-        )
+            out.append(
+                ConnectionBinding(
+                    stable_id=conn_id,
+                    source=src,
+                    target=tgt,
+                    carrying=edge.get("carrying"),
+                )
+            )
+        # Recurse into composed child Parts (NOT ports / value slots / requirement packages).
+        stack.extend(part.children)
 
-    return connections
+    return out
 
 
 def _instantiate_allocations(

{thundergraph_model-1.2.1 → thundergraph_model-1.2.3}/tg_model/model/compile_types.py

@@ -164,6 +164,11 @@ def compile_type(
             "edges": [_serialize_edge(edge) for edge in ctx.edges],
             "child_types": child_types,
             "_type_registry": type_registry,
+            # Threaded path prefix used by Requirement parameter()/attribute() refs.
+            # Runtime needs this to translate refs that carry the threaded path
+            # back to a local-relative path before prepending the instance path
+            # of a composed Requirement block.
+            "_symbol_path_prefix": tuple(ctx.symbol_path_prefix),
             "behavior_transitions": _serialize_behavior_transitions(ctx.behavior_transitions),
         }
         cls_mut._compiled_definition = artifact
@@ -517,7 +522,13 @@ def _validate_requirement_package_value_exprs(ctx: Any) -> None:
 
 
 def _validate_references_edges(ctx: Any) -> None:
-    """``references`` edges must resolve to declared nodes; target must be a citation."""
+    """``references`` edges must resolve to declared nodes; target must be a citation.
+
+    Source refs may also point at the root_block (``path=()``, ``kind='part'``,
+    ``owner_type is ctx.owner_type``), which represents a citation on the class
+    itself rather than on one of its declared members. We treat that as valid
+    without requiring a node lookup.
+    """
     for edge in ctx.edges:
         if edge.get("kind") != "references":
             continue
@@ -530,11 +541,20 @@ def _validate_references_edges(ctx: Any) -> None:
                 f"{ctx.owner_type.__name__}: references target must be a citation ref, "
                 f"got {getattr(tgt, 'kind', None)!r}"
             )
-        sdecl = _lookup_node_decl_for_ref(ctx, src)
-        if sdecl is None:
-            raise ModelDefinitionError(
-                f"{ctx.owner_type.__name__}: references source path {getattr(src, 'path', ())!r} does not resolve"
-            )
+        # Self-reference (root_block): empty path, kind=part, owner_type matches.
+        # No node decl exists for the class itself — accept without lookup.
+        if (
+            getattr(src, "path", None) == ()
+            and getattr(src, "kind", None) == "part"
+            and getattr(src, "owner_type", None) is ctx.owner_type
+        ):
+            pass
+        else:
+            sdecl = _lookup_node_decl_for_ref(ctx, src)
+            if sdecl is None:
+                raise ModelDefinitionError(
+                    f"{ctx.owner_type.__name__}: references source path {getattr(src, 'path', ())!r} does not resolve"
+                )
         tdecl = _lookup_node_decl_for_ref(ctx, tgt)
         if tdecl is None or tdecl.kind != "citation":
             raise ModelDefinitionError(
@@ -543,13 +563,26 @@ def _validate_references_edges(ctx: Any) -> None:
 
 
 def _lookup_node_decl_for_ref(ctx: Any, ref: Any) -> NodeDecl | None:
-    """Resolve a definition-time ref using the owning type's definition context (no recursive ``compile()``)."""
+    """Resolve a definition-time ref using the owning type's definition context (no recursive ``compile()``).
+
+    Refs from ``Requirement`` ``parameter()`` / ``attribute()`` calls are threaded
+    under ``ctx.symbol_owner`` (typically the configured root type) with a path
+    prefixed by ``ctx.symbol_path_prefix``. Strip that prefix before walking the
+    local context so refs and locally-declared nodes line up.
+    """
     path = getattr(ref, "path", ())
     if not path:
         return None
-    if getattr(ref, "owner_type", None) is not ctx.owner_type:
-        return None
-    return _walk_path_in_definition_ctx(ctx, path)
+    ref_owner = getattr(ref, "owner_type", None)
+    if ref_owner is ctx.owner_type:
+        return _walk_path_in_definition_ctx(ctx, path)
+    symbol_owner = getattr(ctx, "symbol_owner", None)
+    symbol_prefix = tuple(getattr(ctx, "symbol_path_prefix", ()) or ())
+    if ref_owner is symbol_owner and (not symbol_prefix or path[: len(symbol_prefix)] == symbol_prefix):
+        local_path = path[len(symbol_prefix):]
+        if local_path:
+            return _walk_path_in_definition_ctx(ctx, local_path)
+    return None
 
 
 def _walk_path_in_definition_ctx(ctx: Any, path: tuple[str, ...]) -> NodeDecl | None:

{thundergraph_model-1.2.1 → thundergraph_model-1.2.3}/tg_model/model/definition_context.py

@@ -1295,7 +1295,12 @@ class ModelDefinitionContext:
         Parameters
         ----------
         source : Ref
-            Any declared node on this type (part, port, parameter, requirement, …).
+            Any declared node on this type (part, port, parameter, attribute,
+            requirement, …). For ``Requirement`` blocks, parameters and
+            attributes are threaded under ``symbol_owner`` so allocations can
+            wire them across boundaries; refs whose ``owner_type`` is either
+            the local ``owner_type`` or the configured ``symbol_owner`` are
+            both accepted as sources.
         citation : Ref
             Must be ``kind='citation'`` on this type.
 
@@ -1307,8 +1312,23 @@ class ModelDefinitionContext:
         self._check_frozen()
         if citation.kind != "citation":
             raise ModelDefinitionError(f"references(): citation must be a citation ref, got kind={citation.kind!r}")
-        if source.owner_type is not self.owner_type or citation.owner_type is not self.owner_type:
-            raise ModelDefinitionError("references(): source and citation must belong to this type")
+        # Accept refs from either the local owner_type or the threaded
+        # symbol_owner. For Parts, both are the same. For Requirements,
+        # parameter()/attribute() return refs with owner_type=symbol_owner so
+        # they can flow through allocations; those must be valid sources here.
+        valid_owners = (self.owner_type, self.symbol_owner)
+        if source.owner_type not in valid_owners or citation.owner_type not in valid_owners:
+            raise ModelDefinitionError(
+                f"references(): source and citation must belong to this type "
+                f"({self.owner_type.__name__})"
+                + (
+                    f" or its symbol owner ({self.symbol_owner.__name__})"
+                    if self.symbol_owner is not self.owner_type
+                    else ""
+                )
+                + f". Got source.owner_type={source.owner_type.__name__}, "
+                f"citation.owner_type={citation.owner_type.__name__}."
+            )
         self.edges.append(
             {
                 "kind": "references",

{thundergraph_model-1.2.1 → thundergraph_model-1.2.3}/uv.lock

@@ -1815,7 +1815,7 @@ wheels = [
 
 [[package]]
 name = "thundergraph-model"
-version = "1.2.1"
+version = "1.2.2"
 source = { editable = "." }
 dependencies = [
     { name = "unitflow", extra = ["numpy"] },