process-bigraph 0.0.17__tar.gz → 0.0.18__tar.gz

{process-bigraph-0.0.17/process_bigraph.egg-info → process-bigraph-0.0.18}/PKG-INFO

@@ -1,9 +1,12 @@
 Metadata-Version: 2.1
 Name: process-bigraph
-Version: 0.0.17
+Version: 0.0.18
+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.17 → process-bigraph-0.0.18}/process_bigraph/composite.py

@@ -7,12 +7,13 @@ Composite, Process, and Step classes
 import abc
 import copy
 import math
+import types
 import collections
 from typing import Dict
 
 
 from bigraph_schema import Edge, TypeSystem, get_path, establish_path, set_path, deep_merge
-from bigraph_schema.registry import Registry, validate_merge
+from bigraph_schema.registry import Registry, validate_merge, visit_method
 
 from process_bigraph.protocols import local_lookup, local_lookup_module
 
@@ -33,8 +34,50 @@ def check_process(schema, state, core):
         Edge)
 
 
-def divide_process(schema, value, core):
-    return value
+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):
@@ -70,8 +113,8 @@ def deserialize_process(schema, encoded, core):
     :returns: The deserialized state with an instantiated process.
     """
     deserialized = encoded.copy()
-    if 'address' not in encoded:
-        import ipdb; ipdb.set_trace()
+    if 'address' not in deserialized:
+        return deserialized
 
     protocol, address = encoded['address'].split(':', 1)
 
@@ -154,6 +197,7 @@ process_types = {
         '_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
@@ -167,11 +211,13 @@ process_types = {
         '_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': 'tree[any]'},
 }
 
 
@@ -187,8 +233,8 @@ def register_protocols(core):
 
 
 def register_emitters(core):
-    core.process_registry.register('console-emitter', ConsoleEmitter)
-    core.process_registry.register('ram-emitter', RAMEmitter)
+    core.register_process('console-emitter', ConsoleEmitter)
+    core.register_process('ram-emitter', RAMEmitter)
 
 
 class ProcessTypes(TypeSystem):
@@ -201,8 +247,10 @@ class ProcessTypes(TypeSystem):
         register_protocols(self)
         register_emitters(self)
 
+        self.register_process('composite', Composite)
 
-    def register_process(name, process_data):
+
+    def register_process(self, name, process_data):
         self.process_registry.register(name, process_data)
 
 
@@ -227,19 +275,20 @@ class ProcessTypes(TypeSystem):
                     key: value
                     for key, value in state.items()
                     if key.startswith('_')}
+
                 state_schema = self.access(
                     state_type)
 
-                hydrated_state = self.deserialize(state_schema, state)
-                top_state = set_path(
-                    top_state,
-                    path,
-                    hydrated_state)
+                hydrated_state = self.deserialize(
+                    state_schema,
+                    state)
 
-                schema = set_path(
+                schema, top_state = self.set_slice(
                     schema,
+                    top_state,
                     path,
-                    state_schema)
+                    state_schema,
+                    hydrated_state)
 
                 # TODO: fix is_descendant
                 # if core.type_registry.is_descendant('process', state_schema) or core.registry.is_descendant('step', state_schema):
@@ -252,13 +301,6 @@ class ProcessTypes(TypeSystem):
                         subschema = port_schema.get(
                             port_key, {})
 
-                        # _, schema = self.set_slice(
-                        #     'schema',
-                        #     schema,
-                        #     path + (f'_{port_key}',),
-                        #     'schema',
-                        #     subschema)
-
                         schema = set_path(
                             schema,
                             path + (f'_{port_key}',),
@@ -272,7 +314,7 @@ class ProcessTypes(TypeSystem):
                             hydrated_state,
                             ports,
                             top_schema=schema,
-                            path=path[:-1])
+                            path=path)
 
             elif '_type' in schema:
                 hydrated_state = self.deserialize(schema, state)
@@ -295,21 +337,11 @@ class ProcessTypes(TypeSystem):
             pass
 
         else:
-            type_schema = TYPE_SCHEMAS.get(str(type(state)), schema)
-
-            peer = get_path(schema, path)
-            destination = establish_path(
-                peer,
-                path[:-1],
-                top=schema,
-                cursor=path[:-1])
-
-            path_key = path[-1]
-            if path_key in destination:
-                # TODO: validate
-                pass
-            else:
-                destination[path_key] = type_schema
+            schema, top_state = super().infer_schema(
+                schema,
+                state,
+                top_state,
+                path)
 
         return schema, top_state
 
@@ -333,23 +365,32 @@ class ProcessTypes(TypeSystem):
 
     def initialize_edge_state(self, schema, path, edge):
         initial_state = edge['instance'].initial_state()
+        if not initial_state:
+            return initial_state
+
         input_ports = get_path(schema, path + ('_inputs',))
         output_ports = get_path(schema, path + ('_outputs',))
-        ports = {'_inputs': input_ports, '_outputs': output_ports}
-
-        input_state = self.project_edge(
-            ports,
-            edge,
-            path[:-1],
-            initial_state,
-            ports_key='inputs')
-
-        output_state = self.project_edge(
-            ports,
-            edge,
-            path[:-1],
-            initial_state,
-            ports_key='outputs')
+        ports = {
+            '_inputs': input_ports,
+            '_outputs': output_ports}
+
+        input_state = {}
+        if input_ports:
+            input_state = self.project_edge(
+                ports,
+                edge,
+                path[:-1],
+                initial_state,
+                ports_key='inputs')
+
+        output_state = {}
+        if output_ports:
+            output_state = self.project_edge(
+                ports,
+                edge,
+                path[:-1],
+                initial_state,
+                ports_key='outputs')
 
         state = deep_merge(input_state, output_state)
 
@@ -362,6 +403,7 @@ class ProcessTypes(TypeSystem):
         if protocol == 'local':
             self.lookup_local(config)
 
+
 def hierarchy_depth(hierarchy, path=()):
     """
     Create a mapping of every path in the hierarchy to the node living at
@@ -372,7 +414,9 @@ def hierarchy_depth(hierarchy, path=()):
 
     for key, inner in hierarchy.items():
         down = tuple(path + (key,))
-        if isinstance(inner, dict) and 'instance' not in inner:
+        if key.startswith('_'):
+            base[path] = inner
+        elif isinstance(inner, dict) and 'instance' not in inner:
             base.update(hierarchy_depth(inner, down))
         else:
             base[down] = inner
@@ -524,19 +568,19 @@ def find_instances(state, instance_type='process_bigraph.composite.Process'):
     found = {}
 
     for key, inner in state.items():
-        if isinstance(inner, dict) and isinstance(inner.get('instance'), process_class):
-            found[key] = inner
+        if isinstance(inner, dict):
+            if isinstance(inner.get('instance'), process_class):
+                found[key] = inner
+            elif not key.startswith('_'):
+                inner_instances = find_instances(
+                    inner,
+                    instance_type=instance_type)
+
+                if inner_instances:
+                    found[key] = inner_instances
     return found
 
 
-def find_processes(state):
-    return find_instances(state, 'process_bigraph.composite.Process')
-
-
-def find_steps(state):
-    return find_instances(state, 'process_bigraph.composite.Step')
-
-
 def find_instance_paths(state, instance_type='process_bigraph.composite.Process'):
     instances = find_instances(state, instance_type)
     return hierarchy_depth(instances)
@@ -745,7 +789,7 @@ class Composite(Process):
     config_schema = {
         'composition': 'schema',
         'state': 'tree[any]',
-        'schema': {
+        'interface': {
             'inputs': 'schema',
             'outputs': 'schema'},
         'bridge': {
@@ -775,22 +819,10 @@ class Composite(Process):
             self.core.access(composition))
 
         # TODO: add flag to self.core.access(copy=True)
-        initial_schema = self.core.access(
-            self.config.get('schema', {})) or {}
         self.bridge = self.config.get('bridge', {})
 
-        # find all processes, steps, and emitter in the state
-        self.process_paths = find_instance_paths(
-            state,
-            'process_bigraph.composite.Process')
-
-        self.step_paths = find_instance_paths(
-            state,
-            'process_bigraph.composite.Step')
-
-        self.emitter_paths = find_instance_paths(
-            state,
-            'process_bigraph.composite.Emitter')
+        self.find_instance_paths(
+            state)
 
         # merge the processes and steps into a single "edges" dict
         self.edge_paths = self.process_paths.copy()
@@ -808,7 +840,7 @@ class Composite(Process):
                 edge)
 
             try:
-                edge_state = validate_merge(state, edge_state, initial)
+                edge_state = deep_merge(edge_state, initial)
             except:
                 raise Exception(
                     f'initial state from edge does not match initial state from other edges:\n{path}\n{edge}\n{edge_state}')
@@ -875,8 +907,27 @@ class Composite(Process):
         return to_run
 
 
-    def interface(self):
-        return self.process_schema
+    def find_instance_paths(self, state):
+        # find all processes, steps, and emitter in the state
+        self.process_paths = find_instance_paths(
+            state,
+            'process_bigraph.composite.Process')
+
+        self.step_paths = find_instance_paths(
+            state,
+            'process_bigraph.composite.Step')
+
+        self.emitter_paths = find_instance_paths(
+            state,
+            'process_bigraph.composite.Emitter')
+
+
+    def inputs(self):
+        return self.process_schema.get('inputs', {})
+
+
+    def outputs(self):
+        return self.process_schema.get('outputs', {})
 
 
     def merge(self, initial_state):
@@ -1030,6 +1081,34 @@ class Composite(Process):
         #     self.state.build_topology_views()
 
 
+    def expire_process_paths(self, update_paths):
+        for update_path in update_paths:
+            for process_path in self.process_paths.copy():
+                updated = all([
+                    update == process
+                    for update, process in zip(update_path, process_path)])
+
+                if updated:
+                    self.find_instance_paths(
+                        self.state)
+                    return
+
+                    # del self.process_paths[process_path]
+
+                    # target_schema, target_state = self.core.slice(
+                    #     self.composition,
+                    #     self.state,
+                    #     update_path)
+
+                    # process_subpaths = find_instance_paths(
+                    #     target_state,
+                    #     'process_bigraph.composite.Process')
+
+                    # for subpath, process in process_subpaths.items():
+                    #     process_path = update_path + subpath
+                    #     self.process_paths[process_path] = process
+
+
     def run(self, interval, force_complete=False):
         if self.to_run:
             self.run_steps(self.to_run)
@@ -1076,6 +1155,7 @@ class Composite(Process):
                 # get all update paths, then trigger steps that
                 # depend on those paths
                 update_paths = self.apply_updates(updates)
+                self.expire_process_paths(update_paths)
                 self.trigger_steps(update_paths)
 
                 # # display and emit
@@ -1204,11 +1284,6 @@ class Composite(Process):
         self.merge(
             projection)
 
-        # self.state = self.core.set(
-        #     self.composition,
-        #     self.state,
-        #     projection)
-
         self.run(interval)
 
         updates = self.bridge_updates

process-bigraph-0.0.18/process_bigraph/experiments/growth_division.py

@@ -0,0 +1,207 @@
+import pytest
+from process_bigraph import Step, Process, Composite, ProcessTypes, interval_time_precision, deep_merge
+
+
+class Grow(Process):
+    config_schema = {
+        'rate': 'float'}
+
+
+    def __init__(self, config, core=None):
+        super().__init__(config, core)
+
+
+    def inputs(self):
+        return {
+            'mass': 'float'}
+
+
+    def outputs(self):
+        return {
+            'mass': 'float'}
+
+
+    def update(self, state, interval):
+        # this calculates a delta
+
+        return {
+            'mass': state['mass'] * self.config['rate'] * interval}
+
+
+# TODO: build composite and divide within it
+
+class Divide(Step):
+    # assume the agent_schema has the right divide methods present
+    config_schema = {
+        'agent_id': 'string',
+        'agent_schema': 'schema',
+        'threshold': 'float',
+        'divisions': {
+            '_type': 'integer',
+            '_default': 2}}
+
+
+    def __init__(self, config, core=None):
+        super().__init__(config, core)
+
+
+    def inputs(self):
+        return {
+            'trigger': 'float'}
+
+
+    def outputs(self):
+        return {
+            'environment': {
+                '_type': 'map',
+                '_value': self.config['agent_schema']}}
+
+
+    # this should be generalized to some function that depends on
+    # state from the self.config['agent_schema'] (instead of trigger > threshold)
+    def update(self, state):
+        if state['trigger'] > self.config['threshold']:
+            mother = self.config['agent_id']
+            daughters = [(
+                f'{mother}_{i}', {
+                    'state': {
+                        'divide': {
+                            'config': {
+                                'agent_id': f'{mother}_{i}'}}}})
+                for i in range(self.config['divisions'])]
+
+            # return divide reaction
+            return {
+                'environment': {
+                    '_react': {
+                        'divide': {
+                            'mother': mother,
+                            'daughters': daughters}}}}
+
+
+def generate_bridge_wires(schema):
+    return {
+        key: [key]
+        for key in schema
+        if not key.startswith('_')}
+
+
+def generate_bridge(schema, state, interval=1.0):
+    bridge = {
+        port: generate_bridge_wires(schema[port])
+        for port in ['inputs', 'outputs']}
+
+    config = {
+        'state': state,
+        'bridge': bridge}
+
+    composite = {
+        '_type': 'process',
+        'address': 'local:composite',
+        'interval': interval,
+        'config': config,
+        'inputs': generate_bridge_wires(schema['inputs']),
+        'outputs': generate_bridge_wires(schema['outputs'])}
+
+    return composite
+
+
+def grow_divide_agent(config=None, state=None, path=None):
+    agent_id = path[-1]
+
+    config = config or {}
+    state = state or {}
+    path = path or []
+
+    agent_schema = config.get(
+        'agent_schema',
+        {'mass': 'float'})
+
+    grow_config = {
+        'rate': 0.1}
+
+    grow_config = deep_merge(
+        grow_config,
+        config.get(
+            'grow'))
+
+    divide_config = {
+        'agent_id': agent_id,
+        'agent_schema': agent_schema,
+        'threshold': 2.0,
+        'divisions': 2}
+
+    divide_config = deep_merge(
+        divide_config,
+        config.get(
+            'divide'))
+
+    grow_divide_state = {
+        'grow': {
+            '_type': 'process',
+            'address': 'local:grow',
+            'config': grow_config,
+            'inputs': {
+                'mass': ['mass']},
+            'outputs': {
+                'mass': ['mass']}},
+
+        'divide': {
+            '_type': 'process',
+            'address': 'local:divide',
+            'config': divide_config,
+            'inputs': {
+                'trigger': ['mass']},
+            'outputs': {
+                'environment': ['environment']}}}
+
+    grow_divide_state = deep_merge(
+        grow_divide_state,
+        state)
+
+    composite = generate_bridge({
+        'inputs': {},
+        'outputs': agent_schema},
+        grow_divide_state)
+
+    composite['config']['bridge']['outputs']['environment'] = ['environment']
+    composite['outputs']['environment'] = ['..']
+
+    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)
+
+
+@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)

{process-bigraph-0.0.17 → process-bigraph-0.0.18}/process_bigraph/tests.py

@@ -88,7 +88,7 @@ def test_composite(core):
         'composition': {
             'increase': 'process[level:float,level:float]',
             'value': 'float'},
-        'schema': {
+        'interface': {
             'inputs': {
                 'exchange': 'float'},
             'outputs': {

{process-bigraph-0.0.17 → process-bigraph-0.0.18/process_bigraph.egg-info}/PKG-INFO

@@ -1,9 +1,12 @@
 Metadata-Version: 2.1
 Name: process-bigraph
-Version: 0.0.17
+Version: 0.0.18
+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.17 → process-bigraph-0.0.18}/setup.py

@@ -2,7 +2,7 @@ import re
 from setuptools import setup, find_packages
 
 
-VERSION = '0.0.17'
+VERSION = '0.0.18'
 
 
 with open("README.md", "r") as readme:

process-bigraph-0.0.17/process_bigraph/experiments/growth_division.py

@@ -1,66 +0,0 @@
-from process_bigraph import Step, Process, Composite, ProcessTypes, interval_time_precision, deep_merge
-
-
-def Growth(Process):
-    config_schema = {
-        'rate': 'float'}
-
-
-    def __init__(self, config, core=None):
-        super().__init__(config, core)
-
-
-    def inputs(self):
-        return {
-            'mass': 'float'}
-
-
-    def outputs(self):
-        return {
-            'mass': 'float'}
-
-
-    def update(self, state, interval):
-        # this calculates a delta
-
-        return {
-            'mass': state['mass'] * self.config['rate'] * interval}
-
-
-example_agent_schema = {
-    'id': 'string',
-    
-}
-
-
-# TODO: build composite and divide within it
-
-def Divide(Step):
-    # assume the agent_schema has the right divide methods present
-    config_schema = {
-        'agent_schema': 'schema',
-        'threshold': 'float'}
-
-
-    def __init__(self, config, core=None):
-        super().__init__(config, core)
-
-
-    def inputs(self):
-        return {
-            'trigger': 'float'}
-
-
-    def outputs(self):
-        return {
-            'self': self.config['agent_schema']}
-
-
-    def update(self, state):
-        if state['trigger'] > self.config['threshold']:
-            # return divide reaction
-            return {
-                'self': {
-                    '_fold': {
-                        'method': 'divide',
-                        'divisions': 2}}}