process-bigraph 0.0.39__tar.gz → 0.0.41__tar.gz

{process-bigraph-0.0.39/process_bigraph.egg-info → process-bigraph-0.0.41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: process-bigraph
-Version: 0.0.39
+Version: 0.0.41
 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.39 → process-bigraph-0.0.41}/process_bigraph/__init__.py

@@ -1,9 +1,8 @@
 import pprint
 from bigraph_schema.registry import deep_merge, default
 from process_bigraph.processes import register_processes
-from process_bigraph.composite import Process, Step, Composite, interval_time_precision
-from process_bigraph.process_types import ProcessTypes
-from process_bigraph.emitter import Emitter, gather_emitter_results, generate_emitter_state
+from process_bigraph.composite import Process, Step, Composite, interval_time_precision, ProcessTypes
+from process_bigraph.emitter import Emitter, gather_emitter_results, generate_emitter_state, BASE_EMITTERS
 
 
 pretty = pprint.PrettyPrinter(indent=2)
@@ -42,9 +41,12 @@ def register_types(core):
         'rates': 'map[float]',
         'species': 'map[float]'})
 
-    core = register_processes(
+    register_processes(
         core)
 
     return core
 
 
+def allocate_core():
+    core = ProcessTypes()
+    return register_types(core)

{process-bigraph-0.0.39 → process-bigraph-0.0.41}/process_bigraph/composite.py

@@ -11,7 +11,7 @@ import collections
 from typing import Dict
 
 from bigraph_schema import (
-    Edge, Registry, 
+    Edge, Registry, TypeSystem, visit_method,
     get_path, set_path, resolve_path, hierarchy_depth, deep_merge,
     is_schema_key, strip_schema_keys)
 
@@ -22,6 +22,7 @@ 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']
@@ -951,3 +952,369 @@ class Composite(Process):
         self.bridge_updates = []
 
         return updates
+
+
+# ======================
+# Process Type Functions
+# ======================
+
+
+def apply_process(schema, current, update, top_schema, top_state, path, core):
+    """Apply an update to a process."""
+    process_schema = schema.copy()
+    process_schema.pop('_apply')
+    return core.apply_update(
+        process_schema,
+        current,
+        update,
+        top_schema=top_schema,
+        top_state=top_state,
+        path=path)
+
+
+def check_process(schema, state, core):
+    """Check if this is a process."""
+    return 'instance' in state and isinstance(
+        state['instance'],
+        Edge)
+
+
+def fold_visit(schema, state, method, values, core):
+    visit = visit_method(
+        schema,
+        state,
+        method,
+        values,
+        core)
+
+    return visit
+
+
+def divide_process(schema, state, values, core):
+    # daughter_configs must have a config per daughter
+
+    daughter_configs = values.get(
+        'daughter_configs',
+        [{} for index in range(values['divisions'])])
+
+    if 'config' not in state:
+        return daughter_configs
+
+    existing_config = state['config']
+
+    divisions = []
+    for index in range(values['divisions']):
+        daughter_config = copy.deepcopy(
+            existing_config)
+        daughter_config = deep_merge(
+            daughter_config,
+            daughter_configs[index])
+
+        # TODO: provide a way to override inputs and outputs
+        daughter_state = {
+            'address': state['address'],
+            'config': daughter_config,
+            'inputs': copy.deepcopy(state['inputs']),
+            'outputs': copy.deepcopy(state['outputs'])}
+
+        if 'interval' in state:
+            daughter_state['interval'] = state['interval']
+
+        divisions.append(daughter_state)
+
+    return divisions
+
+
+def serialize_process(schema, value, core):
+    """Serialize a process to a JSON-safe representation."""
+    # TODO -- need to get back the protocol: address and the config
+    process = value.copy()
+    process['config'] = core.serialize(
+        process['instance'].config_schema,
+        process['config'])
+    del process['instance']
+    return process
+
+
+def deserialize_process(schema, encoded, core):
+    """Deserialize a process from a serialized state.
+
+    This function is used by the type system to deserialize a process.
+
+    :param encoded: A JSON-safe representation of the process.
+    :param bindings: The bindings to use for deserialization.
+    :param core: The type system to use for deserialization.
+
+    :returns: The deserialized state with an instantiated process.
+    """
+    encoded = encoded or {}
+    schema = schema or {}
+
+    default = core.default(schema)
+    deserialized = deep_merge(default, encoded)
+
+    if not deserialized.get('address'):
+        return deserialized
+
+    protocol, address = deserialized['address'].split(':', 1)
+
+    existing_instance = 'instance' in deserialized and deserialized['instance']
+    if existing_instance:
+        instantiate = type(deserialized['instance'])
+    else:
+        process_lookup = core.protocol_registry.access(protocol)
+        if not process_lookup:
+            raise Exception(f'protocol "{protocol}" not implemented')
+
+        instantiate = process_lookup(core, address)
+        if not instantiate:
+            raise Exception(f'process "{address}" not found')
+
+    config = core.deserialize(
+        instantiate.config_schema,
+        deserialized.get('config', {}))
+
+    interval = core.deserialize(
+        'interval',
+        deserialized.get('interval'))
+
+    if interval is None:
+        interval = core.default(
+            schema.get(
+                'interval',
+                'interval'))
+
+    if existing_instance:
+        process = deserialized['instance']
+    else:
+        process = instantiate(
+            config,
+            core=core)
+
+        deserialized['instance'] = process
+
+    # TODO: this mutating the original value directly into
+    #   the return value is weird (?)
+    shared = deserialized.get('shared', {})
+    deserialized['shared'] = {}
+    if shared:
+        for step_id, step_config in shared.items():
+            step = deserialize_step(
+                'step',
+                step_config,
+                core)
+
+            step['instance'].register_shared(
+                process)
+
+            deserialized['shared'][step_id] = step
+
+    deserialized['config'] = config
+    deserialized['interval'] = interval
+    deserialized['_inputs'] = copy.deepcopy(
+        deserialized['instance'].inputs())
+    deserialized['_outputs'] = copy.deepcopy(
+        deserialized['instance'].outputs())
+
+    return deserialized
+
+
+def deserialize_step(schema, encoded, core):
+    default = core.default(schema)
+    deserialized = deep_merge(default, encoded)
+
+    if not deserialized['address']:
+        return deserialized
+
+    protocol, address = deserialized['address'].split(':', 1)
+
+    existing_instance = 'instance' in deserialized and deserialized['instance']
+    if existing_instance:
+        instantiate = type(deserialized['instance'])
+    else:
+        process_lookup = core.protocol_registry.access(protocol)
+        if not process_lookup:
+            raise Exception(f'protocol "{protocol}" not implemented')
+
+        instantiate = process_lookup(core, address)
+        if not instantiate:
+            raise Exception(f'process "{address}" not found')
+
+    config = core.deserialize(
+        instantiate.config_schema,
+        deserialized.get('config', {}))
+
+    if not existing_instance:
+        process = instantiate(config, core=core)
+        deserialized['instance'] = process
+
+    deserialized['config'] = config
+    deserialized['_inputs'] = copy.deepcopy(
+        deserialized['instance'].inputs())
+    deserialized['_outputs'] = copy.deepcopy(
+        deserialized['instance'].outputs())
+
+    return deserialized
+
+
+# ===================
+# Process Type System
+# ===================
+
+class ProcessTypes(TypeSystem):
+    """
+    ProcessTypes class extends the TypeSystem class to include process types.
+    It maintains a registry of process types and provides methods to register
+    new process types, protocols, and emitters.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.process_registry = Registry()
+        self.protocol_registry = Registry()
+
+        self.update_types(PROCESS_TYPES)
+        self.register_protocols(BASE_PROTOCOLS)
+
+        self.register_process('composite', Composite)
+
+
+    def register_protocols(self, protocols):
+        """Register protocols with the core"""
+        self.protocol_registry.register_multiple(protocols)
+
+
+    def register_process(
+            self,
+            name,
+            process_data
+    ):
+        """
+        Registers a new process type in the process registry.
+
+        Args:
+            name (str): The name of the process type.
+            process_data: The data associated with the process type.
+        """
+        self.process_registry.register(name, process_data)
+
+
+    def register_processes(self, processes):
+        for process_key, process_data in processes.items():
+            self.register_process(
+                process_key,
+                process_data)
+
+
+    def initialize_edge_state(self, schema, path, edge):
+        """
+        Initialize the state for an edge based on the schema and the edge.
+        """
+        initial_state = edge['instance'].initial_state()
+        if not initial_state:
+            return initial_state
+
+        input_ports = copy.deepcopy(get_path(schema, path + ('_inputs',)))
+        output_ports = copy.deepcopy(get_path(schema, path + ('_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)
+
+        return state
+
+
+    def default_state(self, process_class, initial_state=None):
+        default_config = self.default(
+            process_class.config_schema)
+
+        instance = process_class(
+            default_config,
+            core=self)
+
+        state = {
+            '_type': 'process',
+            'address': f'local:!{process_class.__module__}.{process_class.__name__}',
+            'config': default_config,
+            'inputs': instance.default_inputs(),
+            'outputs': instance.default_outputs()}
+
+        if issubclass(process_class, Process):
+            state['interval'] = 1.0
+
+        if initial_state:
+            state = deep_merge(
+                state,
+                initial_state)
+
+        return state
+
+
+PROCESS_TYPES = {
+    'protocol': {
+        '_type': 'protocol',
+        '_inherit': 'string'},
+
+    'emitter_mode': 'enum[none,all,stores,bridge,paths,ports]',
+
+    'interval': {
+        '_type': 'interval',
+        '_inherit': 'float',
+        '_apply': 'set',
+        '_default': '1.0'},
+
+    'step': {
+        '_type': 'step',
+        '_inherit': 'edge',
+        '_apply': apply_process,
+        '_serialize': serialize_process,
+        '_deserialize': deserialize_step,
+        '_check': check_process,
+        '_fold': fold_visit,
+        '_divide': divide_process,
+        '_description': '',
+        # TODO: support reference to type parameters from other states
+        'address': 'protocol',
+        'config': 'quote'},
+
+    # TODO: slice process to allow for navigating through a port
+    'process': {
+        '_type': 'process',
+        '_inherit': 'edge',
+        '_apply': apply_process,
+        '_serialize': serialize_process,
+        '_deserialize': deserialize_process,
+        '_check': check_process,
+        '_fold': fold_visit,
+        '_divide': divide_process,
+        '_description': '',
+        # TODO: support reference to type parameters from other states
+        'interval': 'interval',
+        'address': 'protocol',
+        'config': 'quote',
+        'shared': 'map[step]'},
+}
+
+
+BASE_PROTOCOLS = {
+    'local': local_lookup}
+

{process-bigraph-0.0.39 → process-bigraph-0.0.41}/process_bigraph/process_types.py

@@ -306,6 +306,32 @@ class ProcessTypes(TypeSystem):
         return state
 
 
+    def default_state(self, process_class, initial_state=None):
+        default_config = self.default(
+            process_class.config_schema)
+
+        instance = process_class(
+            default_config,
+            core=self)
+
+        state = {
+            '_type': 'process',
+            'address': f'local:!{process_class.__module__}.{process_class.__name__}',
+            'config': default_config,
+            'inputs': instance.default_inputs(),
+            'outputs': instance.default_outputs()}
+
+        if issubclass(process_class, Process):
+            state['interval'] = 1.0        
+
+        if initial_state:
+            state = deep_merge(
+                state,
+                initial_state)
+
+        return state
+
+
 PROCESS_TYPES = {
     'protocol': {
         '_type': 'protocol',

{process-bigraph-0.0.39 → process-bigraph-0.0.41}/process_bigraph/processes/__init__.py

@@ -1,5 +1,6 @@
 from process_bigraph.processes.parameter_scan import ToySystem, ODE, RunProcess, ParameterScan
 from process_bigraph.processes.growth_division import Grow, Divide
+from process_bigraph.emitter import BASE_EMITTERS
 # from process_bigraph.experiments.minimal_gillespie import GillespieInterval, GillespieEvent
 
 
@@ -18,4 +19,8 @@ TOY_PROCESSES = {
 def register_processes(core):
     for name, process in TOY_PROCESSES.items():
         core.register_process(name, process)
+
+    core = core.register_processes(
+        BASE_EMITTERS)
+
     return core

{process-bigraph-0.0.39 → process-bigraph-0.0.41}/process_bigraph/tests.py

@@ -7,10 +7,9 @@ import random
 from bigraph_schema import default
 from process_bigraph import register_types
 
-from process_bigraph.composite import Process, Step, Composite, merge_collections, match_star_path
+from process_bigraph.composite import Process, Step, Composite, merge_collections, match_star_path, ProcessTypes
 
-from process_bigraph.processes.growth_division import grow_divide_agent
-from process_bigraph.process_types import ProcessTypes
+from process_bigraph.processes.growth_division import grow_divide_agent, Grow, Divide
 from process_bigraph.emitter import emitter_from_wires, gather_emitter_results
 
 
@@ -871,20 +870,68 @@ def test_star_update(core):
     assert star.state['Compartments']['2']['Shared Environment']['counts']['biomass'] == 2899
 
 
+class GlobalProcess(Process):
+    config_schema = {}
+
+
+    def initialize(self, config):
+        pass
+
+
+    
+
+
+def test_default_process_state(core):
+    # provide some initial values
+    default_rate = {
+        'config': {
+            'rate': 0.001}}
+
+    # generate a default state for the Grow process
+    default_grow = core.default_state(
+        Grow,
+        default_rate)
+
+    # create a composite from the default process state
+    composite = Composite({
+        'state': {
+            'grow': default_grow,
+            'mass': 1.0}},
+        core=core)
+
+    # run the composite
+    composite.run(10.0)
+
+    # assert the process ran and the mass increased
+    assert composite.state['mass'] > 1.0
+
+    default_divide = core.default_state(
+        Divide)
+
+    assert 'interval' not in default_divide
+
+
+def test_update_removal(core):
+    return {}
+
+
 def test_stochastic_deterministic_composite(core):
     # TODO make the demo for a hybrid stochastic/deterministic simulator
     pass
 
+
 def test_match_star_path(core):
     assert match_star_path(["first", "list", "test"], ["first", "*", "test"])
     assert not match_star_path(["first", "list", "tent"], ["first", "*", "test"])
     assert match_star_path(["first", "list", "test"], ["first", "list", "test"])
 
+
 if __name__ == '__main__':
     core = ProcessTypes()
     core = register_types(core)
 
     test_default_config(core)
+    test_default_process_state(core)
     test_merge_collections(core)
     test_process(core)
     test_composite(core)
@@ -904,4 +951,4 @@ if __name__ == '__main__':
     test_merge_schema(core)
     test_grow_divide(core)
     test_star_update(core)
-    test_match_star_path(core)
+    test_match_star_path(core)

{process-bigraph-0.0.39 → process-bigraph-0.0.41/process_bigraph.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: process-bigraph
-Version: 0.0.39
+Version: 0.0.41
 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.39 → process-bigraph-0.0.41}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "process-bigraph"
-version = "0.0.39"
+version = "0.0.41"
 description = ""
 readme = "README.md"
 requires-python = "==3.12.9"

{process-bigraph-0.0.39 → process-bigraph-0.0.41}/setup.py

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