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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: process-bigraph
-Version: 0.0.23
+Version: 0.0.25
 Summary: UNKNOWN
 Home-page: https://github.com/vivarium-collective/process-bigraph
 Author: Ryan Spangler, Eran Agmon

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

@@ -15,6 +15,11 @@ from bigraph_schema import Edge, TypeSystem, get_path, set_path, deep_merge, is_
 from process_bigraph.protocols import local_lookup, local_lookup_module
 
 
+
+# =========================
+# Process Utility Functions
+# =========================
+
 def assert_interface(interface: Dict):
     """Ensure that an interface dict has the required keys"""
     required_keys = ['inputs', 'outputs']
@@ -22,6 +27,224 @@ 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 find_instances(state, instance_type='process_bigraph.composite.Process'):
+    process_class = local_lookup_module(instance_type)
+    found = {}
+
+    for key, inner in state.items():
+        if isinstance(inner, dict):
+            if isinstance(inner.get('instance'), process_class):
+                found[key] = inner
+            elif not is_schema_key(key):
+                inner_instances = find_instances(
+                    inner,
+                    instance_type=instance_type)
+
+                if inner_instances:
+                    found[key] = inner_instances
+    return found
+
+
+def find_instance_paths(state, instance_type='process_bigraph.composite.Process'):
+    instances = find_instances(state, instance_type)
+    return hierarchy_depth(instances)
+
+
+def find_step_triggers(path, step):
+    prefix = tuple(path[:-1])
+    triggers = {}
+    wire_paths = find_leaves(
+        step['inputs'])
+
+    for wire in wire_paths:
+        trigger_path = tuple(prefix) + tuple(wire)
+        if trigger_path not in triggers:
+            triggers[trigger_path] = []
+        triggers[trigger_path].append(path)
+
+    return triggers
+
+
+def explode_path(path):
+    explode = ()
+    paths = [explode]
+
+    for node in path:
+        explode = explode + (node,)
+        paths.append(explode)
+
+    return paths
+
+
+def merge_collections(existing, new):
+    if existing is None:
+        existing = {}
+    if new is None:
+        new = {}
+    for key, value in new.items():
+        if key in existing:
+            if isinstance(existing[key], dict) and isinstance(new[key], collections.abc.Mapping):
+                merge_collections(existing[key], new[key])
+            elif isinstance(existing[key], list) and isinstance(new[key], collections.abc.Sequence):
+                existing[key].extend(new[key])
+            else:
+                raise Exception(
+                    f'cannot merge collections as they do not match:\n{existing}\n{new}')
+        else:
+            existing[key] = value
+
+    return existing
+
+
+def empty_front(time):
+    return {
+        'time': time,
+        'update': {}
+    }
+
+
+def find_leaves(tree_structure, path=None):
+    leaves = []
+    path = ()
+
+    if tree_structure is None:
+        pass
+    elif isinstance(tree_structure, list):
+        leaves = tree_structure
+    elif isinstance(tree_structure, tuple):
+        leaves.append(tree_structure)
+    else:
+        for key, value in tree_structure.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: {
+            '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'].interface()
+            other_schema = other_step['instance'].interface()
+
+            assert_interface(schema)
+            assert_interface(other_schema)
+
+            if ancestors[step_key]['input_paths'] is None:
+                ancestors[step_key]['input_paths'] = find_leaves(
+                    step['inputs'])
+            input_paths = ancestors[step_key]['input_paths']
+
+            if ancestors[step_key]['output_paths'] is None:
+                ancestors[step_key]['output_paths'] = find_leaves(
+                    step.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:
+                if output in input_paths:
+                    continue
+
+                path = tuple(output)
+                if not path in nodes:
+                    nodes[path] = {
+                        'before': set([]),
+                        'after': set([])}
+                nodes[path]['before'].add(step_key)
+
+    return ancestors, nodes
+
+
+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:
+                step_outputs = steps[step_path]['output_paths']
+                if step_outputs is None:
+                    step_outputs = []  # Ensure step_outputs is always an iterable
+                for output in step_outputs:
+                    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']
+        if step_inputs is None:
+            step_inputs = []
+        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']
+        if step_outputs is None:
+            step_outputs = []
+
+        for output in step_outputs:
+            if output in fulfilled and step_path in fulfilled[output]:
+                fulfilled[output].remove(step_path)
+
+    return to_run, remaining, fulfilled
+
+
+def interval_time_precision(timestep):
+    # get number of decimal places to set global time precision
+    timestep_str = str(timestep)
+    global_time_precision = 0
+    if '.' in timestep_str:
+        _, decimals = timestep_str.split('.')
+        global_time_precision = len(decimals)
+
+    return global_time_precision
+
+
+# ======================
+# Process Type Functions
+# ======================
+
 def apply_process(schema, current, update, core):
     """Apply an update to a process."""
     process_schema = schema.copy()
@@ -245,6 +468,10 @@ BASE_PROTOCOLS = {
     'local': local_lookup}
 
 
+# ===================
+# Process Type System
+# ===================
+
 class ProcessTypes(TypeSystem):
     """
     ProcessTypes class extends the TypeSystem class to include process types.
@@ -328,6 +555,10 @@ class ProcessTypes(TypeSystem):
         return state
 
 
+# ===============
+# Process Classes
+# ===============
+
 class SyncUpdate():
     def __init__(self, update):
         self.update = update
@@ -344,23 +575,6 @@ class Step(Edge):
     like a workflow.
     """
     # TODO: support trigger every time as well as dependency trigger
-    config_schema = {}
-
-
-    def __init__(self, config=None, core=None):
-        self.core = core or ProcessTypes()
-
-        if config is None:
-            config = {}
-
-        self.config = self.core.fill(
-            self.config_schema,
-            config)
-
-
-    def initial_state(self):
-        return {}
-
 
     def invoke(self, state, _=None):
         update = self.update(state)
@@ -389,34 +603,6 @@ class Process(Edge):
           config: Override the class defaults. This dictionary may
               also contain the following special keys (TODO):
     """
-    config_schema = {}
-
-    def __init__(self, config=None, core=None):
-        self.core = core or ProcessTypes()
-
-        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__}')
-
-        # fill in defaults for config
-        self.config = self.core.fill(
-            self.config_schema,
-            config)
-
-        # TODO: validate your config after filling, report if anything
-        #   is off
-        # print(self.core.validate_state(
-        #     self.config_schema,
-        #     config))
-
-
-    def initial_state(self):
-        return {}
-
 
     def invoke(self, state, interval):
         update = self.update(state, interval)
@@ -428,9 +614,33 @@ class Process(Edge):
         return {}
 
 
-    # TODO: should we include run(interval) here?
-    #   process would have to maintain state
+class ProcessEnsemble(Process):
+    def __init__(self, config=None, core=None):
+        self.__init__(config, core)
+
+        
+    def union_interface(self):
+        union_inputs = {}
+        union_outputs = {}
+
+        for self_key in dir(self):
+            if self_key.startswith('inputs_'):
+                inputs = self.getattr(self_key)()
+                union_inputs = self.core.resolve_schemas(
+                    union_inputs,
+                    inputs)
+
+            if self_key.startswith('outputs_'):
+                outputs = self.getattr(self_key)()
+                union_outputs = self.core.resolve_schemas(
+                    union_outputs,
+                    outputs)
+
+        return {
+            'inputs': union_inputs,
+            'outputs': union_outputs}
 
+        
 
 class Defer:
     """Allows for delayed application of a function to an update.
@@ -443,7 +653,7 @@ class Defer:
         defer: An object with a ``.get_command_result()`` method
             whose output will be passed to the function. For
             example, the object could be an
-            :py:class:`vivarium.core.process.Process` object whose
+            :Process` object whose
             ``.get_command_result()`` method will return the process
             update.
         function: The function. For example,
@@ -475,216 +685,6 @@ class Defer:
             self.args)
 
 
-def find_instances(state, instance_type='process_bigraph.composite.Process'):
-    process_class = local_lookup_module(instance_type)
-    found = {}
-
-    for key, inner in state.items():
-        if isinstance(inner, dict):
-            if isinstance(inner.get('instance'), process_class):
-                found[key] = inner
-            elif not is_schema_key(key):
-                inner_instances = find_instances(
-                    inner,
-                    instance_type=instance_type)
-
-                if inner_instances:
-                    found[key] = inner_instances
-    return found
-
-
-def find_instance_paths(state, instance_type='process_bigraph.composite.Process'):
-    instances = find_instances(state, instance_type)
-    return hierarchy_depth(instances)
-
-
-def find_step_triggers(path, step):
-    prefix = tuple(path[:-1])
-    triggers = {}
-    wire_paths = find_leaves(
-        step['inputs'])
-
-    for wire in wire_paths:
-        trigger_path = tuple(prefix) + tuple(wire)
-        if trigger_path not in triggers:
-            triggers[trigger_path] = []
-        triggers[trigger_path].append(path)
-
-    return triggers
-
-
-def explode_path(path):
-    explode = ()
-    paths = [explode]
-
-    for node in path:
-        explode = explode + (node,)
-        paths.append(explode)
-
-    return paths
-
-
-def merge_collections(existing, new):
-    if existing is None:
-        existing = {}
-    if new is None:
-        new = {}
-    for key, value in new.items():
-        if key in existing:
-            if isinstance(existing[key], dict) and isinstance(new[key], collections.abc.Mapping):
-                merge_collections(existing[key], new[key])
-            elif isinstance(existing[key], list) and isinstance(new[key], collections.abc.Sequence):
-                existing[key].extend(new[key])
-            else:
-                raise Exception(
-                    f'cannot merge collections as they do not match:\n{existing}\n{new}')
-        else:
-            existing[key] = value
-
-    return existing
-
-
-def empty_front(time):
-    return {
-        'time': time,
-        'update': {}
-    }
-
-
-def find_leaves(tree_structure, path=None):
-    leaves = []
-    path = ()
-
-    if tree_structure is None:
-        pass
-    elif isinstance(tree_structure, list):
-        leaves = tree_structure
-    elif isinstance(tree_structure, tuple):
-        leaves.append(tree_structure)
-    else:
-        for key, value in tree_structure.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: {
-            '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'].interface()
-            other_schema = other_step['instance'].interface()
-
-            assert_interface(schema)
-            assert_interface(other_schema)
-
-            if ancestors[step_key]['input_paths'] is None:
-                ancestors[step_key]['input_paths'] = find_leaves(
-                    step['inputs'])
-            input_paths = ancestors[step_key]['input_paths']
-
-            if ancestors[step_key]['output_paths'] is None:
-                ancestors[step_key]['output_paths'] = find_leaves(
-                    step.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 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:
-                step_outputs = steps[step_path]['output_paths']
-                if step_outputs is None:
-                    step_outputs = []  # Ensure step_outputs is always an iterable
-                for output in step_outputs:
-                    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']
-        if step_inputs is None:
-            step_inputs = []
-        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']
-        if step_outputs is None:
-            step_outputs = []
-        for output in step_outputs:
-            fulfilled[output].remove(step_path)
-
-    return to_run, remaining, fulfilled
-
-
-def interval_time_precision(timestep):
-    # get number of decimal places to set global time precision
-    timestep_str = str(timestep)
-    global_time_precision = 0
-    if '.' in timestep_str:
-        _, decimals = timestep_str.split('.')
-        global_time_precision = len(decimals)
-
-    return global_time_precision
-
-
 class Composite(Process):
     """
     Composite parent class.
@@ -724,8 +724,7 @@ class Composite(Process):
         return composite
 
 
-    def __init__(self, config=None, core=None):
-        super().__init__(config, core)
+    def initialize(self, config=None):
 
         # insert global_time into schema if not present
         initial_composition = self.config.get('composition', {})
@@ -798,8 +797,19 @@ class Composite(Process):
             self.add_emitter(
                 emitter_config)
 
-        self.step_triggers = {}
+        self.front: Dict = {
+            path: empty_front(self.state['global_time'])
+            for path in self.process_paths}
+
+        self.bridge_updates = []
+
+        # build the step network
+        self.build_step_network()
+
+        # self.run_steps(self.to_run)
 
+    def build_step_network(self):
+        self.step_triggers = {}
         for step_path, step in self.step_paths.items():
             step_triggers = find_step_triggers(
                 step_path, step)
@@ -809,20 +819,18 @@ class Composite(Process):
 
         self.steps_run = set([])
 
-        self.front: Dict = {
-            path: empty_front(self.state['global_time'])
-            for path in self.process_paths}
-
-        self.bridge_updates = []
-
         self.step_dependencies, self.node_dependencies = build_step_network(
             self.step_paths)
 
-        self.reset_step_state(self.step_paths)
-        self.to_run = self.cycle_step_state()
+        self.reset_step_state(
+            self.step_paths)
 
-        # self.run_steps(self.to_run)
+        self.to_run = self.cycle_step_state()
 
+    def serialize_state(self):
+        return self.core.serialize(
+            self.composition,
+            self.state)
 
     def save(self,
              filename='composite.json',
@@ -830,9 +838,9 @@ class Composite(Process):
              schema=False,
              state=False):
 
-        # TODO: add in dependent packages and version
-        #   maybe packagename.typename?
-        # TODO: add in dependent types
+        # upcoming deprecation warning
+        print("Warning: save() is deprecated and will be removed in a future version. "
+              "Use use Vivarium for managing simulations instead of Composite.")
 
         document = {}
 
@@ -840,30 +848,15 @@ class Composite(Process):
             schema = state = True
 
         if state:
-            serialized_state = self.core.serialize(
-                self.composition,
-                self.state)
-
+            serialized_state = self.serialize_state()
             document['state'] = serialized_state
 
         if schema:
-            # serialized_schema = self.core.serialize(
-            #     'schema',
-            #     self.composition)
-
             serialized_schema = self.core.representation(
                 self.composition)
-
             document['composition'] = serialized_schema
 
-        # TODO: make this true
-        # copy_composite = Composite({
-        #     'state': self.state})
-
-        # assert copy_composite == self
-
         # save the dictionary to a JSON file
-
         if not os.path.exists(outdir):
             os.makedirs(outdir)
         filename = os.path.join(outdir, filename)
@@ -873,10 +866,10 @@ class Composite(Process):
             json.dump(document, json_file, indent=4)
             print(f"Created new file: {filename}")
 
+
     def reset_step_state(self, step_paths):
         self.trigger_state = build_trigger_state(
             self.node_dependencies)
-
         self.steps_remaining = set(step_paths)
 
 
@@ -885,7 +878,6 @@ class Composite(Process):
             self.step_dependencies,
             self.steps_remaining,
             self.trigger_state)
-
         return to_run
 
 
@@ -913,6 +905,11 @@ class Composite(Process):
 
 
     def read_emitter_config(self, emitter_config):
+
+        # upcoming deprecation warning
+        print("Warning: read_emitter_config() is deprecated and will be removed in a future version. "
+              "Use use Vivarium for managing simulations and emitters instead of Composite.")
+
         address = emitter_config.get('address', 'local:ram-emitter')
         config = emitter_config.get('config', {})
         mode = emitter_config.get('mode', 'none')
@@ -1221,25 +1218,6 @@ 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)
-
-    #     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 = []
@@ -1316,6 +1294,7 @@ class Composite(Process):
 
         return results
 
+
     def update(self, state, interval):
         # do everything
 
@@ -1337,13 +1316,11 @@ class Composite(Process):
         return updates
 
 
-
-"""
-Emitters
---------
-Emitters are steps that observe the state of the system and emit it to an external source. 
-This could be to a database, to a file, or to the console.
-"""
+# ========
+# Emitters
+# ========
+# Emitters are steps that observe the state of the system and emit it to an external source.
+# This could be to a database, to a file, or to the console.
 
 class Emitter(Step):
     """Base emitter class.
@@ -1407,16 +1384,3 @@ class RAMEmitter(Emitter):
 BASE_EMITTERS = {
     'console-emitter': ConsoleEmitter,
     'ram-emitter': RAMEmitter}
-
-
-# def StateEmitter(Emitter):
-
-
-# def test_emitter():
-#     composite = Composite({})
-
-#     composite.add_emitter(['emitters', 'ram'], 'ram-emitter')
-#     composite.emit_port(
-#         ['emitters', 'ram'],
-#         ['processes', 'translation'],
-#         ['outputs', 'protein'])

{process-bigraph-0.0.23 → process-bigraph-0.0.25}/process_bigraph/experiments/minimal_gillespie.py

@@ -11,7 +11,7 @@ general stochastic transcription.
 import numpy as np
 import pytest
 
-from process_bigraph.composite import Step, Process, Composite
+from process_bigraph.composite import Step, Process, Composite, ProcessEnsemble
 
 
 class GillespieInterval(Step):
@@ -71,7 +71,7 @@ class GillespieInterval(Step):
         output = {
             'interval': interval}
 
-        print(f'produced interval: {output}')
+        # print(f'produced interval: {output}')
 
         return output
 
@@ -87,9 +87,7 @@ class GillespieEvent(Process):
             '_default': '1e-1'}}
 
 
-    def __init__(self, config=None, core=None):
-        super().__init__(config, core)
-
+    def initialize(self, config=None):
         self.stoichiometry = np.array([[0, 1], [0, -1]])
 
 
@@ -151,8 +149,59 @@ class GillespieEvent(Process):
             'mRNA': {
                 'A mRNA': d_c}}
 
-        print(f'received interval: {interval}')
+        # print(f'received interval: {interval}')
 
         return update
 
 
+class GillespieSimulation(ProcessEnsemble):
+    def __init__(self, config=None, core=None):
+        super.__init__(config, core)
+
+
+    def inputs_interval(self):
+        return {
+            'DNA': 'map[default 1]',
+            'mRNA': {
+                'A mRNA': 'default 1',
+                'B mRNA': 'default 1'}}
+
+                    # {
+                    # '_type': 'map',
+                    # '_value': 'float(default:1.0)'},
+
+                    # 'G': {
+                    #     '_type': 'float',
+                    #     '_default': '1.0'}},
+
+
+    def outputs_interval(self):
+        return {
+            'interval': 'interval'}
+
+
+    # def interface_interval(self):
+
+
+    def calculate_interval(self, inputs):
+        # retrieve the state values
+        g = input['DNA']['A gene']
+        c = input['mRNA']['A mRNA']
+
+        array_state = np.array([g, c])
+
+        # Calculate propensities
+        propensities = [
+            self.config['ktsc'] * array_state[0],
+            self.config['kdeg'] * array_state[1]]
+        prop_sum = sum(propensities)
+
+        # The wait time is distributed exponentially
+        interval = np.random.exponential(scale=prop_sum)
+
+        output = {
+            'interval': interval}
+
+        print(f'produced interval: {output}')
+
+        return output

process-bigraph-0.0.25/process_bigraph/processes/__init__.py

@@ -0,0 +1,21 @@
+from process_bigraph.processes.parameter_scan import ToySystem, ODE, RunProcess, ParameterScan
+from process_bigraph.processes.growth_division import Grow, Divide
+# from process_bigraph.experiments.minimal_gillespie import GillespieInterval, GillespieEvent
+
+
+TOY_PROCESSES = {
+    'ToySystem': ToySystem,
+    'ToyODE': ODE,
+    'RunProcess': RunProcess,
+    'ParameterScan': ParameterScan,
+    'grow': Grow,
+    'divide': Divide,
+    # 'GillespieInterval': GillespieInterval,
+    # 'GillespieEvent': GillespieEvent
+}
+
+
+def register_processes(core):
+    for name, process in TOY_PROCESSES.items():
+        core.register_process(name, process)
+    return core

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

@@ -1,26 +1,18 @@
-import pytest
-from process_bigraph.composite import Step, Process, Composite, ProcessTypes, interval_time_precision, deep_merge
+from process_bigraph.composite import Step, Process, 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
 

{process-bigraph-0.0.23 → process-bigraph-0.0.25}/process_bigraph/processes/parameter_scan.py

@@ -2,7 +2,7 @@ import copy
 import numpy as np
 
 from bigraph_schema import get_path, set_path, transform_path
-from process_bigraph.composite import Step, Process, Composite, ProcessTypes, interval_time_precision, deep_merge
+from process_bigraph.composite import Step, Process, Composite, interval_time_precision, deep_merge
 
 
 class ToySystem(Process):
@@ -33,9 +33,7 @@ class ToySystem(Process):
 class ODE(Process):
     config_schema = 'ode_config'
 
-    def __init__(self, config, core):
-        super().__init__(config, core)
-
+    def initialize(self, config=None):
         self.reactions_count = len(self.config['rates'])
 
         self.species_count = len(
@@ -70,10 +68,9 @@ class RunProcess(Step):
         'timestep': 'float',
         'runtime': 'float'}
 
-    def __init__(self, config, core):
-        super().__init__(config, core)
+    def initialize(self, config):
 
-        self.process = core.deserialize('process', {
+        self.process = self.core.deserialize('process', {
             '_type': 'process',
             'address': self.config['process_address'],
             'config': self.config['process_config'],
@@ -154,7 +151,7 @@ class RunProcess(Step):
                         **self.inputs_config),
                     'outputs': {}}}}
 
-        self.composite = Composite(composite_config, core=core)
+        self.composite = Composite(composite_config, core=self.core)
 
     def inputs(self):
         return self.process.inputs()
@@ -232,8 +229,7 @@ class ParameterScan(Step):
         'timestep': 'float',
         'runtime': 'float'}
 
-    def __init__(self, config, core):
-        super().__init__(config, core)
+    def initialize(self, config=None):
 
         self.steps_count = int(
             self.config['runtime'] / self.config['timestep']) + 1
@@ -283,7 +279,7 @@ class ParameterScan(Step):
         self.scan = Composite({
             'bridge': bridge,
             'state': state},
-            core=core)
+            core=self.core)
 
         results_schema = {}
         process = self.first_process()
@@ -339,4 +335,3 @@ class ParameterScan(Step):
         return {
             'results': update}
 
-

{process-bigraph-0.0.23 → process-bigraph-0.0.25}/process_bigraph/tests.py

@@ -1,13 +1,21 @@
 """
 Tests for Process Bigraph
 """
-
-import random
 import pytest
+import random
 
 from process_bigraph import register_types
-from process_bigraph.composite import Process, Step, Composite, merge_collections, ProcessTypes
-from process_bigraph.experiments.growth_division import grow_divide_agent
+from process_bigraph.composite import (
+    Process, Step, Composite, merge_collections, ProcessTypes
+)
+from process_bigraph.processes.growth_division import grow_divide_agent
+from process_bigraph.processes import TOY_PROCESSES
+
+
+@pytest.fixture
+def core():
+    core = ProcessTypes()
+    return register_types(core)
 
 
 class IncreaseProcess(Process):
@@ -329,9 +337,6 @@ class SimpleCompartment(Process):
         return update
 
 
-# TODO: create reaction registry, register this under "divide"
-
-
 def engulf_reaction(config):
     return {
         'redex': {},
@@ -533,15 +538,13 @@ def test_parameter_scan(core):
             'outputs': {
                 'results': ['results']}}}
 
-    # TODO: make a Workflow class that is a Step-composite
-    # scan = Workflow({
     scan = Composite({
         'bridge': {
             'outputs': {
                 'results': ['results']}},
         'state': state},
         core=core)
-            
+
     # TODO: make a method so we can run it directly, provide some way to get the result out
     # result = scan.update({})
     result = scan.update({}, 0.0)
@@ -574,16 +577,12 @@ def test_grow_divide(core):
                 'environment': ['environment']}}},
         core=core)
 
-    import ipdb; ipdb.set_trace()
-
     updates = composite.update({
         'environment': {
             '0': {
                 'mass': 1.1}}},
         100.0)
 
-    import ipdb; ipdb.set_trace()
-
     # TODO: mass is not synchronized between inside and outside the composite?
 
     assert '0_0_0_0_1' in composite.state['environment']
@@ -592,45 +591,6 @@ def test_grow_divide(core):
 
 def test_gillespie_composite(core):
     composite_schema = {
-        # This all gets inferred -------------
-        # ==================================
-        # 'composition': {
-        #     'interval': {
-        #         '_type': 'step',
-        #         '_ports': {
-        #             'inputs': {
-        #                 'DNA': {
-        #                     'G': 'float'},
-        #                 'mRNA': {
-        #                     'C': 'float'}},
-        #             'outputs': {
-        #                 'interval': 'float'}}},
-        #     'event': {
-        #         '_type': 'process',
-        #         '_ports': {
-        #             'DNA': {
-        #                 'G': 'float'},
-        #             'mRNA': {
-        #                 'C': 'float'}},
-        #             'interval': 'float'}}},
-        #     'emitter': {
-        #         '_type': 'step',
-        #         '_ports': {
-        #             'inputs': {
-        #                 'DNA': {
-        #                     'G': 'float'},
-        #                 'mRNA': {
-        #                     'C': 'float'}}},
-        #     'DNA': {
-        #         'G': 'float'},
-        #     'mRNA': {
-        #         'C': 'float'}},
-        # 'schema': {
-        #     'DNA': {
-        #         'G': 'float'},
-        #     'mRNA': {
-        #         'C': 'float'}},
-
         'bridge': {
             'inputs': {
                 'DNA': ['DNA'],
@@ -674,31 +634,6 @@ def test_gillespie_composite(core):
                     'mRNA': ['mRNA'],
                     'interval': ['event', 'interval']}}}}
 
-                #     'emit': 'any'},
-                # 'inputs': ()}}}
-
-
-            # TODO: provide a way to emit everything:
-            # 'emitter': emit_all(
-            #     'console-emitter',
-            #     exclusions={'DNA': {}}),
-
-            # TODO: make us able to wire to the top with '**'
-            # 'ram': {
-            #     '_type': 'step',
-            #     'address': 'local:ram-emitter',
-            #     'config': {
-            #         'ports': {
-            #             'inputs': 'tree[any]'}},
-            #     'wires': {
-            #         'inputs': '**'}}}}
-
-            # 'DNA': {
-            #     'G': 13.0},
-
-            # 'mRNA': {
-            #     'C': '21.0'}}}
-
     gillespie = Composite(
         composite_schema,
         core=core)
@@ -751,3 +686,4 @@ if __name__ == '__main__':
     test_parameter_scan(core)
 
     test_stochastic_deterministic_composite(core)
+

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: process-bigraph
-Version: 0.0.23
+Version: 0.0.25
 Summary: UNKNOWN
 Home-page: https://github.com/vivarium-collective/process-bigraph
 Author: Ryan Spangler, Eran Agmon

{process-bigraph-0.0.23 → process-bigraph-0.0.25}/process_bigraph.egg-info/SOURCES.txt

@@ -13,7 +13,7 @@ process_bigraph.egg-info/dependency_links.txt
 process_bigraph.egg-info/requires.txt
 process_bigraph.egg-info/top_level.txt
 process_bigraph/experiments/__init__.py
-process_bigraph/experiments/growth_division.py
 process_bigraph/experiments/minimal_gillespie.py
 process_bigraph/processes/__init__.py
+process_bigraph/processes/growth_division.py
 process_bigraph/processes/parameter_scan.py

{process-bigraph-0.0.23 → process-bigraph-0.0.25}/process_bigraph.egg-info/requires.txt

@@ -1,6 +1,5 @@
 bigraph-schema
 numpy
-pytest>=6.2.5
-pymongo
+pytest
 orjson
 matplotlib

{process-bigraph-0.0.23 → process-bigraph-0.0.25}/setup.py

@@ -2,7 +2,7 @@ import re
 from setuptools import setup, find_packages
 
 
-VERSION = '0.0.23'
+VERSION = '0.0.25'
 
 
 with open("README.md", "r") as readme:
@@ -30,6 +30,7 @@ setup(
     packages=[
         'process_bigraph',
         'process_bigraph.processes',
+        'process_bigraph.experiments'
     ],
     classifiers=[
         "Development Status :: 3 - Alpha",
@@ -49,8 +50,7 @@ setup(
     install_requires=[
         "bigraph-schema",
         "numpy",
-        "pytest>=6.2.5",
-        "pymongo",
+        "pytest",
         "orjson",
         "matplotlib"
     ]

process-bigraph-0.0.23/process_bigraph/processes/__init__.py

@@ -1,18 +0,0 @@
-from process_bigraph.processes.parameter_scan import ToySystem, ODE, RunProcess, ParameterScan
-from process_bigraph.experiments.growth_division import Grow, Divide
-from process_bigraph.experiments.minimal_gillespie import GillespieInterval, GillespieEvent
-
-
-def register_processes(core):
-    core.register_process('ToySystem', ToySystem)
-    core.register_process('ToyODE', ODE)
-    core.register_process('RunProcess', RunProcess)
-    core.register_process('ParameterScan', ParameterScan)
-
-    core.register_process('grow', Grow)
-    core.register_process('divide', Divide)
-
-    core.register_process('GillespieInterval', GillespieInterval)
-    core.register_process('GillespieEvent', GillespieEvent)
-
-    return core