process-bigraph 0.0.5__tar.gz → 0.0.7__tar.gz

{process-bigraph-0.0.5/process_bigraph.egg-info → process-bigraph-0.0.7}/PKG-INFO

@@ -1,12 +1,9 @@
 Metadata-Version: 2.1
 Name: process-bigraph
-Version: 0.0.5
-Summary: UNKNOWN
+Version: 0.0.7
 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
@@ -73,5 +70,3 @@ 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.5 → process-bigraph-0.0.7}/process_bigraph/__init__.py

@@ -12,3 +12,4 @@ protocol_registry.register('local', local_lookup)
 # TODO
 process_registry.register('console-emitter', ConsoleEmitter)
 process_registry.register('ram-emitter', RAMEmitter)
+

{process-bigraph-0.0.5 → process-bigraph-0.0.7}/process_bigraph/composite.py

@@ -244,7 +244,10 @@ def find_instance_paths(state, instance_type='process_bigraph.composite.Process'
 def find_step_triggers(path, step):
     prefix = tuple(path[:-1])
     triggers = {}
-    for wire in step['wires']['inputs'].values():
+    wire_paths = find_leaves(
+        step['wires']['inputs'])
+
+    for wire in wire_paths:
         trigger_path = tuple(prefix) + tuple(wire)
         if trigger_path not in triggers:
             triggers[trigger_path] = []
@@ -291,18 +294,139 @@ def empty_front(time):
     }
 
 
-class Composite(Process):
-    """Composite parent class.
+def find_leaves(d, path=None):
+    leaves = []
+    path = ()
+
+    for key, value in d.items():
+        if isinstance(value, dict):
+            subleaves = find_leaves(value, path + (key,))
+            leaves.extend(subleaves)
+        else:
+            leaves.append(path + tuple(value))
+
+    return leaves
+
+
+def build_step_network(steps):
+    ancestors = {
+        step_key: {
+            # 'ancestors': [],
+            'input_paths': None,
+            'output_paths': None}
+        for step_key in steps}
+
+    nodes = {}
+
+    for step_key, step in steps.items():
+        for other_key, other_step in steps.items():
+            if step_key == other_key:
+                continue
+
+            schema = step['instance'].schema()
+            wires = step['wires']
+            other_schema = other_step['instance'].schema()
+            other_wires = other_step['wires']
+
+            if ancestors[step_key]['input_paths'] is None:
+                ancestors[step_key]['input_paths'] = find_leaves(
+                    wires['inputs'])
+            input_paths = ancestors[step_key]['input_paths']
+
+            if ancestors[step_key]['output_paths'] is None:
+                ancestors[step_key]['output_paths'] = find_leaves(
+                    wires.get('outputs', {}))
+            output_paths = ancestors[step_key]['output_paths']
+
+            for input in input_paths:
+                path = tuple(input)
+                if not path in nodes:
+                    nodes[path] = {
+                        'before': set([]),
+                        'after': set([])}
+                nodes[path]['after'].add(step_key)
+
+            for output in output_paths:
+                path = tuple(output)
+                if not path in nodes:
+                    nodes[path] = {
+                        'before': set([]),
+                        'after': set([])}
+                nodes[path]['before'].add(step_key)
+
+    return ancestors, nodes
+
+
+def combined_step_network(steps):
+    steps, nodes = build_step_network(steps)
+
+    trigger_state = {
+        'steps': steps,
+        'nodes': nodes}
+
+    return trigger_state
+
+
+def build_trigger_state(nodes):
+    return {
+        key: value['before'].copy()
+        for key, value in nodes.items()}
+
+
+def find_downstream(steps, nodes, upstream):
+    downstream = set(upstream)
+    visited = set([])
+    previous_len = -1
+
+    while len(downstream) > len(visited) and len(visited) > previous_len:
+        previous_len = len(visited)
+        down = set([])
+        for step_path in downstream:
+            if step_path not in visited:
+                for output in steps[step_path]['output_paths']:
+                    for dependent in nodes[output]['after']:
+                        down.add(dependent)
+                visited.add(step_path)
+        downstream ^= down
+
+    return downstream
+
+
+def determine_steps(steps, remaining, fulfilled):
+    to_run = []
+
+    for step_path in remaining:
+        step_inputs = steps[step_path]['input_paths']
+        all_fulfilled = True
+        for input in step_inputs:
+            if len(fulfilled[input]) > 0:
+                all_fulfilled = False
+        if all_fulfilled:
+            to_run.append(step_path)
+
+    for step_path in to_run:
+        remaining.remove(step_path)
+        step_outputs = steps[step_path]['output_paths']
+        for output in step_outputs:
+            fulfilled[output].remove(step_path)
+
+    return to_run, remaining, fulfilled
+
 
+class Composite(Process):
+    """
+    Composite parent class.
     """
+
+
     config_schema = {
         # TODO: add schema type
         'composition': 'tree[any]',
         'state': 'tree[any]',
         'schema': 'tree[any]',
         'bridge': 'wires',
-        'global_time_precision': 'maybe[float]',
-    }
+        'global_time_precision': 'maybe[float]'}
+
 
     # TODO: if processes are serialized, deserialize them first
     def __init__(self, config=None, local_types=None):
@@ -311,11 +435,17 @@ class Composite(Process):
         initial_composition = self.config.get('composition', {})
         if 'global_time' not in initial_composition:
             initial_composition['global_time'] = 'float'
+        initial_composition = types.access(
+            initial_composition)
 
         initial_state = self.config.get('state', {})
         if 'global_time' not in initial_state:
             initial_state['global_time'] = 0.0
 
+        initial_state = types.hydrate(
+            initial_composition,
+            initial_state)
+
         initial_schema = types.access(
             self.config.get('schema', {})) or {}
         self.bridge = self.config.get('bridge', {})
@@ -394,11 +524,35 @@ class Composite(Process):
 
         self.bridge_updates = []
 
-        self.run_steps(self.step_triggers.keys())
+        self.step_dependencies, self.node_dependencies = build_step_network(
+            self.step_paths)
+
+        self.reset_step_state(self.step_paths)
+        to_run = self.cycle_step_state()
+
+        self.run_steps(to_run)
+
+
+    def reset_step_state(self, step_paths):
+        self.trigger_state = build_trigger_state(
+            self.node_dependencies)
+
+        self.steps_remaining = set(step_paths)
+
+
+    def cycle_step_state(self):
+        to_run, self.steps_remaining, self.trigger_state = determine_steps(
+            self.step_dependencies,
+            self.steps_remaining,
+            self.trigger_state)
+
+        return to_run
+
 
     def schema(self):
         return self.process_schema
 
+
     def process_update(
             self,
             path,
@@ -446,6 +600,7 @@ class Composite(Process):
 
         return absolute
 
+
     def run_process(self, path, process, end_time, full_step, force_complete):
         if path not in self.front:
             self.front[path] = empty_front(self.state['global_time'])
@@ -516,8 +671,6 @@ class Composite(Process):
                 series = [series]
 
             for update in series:
-                # print(update)
-
                 paths = hierarchy_depth(update)
                 update_paths.extend(paths.keys())
 
@@ -535,7 +688,7 @@ class Composite(Process):
                 if bridge_update:
                     self.bridge_updates.append(bridge_update)
 
-        self.run_steps(update_paths)
+        return update_paths
 
                 # view_expire_update = self.apply_update(up, store)
                 # view_expire = view_expire or view_expire_update
@@ -543,6 +696,7 @@ class Composite(Process):
         # if view_expire:
         #     self.state.build_topology_views()
 
+
     def run(self, interval, force_complete=False):
         end_time = self.state['global_time'] + interval
         while self.state['global_time'] < end_time or force_complete:
@@ -581,7 +735,10 @@ class Composite(Process):
                         advance['update'] = {}
                         paths.append(path)
 
-                self.apply_updates(updates)
+                # get all update paths, then trigger steps that
+                # depend on those paths
+                update_paths = self.apply_updates(updates)
+                self.trigger_steps(update_paths)
 
                 # # display and emit
                 # if self.progress_bar:
@@ -600,22 +757,34 @@ class Composite(Process):
             if force_complete and self.state['global_time'] == end_time:
                 force_complete = False
 
-    def run_steps(self, update_paths):
-        steps_to_run = []
 
-        for update_path in update_paths:
-            paths = explode_path(update_path)
-            for path in paths:
-                step_paths = self.step_triggers.get(path, [])
-                for step_path in step_paths:
-                    if step_path is not None and step_path not in self.steps_run:
-                        steps_to_run.append(step_path)
-                        self.steps_run.add(step_path)
+    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)
 
-        if len(steps_to_run) > 0:
+        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
+
+
+    def run_steps(self, step_paths):
+        if len(step_paths) > 0:
             updates = []
-            for step_path in steps_to_run:
-                step = get_path(self.state, step_path)
+            for step_path in step_paths:
+                step = get_path(
+                    self.state,
+                    step_path)
+
                 state = types.view_edge(
                     self.composition,
                     self.state,
@@ -631,11 +800,37 @@ class Composite(Process):
 
                 updates.append(step_update)
 
-            self.apply_updates(updates)
+            update_paths = self.apply_updates(updates)
+            to_run = self.cycle_step_state()
+            if len(to_run) > 0:
+                self.run_steps(to_run)
         else:
             self.steps_run = set([])
 
 
+    def trigger_steps(self, update_paths):
+        steps_to_run = []
+
+        for update_path in update_paths:
+            paths = explode_path(update_path)
+            for path in paths:
+                step_paths = self.step_triggers.get(path, [])
+                for step_path in step_paths:
+                    if step_path is not None and step_path not in self.steps_run:
+                        steps_to_run.append(step_path)
+                        self.steps_run.add(step_path)
+
+        steps_to_run = find_downstream(
+            self.step_dependencies,
+            self.node_dependencies,
+            steps_to_run)
+
+        self.reset_step_state(steps_to_run)
+        to_run = self.cycle_step_state()
+
+        self.run_steps(to_run)
+
+
     def gather_results(self, queries=None):
         '''
         a map of paths to emitters --> queries for the emitter at that path

{process-bigraph-0.0.5 → process-bigraph-0.0.7}/process_bigraph/registry.py

@@ -24,3 +24,4 @@ process_registry = Registry()
 
 #: Maps process names to :term:`protocol methods`
 protocol_registry = Registry()
+

process-bigraph-0.0.7/process_bigraph/tests.py

@@ -0,0 +1,354 @@
+"""
+Tests for Process Bigraph
+"""
+
+import random
+
+from process_bigraph.composite import Process, Step, Composite
+from process_bigraph.composite import merge_collections
+from process_bigraph.type_system import types
+
+
+class IncreaseProcess(Process):
+    config_schema = {
+        'rate': {
+            '_type': 'float',
+            '_default': '0.1'}}
+
+    def __init__(self, config=None):
+        super().__init__(config)
+
+    def schema(self):
+        return {
+            'level': 'float'}
+
+    def update(self, state, interval):
+        return {
+            'level': state['level'] * self.config['rate']}
+
+
+def test_default_config():
+    process = IncreaseProcess()
+    assert process.config['rate'] == 0.1
+
+
+def test_merge_collections():
+    a = {('what',): [1, 2, 3]}
+    b = {('okay', 'yes'): [3, 3], ('what',): [4, 5, 11]}
+
+    c = merge_collections(a, b)
+
+    assert c[('what',)] == [1, 2, 3, 4, 5, 11]
+
+
+def test_process():
+    process = IncreaseProcess({'rate': 0.2})
+    schema = process.schema()
+    state = types.fill(schema)
+    update = process.update({'level': 5.5}, 1.0)
+    new_state = types.apply(schema, state, update)
+
+    assert new_state['level'] == 1.1
+
+
+def test_composite():
+    # TODO: add support for the various vivarium emitters
+
+    # increase = IncreaseProcess({'rate': 0.3})
+    # TODO: This is the config of the composite,
+    #   we also need a way to serialize the entire composite
+
+    composite = Composite({
+        'composition': {
+            'increase': 'process[level:float]',
+            'value': 'float'},
+        'schema': {
+            'exchange': 'float'},
+        'bridge': {
+            'exchange': ['value']},
+        'state': {
+            'increase': {
+                'address': 'local:!process_bigraph.tests.IncreaseProcess',
+                'config': {'rate': '0.3'},
+                'interval': '1.0',
+                'wires': {'level': ['value']}},
+            'value': '11.11'}})
+
+    initial_state = {'exchange': 3.33}
+
+    updates = composite.update(initial_state, 10.0)
+
+    final_exchange = sum([
+        update['exchange']
+        for update in [initial_state] + updates])
+
+    assert composite.state['value'] > 45
+    assert 'exchange' in updates[0]
+    assert updates[0]['exchange'] == 0.999
+
+
+def test_infer():
+    composite = Composite({
+        'state': {
+            'increase': {
+                '_type': 'process',
+                'address': 'local:!process_bigraph.tests.IncreaseProcess',
+                'config': {'rate': '0.3'},
+                'wires': {'level': ['value']}},
+            'value': '11.11'}})
+
+    assert composite.composition['value']['_type'] == 'float'
+    assert composite.state['value'] == 11.11
+
+
+class OperatorStep(Step):
+    config_schema = {
+        'operator': 'string'}
+
+
+    def schema(self):
+        return {
+            'inputs': {
+                'a': 'float',
+                'b': 'float'},
+            'outputs': {
+                'c': 'float'}}
+
+
+    def update(self, inputs):
+        a = inputs['a']
+        b = inputs['b']
+
+        if self.config['operator'] == '+':
+            c = a + b
+        elif self.config['operator'] == '*':
+            c = a * b
+        elif self.config['operator'] == '-':
+            c = a - b
+
+        return {'c': c}
+
+
+def test_step_initialization():
+    composite = Composite({
+        'state': {
+            'A': 13,
+            'B': 21,
+            'step1': {
+                '_type': 'step',
+                'address': 'local:!process_bigraph.tests.OperatorStep',
+                'config': {
+                    'operator': '+'},
+                # TODO: avoid inputs/outputs key in wires?
+                'wires': {
+                    'inputs': {
+                        'a': ['A'],
+                        'b': ['B']},
+                    'outputs': {
+                        'c': ['C']}}},
+            'step2': {
+                '_type': 'step',
+                'address': 'local:!process_bigraph.tests.OperatorStep',
+                'config': {
+                    'operator': '*'},
+                'wires': {
+                    'inputs': {
+                        'a': ['B'],
+                        'b': ['C']},
+                    'outputs': {
+                        'c': ['D']}}}}})
+
+
+    assert composite.state['D'] == (13 + 21) * 21
+
+
+def test_dependencies():
+    operation = {
+        'a': 11.111,
+        'b': 22.2,
+        'c': 555.555,
+
+        '1': {
+            '_type': 'step',
+            'address': 'local:!process_bigraph.tests.OperatorStep',
+            'config': {
+                'operator': '+'},
+            'wires': {
+                'inputs': {
+                    'a': ['a'],
+                    'b': ['b']},
+                'outputs': {
+                    'c': ['e']}}},
+        '2.1': {
+            '_type': 'step',
+            'address': 'local:!process_bigraph.tests.OperatorStep',
+            'config': {
+                'operator': '-'},
+            'wires': {
+                'inputs': {
+                    'a': ['c'],
+                    'b': ['e']},
+                'outputs': {
+                    'c': ['f']}}},
+        '2.2': {
+            '_type': 'step',
+            'address': 'local:!process_bigraph.tests.OperatorStep',
+            'config': {
+                'operator': '-'},
+            'wires': {
+                'inputs': {
+                    'a': ['d'],
+                    'b': ['e']},
+                'outputs': {
+                    'c': ['g']}}},
+        '3': {
+            '_type': 'step',
+            'address': 'local:!process_bigraph.tests.OperatorStep',
+            'config': {
+                'operator': '*'},
+            'wires': {
+                'inputs': {
+                    'a': ['f'],
+                    'b': ['g']},
+                'outputs': {
+                    'c': ['h']}}},
+        '4': {
+            '_type': 'step',
+            'address': 'local:!process_bigraph.tests.OperatorStep',
+            'config': {
+                'operator': '+'},
+            'wires': {
+                'inputs': {
+                    'a': ['e'],
+                    'b': ['h']},
+                'outputs': {
+                    'c': ['i']}}}}
+
+    composite = Composite({'state': operation})
+
+    assert composite.state['h'] == -17396.469884
+
+
+def test_dependency_cycle():
+    # test a step network with cycles in a few ways
+    pass
+
+
+class SimpleCompartment(Process):
+    config_schema = {
+        'id': 'string'}
+
+
+    def schema(self):
+        return {
+            'outer': 'tree[process]',
+            'inner': 'tree[process]'}
+
+
+    def update(self, state, interval):
+        choice = random.random()
+        update = {}
+
+        outer = state['outer']
+        inner = state['inner']
+
+        # TODO: implement divide_state(_)
+        divisions = self.types.divide_state(
+            self.schema(),
+            inner)
+
+        if choice < 0.2:
+            # update = {
+            #     'outer': {
+            #         '_divide': {
+            #             'mother': self.config['id'],
+            #             'daughters': [
+            #                 {'id': self.config['id'] + '0'},
+            #                 {'id': self.config['id'] + '1'}]}}}
+
+            # daughter_ids = [self.config['id'] + str(i)
+            #     for i in range(2)]
+
+            # update = {
+            #     'outer': {
+            #         '_react': {
+            #             'redex': {
+            #                 'inner': {
+            #                     self.config['id']: {}}},
+            #             'reactum': {
+            #                 'inner': {
+            #                     daughter_config['id']: {
+            #                         '_type': 'process',
+            #                         'address': 'local:!process_bigraph.tests.SimpleCompartment',
+            #                         'config': daughter_config,
+            #                         'inner': daughter_inner,
+            #                         'wires': {
+            #                             'outer': ['..']}}
+            #                     for daughter_config, daughter_inner in zip(daughter_configs, divisions)}}}}}
+
+            update = {
+                'outer': {
+                    'inner': {
+                        '_react': {
+                            'reaction': 'divide',
+                            'config': {
+                                'id': self.config['id'],
+                                'daughters': [{
+                                        'id': daughter_id,
+                                        'state': daughter_state}
+                                    for daughter_id, daughter_state in zip(
+                                        daughter_ids,
+                                        divisions)]}}}}}
+
+        return update
+
+
+# TODO: create reaction registry, register this under "divide"
+
+
+def engulf_reaction(config):
+    return {
+        'redex': {},
+        'reactum': {}}
+
+
+def burst_reaction(config):
+    return {
+        'redex': {},
+        'reactum': {}}
+
+
+def test_reaction():
+    composite = {
+        'state': {
+            'environment': {
+                'concentrations': {},
+                'inner': {
+                    'agent1': {
+                        '_type': 'process',
+                        'address': 'local:!process_bigraph.tests.SimpleCompartment',
+                        'config': {'id': '0'},
+                        'concentrations': {},
+                        'inner': {
+                            'agent2': {
+                                '_type': 'process',
+                                'address': 'local:!process_bigraph.tests.SimpleCompartment',
+                                'config': {'id': '0'},
+                                'inner': {},
+                                'wires': {
+                                    'outer': ['..', '..'],
+                                    'inner': ['inner']}}},
+                        'wires': {
+                            'outer': ['..', '..'],
+                            'inner': ['inner']}}}}}}
+
+
+if __name__ == '__main__':
+    test_default_config()
+    test_merge_collections()
+    test_process()
+    test_composite()
+    test_infer()
+    test_step_initialization()
+    test_dependencies()
+    # test_reaction()

{process-bigraph-0.0.5 → process-bigraph-0.0.7}/process_bigraph/type_system.py

@@ -245,19 +245,40 @@ class ProcessTypes(TypeSystem):
 
                     subwires = hydrated_state['wires']
                     if state_type == 'step':
-                        subwires = subwires.get('inputs', {})
-                        port_schema = port_schema.get('inputs', {})
-
-                    schema = self.infer_wires(
-                        port_schema,
-                        hydrated_state,
-                        subwires,
-                        top_schema=schema,
-                        path=path[:-1])
+                        input_subwires = subwires.get('inputs', {})
+                        input_port_schema = port_schema.get('inputs', {})
+                        schema = self.infer_wires(
+                            input_port_schema,
+                            hydrated_state,
+                            input_subwires,
+                            top_schema=schema,
+                            path=path[:-1])
+
+                        output_subwires = subwires.get('outputs', {})
+                        output_port_schema = port_schema.get('outputs', {})
+                        schema = self.infer_wires(
+                            output_port_schema,
+                            hydrated_state,
+                            output_subwires,
+                            top_schema=schema,
+                            path=path[:-1])
+                    else:
+                        schema = self.infer_wires(
+                            port_schema,
+                            hydrated_state,
+                            subwires,
+                            top_schema=schema,
+                            path=path[:-1])
+            elif '_type' in schema:
+                hydrated_state = self.deserialize(schema, state)
+                top_state = set_path(
+                    top_state,
+                    path,
+                    hydrated_state)
             else:
                 for key, value in state.items():
                     inner_path = path + (key,)
-                    if get_path(schema, inner_path) is None:
+                    if get_path(schema, inner_path) is None or get_path(state, inner_path) is None or (isinstance(value, dict) and '_type' in value):
                         schema, top_state = self.infer_schema(
                             schema,
                             value,
@@ -325,16 +346,17 @@ class ProcessTypes(TypeSystem):
                 schema = self.access(schema)
                 return self.hydrate_state(schema, state)
             else:
-                result = {}
-                for key, value in state.items():
+                result = state.copy()
+                for key, value in schema.items():
                     if key in schema:
                         subschema = schema[key]
                     else:
                         subschema = schema
 
-                    result[key] = self.hydrate_state(
-                        subschema,
-                        state.get(key))
+                    if key in state:
+                        result[key] = self.hydrate_state(
+                            subschema,
+                            state.get(key))
         else:
             result = state
 

{process-bigraph-0.0.5 → process-bigraph-0.0.7/process_bigraph.egg-info}/PKG-INFO

@@ -1,12 +1,9 @@
 Metadata-Version: 2.1
 Name: process-bigraph
-Version: 0.0.5
-Summary: UNKNOWN
+Version: 0.0.7
 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
@@ -73,5 +70,3 @@ 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.7/process_bigraph.egg-info/requires.txt

@@ -0,0 +1,3 @@
+bigraph-schema
+numpy
+pytest>=6.2.5

{process-bigraph-0.0.5 → process-bigraph-0.0.7}/setup.py

@@ -2,7 +2,7 @@ import re
 from setuptools import setup, find_packages
 
 
-VERSION = '0.0.5'
+VERSION = '0.0.7'
 
 
 with open("README.md", "r") as readme:
@@ -44,6 +44,8 @@ setup(
     python_requires=">=3.6",
     install_requires=[
         # List your package dependencies here
-        "bigraph-schema"
+        "bigraph-schema",
+        "numpy",
+        "pytest>=6.2.5",
     ],
 )

process-bigraph-0.0.5/process_bigraph/tests.py

@@ -1,138 +0,0 @@
-"""
-Tests for Process Bigraph
-"""
-
-from process_bigraph.composite import Process, Composite
-from process_bigraph.composite import merge_collections
-from process_bigraph.type_system import types
-
-
-class IncreaseProcess(Process):
-    config_schema = {
-        'rate': {
-            '_type': 'float',
-            '_default': '0.1'}}
-
-    def __init__(self, config=None):
-        super().__init__(config)
-
-    def schema(self):
-        return {
-            'level': 'float'}
-
-    def update(self, state, interval):
-        return {
-            'level': state['level'] * self.config['rate']}
-
-
-def test_serialized_composite():
-    # This should specify the same thing as above
-    composite_schema = {
-        '_type': 'process[exchange:float]',
-        'address': 'local:!process_bigraph.composite.Composite',
-        'config': {
-            'state': {
-                'increase': {
-                    '_type': 'process[level:float]',
-                    'address': 'local:!process_bigraph.tests.IncreaseProcess',
-                    'config': {'rate': '0.3'},
-                    'wires': {'level': ['value']}
-                },
-                'value': '11.11',
-            },
-            'schema': {
-                'increase': 'process[level:float]',
-                # 'increase': 'process[{"level":"float","down":{"a":"int"}}]',
-                'value': 'float',
-            },
-            'bridge': {
-                'exchange': 'value'
-            },
-        }
-    }
-
-    composite_instance = types.deserialize(composite_schema, {})
-    composite_instance.update()
-
-
-def test_default_config():
-    process = IncreaseProcess()
-    assert process.config['rate'] == 0.1
-
-
-def test_merge_collections():
-    a = {('what',): [1, 2, 3]}
-    b = {('okay', 'yes'): [3, 3], ('what',): [4, 5, 11]}
-
-    c = merge_collections(a, b)
-
-    assert c[('what',)] == [1, 2, 3, 4, 5, 11]
-
-
-def test_process():
-    process = IncreaseProcess({'rate': 0.2})
-    schema = process.schema()
-    state = types.fill(schema)
-    update = process.update({'level': 5.5}, 1.0)
-    new_state = types.apply(schema, state, update)
-
-    assert new_state['level'] == 1.1
-
-
-def test_composite():
-    # TODO: add support for the various vivarium emitters
-
-    # increase = IncreaseProcess({'rate': 0.3})
-    # TODO: This is the config of the composite,
-    #   we also need a way to serialize the entire composite
-
-    composite = Composite({
-        'composition': {
-            'increase': 'process[level:float]',
-            'value': 'float'},
-        'schema': {
-            'exchange': 'float'},
-        'bridge': {
-            'exchange': ['value']},
-        'state': {
-            'increase': {
-                'address': 'local:!process_bigraph.tests.IncreaseProcess',
-                'config': {'rate': '0.3'},
-                'interval': '1.0',
-                'wires': {'level': ['value']}},
-            'value': '11.11'}})
-
-    initial_state = {'exchange': 3.33}
-
-    updates = composite.update(initial_state, 10.0)
-
-    final_exchange = sum([
-        update['exchange']
-        for update in [initial_state] + updates])
-
-    assert composite.state['value'] > 45
-    assert 'exchange' in updates[0]
-    assert updates[0]['exchange'] == 0.999
-
-
-def test_infer():
-    composite = Composite({
-        'state': {
-            'increase': {
-                '_type': 'process',
-                'address': 'local:!process_bigraph.tests.IncreaseProcess',
-                'config': {'rate': '0.3'},
-                'wires': {'level': ['value']}},
-            'value': '11.11'}})
-
-    assert composite.composition['value']['_type'] == 'float'
-    assert composite.state['value'] == 11.11
-
-
-
-if __name__ == '__main__':
-    test_default_config()
-    test_merge_collections()
-    test_process()
-    test_composite()
-    test_infer()

process-bigraph-0.0.5/process_bigraph.egg-info/requires.txt

@@ -1 +0,0 @@
-bigraph-schema