process-bigraph 0.0.22__tar.gz → 0.0.23__tar.gz

{process-bigraph-0.0.22/process_bigraph.egg-info → process-bigraph-0.0.23}/PKG-INFO

@@ -1,9 +1,12 @@
 Metadata-Version: 2.1
 Name: process-bigraph
-Version: 0.0.22
+Version: 0.0.23
+Summary: UNKNOWN
 Home-page: https://github.com/vivarium-collective/process-bigraph
 Author: Ryan Spangler, Eran Agmon
 Author-email: ryan.spangler@gmail.com, agmon.eran@gmail.com
+License: UNKNOWN
+Platform: UNKNOWN
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -70,3 +73,5 @@ diagraph of a whole-cell E. coli model.
 ## License
 
 Bigraph-schema is open-source software released under the [Apache 2 License](https://github.com/vivarium-collective/process-bigraph/blob/main/LICENSE).
+
+

process-bigraph-0.0.23/process_bigraph/__init__.py

@@ -0,0 +1,48 @@
+import pprint
+from bigraph_schema.registry import deep_merge, default
+from process_bigraph.processes import register_processes
+from process_bigraph.composite import Process, Step, Composite, ProcessTypes, interval_time_precision
+
+
+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('default 1', {
+        '_inherit': 'float',
+        '_default': 1.0})
+
+    core.register('species_dependent_process', {
+        '_inherit': ['process'],
+        '_inputs': {
+            'species': {
+                '_type': 'array',
+                '_data': 'float'}},
+        '_outputs': {
+            'species': {
+                '_type': 'array',
+                '_data': 'float'}}})
+
+    core.register('ode_config', {
+        'stoichiometry': {
+            '_type': 'array',
+            '_data': 'integer'},
+        'rates': 'map[float]',
+        'species': 'map[float]'})
+
+    core = register_processes(
+        core)
+
+    return core
+
+

{process-bigraph-0.0.22 → process-bigraph-0.0.23}/process_bigraph/composite.py

@@ -10,9 +10,8 @@ import math
 import collections
 from typing import Dict
 
-from bigraph_schema import Edge, TypeSystem, get_path, set_path, deep_merge, is_schema_key, strip_schema_keys, Registry, hierarchy_depth
+from bigraph_schema import Edge, TypeSystem, get_path, set_path, deep_merge, is_schema_key, strip_schema_keys, Registry, hierarchy_depth, visit_method
 
-from process_bigraph.process_types import process_types
 from process_bigraph.protocols import local_lookup, local_lookup_module
 
 
@@ -23,22 +22,227 @@ def assert_interface(interface: Dict):
     assert existing_keys == set(required_keys), f"every interface requires an inputs schema and an outputs schema, not {existing_keys}"
 
 
-def register_process_types(core: TypeSystem):
-    """Register process types with the core"""
-    for process_key, process_type in process_types.items():
-        core.register(process_key, process_type)
-    return core
+def apply_process(schema, current, update, core):
+    """Apply an update to a process."""
+    process_schema = schema.copy()
+    process_schema.pop('_apply')
+    return core.apply(
+        process_schema,
+        current,
+        update)
 
 
-def register_protocols(core: TypeSystem):
-    """Register protocols with the core"""
-    core.protocol_registry.register('local', local_lookup)
+def check_process(schema, state, core):
+    """Check if this is a process."""
+    return 'instance' in state and isinstance(
+        state['instance'],
+        Edge)
 
 
-def register_emitters(core: TypeSystem):
-    """Register emitters with the core"""
-    core.register_process('console-emitter', ConsoleEmitter)
-    core.register_process('ram-emitter', RAMEmitter)
+def fold_visit(schema, state, method, values, core):
+    visit = visit_method(
+        schema,
+        state,
+        method,
+        values,
+        core)
+
+    return visit
+
+
+def divide_process(schema, state, values, core):
+    # daughter_configs must have a config per daughter
+
+    daughter_configs = values.get(
+        'daughter_configs',
+        [{} for index in range(values['divisions'])])
+
+    if 'config' not in state:
+        return daughter_configs
+
+    existing_config = state['config']
+
+    divisions = []
+    for index in range(values['divisions']):
+        daughter_config = copy.deepcopy(
+            existing_config)
+        daughter_config = deep_merge(
+            daughter_config,
+            daughter_configs[index])
+
+        # TODO: provide a way to override inputs and outputs
+        daughter_state = {
+            'address': state['address'],
+            'config': daughter_config,
+            'inputs': copy.deepcopy(state['inputs']),
+            'outputs': copy.deepcopy(state['outputs'])}
+
+        if 'interval' in state:
+            daughter_state['interval'] = state['interval']
+
+        divisions.append(daughter_state)
+
+    return divisions
+
+
+def serialize_process(schema, value, core):
+    """Serialize a process to a JSON-safe representation."""
+    # TODO -- need to get back the protocol: address and the config
+    process = value.copy()
+    process['config'] = core.serialize(
+        process['instance'].config_schema,
+        process['config'])
+    del process['instance']
+    return process
+
+
+def deserialize_process(schema, encoded, core):
+    """Deserialize a process from a serialized state.
+
+    This function is used by the type system to deserialize a process.
+
+    :param encoded: A JSON-safe representation of the process.
+    :param bindings: The bindings to use for deserialization.
+    :param core: The type system to use for deserialization.
+
+    :returns: The deserialized state with an instantiated process.
+    """
+    encoded = encoded or {}
+    schema = schema or {}
+
+    if not encoded:
+        deserialized = core.default(schema)
+    else:
+        deserialized = encoded.copy()
+
+    if not deserialized.get('address'):
+        return deserialized
+
+    protocol, address = deserialized['address'].split(':', 1)
+
+    if 'instance' in deserialized:
+        instantiate = type(deserialized['instance'])
+    else:
+        process_lookup = core.protocol_registry.access(protocol)
+        if not process_lookup:
+            raise Exception(f'protocol "{protocol}" not implemented')
+
+        instantiate = process_lookup(core, address)
+        if not instantiate:
+            raise Exception(f'process "{address}" not found')
+
+    config = core.deserialize(
+        instantiate.config_schema,
+        deserialized.get('config', {}))
+
+    interval = core.deserialize(
+        'interval',
+        deserialized.get('interval'))
+
+    if interval is None:
+        interval = core.default(
+            schema.get(
+                'interval',
+                'interval'))
+
+    if not 'instance' in deserialized:
+        process = instantiate(
+            config,
+            core=core)
+
+        deserialized['instance'] = process
+
+    deserialized['config'] = config
+    deserialized['interval'] = interval
+    deserialized['_inputs'] = deserialized['instance'].inputs()
+    deserialized['_outputs'] = deserialized['instance'].outputs()
+
+    return deserialized
+
+
+def deserialize_step(schema, encoded, core):
+    if not encoded:
+        deserialized = core.default(schema)
+    else:
+        deserialized = encoded.copy()
+
+    if not deserialized['address']:
+        return deserialized
+
+    protocol, address = deserialized['address'].split(':', 1)
+
+    if 'instance' in deserialized:
+        instantiate = type(deserialized['instance'])
+    else:
+        process_lookup = core.protocol_registry.access(protocol)
+        if not process_lookup:
+            raise Exception(f'protocol "{protocol}" not implemented')
+
+        instantiate = process_lookup(core, address)
+        if not instantiate:
+            raise Exception(f'process "{address}" not found')
+
+    config = core.deserialize(
+        instantiate.config_schema,
+        deserialized.get('config', {}))
+
+    if not 'instance' in deserialized:
+        process = instantiate(config, core=core)
+        deserialized['instance'] = process
+
+    deserialized['config'] = config
+    deserialized['_inputs'] = deserialized['instance'].inputs()
+    deserialized['_outputs'] = deserialized['instance'].outputs()
+
+    return deserialized
+
+
+PROCESS_TYPES = {
+    'protocol': {
+        '_type': 'protocol',
+        '_inherit': 'string'},
+
+    'emitter_mode': 'enum[none,all,stores,bridge,paths,ports]',
+
+    'interval': {
+        '_type': 'interval',
+        '_inherit': 'float',
+        '_apply': 'set',
+        '_default': '1.0'},
+
+    'step': {
+        '_type': 'step',
+        '_inherit': 'edge',
+        '_apply': apply_process,
+        '_serialize': serialize_process,
+        '_deserialize': deserialize_step,
+        '_check': check_process,
+        '_fold': fold_visit,
+        '_divide': divide_process,
+        '_description': '',
+        # TODO: support reference to type parameters from other states
+        'address': 'protocol',
+        'config': 'quote'},
+
+    # TODO: slice process to allow for navigating through a port
+    'process': {
+        '_type': 'process',
+        '_inherit': 'edge',
+        '_apply': apply_process,
+        '_serialize': serialize_process,
+        '_deserialize': deserialize_process,
+        '_check': check_process,
+        '_fold': fold_visit,
+        '_divide': divide_process,
+        '_description': '',
+        # TODO: support reference to type parameters from other states
+        'interval': 'interval',
+        'address': 'protocol',
+        'config': 'quote'}}
+
+
+BASE_PROTOCOLS = {
+    'local': local_lookup}
 
 
 class ProcessTypes(TypeSystem):
@@ -53,13 +257,18 @@ class ProcessTypes(TypeSystem):
         self.process_registry = Registry()
         self.protocol_registry = Registry()
 
-        register_process_types(self)
-        register_protocols(self)
-        register_emitters(self)
+        self.register_types(PROCESS_TYPES)
+        self.register_protocols(BASE_PROTOCOLS)
+        self.register_processes(BASE_EMITTERS)
 
         self.register_process('composite', Composite)
 
 
+    def register_protocols(self, protocols):
+        """Register protocols with the core"""
+        self.protocol_registry.register_multiple(protocols)
+
+
     def register_process(
             self,
             name,
@@ -75,6 +284,13 @@ class ProcessTypes(TypeSystem):
         self.process_registry.register(name, process_data)
 
 
+    def register_processes(self, processes):
+        for process_key, process_data in processes.items():
+            self.register_process(
+                process_key,
+                process_data)
+
+
     def initialize_edge_state(self, schema, path, edge):
         """
         Initialize the state for an edge based on the schema and the edge.
@@ -181,10 +397,10 @@ class Process(Edge):
         if config is None:
             config = {}
 
-        # check that all keywords in config are in config_schema
-        for key in config.keys():
-            if key not in self.config_schema:
-                raise Exception(f'config key {key} not in config_schema for {self.__class__.__name__}')
+        # # check that all keywords in config are in config_schema
+        # for key in config.keys():
+        #     if key not in self.config_schema:
+        #         raise Exception(f'config key {key} not in config_schema for {self.__class__.__name__}')
 
         # fill in defaults for config
         self.config = self.core.fill(
@@ -339,7 +555,9 @@ def find_leaves(tree_structure, path=None):
     leaves = []
     path = ()
 
-    if isinstance(tree_structure, list):
+    if tree_structure is None:
+        pass
+    elif isinstance(tree_structure, list):
         leaves = tree_structure
     elif isinstance(tree_structure, tuple):
         leaves.append(tree_structure)
@@ -519,18 +737,18 @@ class Composite(Process):
         if 'global_time' not in initial_state:
             initial_state['global_time'] = 0.0
 
-        composition, state = self.core.complete(
+        self.composition, self.state = self.core.generate(
             initial_composition,
             initial_state)
 
-        self.composition = copy.deepcopy(
-            self.core.access(composition))
+        # self.composition = copy.deepcopy(
+        #     self.core.access(composition))
 
         # TODO: add flag to self.core.access(copy=True)
         self.bridge = self.config.get('bridge', {})
 
         self.find_instance_paths(
-            state)
+            self.state)
 
         # merge the processes and steps into a single "edges" dict
         self.edge_paths = self.process_paths.copy()
@@ -553,11 +771,13 @@ class Composite(Process):
                 raise Exception(
                     f'initial state from edge does not match initial state from other edges:\n{path}\n{edge}\n{edge_state}')
 
-        state = deep_merge(state, edge_state)
+        self.state = deep_merge(
+            self.state,
+            edge_state)
 
-        self.state = self.core.deserialize(
-            self.composition,
-            state)
+        # self.state = self.core.deserialize(
+        #     self.composition,
+        #     self.state)
 
         # TODO: call validate on this composite, not just check
         # assert self.core.validate(
@@ -603,6 +823,7 @@ class Composite(Process):
 
         # self.run_steps(self.to_run)
 
+
     def save(self,
              filename='composite.json',
              outdir='out',
@@ -729,7 +950,11 @@ class Composite(Process):
         step_config = self.read_emitter_config(emitter_config)
         emitter = set_path(
             {}, path, step_config)
-        self.merge(emitter)
+
+        self.merge(
+            {},
+            emitter)
+
         _, instance = self.core.slice(
             self.composition,
             self.state,
@@ -739,19 +964,14 @@ class Composite(Process):
         self.step_paths[path] = instance
 
 
-    # TODO: merge needs to be schema aware,
-    #   and since the results of the merge may
-    #   entail a schema update, we need to return
-    #   the new schema
-    def merge(self, initial_state):
-        self.state = self.core.merge(
+    def merge(self, schema, state, path=None):
+        path = path or []
+        self.composition, self.state = self.core.merge(
             self.composition,
             self.state,
-            initial_state)
-
-        self.composition, self.state = self.core.complete(
-            self.composition,
-            self.state)
+            path,
+            schema,
+            state)
 
 
     def process_update(
@@ -1001,23 +1221,23 @@ class Composite(Process):
                 force_complete = False
 
 
-    def determine_steps(self):
-        to_run = []
-        for step_key, wires in trigger_state['steps']:
-            fulfilled = True
-            for input in wires['input_paths']:
-                if len(trigger_state['states'][tuple(input)]) > 0:
-                    fulfilled = False
-                    break
-            if fulfilled:
-                to_run.append(step_key)
+    # def determine_steps(self):
+    #     to_run = []
+    #     for step_key, wires in trigger_state['steps']:
+    #         fulfilled = True
+    #         for input in wires['input_paths']:
+    #             if len(trigger_state['states'][tuple(input)]) > 0:
+    #                 fulfilled = False
+    #                 break
+    #         if fulfilled:
+    #             to_run.append(step_key)
 
-        for step_key in to_run:
-            wires = trigger_state['steps'][step_key]
-            for output in wires['output_paths']:
-                trigger_state['states'][tuple(output)].remove(step_key)
+    #     for step_key in to_run:
+    #         wires = trigger_state['steps'][step_key]
+    #         for output in wires['output_paths']:
+    #             trigger_state['states'][tuple(output)].remove(step_key)
 
-        return to_run, trigger_state
+    #     return to_run, trigger_state
 
 
     def run_steps(self, step_paths):
@@ -1106,6 +1326,7 @@ class Composite(Process):
             state)
 
         self.merge(
+            {},
             projection)
 
         self.run(interval)
@@ -1183,6 +1404,11 @@ class RAMEmitter(Emitter):
         return result
 
 
+BASE_EMITTERS = {
+    'console-emitter': ConsoleEmitter,
+    'ram-emitter': RAMEmitter}
+
+
 # def StateEmitter(Emitter):
 
 

{process-bigraph-0.0.22 → process-bigraph-0.0.23}/process_bigraph/experiments/growth_division.py

@@ -1,5 +1,5 @@
 import pytest
-from process_bigraph import Step, Process, Composite, ProcessTypes, interval_time_precision, deep_merge
+from process_bigraph.composite import Step, Process, Composite, ProcessTypes, interval_time_precision, deep_merge
 
 
 class Grow(Process):
@@ -92,6 +92,7 @@ def generate_bridge(schema, state, interval=1.0):
         for port in ['inputs', 'outputs']}
 
     config = {
+        '_type': 'quote',
         'state': state,
         'bridge': bridge}
 
@@ -160,7 +161,7 @@ def grow_divide_agent(config=None, state=None, path=None):
         state)
 
     composite = generate_bridge({
-        'inputs': {},
+        'inputs': {'mass': ['mass']},
         'outputs': agent_schema},
         grow_divide_state)
 
@@ -170,39 +171,3 @@ def grow_divide_agent(config=None, state=None, path=None):
     return composite
 
 
-def test_grow_divide(core):
-    initial_mass = 1.0
-
-    grow_divide = grow_divide_agent(
-        {'grow': {'rate': 0.03}},
-        {'mass': initial_mass},
-        ['environment', '0'])
-
-    environment = {
-        'environment': {
-            '0': {
-                'mass': initial_mass,
-                'grow_divide': grow_divide}}}
-
-    composite = Composite({
-        'state': environment},
-        core=core)
-
-    updates = composite.update({}, 100.0)
-    assert '0_0_0_0_0' in composite.state['environment']
-
-
-@pytest.fixture
-def core():
-    core = ProcessTypes()
-    core.register_process('grow', Grow)
-    core.register_process('divide', Divide)
-    return core
-
-
-if __name__ == '__main__':
-    core = ProcessTypes()
-    core.register_process('grow', Grow)
-    core.register_process('divide', Divide)
-
-    test_grow_divide(core)