process-bigraph 0.0.51__tar.gz → 1.0.2__tar.gz

{process_bigraph-0.0.51/process_bigraph.egg-info → process_bigraph-1.0.2}/PKG-INFO

@@ -1,17 +1,15 @@
 Metadata-Version: 2.4
 Name: process-bigraph
-Version: 0.0.51
+Version: 1.0.2
 Summary: protocol and execution for compositional systems biology
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: AUTHORS.md
 Requires-Dist: bigraph-schema
-Requires-Dist: docker>=7.1.0
 Requires-Dist: ipdb>=0.13.13
 Requires-Dist: matplotlib
 Requires-Dist: pint>=0.24.4
-Requires-Dist: pytest
 Dynamic: license-file
 
 # Process-Bigraph

process_bigraph-1.0.2/process_bigraph/__init__.py

@@ -0,0 +1,36 @@
+from bigraph_schema import allocate_core
+
+from process_bigraph.composite import Process, Step, Composite, interval_time_precision
+from process_bigraph.emitter import Emitter, gather_emitter_results, generate_emitter_state
+from process_bigraph.types import StepLink, ProcessLink, CompositeLink
+
+
+import pprint
+pretty = pprint.PrettyPrinter(indent=2)
+
+def pp(x):
+    """Print ``x`` in a pretty format."""
+    pretty.pprint(x)
+
+def pf(x):
+    """Format ``x`` for display."""
+    return pretty.pformat(x)
+
+
+def register_types(core):
+    core.register_type('interval', {
+        '_inherit': 'float'})
+
+    core.register_type('default 1', {
+        '_inherit': 'float',
+        '_default': 1.0})
+
+    core.register_type('ode_config', {
+        'stoichiometry': {
+            '_type': 'array',
+            '_data': 'int64'},
+        'rates': 'map[float]',
+        'species': 'map[float]'})
+
+    return core
+

{process_bigraph-0.0.51 → process_bigraph-1.0.2}/process_bigraph/composite.py

@@ -24,8 +24,8 @@ from typing import (
 import collections
 
 from bigraph_schema import (
-    Edge, Registry, TypeSystem, visit_method,
-    get_path, set_path, resolve_path, hierarchy_depth, deep_merge,
+    Edge,
+    get_path, set_path, resolve_path, hierarchy_depth,
     is_schema_key, strip_schema_keys)
 
 from bigraph_schema.protocols import local_lookup_module
@@ -120,6 +120,8 @@ def find_step_triggers(
 
     for wire in wire_paths:
         trigger_path = resolve_path(prefix + tuple(wire))
+        if isinstance(trigger_path, list):
+            import ipdb; ipdb.set_trace()
         triggers.setdefault(trigger_path, []).append(path)
 
     return triggers
@@ -404,7 +406,7 @@ class Open(Edge):
         'initial_state', 'inputs', 'outputs', 'update')
 
     ATTRIBUTE_READ_COMMANDS = (
-        'config', 'composition', 'state')
+        'config', 'schema', 'state')
 
 
     def __init__(self, config=None, core=None):
@@ -678,7 +680,7 @@ def as_step(inputs, outputs, core=None):
         FunctionStep.__name__ = step_name + 'Step'
 
         if core is not None:
-            core.register_process(step_name, FunctionStep)
+            core.register_link(step_name, FunctionStep)
 
         return FunctionStep
 
@@ -710,7 +712,7 @@ def as_process(inputs, outputs, core=None):
         FunctionProcess.__name__ = process_name + 'Process'
 
         if core is not None:
-            core.register_process(process_name, FunctionProcess)
+            core.register_link(process_name, FunctionProcess)
 
         return FunctionProcess
 
@@ -748,13 +750,13 @@ class ProcessEnsemble(Process):
                 inputs_func = getattr(self, attr_name)
                 if callable(inputs_func):
                     inputs = inputs_func()
-                    union_inputs = self.core.resolve_schemas(union_inputs, inputs)
+                    union_inputs = self.core.resolve(union_inputs, inputs)
 
             if attr_name.startswith('outputs_'):
                 outputs_func = getattr(self, attr_name)
                 if callable(outputs_func):
                     outputs = outputs_func()
-                    union_outputs = self.core.resolve_schemas(union_outputs, outputs)
+                    union_outputs = self.core.resolve(union_outputs, outputs)
 
         return {
             'inputs': union_inputs,
@@ -836,8 +838,8 @@ class Composite(Process):
     """
 
     config_schema = {
-        'composition': 'schema',
-        'state': 'tree[any]',
+        'schema': 'schema',
+        'state': 'tree[node]',
         'interface': {
             'inputs': 'schema',
             'outputs': 'schema'
@@ -860,7 +862,7 @@ class Composite(Process):
 
         This method:
         - Adds `global_time` to schema/state if missing
-        - Generates the full composition/state tree
+        - Generates the full schema/state tree
         - Finds all step/process instances
         - Resolves the schema bridge
         - Prepares the step execution network
@@ -870,12 +872,12 @@ class Composite(Process):
             config: Optional override configuration (usually not needed).
         """
 
-        # Get the initial composition schema from config.
-        initial_composition = self.config.get('composition', {})
+        # Get the initial schema schema from config.
+        initial_schema = self.config.get('schema', {})
 
         # Ensure 'global_time' is explicitly declared in the schema.
-        if 'global_time' not in initial_composition:
-            initial_composition['global_time'] = 'float'
+        if 'global_time' not in initial_schema:
+            initial_schema['global_time'] = 'float'
 
         # Get the initial state from config.
         initial_state = self.config.get('state', {})
@@ -885,8 +887,9 @@ class Composite(Process):
             initial_state['global_time'] = 0.0
 
         # Generate internal schema and state structures using the core engine.
-        self.composition, self.state = self.core.generate(
-            initial_composition,
+        # self.schema, self.state = self.core.generate(
+        self.schema, self.state = self.core.realize(
+            initial_schema,
             initial_state)
 
         # Load the bridge configuration, which defines how inputs/outputs connect to the world.
@@ -902,29 +905,39 @@ class Composite(Process):
         self.edge_paths = {**self.process_paths, **self.step_paths}
 
         # Initialize each process/step's state and accumulate it into a unified state tree.
-        edge_state: Dict[str, Any] = {}
+        edge_schema = {}
+        edge_state = {}
         for path, edge in self.edge_paths.items():
             # Generate the initial state for this specific edge (process or step).
-            initial = self.core.initialize_edge_state(
-                self.composition,
-                path,
-                edge)
+            initial_schema, initial_state = self.core.link_state(
+                edge,
+                path)
 
             # Merge the new edge state with the global state tree, checking for conflicts.
             try:
-                edge_state = deep_merge(edge_state, initial)
-            except Exception:
+                edge_schema, edge_state = self.core.combine(
+                    edge_schema, edge_state,
+                    initial_schema, initial_state)
+
+            except Exception as e:
                 raise Exception(
                     f'initial state from edge does not match initial state from other edges:\n'
                     f'{path}\n{edge}\n{edge_state}'
+                    f'{e.message}'
                 )
 
         # Apply the merged edge_state into the global state and update instance paths.
-        self.merge(self.composition, edge_state)
+        if edge_state:
+            self.schema, self.state = self.core.combine(
+                edge_schema, edge_state,
+                self.schema, self.state)
 
         # Wire the input/output schema for the Composite from the bridge config.
         self.process_schema = {
-            port: self.core.wire_schema(self.composition, self.bridge[port])
+            port: self.core.wire_schema(
+                self.schema,
+                self.state,
+                self.bridge[port])
             for port in ['inputs', 'outputs']
         }
 
@@ -952,7 +965,7 @@ class Composite(Process):
         Load a Composite from a saved JSON file.
 
         Args:
-            path: Path to the saved composition file.
+            path: Path to the saved schema file.
             core: Optional core context providing deserialization.
 
         Returns:
@@ -960,8 +973,6 @@ class Composite(Process):
         """
         with open(path) as data:
             document = json.load(data)
-            composition = document['composition']
-            document['composition'] = core.deserialize('schema', composition)
             return cls(document, core=core)
           
     def clean_front(self, state):
@@ -976,7 +987,13 @@ class Composite(Process):
             - self.step_paths
         """
         self.process_paths = find_instance_paths(state, 'process_bigraph.composite.Process')
-        self.step_paths = find_instance_paths(state, 'process_bigraph.composite.Step')
+        if hasattr(self, 'step_paths'):
+            previous_step_paths = self.step_paths.keys()
+            self.step_paths = find_instance_paths(state, 'process_bigraph.composite.Step')
+            if previous_step_paths != self.step_paths.keys():
+                self.build_step_network()
+        else:
+            self.step_paths = find_instance_paths(state, 'process_bigraph.composite.Step')
 
         all_paths = set(
             list(self.process_paths.keys()) +
@@ -999,12 +1016,13 @@ class Composite(Process):
             path: Path where merge should occur (default: root).
         """
         path = path or []
-        self.composition, self.state = self.core.merge(
-            self.composition,
+        # self.schema, self.state = self.core.merge(
+        self.schema, self.state = self.core.combine(
+            self.schema,
             self.state,
-            path,
             schema,
             state)
+
         self.find_instance_paths(self.state)
 
     def merge_schema(
@@ -1025,10 +1043,10 @@ class Composite(Process):
         scoped_schema = set_path({}, path, schema)
 
         # Merge it into the existing schema
-        self.composition = self.core.merge_schemas(self.composition, scoped_schema)
+        self.schema = self.core.merge(self.schema, scoped_schema)
 
         # Re-generate state based on the new schema structure
-        self.composition, self.state = self.core.generate(self.composition, self.state)
+        self.schema, self.state = self.core.generate(self.schema, self.state)
 
         # Re-scan the state tree for processes and steps
         self.find_instance_paths(self.state)
@@ -1043,7 +1061,7 @@ class Composite(Process):
         """
         path = path or []
         scoped_update = set_path({}, path, update)
-        self.state = self.core.apply(self.composition, self.state, scoped_update)
+        self.state = self.core.apply(self.schema, self.state, scoped_update)
         self.find_instance_paths(self.state)
 
 
@@ -1058,16 +1076,17 @@ class Composite(Process):
         Returns:
             A serialized representation of the current state.
         """
-        return self.core.serialize(self.composition, self.state)
+        return self.core.serialize(self.schema, self.state)
 
     def serialize_schema(self) -> Dict[str, Any]:
         """
-        Serialize the composition (schema) using the core serializer.
+        Serialize the schema (schema) using the core serializer.
 
         Returns:
             A serialized schema representation.
         """
-        return self.core.serialize('schema', self.composition)
+        return self.core.render(self.schema)
+        # return self.core.serialize('schema', self.schema)
 
     def save(
             self,
@@ -1092,7 +1111,7 @@ class Composite(Process):
         if state:
             document['state'] = self.serialize_state()
         if schema:
-            document['composition'] = self.serialize_schema()
+            document['schema'] = self.serialize_schema()
 
         os.makedirs(outdir, exist_ok=True)
         filepath = os.path.join(outdir, filename)
@@ -1128,13 +1147,15 @@ class Composite(Process):
         """
         state = state or self.state
 
-        bridge_view = self.core.view(
-            self.interface()['outputs'],
-            self.bridge['outputs'],
+        # if 'environment' in state and '_add' in state['environment']:
+        #     import ipdb; ipdb.set_trace()
+
+        bridge_view = self.core.view_ports(
+            self.schema,
+            state,
             (),
-            top_schema=self.composition,
-            top_state=state
-        )
+            self.interface()['outputs'],
+            self.bridge['outputs'])
 
         return bridge_view
 
@@ -1268,14 +1289,13 @@ class Composite(Process):
 
             for step_path in step_paths:
                 step = get_path(self.state, step_path)
-                state = self.core.view_edge(
-                    self.composition, self.state, step_path, 'inputs'
-                )
+                state = self.core.view(
+                    self.schema, self.state, step_path, 'inputs')
 
                 # Steps are always invoked with interval = -1.0
                 step_update = self.process_update(
-                    step_path, step, state, -1.0, 'outputs'
-                )
+                    step_path, step, state, -1.0, 'outputs')
+
                 updates.append(step_update)
 
             update_paths = self.apply_updates(updates)
@@ -1364,7 +1384,7 @@ class Composite(Process):
         and captures its update as a deferred computation.
 
         Args:
-            path: The path to the process in the state/composition tree.
+            path: The path to the process in the state/schema tree.
             process: The dictionary representing the process (must contain 'interval').
             end_time: The simulation time to run up to.
             full_step: The current smallest time step among all processes.
@@ -1387,7 +1407,10 @@ class Composite(Process):
                 state = future_front['state']
             else:
                 # Otherwise, slice the current state for the process
-                state = self.core.view_edge(self.composition, self.state, path)
+                state = self.core.view(
+                    self.schema,
+                    self.state,
+                    path)
                 process_interval = process['interval']
 
             # Determine the target time for the next update
@@ -1437,7 +1460,7 @@ class Composite(Process):
         into absolute state terms until `.get()` is called on the returned `Defer` object.
 
         Args:
-            path: The path to the process in the state/composition tree.
+            path: The path to the process in the state/schema tree.
             process: The dictionary representing the process instance (must include 'instance').
             states: The current state values at the process’s ports.
             interval: The time interval to simulate.
@@ -1451,14 +1474,22 @@ class Composite(Process):
 
         # Invoke the process and retrieve a wrapped SyncUpdate object
         update = process['instance'].invoke(clean_state, interval)
-
         # This nested function projects the update into the global state at the given path
-        def defer_project(update_result: Any, args: Tuple[Any, Any, Union[str, Tuple[str, ...]]]) -> Any:
+        def defer_project(update_results: Any, args: Tuple[Any, Any, Union[str, Tuple[str, ...]]]) -> Any:
             schema, state, process_path = args
-            return self.core.project_edge(schema, state, process_path, update_result, ports_key)
+
+            if not isinstance(update_results, list):
+                update_results = [update_results]
+
+            return [self.core.project(
+                schema,
+                state,
+                process_path,
+                update_result,
+                ports_key) for update_result in update_results]
 
         # Return a deferred object that will project the update when requested
-        return Defer(update, defer_project, (self.composition, self.state, path))
+        return Defer(update, defer_project, (self.schema, self.state, path))
 
     def apply_updates(self, updates: List["Defer"]) -> List[Union[str, Tuple[str, ...]]]:
         """
@@ -1484,22 +1515,33 @@ class Composite(Process):
             if not isinstance(series, list):
                 series = [series]
 
-            for update in series:
+            for update_schema, update_state in series:
                 # if update and isinstance(update, dict) and 'environment' in update and update['environment'] and isinstance(update['environment'], dict) and '_react' in update['environment']:
                 #     import ipdb; ipdb.set_trace()
 
                 # Extract all hierarchical paths touched by this update
-                paths = hierarchy_depth(update)
+                paths = hierarchy_depth(update_state)
                 update_paths.extend(paths.keys())
 
-                # Apply update directly to the internal state
-                self.state = self.core.apply_update(self.composition, self.state, update)
+                # Apply update directly to the internal state,
+                # using the schema from the link itself
+                self.state, merges = self.core.apply(
+                    update_schema,
+                    self.state,
+                    update_state)
+
+                self.schema = self.core.resolve_merges(
+                    self.schema,
+                    merges)
 
                 # Read updated bridge outputs, if available
-                bridge_update = self.read_bridge(update)
+                bridge_update = self.read_bridge(update_state)
                 if bridge_update:
                     self.bridge_updates.append(bridge_update)
 
+        self.schema, self.state = self.core.realize(self.schema, self.state)
+
+        # TODO: are we doing this twice?
         # Refresh process and step instance paths
         self.find_instance_paths(self.state)
 
@@ -1549,17 +1591,19 @@ class Composite(Process):
         Returns:
             A list of updates generated for the bridge outputs.
         """
-        projection = self.core.project(
+        project_schema, project_state = self.core.project_ports(
             self.interface()['inputs'],
             self.bridge['inputs'],
             [],
-            state
-        )
+            state)
+        self.merge({}, project_state)
 
-        self.merge({}, projection)
-        self.run(interval)
+        # first_update = self.read_bridge(
+        #     self.state)
+        # self.bridge_updates = [first_update]
 
-        updates = self.bridge_updates
         self.bridge_updates = []
 
-        return updates
+        self.run(interval)
+
+        return self.bridge_updates