process-bigraph 0.0.44__tar.gz → 0.0.46__tar.gz

{process_bigraph-0.0.44/process_bigraph.egg-info → process_bigraph-0.0.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: process-bigraph
-Version: 0.0.44
+Version: 0.0.46
 Summary: protocol and execution for compositional systems biology
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

process_bigraph-0.0.46/process_bigraph/package/discover.py

@@ -0,0 +1,99 @@
+import importlib.metadata
+import pkgutil
+import inspect
+
+from process_bigraph import Process, Step, ProcessTypes
+
+
+def recursive_dynamic_import(core, package_name: str, verbose: bool = False) -> list[tuple[str, Process | Step ]]:
+    classes_to_import = []
+    adjusted_package_name: str = package_name.replace("-", "_")
+    # TODO: fix module name discovery based on package name
+    if adjusted_package_name == "vivarium_interface":
+        adjusted_package_name = "vivarium"
+    try:
+        module = importlib.import_module(adjusted_package_name)
+    except ModuleNotFoundError:
+        # TODO: Add code to try and find correct module name via accessing `top_level.txt`,
+        #  and getting the correct module name
+        # find top-level.txt
+        # find correct module name
+        # return recursive_dynamic_import(correct_module_name)
+        raise ModuleNotFoundError(f"Error: module `{adjusted_package_name}` not found when trying to dynamically import!")
+
+    if hasattr(module, 'register_types'):
+        core = module.register_types(core)
+
+    class_members = inspect.getmembers(module, inspect.isclass)
+    if verbose:
+        print(f"Processing {len(class_members)} members...")
+    for class_name, clazz in class_members:
+        if clazz == Process:
+            if verbose:
+                print(f'Process `{class_name}` skipped, because it is `Process` itself.')
+            continue
+        if clazz == Step:
+            if verbose:
+                print(f'Process `{class_name}` skipped, because it is `Step` itself.')
+            continue
+        if issubclass(clazz, Process):
+            if verbose:
+                print(f'Process `{class_name}` added to queue!')
+            classes_to_import.append((f"{package_name}.{class_name}", clazz))
+        if issubclass(clazz, Step):
+            if verbose:
+                print(f'Step `{class_name}` added to queue!')
+            classes_to_import.append((f"{package_name}.{class_name}", clazz))
+        if verbose:
+            print(f'Invalid `{class_name}` skipped; not a Process nor Step!')
+
+    path = module.__path__ if hasattr(module, '__path__') else "<No `__path__` attr>"
+    modules_to_check = pkgutil.iter_modules(module.__path__) if hasattr(module, '__path__') else []
+    if verbose:
+        print(f"Checking for modules in `{module.__name__}` [path: {path}]...")
+    for _module_loader, subname, isPkg in modules_to_check:
+        # if not isPkg: continue
+        if verbose:
+            print(f"Found: {adjusted_package_name}.{subname}")
+        classes_to_import += recursive_dynamic_import(core, f"{adjusted_package_name}.{subname}", verbose)
+    if verbose:
+        print(f'Found {len(classes_to_import)} classes in `{package_name}` to import'"")
+    return classes_to_import
+
+
+def load_local_modules(core, verbose: bool = False) -> list[tuple[str, Process | Step ]]:
+    if verbose:
+        print("Loading local registry...")
+    packages = importlib.metadata.distributions()
+    classes_to_load = []
+    for package in packages:
+        if not does_package_require_process_bigraph(package):
+            continue
+        # If a package requires BSail, it probably has abstractions for us; worth importing.
+        if verbose:
+            print(f'Relevant Processes found in `{package.name}`...')
+        classes_to_load += recursive_dynamic_import(core, package.name, verbose)
+
+    return classes_to_load
+
+def does_package_require_process_bigraph(package: importlib.metadata.Distribution) -> bool:
+    for entry in ([] if package.requires is None else package.requires):
+        if "process-bigraph" in entry:
+            return True
+    return False
+
+
+def discover_packages(core, verbose: bool) -> ProcessTypes:
+    # core = ProcessTypes()
+    counter = 0
+    for name, clazz in load_local_modules(core, verbose):
+        if name not in core.process_registry.registry:
+            core.register_process(name, clazz)
+            if verbose:
+                counter += 1
+                print(f'Registered `{name}` to `{clazz.__name__}`')
+    if verbose:
+        print(f"Registered {counter} processes...")
+
+    return core
+

process_bigraph-0.0.46/process_bigraph/protocols/__init__.py

@@ -0,0 +1,17 @@
+"""
+===============================================
+Protocols for retrieving processes from address
+===============================================
+"""
+
+from process_bigraph.protocols.local import local_lookup, LocalProtocol
+from process_bigraph.protocols.parallel import ParallelProtocol
+from process_bigraph.protocols.docker import DockerProtocol
+from process_bigraph.protocols.rest import RestProtocol
+
+
+BASE_PROTOCOLS = {
+    'local': LocalProtocol,
+    'parallel': ParallelProtocol,
+    'docker': DockerProtocol,
+    'rest': RestProtocol}

process_bigraph-0.0.46/process_bigraph/protocols/docker.py

@@ -0,0 +1,262 @@
+"""
+===============================================
+Protocol for running processes in parallel using
+python multiprocessing
+===============================================
+"""
+
+import sys
+import json
+import time
+import uuid
+import pstats
+import socket
+from pathlib import Path
+from typing import Any, Dict, Optional, Union, List, Tuple
+
+import docker
+
+from docker import DockerClient
+
+from process_bigraph.composite import Process, SyncUpdate
+from process_bigraph.protocols.protocol import Protocol
+from process_bigraph.protocols.local import LocalProtocol
+
+
+def setup_working_directory(path):
+    if not path.exists():
+        path.mkdir(
+            parents=True,
+            exist_ok=True)
+
+
+DOCKER_WORKING_PATH = Path('containers')
+
+
+def receive(sock, buffer_size=4096):
+    data = bytearray()
+    while True:
+        packet = sock.recv(buffer_size)
+        data.extend(packet)
+        if packet[-1] == 10:
+            break
+    return data
+
+
+class DockerProcess(Process):
+    def __init__(self, client, data, config, core) -> None:
+        """
+        Sets up a docker container to be a process and communicates with
+        it over a socket.
+        """
+
+        self._ended = False
+        self._pending_command: Optional[
+            Tuple[str, Optional[tuple], Optional[dict]]] = None
+
+        self.client = client
+        self.data = data
+        self.image = self.data['image']
+        self.host = self.data.get('host', '0.0.0.0')
+        self.port = self.data.get('port', 11111)
+
+        self.uuid = str(uuid.uuid4())
+        self.work_path = DOCKER_WORKING_PATH / self.uuid
+        self.config_path = self.work_path / 'config'
+
+        setup_working_directory(self.config_path)
+
+        with open(self.config_path / 'config.json', 'w') as config_file:
+            json.dump(config, config_file)
+
+        self.container = self.client.containers.run(
+            self.image,
+            ports={f'{self.port}/tcp': str(self.port)},
+            volumes={
+                str(self.config_path.absolute()): {
+                    'bind': '/config', 'mode': 'ro'}},
+            detach=True)
+
+        # wait to start the socket until the container is running (!)
+        while self.container.status != "running":
+            print(f"'{self.image}' status: {self.container.status} - waiting...")
+            time.sleep(1)
+            self.container.reload()
+
+        print(f'{self.image} now running')
+
+        self.socket = socket.socket(
+            socket.AF_INET,
+            socket.SOCK_STREAM)
+
+        self.socket.connect((
+            self.host,
+            self.port))
+
+        super().__init__(config, core=core)
+
+    def send_command(
+            self, command: str, args: Optional[tuple] = None,
+            kwargs: Optional[dict] = None,
+            run_pre_check: bool = True) -> None:
+        '''Send a command to the parallel process.
+
+        See :py:func:``_handle_parallel_process`` for details on how the
+        command will be handled.
+        '''
+        if run_pre_check:
+            self.pre_send_command(command, args, kwargs)
+
+        send = {
+            'command': command,
+            'arguments': {}}
+
+        if command == 'update':
+            state, interval = args
+            send['arguments'] = {
+                'state': state,
+                'interval': interval}
+
+        send_json = f'{json.dumps(send)}\n'.encode('utf-8')
+
+        print(f'sending {send_json}')
+
+        self.socket.sendall(
+            send_json)
+
+    def get_command_result(self):
+        """Get the result of a command sent to the parallel process.
+
+        Commands and their results work like a queue, so unlike
+        :py:class:`Process`, you can technically call this method
+        multiple times and get different return values each time.
+        This behavior is subject to change, so you should not rely on
+        it.
+
+        Returns:
+            The command result.
+        """
+
+        if not self._pending_command:
+            raise RuntimeError(
+                'Trying to retrieve command result, but no command is '
+                'pending.')
+        self._pending_command = None
+
+        result_json = receive(self.socket)
+        result = json.loads(result_json)
+
+        return result
+
+    def get(self):
+        return self.get_command_result()
+
+    @staticmethod
+    def generate_state(config=None):
+        """Generate static initial state for user configuration or inspection."""
+        return {}
+
+    @property
+    def config(self) -> Dict[str, Any]:
+        return self._config
+
+    @config.setter
+    def config(self, config):
+        self._config = config
+        
+    @property
+    def composition(self) -> Dict[str, Any]:
+        return {
+            '_type': 'process',
+            '_inputs': self.inputs(),
+            '_outputs': self.outputs()}
+
+    @composition.setter
+    def composition(self, composition):
+        pass
+
+    @property
+    def state(self) -> Dict[str, Any]:
+        return self
+
+    @state.setter
+    def state(self, state):
+        pass
+
+    def initial_state(self):
+        """Return initial state values, if applicable."""
+        return {}
+
+    def inputs(self):
+        """
+        Return a dictionary mapping input port names to bigraph types.
+
+        Example:
+            {'glucose': 'float', 'biomass': 'map[float]'}
+        """
+        return self.run_command('inputs', ())
+
+    def outputs(self):
+        """
+        Return a dictionary mapping output port names to bigraph types.
+
+        Example:
+            {'growth_rate': 'float'}
+        """
+        return self.run_command('outputs', ())
+
+    def invoke(self, state, interval):
+        result = self.run_command('update', (state, interval))
+        return SyncUpdate(result)
+
+    def update(self, state, interval):
+        return self.run_command('update', (state, interval))
+
+    def end(self) -> None:
+        """
+        remove the container
+        """
+        # Only end once.
+        if self._ended:
+            return
+
+        self.socket.close()
+
+        self.container.stop()
+        self.container.remove()
+
+        self._ended = True
+
+    def __del__(self) -> None:
+        self.end()
+
+def initialize_docker():
+    client: DockerClient = None
+    try:
+        client = docker.from_env()
+    except Exception:
+        pass # We handle this by checking if client is None elsewhere.
+    return client
+
+class DockerProtocol(Protocol):
+    client = initialize_docker()
+
+    @classmethod
+    def interface(cls, core, data):
+        if cls.client is None:
+            raise NotImplementedError("Docker was unable to be initialized; check your installation and try again.")
+        image = cls.client.images.get(
+            data['image'])
+
+        config_schema = json.loads(
+            image.labels['config_schema'])
+
+        def instantiate(config, core=None):
+            return DockerProcess(
+                cls.client,
+                data,
+                config,
+                core)
+
+        instantiate.config_schema = config_schema
+        return instantiate

process_bigraph-0.0.46/process_bigraph/protocols/local.py

@@ -0,0 +1,43 @@
+"""
+===============================================
+Protocol for processes running locally
+===============================================
+"""
+
+from bigraph_schema.protocols import local_lookup_module
+from process_bigraph.protocols.protocol import Protocol
+
+
+def local_lookup_registry(core, address):
+    """Process Registry Protocol
+
+    Retrieves from the process registry
+    """
+    return core.process_registry.access(address)
+
+
+def local_lookup(core, address):
+    """Local Lookup Protocol
+
+    Retrieves local processes, from the process registry or from a local module
+    """
+    if address[0] == '!':
+        instantiate = local_lookup_module(address[1:])
+    else:
+        instantiate = local_lookup_registry(core, address)
+    return instantiate
+
+
+class LocalProtocol(Protocol):
+    @staticmethod
+    def interface(core, address):
+        if isinstance(address, str):
+            return local_lookup(core, address)
+        elif isinstance(address, dict):
+            if 'address' not in address:
+                raise Exception(f'must include address in local protocol: {address}')
+            else:
+                return local_lookup(core, address['address'])
+        else:
+            raise Exception(f'address must be str or dict, not {address}')
+            

process_bigraph-0.0.46/process_bigraph/protocols/parallel.py

@@ -0,0 +1,241 @@
+"""
+===============================================
+Protocol for running processes in parallel using
+python multiprocessing
+===============================================
+"""
+
+import sys
+import pstats
+from typing import Any, Dict, Optional, Union, List, Tuple
+
+import multiprocessing
+from multiprocessing.connection import Connection
+
+from process_bigraph.composite import Process
+from process_bigraph.protocols.protocol import Protocol
+from process_bigraph.protocols.local import LocalProtocol
+
+def _handle_parallel_process(
+        connection: Connection, process: Process,
+        profile: bool) -> None:
+    '''Handle a parallel Vivarium :term:`process`.
+
+    This function is designed to be passed as ``target`` to
+    ``Multiprocess()``. In a loop, it receives :term:`process commands`
+    from a pipe, passes those commands to the parallel process, and
+    passes the result back along the pipe.
+
+    The special command ``end`` is handled directly by this function.
+    This command causes the function to exit and therefore shut down the
+    OS process created by multiprocessing.
+
+    Args:
+        connection: The child end of a multiprocessing pipe. All
+            communications received from the pipe should be a 3-tuple of
+            the form ``(command, args, kwargs)``, and the tuple contents
+            will be passed to :py:meth:`Process.run_command`. The
+            result, which may be of any type, will be sent back through
+            the pipe.
+        process: The process running in parallel.
+        profile: Whether to profile the process.
+    '''
+    if profile:
+        profiler = cProfile.Profile()
+        profiler.enable()
+    running = True
+
+    while running:
+        command, args, kwargs = connection.recv()
+
+        if command == 'end':
+            running = False
+        else:
+            result = process.run_command(command, args, kwargs)
+            connection.send(result)
+
+    if profile:
+        profiler.disable()
+        stats = pstats.Stats(profiler)
+        connection.send(stats.stats)  # type: ignore
+
+    connection.close()
+
+
+class ParallelProcess(Process):
+    def __init__(
+            self, process: Process, profile: bool = False,
+            stats_objs: Optional[List[pstats.Stats]] = None) -> None:
+        """Wraps a :py:class:`Process` for multiprocessing.
+
+        To run a simulation distributed across multiple processors, we
+        use Python's multiprocessing tools. This object runs in the main
+        process and manages communication between the main (parent)
+        process and the child process with the :py:class:`Process` that
+        this object manages.
+
+        Most methods pass their name and arguments to
+        :py:class:`Process.run_command`.
+
+        Args:
+            process: The Process to manage.
+            profile: Whether to use cProfile to profile the subprocess.
+            stats_objs: List to add cProfile stats objs to when process
+                is deleted. Only used if ``profile`` is true.
+        """
+
+        self._ended = False
+        self._pending_command: Optional[
+            Tuple[str, Optional[tuple], Optional[dict]]] = None
+        self.process = process
+
+        super().__init__(process.config, core=process.core)
+
+        self.profile = profile
+        self._stats_objs = stats_objs
+        assert not self.profile or self._stats_objs is not None
+        # Linux's default ``fork`` start method causes a lot of random
+        # issues, including python/cpython#110770 (prompted this change)
+        # and python/cpython#84559 (general discussion). This default
+        # will be changed to ``forkserver`` in Python 3.14. MacOS and
+        # Windows use the much safer but slightly slower ``spawn`` method
+        if sys.platform not in ("darwin", "win32"):
+            start_method = "forkserver"
+        else:
+            start_method = "spawn"
+        mp_ctx = multiprocessing.get_context(start_method)
+        self.parent, child = mp_ctx.Pipe()
+        self.multiprocess = mp_ctx.Process( # type: ignore[attr-defined]
+            target=_handle_parallel_process,
+            args=(child, process, self.profile))
+        self.multiprocess.start()
+
+    def send_command(
+            self, command: str, args: Optional[tuple] = None,
+            kwargs: Optional[dict] = None,
+            run_pre_check: bool = True) -> None:
+        '''Send a command to the parallel process.
+
+        See :py:func:``_handle_parallel_process`` for details on how the
+        command will be handled.
+        '''
+        if run_pre_check:
+            self.pre_send_command(command, args, kwargs)
+        self.parent.send((command, args, kwargs))
+
+    def get_command_result(self):
+        """Get the result of a command sent to the parallel process.
+
+        Commands and their results work like a queue, so unlike
+        :py:class:`Process`, you can technically call this method
+        multiple times and get different return values each time.
+        This behavior is subject to change, so you should not rely on
+        it.
+
+        Returns:
+            The command result.
+        """
+        if not self._pending_command:
+            raise RuntimeError(
+                'Trying to retrieve command result, but no command is '
+                'pending.')
+        self._pending_command = None
+        return self.parent.recv()
+
+    def get(self):
+        return self.get_command_result()
+
+    @staticmethod
+    def generate_state(config=None):
+        """Generate static initial state for user configuration or inspection."""
+        return type(self.process).generate_state(config)
+
+    @property
+    def config(self) -> Dict[str, Any]:
+        return self.run_command('config')
+
+    @config.setter
+    def config(self, config):
+        self.run_command('set_config', (config,))
+
+    @property
+    def composition(self) -> Dict[str, Any]:
+        return self.run_command('composition')
+
+    @composition.setter
+    def composition(self, composition):
+        self.run_command('set_composition', (composition,))
+
+    @property
+    def state(self) -> Dict[str, Any]:
+        return self.run_command('state')
+
+    @state.setter
+    def state(self, state):
+        self.run_command('set_state', (state,))
+
+    def initial_state(self):
+        """Return initial state values, if applicable."""
+        return self.run_command('initial_state', ())
+
+    def inputs(self):
+        """
+        Return a dictionary mapping input port names to bigraph types.
+
+        Example:
+            {'glucose': 'float', 'biomass': 'map[float]'}
+        """
+        # return self.run_command('inputs', ())
+        return self.process.inputs()
+
+    def outputs(self):
+        """
+        Return a dictionary mapping output port names to bigraph types.
+
+        Example:
+            {'growth_rate': 'float'}
+        """
+        return self.process.outputs()
+        # return self.run_command('outputs', ())
+
+    def invoke(self, state, interval):
+        self.send_command('update', (state, interval))
+        return self
+
+    def update(self, state, interval):
+        return self.run_command('update', (state, interval))
+
+    def end(self) -> None:
+        """End the child process.
+
+        If profiling was enabled, then when the child process ends, it
+        will compile its profiling stats and send those to the parent.
+        The parent then saves those stats in ``self.stats``.
+        """
+        # Only end once.
+        if self._ended:
+            return
+        self.send_command('end')
+        if self.profile:
+            stats = pstats.Stats()
+            stats.stats = self.get_command_result()  # type: ignore
+            assert self._stats_objs is not None
+            self._stats_objs.append(stats)
+        self.multiprocess.join()
+        self.multiprocess.close()
+        self._ended = True
+
+    def __del__(self) -> None:
+        self.end()
+
+
+class ParallelProtocol(Protocol):
+    @staticmethod
+    def interface(core, address):
+        local_instantiate = LocalProtocol.interface(core, address)
+        def instantiate(config, core=None):
+            instance = local_instantiate(config, core=core)
+            return ParallelProcess(instance)
+
+        instantiate.config_schema = local_instantiate.config_schema
+        return instantiate

process_bigraph-0.0.46/process_bigraph/protocols/protocol.py

@@ -0,0 +1,3 @@
+class Protocol():
+    def __init__(self):
+        pass

process_bigraph-0.0.46/process_bigraph/protocols/rest.py

@@ -0,0 +1,171 @@
+"""
+===============================================
+Protocol for running processes in parallel using
+python multiprocessing
+===============================================
+"""
+
+import sys
+import json
+import time
+import uuid
+import pstats
+import socket
+from pathlib import Path
+from typing import Any, Dict, Optional, Union, List, Tuple
+
+from urllib.parse import urlparse, urlunparse
+import requests
+
+from process_bigraph.composite import Process, SyncUpdate
+from process_bigraph.protocols.protocol import Protocol
+from process_bigraph.protocols.local import LocalProtocol
+
+
+def rest_get(url, parameters=None):
+    return requests.get(
+        urlunparse(url),
+        json=parameters).json()
+
+
+def rest_post(url, parameters=None):
+    return requests.post(
+        urlunparse(url),
+        json=parameters).json()
+
+
+class RestProcess(Process):
+    def __init__(self, data, config, core) -> None:
+        self._ended = False
+
+        self.process_name = data['process']
+
+        self.base_url = data['base_url'] or urlparse('http://localhost:22222')
+
+        self.initialize_url = self.base_url._replace(
+            path=f'/process/{self.process_name}/initialize')
+        self.process_id = rest_post(
+            self.initialize_url,
+            config)
+
+        self.end_url = self.base_url._replace(
+            path=f'/process/{self.process_name}/end/{self.process_id}')
+        self.inputs_url = self.base_url._replace(
+            path=f'/process/{self.process_name}/inputs/{self.process_id}')
+        self.outputs_url = self.base_url._replace(
+            path=f'/process/{self.process_name}/outputs/{self.process_id}')
+        self.update_url = self.base_url._replace(
+            path=f'/process/{self.process_name}/update/{self.process_id}')
+
+        super().__init__(config, core=core)
+
+    def get(self):
+        return self.get_command_result()
+
+    @staticmethod
+    def generate_state(config=None):
+        """Generate static initial state for user configuration or inspection."""
+        return {}
+
+    @property
+    def config(self) -> Dict[str, Any]:
+        return self._config
+
+    @config.setter
+    def config(self, config):
+        self._config = config
+
+    @property
+    def composition(self) -> Dict[str, Any]:
+        return {
+            '_type': 'process',
+            '_inputs': self.inputs(),
+            '_outputs': self.outputs()}
+
+    @composition.setter
+    def composition(self, composition):
+        pass
+
+    @property
+    def state(self) -> Dict[str, Any]:
+        return self
+
+    @state.setter
+    def state(self, state):
+        pass
+
+    def initial_state(self):
+        """Return initial state values, if applicable."""
+        return {}
+
+    def inputs(self):
+        """
+        Return a dictionary mapping input port names to bigraph types.
+
+        Example:
+            {'glucose': 'float', 'biomass': 'map[float]'}
+        """
+        response = rest_get(self.inputs_url)
+
+        return response
+
+    def outputs(self):
+        """
+        Return a dictionary mapping output port names to bigraph types.
+
+        Example:
+            {'growth_rate': 'float'}
+        """
+        response = rest_get(self.outputs_url)
+
+        return response
+
+    def update(self, state, interval):
+        response = rest_post(self.update_url, {
+            'state': state,
+            'interval': interval})
+        return response
+
+    def end(self) -> None:
+        """
+        remove the container
+        """
+        # Only end once.
+        if self._ended:
+            return
+
+        rest_post(self.end_url)
+
+        self._ended = True
+
+    def __del__(self) -> None:
+        self.end()
+
+
+class RestProtocol(Protocol):
+    @classmethod
+    def interface(cls, core, data):
+        ssh = ''
+        process_name = data['process']
+        host = data['host']
+        port = data['port']
+        base_raw = f'http{ssh}://{host}:{port}'
+        base_url = urlparse(base_raw)
+
+        config_schema_url = base_url._replace(
+            path=f'/process/{process_name}/config-schema')
+        config_schema = rest_get(
+            config_schema_url)
+
+        instance = {
+            'base_url': base_url,
+            'process': process_name}
+
+        def instantiate(config, core=None):
+            return RestProcess(
+                instance,
+                config,
+                core)
+
+        instantiate.config_schema = config_schema
+        return instantiate

process_bigraph-0.0.46/process_bigraph/protocols/socket.py

@@ -0,0 +1,2 @@
+import socket
+

{process_bigraph-0.0.44 → process_bigraph-0.0.46/process_bigraph.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: process-bigraph
-Version: 0.0.44
+Version: 0.0.46
 Summary: protocol and execution for compositional systems biology
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{process_bigraph-0.0.44 → process_bigraph-0.0.46}/process_bigraph.egg-info/SOURCES.txt

@@ -27,6 +27,15 @@ process_bigraph.egg-info/requires.txt
 process_bigraph.egg-info/top_level.txt
 process_bigraph/experiments/__init__.py
 process_bigraph/experiments/minimal_gillespie.py
+process_bigraph/package/__init__.py
+process_bigraph/package/discover.py
 process_bigraph/processes/__init__.py
 process_bigraph/processes/growth_division.py
-process_bigraph/processes/parameter_scan.py
+process_bigraph/processes/parameter_scan.py
+process_bigraph/protocols/__init__.py
+process_bigraph/protocols/docker.py
+process_bigraph/protocols/local.py
+process_bigraph/protocols/parallel.py
+process_bigraph/protocols/protocol.py
+process_bigraph/protocols/rest.py
+process_bigraph/protocols/socket.py

{process_bigraph-0.0.44 → process_bigraph-0.0.46}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "process-bigraph"
-version = "0.0.44"
+version = "0.0.46"
 description = "protocol and execution for compositional systems biology"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -16,7 +16,10 @@ dependencies = [
 [tool.setuptools]
 packages = [
     "process_bigraph",
-    "process_bigraph.processes"
+    "process_bigraph.processes",
+    "process_bigraph.protocols",
+    "process_bigraph.experiments",
+    "process_bigraph.package"
 ]
 
 [tool.uv.sources]