process-bigraph 0.0.35__tar.gz → 0.0.37__tar.gz

{process-bigraph-0.0.35/process_bigraph.egg-info → process-bigraph-0.0.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: process-bigraph
-Version: 0.0.35
+Version: 0.0.37
 Home-page: https://github.com/vivarium-collective/process-bigraph
 Author: Ryan Spangler, Eran Agmon
 Author-email: ryan.spangler@gmail.com, agmon.eran@gmail.com

{process-bigraph-0.0.35 → process-bigraph-0.0.37}/process_bigraph/composite.py

@@ -12,7 +12,7 @@ from typing import Dict
 
 from bigraph_schema import (
     Edge, Registry, 
-    get_path, resolve_path, hierarchy_depth, deep_merge,
+    get_path, set_path, resolve_path, hierarchy_depth, deep_merge,
     is_schema_key, strip_schema_keys)
 
 from process_bigraph.protocols import local_lookup, local_lookup_module
@@ -482,7 +482,7 @@ class Composite(Process):
         # build the step network
         self.build_step_network()
 
-        # self.run_steps(self.to_run)
+        self.run_steps(self.to_run)
 
 
     def build_step_network(self):
@@ -587,7 +587,24 @@ class Composite(Process):
             path,
             schema,
             state)
+        self.find_instance_paths(self.state)
 
+    def apply(self, update, path=None):
+        path = path or []
+        update = set_path({}, path, update)
+        self.state = self.core.apply(
+            self.composition,
+            self.state,
+            update)
+        self.find_instance_paths(
+            self.state)
+
+    def merge_schema(self, schema, path=None):
+        path = path or []
+        schema = set_path({}, path, schema)
+        self.composition = self.core.merge_schemas(self.composition, schema)
+        self.composition, self.state = self.core.generate(self.composition, self.state)
+        self.find_instance_paths(self.state)
 
     def process_update(
             self,
@@ -697,6 +714,20 @@ class Composite(Process):
         return full_step
 
 
+    def read_bridge(self, state=None):
+        if state is None:
+            state = self.state
+
+        bridge_view = self.core.view(
+            self.interface()['outputs'],
+            self.bridge['outputs'],
+            (),
+            top_schema=self.composition,
+            top_state=state)
+
+        return bridge_view
+
+
     def apply_updates(self, updates):
         # view_expire = False
         update_paths = []
@@ -718,15 +749,15 @@ class Composite(Process):
                     self.state,
                     update)
 
-                bridge_update = self.core.view(
-                    self.interface()['outputs'],
-                    self.bridge['outputs'],
-                    (),
-                    top_schema=self.composition,
-                    top_state=update)
+                bridge_update = self.read_bridge(
+                    update)
 
                 if bridge_update:
-                    self.bridge_updates.append(bridge_update)
+                    self.bridge_updates.append(
+                        bridge_update)
+
+        self.find_instance_paths(
+            self.state)
 
         return update_paths
 
@@ -766,11 +797,6 @@ class Composite(Process):
 
 
     def run(self, interval, force_complete=False):
-        # If there are steps to run, execute them
-        if self.to_run:
-            self.run_steps(self.to_run)
-            self.to_run = None
-
         # Define the end time for the run
         end_time = self.state['global_time'] + interval
 

{process-bigraph-0.0.35 → process-bigraph-0.0.37}/process_bigraph/emitter.py

@@ -251,11 +251,9 @@ class RAMEmitter(Emitter):
                         state=t,
                         path=path)
                 
-                    # element = get_path(t, path)
                     result = set_path(result, path, state)
                 results.append(result)
-                # element = get_path(self.history, path)
-                # result = set_path(result, path, element)
+
         else:
             results = self.history
 
@@ -363,12 +361,13 @@ def test_ram_emitter(core):
             # 'interval': 1.0,
             'inputs': {'level': ['valueB']},
             'outputs': {'level': ['valueB']}},
-    }
-    composite = Composite({'state': composite_spec}, core)
-    composite = add_emitter_to_composite(composite,
-                                         core,
-                                         emitter_mode='all',
-                                         address='local:ram-emitter')
+        'emitter': emitter_from_wires({
+            'time': ['global_time'],
+            'valueA': ['valueA'],
+            'valueB': ['valueB']})}
+
+    composite = Composite(
+        {'state': composite_spec}, core=core)
 
     # run the simulation
     composite.run(10)
@@ -376,15 +375,16 @@ def test_ram_emitter(core):
     # query the emitter
     results = composite.state['emitter']['instance'].query()
     assert len(results) == 11
-    assert results[-1]['global_time'] == 10
+    assert results[-1]['time'] == 10
     assert 'valueA' in results[0] and 'valueB' in results[0]
     # print(results)
 
-    composite2 = Composite({'state': composite_spec}, core)
-    composite2 = add_emitter_to_composite(composite2,
-                                         core,
-                                         emitter_mode={'paths': ['valueA']},
-                                         address='local:ram-emitter')
+    composite_spec['emitter'] = emitter_from_wires({
+        'time': ['global_time'],
+        'valueA': ['valueA']})
+
+    composite2 = Composite({
+        'state': composite_spec}, core=core)
 
     # run the simulation
     composite2.run(10)
@@ -406,17 +406,18 @@ def test_json_emitter(core):
             'outputs': {'level': ['value']}},
     }
     composite = Composite({'state': composite_spec}, core)
-    composite = add_emitter_to_composite(composite,
-                                         core,
-                                         emitter_mode='all',
-                                         address='local:json-emitter')
+    composite = add_emitter_to_composite(
+        composite,
+        core,
+        emitter_mode='all',
+        address='local:json-emitter')
 
     # run the simulation
     composite.run(10)
 
     # query the emitter
     results = composite.state['emitter']['instance'].query()
-    assert len(results) == 11
+    assert len(results) == 10
     assert results[-1]['global_time'] == 10
     print(results)
 

{process-bigraph-0.0.35 → process-bigraph-0.0.37}/process_bigraph/process_types.py

@@ -120,7 +120,8 @@ def deserialize_process(schema, encoded, core):
 
     protocol, address = deserialized['address'].split(':', 1)
 
-    if 'instance' in deserialized:
+    existing_instance = 'instance' in deserialized and deserialized['instance']
+    if existing_instance:
         instantiate = type(deserialized['instance'])
     else:
         process_lookup = core.protocol_registry.access(protocol)
@@ -145,14 +146,14 @@ def deserialize_process(schema, encoded, core):
                 'interval',
                 'interval'))
 
-    if not 'instance' in deserialized:
+    if existing_instance:
+        process = deserialized['instance']
+    else:
         process = instantiate(
             config,
             core=core)
 
         deserialized['instance'] = process
-    else:
-        process = deserialized['instance']
 
     # TODO: this mutating the original value directly into
     #   the return value is weird (?)
@@ -189,7 +190,8 @@ def deserialize_step(schema, encoded, core):
 
     protocol, address = deserialized['address'].split(':', 1)
 
-    if 'instance' in deserialized:
+    existing_instance = 'instance' in deserialized and deserialized['instance']
+    if existing_instance:
         instantiate = type(deserialized['instance'])
     else:
         process_lookup = core.protocol_registry.access(protocol)
@@ -204,7 +206,7 @@ def deserialize_step(schema, encoded, core):
         instantiate.config_schema,
         deserialized.get('config', {}))
 
-    if not 'instance' in deserialized:
+    if not existing_instance:
         process = instantiate(config, core=core)
         deserialized['instance'] = process
 

{process-bigraph-0.0.35 → process-bigraph-0.0.37}/process_bigraph/processes/parameter_scan.py

@@ -66,6 +66,7 @@ class RunProcess(Step):
         'process_address': 'string',
         'process_config': 'tree[any]',
         'observables': 'list[path]',
+        'initial_state': 'any',
         'timestep': 'float',
         'runtime': 'float'}
 
@@ -113,59 +114,68 @@ class RunProcess(Step):
             {'time': 'float'},
             **self.observables_schema)
 
-        composite_config = {
+        state = copy.deepcopy(
+            config['initial_state'])
+
+        state['process'] = {
+            '_type': 'process',
+            'address': self.config['process_address'],
+            'config': self.config['process_config'],
+            'instance': self.process,
+            'interval': self.config['timestep'],
+            '_inputs': self.process.inputs(),
+            '_outputs': self.process.outputs(),
+            'inputs': {
+                key: [key]
+                for key in self.process.inputs()},
+            'outputs': {
+                key: [key]
+                for key in process_outputs}}
+
+        state['emitter'] = {
+            '_type': 'step',
+            '_inputs': emit_config,
+            'address': 'local:ram-emitter',
+            'config': {
+                'emit': emit_config},
+            'inputs': dict(
+                {'time': ['global_time']},
+                **self.inputs_config),
+            'outputs': {}}
+
+        self.document = {
             'global_time_precision': global_time_precision,
-            # TODO: support emitter at the composite level
-            #   they are a list of emit dicts that describe
-            #   which emitter to use and what from the composite
-            #   state will be emitted. The schema can be inferred
-            #   from the targets. ALSO: support process ports
-            #   to be targets
-            # 'emit': [{
-            #     'address': 'local:mongo-emitter'
-            #     'targets': dict({'time': ['global_time']}, **{
-            #         key: [key]
-            #         for key in self.process.outputs()})}],
-            'state': {
-                'process': {
-                    '_type': 'process',
-                    'address': self.config['process_address'],
-                    'config': self.config['process_config'],
-                    'instance': self.process,
-                    'interval': self.config['timestep'],
-                    '_inputs': self.process.inputs(),
-                    '_outputs': self.process.outputs(),
-                    'inputs': {
-                        key: [key]
-                        for key in self.process.inputs()},
-                    'outputs': {
-                        key: [key]
-                        for key in process_outputs}},
-                'emitter': {
-                    '_type': 'step',
-                    '_inputs': emit_config,
-                    'address': 'local:ram-emitter',
-                    'config': {
-                        'emit': emit_config},
-                    'inputs': dict(
-                        {'time': ['global_time']},
-                        **self.inputs_config),
-                    'outputs': {}}}}
-
-        self.composite = Composite(composite_config, core=self.core)
+            'state': state}
+
+        # wait to initialize until we get our first update
+        self.composite = None
+
 
     def inputs(self):
         return self.process.inputs()
 
+
     def outputs(self):
         return {
             'results': dict(
                 {'time': 'list[float]'},
                 **self.results_schema)}
 
+
     def update(self, inputs):
-        # TODO: instead of the composite being a reference it is instead read through
-        #   some port and lives in the state of the simulation (??)
+        # TODO: instead of the composite being a reference it is
+        #   instead read through some port and lives in
+        #   the state of the simulation (??)
+
+        if self.composite is None:
+            self.document['state'] = deep_merge(
+                self.document['state'],
+                inputs)
+
+            self.composite = Composite(
+                self.document,
+                core=self.core)
+
         self.composite.merge(
             self.inputs(),
             inputs)
@@ -173,7 +183,8 @@ class RunProcess(Step):
         self.composite.run(
             self.config['runtime'])
 
-        histories = gather_emitter_results(self.composite)
+        histories = gather_emitter_results(
+            self.composite)
 
         results = {
             key: timeseries_from_history(
@@ -185,7 +196,8 @@ class RunProcess(Step):
         for timeseries in results.values():
             all_results = deep_merge(all_results, timeseries)
 
-        return {'results': all_results}
+        return {
+            'results': all_results}
 
 
 def timeseries_from_history(history, observables):

{process-bigraph-0.0.35 → process-bigraph-0.0.37}/process_bigraph/tests.py

@@ -5,8 +5,8 @@ import pytest
 import random
 
 from bigraph_schema import default
-
 from process_bigraph import register_types
+
 from process_bigraph.composite import Process, Step, Composite, merge_collections
 
 from process_bigraph.processes.growth_division import grow_divide_agent
@@ -427,18 +427,9 @@ def test_emitter(core):
                 'outputs': {
                     'mRNA': ['mRNA']},
                 'interval': '3.0'}},
-            'emitter': {
-                '_type': 'step',
-                'address': 'local:ram-emitter',
-                'inputs': {
-                    'time': ['global_time'],
-                    'mRNA': ['mRNA'],
-                    'interval': ['event', 'interval']},
-                'config': {
-                    'emit': {
-                        'time': 'any',
-                        'mRNA': 'any',
-                        'interval': 'any'}}}}
+            'emitter': emitter_from_wires({
+                'mRNA': ['mRNA'],
+                'interval': ['event', 'interval']})}
 
     gillespie = Composite(
         composite_schema,
@@ -466,7 +457,8 @@ def test_run_process(core):
     initial_A = 11.11
 
     state = {
-        'species': {'A': initial_A},
+        'species': {
+            'A': initial_A},
         'run': {
             '_type': 'step',
             'address': 'local:RunProcess',
@@ -480,21 +472,20 @@ def test_run_process(core):
                 'observables': [['species']],
                 'timestep': timestep,
                 'runtime': runtime},
-            # '_outputs': {'results': {'_emit': True}},
             'inputs': {'species': ['species']},
             'outputs': {'results': ['A_results']}}}
 
-    process = Composite({
+    run = Composite({
         'bridge': {
             'outputs': {
                 'results': ['A_results']}},
         'state': state},
         core=core)
 
-    results = process.update({}, 0.0)
+    results = run.read_bridge()['results']
 
-    assert results[0]['results']['time'][-1] == runtime
-    assert results[0]['results']['species'][0]['A'] == initial_A
+    assert results['time'][-1] == runtime
+    assert results['species'][0]['A'] == initial_A
 
 
 def test_nested_wires(core):
@@ -611,8 +602,7 @@ def test_grow_divide(core):
     assert composite.state['environment']['0_0_0_0_1']['mass'] == composite.state['environment']['0_0_0_0_1']['grow_divide']['instance'].state['mass']
 
     # check recursive schema reference
-    assert (id(composite.composition['environment']['_value']['grow_divide']) ==
-            id(composite.composition['environment']['_value']['grow_divide']['_outputs']['environment']['_value']['grow_divide']))
+    assert id(composite.composition['environment'] == id(composite.composition['environment']['_value']['grow_divide']['_outputs']['environment']))
 
     composite.save('test_grow_divide_saved.json')
 
@@ -620,8 +610,7 @@ def test_grow_divide(core):
         'out/test_grow_divide_saved.json',
         core=core)
     
-    assert (id(composite.composition['environment']['_value']['grow_divide']) ==
-            id(composite.composition['environment']['_value']['grow_divide']['_outputs']['environment']['_value']['grow_divide']))
+    assert id(composite.composition['environment'] == id(composite.composition['environment']['_value']['grow_divide']['_outputs']['environment']))
 
 
 def test_gillespie_composite(core):
@@ -695,6 +684,71 @@ def test_union_tree(core):
         {'a': ['what', 'is', 'happening']})
 
 
+def test_merge_schema(core):
+    state = {'a': 11.0}
+    composite = Composite({
+        'state': state}, core=core)
+
+    increase_schema = {
+        'increase': {
+            '_type': 'process',
+            'address': default('string', 'local:!process_bigraph.tests.IncreaseProcess'),
+            'config': default('quote', {'rate': 0.0001}),
+            'inputs': default('wires', {'level': ['b']}),
+            'outputs': default('wires', {'level': ['a']})}}
+
+    composite.merge(
+        increase_schema,
+        {})
+
+    # composite.merge_schema(
+    #     increase_schema)
+
+    assert composite.composition['increase']['_type'] == 'process'
+    assert isinstance(composite.state['increase']['instance'], Process)
+
+    state = {
+        'x': -3.33,
+        'atoms': {
+            'A': {
+                'lll': 55}}}
+
+    composition = {
+        'atoms': 'map[lll:integer]'}
+
+    merge = Composite({
+        'composition': composition,
+        'state': state}, core=core)
+
+    nested_increase_schema = {
+        'increase': {
+            '_type': 'process',
+            'address': default('string', 'local:!process_bigraph.tests.IncreaseProcess'),
+            'config': default('quote', {'rate': 0.0001}),
+            'inputs': default('wires', {'level': ['..', '..', 'b']}),
+            'outputs': default('wires', {'level': ['..', '..', 'a']})}}
+
+    merge.merge(
+        {'atoms': {'_value': nested_increase_schema}},
+        {})
+
+    # TODO: do we need merge_schema if merge works for schema and state?
+    # merge.merge_schema(
+    #     nested_increase_schema,
+    #     path=['atoms', '_value'])
+
+    assert isinstance(merge.state['atoms']['A']['increase']['instance'], Process)
+    assert merge.composition['atoms']['_value']['increase']['_type'] == 'process'
+    assert ('atoms', 'A', 'increase') in merge.process_paths
+
+    merge.merge(
+        {},
+        {'atoms': {'B': {'lll': 11111}}})
+
+    assert isinstance(merge.state['atoms']['B']['increase']['instance'], Process)
+    assert ('atoms', 'B', 'increase') in merge.process_paths
+
+
 def test_shared_steps(core):
     initial_rate = 0.4
 
@@ -714,15 +768,6 @@ def test_shared_steps(core):
         'emitter': emitter_from_wires({
             'level': ['value']})}
 
-        # 'emitter': {
-        #     '_type': 'step',
-        #     'address': 'local:ram-emitter',
-        #     'config': {
-        #         'emit': {
-        #             'level': 'float'}},
-        #     'inputs': {
-        #         'level': ['value']}}}
-
     shared = Composite(
         {'state': state},
         core=core)
@@ -755,11 +800,11 @@ if __name__ == '__main__':
     test_union_tree(core)
 
     test_gillespie_composite(core)
-    test_grow_divide(core)
     test_run_process(core)
     test_nested_wires(core)
     test_parameter_scan(core)
     test_shared_steps(core)
 
     test_stochastic_deterministic_composite(core)
-
+    test_merge_schema(core)
+    test_grow_divide(core)

{process-bigraph-0.0.35 → process-bigraph-0.0.37/process_bigraph.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: process-bigraph
-Version: 0.0.35
+Version: 0.0.37
 Home-page: https://github.com/vivarium-collective/process-bigraph
 Author: Ryan Spangler, Eran Agmon
 Author-email: ryan.spangler@gmail.com, agmon.eran@gmail.com

{process-bigraph-0.0.35 → process-bigraph-0.0.37}/setup.py

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