process-bigraph 1.2.2__tar.gz → 1.3.0__tar.gz

{process_bigraph-1.2.2/process_bigraph.egg-info → process_bigraph-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: process-bigraph
-Version: 1.2.2
+Version: 1.3.0
 Summary: protocol and execution for compositional systems biology
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{process_bigraph-1.2.2 → process_bigraph-1.3.0}/process_bigraph/composite.py

@@ -1328,7 +1328,8 @@ class Composite(Process):
             initial_state['global_time'] = 0.0
 
         # Generate internal schema and state structures using the core engine.
-        self.schema, self.state = self.core.realize(
+        # Top-level realize: realize_root defaults to () so no merges escape.
+        self.schema, self.state, _ = self.core.realize(
             initial_schema,
             initial_state)
 
@@ -1442,7 +1443,7 @@ class Composite(Process):
         with open(path) as data:
             document = json.load(data)
             return cls(document, core=core)
-          
+
     def clean_front(self, state):
         self.find_instance_paths(state)
 
@@ -1454,11 +1455,11 @@ class Composite(Process):
             - self.process_paths
             - self.step_paths
         """
-        # Structural change incoming — drop the compiled-apply cache:
+        # Structural change incoming — drop schema-derived caches:
         # ``apply(dict)`` mutates schemas in place for ``_divide``
-        # sentinels, so cached compiled functions may now reference
-        # stale schema layouts.
-        self.core.invalidate_compiled_apply()
+        # sentinels, so the promote() memo may now key off stale
+        # schema layouts.
+        self.core.invalidate_caches()
         self.process_paths = find_instance_paths(state, 'process_bigraph.composite.Process')
         if hasattr(self, 'step_paths'):
             previous_step_paths = self.step_paths.keys()
@@ -1497,8 +1498,18 @@ class Composite(Process):
                 continue
             if sub_schema is None:
                 continue
-            new_sub_schema, new_sub_state = self.core.realize(
+            # realize_root defaults to ``path`` so port_merges produced
+            # inside the subtree get applied locally with the prefix
+            # stripped. Merges that escape the subtree (via ``..``
+            # wires) come back as ``escape_merges`` and need to land
+            # in ``self.schema`` at their absolute paths.
+            new_sub_schema, new_sub_state, escape_merges = self.core.realize(
                 sub_schema, sub_state, path=tuple(path))
+            if escape_merges:
+                escape_merge_schema = self.core.resolve_merges(
+                    {}, escape_merges)
+                self.schema = self.core.resolve(
+                    self.schema, escape_merge_schema)
             if not path:
                 self.state = new_sub_state
                 continue
@@ -1546,8 +1557,19 @@ class Composite(Process):
                 continue
             if sub_schema is None:
                 continue
-            new_sub_schema, new_sub_state = self.core.realize(
+            # realize_root defaults to ``path`` so port_merges produced
+            # inside the new subtree are applied with the prefix
+            # stripped (correct for the local sub_schema). Merges that
+            # escape (e.g. ``..`` wires writing to global fields) come
+            # back as ``escape_merges`` and must land on ``self.schema``
+            # at their absolute paths.
+            new_sub_schema, new_sub_state, escape_merges = self.core.realize(
                 sub_schema, sub_state, path=tuple(path))
+            if escape_merges:
+                escape_merge_schema = self.core.resolve_merges(
+                    {}, escape_merges)
+                self.schema = self.core.resolve(
+                    self.schema, escape_merge_schema)
             # Splice the realized state back at its path. The parent
             # container is a mutable dict (Map keys are dict-keyed at
             # state level), so we rewrite the leaf entry. Schema dicts
@@ -1581,14 +1603,14 @@ class Composite(Process):
         - ``Divided``: drop the mother's entries, scan each daughter
           subtree.
 
-        The compiled-apply cache is invalidated unconditionally because
+        Schema-derived caches are invalidated unconditionally because
         ``apply(dict)``'s ``_divide`` branch mutates schemas in place.
 
         Step network rebuild is conditional on step_paths actually
         changing — value-only structural events that don't add/remove
         any Step instances skip the rebuild.
         """
-        self.core.invalidate_compiled_apply()
+        self.core.invalidate_caches()
 
         previous_step_paths = (set(self.step_paths.keys())
                                if hasattr(self, 'step_paths') else set())
@@ -2695,12 +2717,17 @@ class Composite(Process):
                     combined_update,
                     update_has_structural=had_structural_sentinels,
                     events=structural_events)
-                # For structural sentinels, apply may have mutated
-                # apply_schema in place (e.g. _divide pops/inserts
-                # keys in a dict schema). Propagate back to self.schema
-                # so downstream realize sees the split.
+                # For structural sentinels, apply mutates the
+                # access-normalized form of ``apply_schema`` in place
+                # (e.g. ``_divide`` pops the mother key and inserts
+                # daughter keys in a dict subschema). ``apply_schema``
+                # itself is the un-normalized input — it does NOT see
+                # those mutations. Pull the cached normalized form
+                # via ``access`` (cache hit since ``core.apply`` just
+                # populated it) so ``self.schema`` reflects the post-
+                # divide structure for downstream consumers.
                 if had_structural_sentinels:
-                    self.schema = apply_schema
+                    self.schema = self.core.access(apply_schema)
 
                 if merges:
                     had_structural_changes = True
@@ -2742,7 +2769,7 @@ class Composite(Process):
                 self._merge_paths_pending = []
             else:
                 # Fallback: no path info available — full realize.
-                self.schema, self.state = self.core.realize(
+                self.schema, self.state, _ = self.core.realize(
                     self.schema, self.state)
             self._build_view_project_cache()
 
@@ -2761,7 +2788,7 @@ class Composite(Process):
                 # detected an in-process update with no _add/_remove/
                 # _divide sentinel). Full realize + rescan is correct
                 # here — we don't know which subtrees changed.
-                self.schema, self.state = self.core.realize(
+                self.schema, self.state, _ = self.core.realize(
                     self.schema, self.state)
                 self.find_instance_paths(self.state)
             self._build_view_project_cache()

{process_bigraph-1.2.2 → process_bigraph-1.3.0}/process_bigraph/processes/parameter_scan.py

@@ -78,7 +78,7 @@ class RunProcess(Step):
             'inputs': {},
             'outputs': {}}
 
-        self.process_schema, self.process = self.core.realize(
+        self.process_schema, self.process, _ = self.core.realize(
             'process', process_state)
         self.process_instance = self.process['instance']
 

{process_bigraph-1.2.2 → process_bigraph-1.3.0}/process_bigraph/types/process.py

@@ -315,7 +315,7 @@ def realize(core, schema: SharedProcess, state, path=()):
     # fields (Quantity, Function, custom types) get reconstructed.
     config_schema = getattr(cls, 'config_schema', None)
     if config_schema:
-        _, config = core.realize(config_schema, config)
+        _, config, _ = core.realize(config_schema, config)
 
     instance = cls(config)
 

{process_bigraph-1.2.2 → process_bigraph-1.3.0/process_bigraph.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: process-bigraph
-Version: 1.2.2
+Version: 1.3.0
 Summary: protocol and execution for compositional systems biology
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{process_bigraph-1.2.2 → process_bigraph-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "process-bigraph"
-version = "1.2.2"
+version = "1.3.0"
 description = "protocol and execution for compositional systems biology"
 readme = "README.md"
 requires-python = ">=3.11"