process-bigraph 1.3.1__tar.gz → 1.4.2__tar.gz

{process_bigraph-1.3.1/process_bigraph.egg-info → process_bigraph-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: process-bigraph
-Version: 1.3.1
+Version: 1.4.2
 Summary: protocol and execution for compositional systems biology
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -12,6 +12,14 @@ Requires-Dist: pint>=0.24.4
 Requires-Dist: scipy>=1.8
 Requires-Dist: pandas
 Requires-Dist: sympy
+Provides-Extra: ray
+Requires-Dist: ray>=2.10; extra == "ray"
+Provides-Extra: server-rest
+Requires-Dist: fastapi>=0.116.1; extra == "server-rest"
+Requires-Dist: fastapi-utils>=0.8.0; extra == "server-rest"
+Requires-Dist: uvicorn>=0.35.0; extra == "server-rest"
+Requires-Dist: fire; extra == "server-rest"
+Requires-Dist: typing-inspect>=0.9.0; extra == "server-rest"
 Dynamic: license-file
 
 # Process-Bigraph

{process_bigraph-1.3.1 → process_bigraph-1.4.2}/process_bigraph/composite.py

@@ -530,6 +530,21 @@ def build_step_network(steps):
                         if producer not in node['after']:
                             node['before'].add(producer)
 
+    # Precompute each step's direct dependents (= the set of steps
+    # that consume something this step writes). ``find_downstream``
+    # was reconstructing this every tick by walking
+    # output_paths × explode_path × nodes lookup; doing it once at
+    # graph-build time makes ``find_downstream`` a plain BFS over a
+    # cached adjacency list.
+    for step_key, ancestor in ancestors.items():
+        direct = set()
+        for output_path in ancestor['output_paths'] or []:
+            for subpath in explode_path(output_path):
+                node = nodes.get(subpath)
+                if node is not None:
+                    direct.update(node['after'])
+        ancestor['_direct_dependents'] = frozenset(direct)
+
     return ancestors, nodes
 
 
@@ -552,36 +567,25 @@ def build_trigger_state(nodes, paths):
 
 def find_downstream(steps, nodes, upstream):
     """
-    Given a set of updated steps, identify all downstream steps that depend on them.
-
-    Args:
-        steps: Step metadata with input/output info.
-        nodes: Dependency graph.
-        upstream: Initial set of triggered step paths.
+    Given a set of updated steps, identify all downstream steps that
+    depend on them — directly or transitively.
 
-    Returns:
-        Set of all steps affected directly or transitively.
+    BFS over the cached ``_direct_dependents`` adjacency that
+    ``build_step_network`` precomputes per step. ``nodes`` is no
+    longer consulted on the hot path (kept in the signature for
+    backward compatibility with callers that still pass it).
     """
     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 subpath in explode_path(output):
-                        if subpath in nodes:
-                            for dependent in nodes[subpath]['after']:
-                                down.add(dependent)
-                visited.add(step_path)
-        downstream |= down
-
+    queue = list(upstream)
+    while queue:
+        step_path = queue.pop()
+        meta = steps.get(step_path)
+        if meta is None:
+            continue
+        for dep in meta.get('_direct_dependents', ()):
+            if dep not in downstream:
+                downstream.add(dep)
+                queue.append(dep)
     return downstream
 
 
@@ -1281,6 +1285,14 @@ class Composite(Process):
         # step hot path releases the GIL (numpy / scipy / numba / C
         # extensions: yes; pure-Python loops: no).
         'parallel_steps': 'boolean{false}',
+        # Time-scheduled processes: when True, the per-tick `run` loop
+        # fans out invocations across a thread pool. Right tool when
+        # processes' update() releases the GIL (network I/O, numpy /
+        # scipy / C extensions, Ray actor calls). Wrong tool when
+        # update() is mostly pure Python — threads will just trade the
+        # GIL and you'll see no speedup. The thread pool is shared with
+        # parallel_steps and bounded by parallel_workers.
+        'parallel_processes': 'boolean{false}',
         'parallel_workers': 'maybe[integer]',
         # When True, ``initialize`` trusts ``state`` as-is and skips the
         # per-process ``link_state`` + ``combine`` pass that normally
@@ -1401,6 +1413,7 @@ class Composite(Process):
         # field in interface_schema for the rationale (threading vs.
         # multiprocessing for inner parallelism).
         self._parallel_steps = bool(self.config.get('parallel_steps', False))
+        self._parallel_processes = bool(self.config.get('parallel_processes', False))
         self._parallel_workers = self.config.get('parallel_workers')
         self._step_executor = None  # lazy: created on first run_steps need
 
@@ -2359,10 +2372,14 @@ class Composite(Process):
             full_step = math.inf
 
             # Run each process and compute the minimum time step that advances simulation
-            for path in self.process_paths:
-                process = get_path(self.state, path)
-                full_step = self.run_process(
-                    path, process, end_time, full_step, force_complete)
+            if self._parallel_processes and len(self.process_paths) > 1:
+                full_step = self._run_processes_layer_parallel(
+                    end_time, full_step, force_complete)
+            else:
+                for path in self.process_paths:
+                    process = get_path(self.state, path)
+                    full_step = self.run_process(
+                        path, process, end_time, full_step, force_complete)
 
             if full_step == math.inf:
                 # No process ran — jump to the next scheduled process time
@@ -2492,6 +2509,95 @@ class Composite(Process):
 
         return full_step
 
+    def _run_processes_layer_parallel(
+            self,
+            end_time: float,
+            full_step: float,
+            force_complete: bool,
+    ) -> float:
+        """Parallel analog of the per-tick `for path in self.process_paths`
+        loop. Splits run_process into a schedule pass (sequential, cheap)
+        and an invoke pass (parallelized over the same ThreadPoolExecutor
+        used by parallel_steps).
+
+        Semantics are identical to the serial loop: same schedule decisions,
+        same Defers stored at the same self.front[path] slots. Only the
+        order in which `instance.invoke()` calls happen changes.
+
+        Safe when:
+          - `instance.update()` releases the GIL on its hot path (network
+            I/O, Ray actor calls, numpy/scipy/C extensions).
+          - Processes don't share mutable state across each other.
+
+        Not safe when processes share mutable state or hold global locks.
+        Like `parallel_steps`, this is opt-in for that reason.
+        """
+        # ---- schedule pass: decide which processes are due now ---------- #
+        due = []  # (path, process_dict, state, future_time, process_interval)
+        for path in self.process_paths:
+            process = get_path(self.state, path)
+            if path not in self.front:
+                self.front[path] = empty_front(self.state['global_time'])
+            process_time = self.front[path]['time']
+
+            if process_time <= self.state['global_time']:
+                if 'future' in self.front[path]:
+                    future_front = self.front[path].pop('future')
+                    process_interval = future_front['interval']
+                    state = future_front['state']
+                else:
+                    state = self._cached_view(path)
+                    state_interval = process['interval']
+                    process_interval = process['instance'].calculate_timestep(
+                        state_interval, state)
+                    process['interval'] = process_interval
+
+                future = (
+                    min(process_time + process_interval, end_time)
+                    if force_complete
+                    else process_time + process_interval
+                )
+                if self.global_time_precision:
+                    future = round(future, self.global_time_precision)
+
+                interval = future - self.state['global_time']
+                if interval < full_step:
+                    full_step = interval
+
+                if future <= end_time:
+                    due.append((path, process, state, future, process_interval))
+            else:
+                process_delay = process_time - self.state['global_time']
+                if process_delay < full_step:
+                    full_step = process_delay
+
+        if not due:
+            return full_step
+
+        # ---- invoke pass: parallel via the shared step executor --------- #
+        # process_update calls instance.invoke(state, interval); that's the
+        # only blocking part. Note: process_update accumulates into
+        # self.process_update_time — there's a benign race on that counter
+        # under contention, but it's only a metric (not correctness).
+        def _invoke(item):
+            path, process, state, _future, process_interval = item
+            return path, self.process_update(
+                path, process, state, process_interval, already_clean=True)
+
+        if len(due) > 1:
+            pool = self._get_step_executor(len(due))
+            results = list(pool.map(_invoke, due))
+        else:
+            results = [_invoke(due[0])]
+
+        # ---- bookkeep pass: store Defers + update self.front time slots - #
+        future_by_path = {p: fut for (p, _, _, fut, _) in due}
+        for path, defer in results:
+            self.front[path]['time'] = future_by_path[path]
+            self.front[path]['update'] = defer
+
+        return full_step
+
     def process_update(
             self,
             path: Union[str, Tuple[str, ...]],

process_bigraph-1.4.2/process_bigraph/protocols/ray.py

@@ -0,0 +1,320 @@
+"""
+RayProcess — distributed transport backed by Ray actors.
+
+Pair with the ``parallel_processes=True`` flag on Composite so the orchestrator
+can dispatch per-step ``update()`` calls concurrently — that's what turns N
+clients talking to a Ray actor pool into N parallel solves.
+
+Install with the optional ray extra::
+
+    pip install process-bigraph[ray]
+
+Architecture: pooled actors
+---------------------------
+Each (process_class, process_config) pair backs a fixed pool of N Ray actors
+(default N = ncpu). Every RayProcess client is round-robin assigned to one
+pool actor; many "logical" processes share the same physical worker. This
+bounds memory at O(ncpu) underlying-process instances instead of O(clients),
+and bounds spawn cost at ncpu actors regardless of how many clients the
+orchestrator wires up.
+
+Why pooled, not actor-per-client:
+  - One actor per cell at moderate grids (e.g. 256 cells with a 150 MB cobra
+    Model each) trivially OOMs a typical workstation.
+  - Per-actor spawn cost (process fork + module import + heavy state init)
+    is 50-500 ms; paying that 256× per run is minutes of overhead.
+  - Ray actor methods are serialized by default — concurrent calls to one
+    actor are queued, so non-thread-safe state inside the underlying Process
+    isn't a concern.
+
+Pool lifecycle:
+  - Pools live for the lifetime of the Python interpreter by default.
+    Subsequent ``Composite`` runs re-use the same actors — no re-spawn,
+    no model reload.
+  - Call ``shutdown_pools()`` to tear them down explicitly (useful in tests).
+  - ``RayProcess.end()`` is a no-op — clients come and go but actors persist.
+
+Usage
+-----
+1. Register the underlying Process classes once at startup so each Ray
+   worker can resolve them by name::
+
+       from process_bigraph.protocols.ray import register_process_class
+       from my_pkg.processes import MyProcess
+       register_process_class("MyProcess", MyProcess)
+
+2. Reference RayProcess in your composite spec::
+
+       "worker_0": {
+           "_type": "process",
+           "address": "local:RayProcess",
+           "config": {
+               "process_class": "MyProcess",
+               "process_config": { ... MyProcess's config ... },
+               # optional: cap pool size (default = os.cpu_count())
+               "pool_size": 8,
+           },
+           "inputs":  { ... },
+           "outputs": { ... },
+           "interval": 0.1,
+       }
+
+3. Pass ``parallel_processes=True`` to Composite so the orchestrator dispatches
+   the per-step ``update()`` calls concurrently.
+"""
+
+from __future__ import annotations
+
+import os
+import json
+import hashlib
+from typing import Any, Dict, List, Type, Optional
+
+# Ray is optional. We let the module import even when ray isn't installed
+# (so package scanners like discover_packages don't trip), and only raise
+# a helpful error when something tries to actually use it.
+try:
+    import ray
+    _RAY_IMPORT_ERROR: Optional[ImportError] = None
+except ImportError as _e:  # pragma: no cover
+    ray = None  # type: ignore[assignment]
+    _RAY_IMPORT_ERROR = _e
+
+
+def _require_ray() -> None:
+    """Guard for code paths that need ray. Raises a clear install hint."""
+    if ray is None:
+        raise ImportError(
+            "process_bigraph.protocols.ray requires the optional `ray` "
+            "dependency. Install with: pip install process-bigraph[ray]"
+        ) from _RAY_IMPORT_ERROR
+
+
+from process_bigraph import Process
+
+
+# ---------------------------------------------------------------------------
+# Process class registry.
+# Ray pickles this into each new actor at spawn so workers don't need to
+# import the same modules in their startup script.
+# ---------------------------------------------------------------------------
+_PROCESS_REGISTRY: Dict[str, Type[Process]] = {}
+
+
+def register_process_class(name: str, cls: Type[Process]) -> None:
+    """Register a Process class so RayProcess can resolve it by name."""
+    _PROCESS_REGISTRY[name] = cls
+
+
+def get_registry() -> Dict[str, Type[Process]]:
+    return dict(_PROCESS_REGISTRY)
+
+
+# ---------------------------------------------------------------------------
+# Ray actor — one per pool slot. Holds a single Process instance.
+#
+# Declared as a plain class at module load time so this file imports cleanly
+# without ray installed. ``ray.remote(...)`` is applied lazily on first use
+# (cached) inside ``_remote_actor_class()``.
+# ---------------------------------------------------------------------------
+class _ProcessActor:
+    def __init__(self, registry: Dict[str, Type[Process]],
+                 class_name: str, config: dict):
+        for k, v in registry.items():
+            _PROCESS_REGISTRY[k] = v
+        cls = _PROCESS_REGISTRY[class_name]
+        from process_bigraph import allocate_core
+        self.instance = cls(config, core=allocate_core())
+
+    def inputs(self):
+        return self.instance.inputs()
+
+    def outputs(self):
+        return self.instance.outputs()
+
+    def update(self, state: dict, interval: float):
+        return self.instance.update(state, interval)
+
+
+_REMOTE_ACTOR_CLASS = None  # cached ray.remote(_ProcessActor)
+
+
+def _remote_actor_class():
+    """Return the ray-remote-wrapped _ProcessActor, building it on first call."""
+    global _REMOTE_ACTOR_CLASS
+    if _REMOTE_ACTOR_CLASS is None:
+        _require_ray()
+        _REMOTE_ACTOR_CLASS = ray.remote(_ProcessActor)
+    return _REMOTE_ACTOR_CLASS
+
+
+# ---------------------------------------------------------------------------
+# Actor pool. One pool per (process_class, process_config). Persistent across
+# RayProcess instances and across simulation runs.
+# ---------------------------------------------------------------------------
+class _ActorPool:
+    def __init__(self, class_name: str, config: dict, n_workers: int):
+        registry = get_registry()
+        actor_cls = _remote_actor_class()
+        # Spawn all actors concurrently — actor.remote() returns immediately;
+        # we don't ray.get on the constructor. The first .inputs.remote() call
+        # implicitly waits for the actor to be ready.
+        self.actors = [
+            actor_cls.remote(registry, class_name, config)
+            for _ in range(n_workers)
+        ]
+        self._next = 0
+
+    def assign(self):
+        actor = self.actors[self._next % len(self.actors)]
+        self._next += 1
+        return actor
+
+    def shutdown(self):
+        for a in self.actors:
+            try:
+                ray.kill(a)
+            except Exception:
+                pass
+        self.actors = []
+
+
+# Module-level pool registry, keyed by (class_name, config_hash).
+_POOLS: Dict[str, _ActorPool] = {}
+
+
+def _config_hash(config: Any) -> str:
+    """Stable hash of a process_config dict for pool keying."""
+    try:
+        s = json.dumps(config, sort_keys=True, default=repr)
+    except TypeError:
+        s = repr(config)
+    return hashlib.sha1(s.encode()).hexdigest()[:12]
+
+
+def _pool_key(class_name: str, config: Any) -> str:
+    return f"{class_name}:{_config_hash(config)}"
+
+
+def _get_or_make_pool(class_name: str, config: dict,
+                      n_workers: Optional[int]) -> _ActorPool:
+    key = _pool_key(class_name, config)
+    pool = _POOLS.get(key)
+    if pool is None:
+        if n_workers is None:
+            n_workers = max(1, os.cpu_count() or 4)
+        pool = _ActorPool(class_name, config, n_workers)
+        _POOLS[key] = pool
+    return pool
+
+
+def shutdown_pools() -> None:
+    """Tear down all actor pools. Call at program exit / between test runs."""
+    for pool in list(_POOLS.values()):
+        pool.shutdown()
+    _POOLS.clear()
+
+
+def pool_stats() -> List[dict]:
+    """Diagnostic: list all live pools."""
+    return [
+        {"key": k, "n_actors": len(p.actors)}
+        for k, p in _POOLS.items()
+    ]
+
+
+# ---------------------------------------------------------------------------
+# Client — what the orchestrator sees as a Process.
+# ---------------------------------------------------------------------------
+class RayProcess(Process):
+    """A Process whose update() runs on a pooled remote Ray actor.
+
+    Config:
+        process_class : str
+            Name of a Process subclass registered via register_process_class().
+        process_config : dict
+            Config dict passed to the underlying Process subclass.
+        pool_size : int (optional)
+            Number of actors in the pool for this (class, config). Defaults
+            to os.cpu_count(). The first RayProcess instantiation for a
+            given (class, config) sizes the pool — subsequent instances
+            reuse the existing pool and ignore this field.
+    """
+
+    config_schema = {
+        "process_class": "string",
+        "process_config": "node",
+        "pool_size": "maybe[integer]",
+    }
+
+    def initialize(self, config):
+        _require_ray()
+        if not ray.is_initialized():
+            ray.init(ignore_reinit_error=True, log_to_driver=False)
+
+        class_name = config["process_class"]
+        if class_name not in _PROCESS_REGISTRY:
+            raise KeyError(
+                f"Process class {class_name!r} not in RayProcess registry. "
+                f"Call register_process_class({class_name!r}, <cls>) first."
+            )
+
+        pool = _get_or_make_pool(
+            class_name,
+            config["process_config"],
+            config.get("pool_size"),
+        )
+        self.actor = pool.assign()
+
+        # Cache port schemas — one round-trip per client at init. (We could
+        # cache per-pool to drop this, but it's a single call and the result
+        # could in principle differ if the underlying Process introspects
+        # config-specific port shapes.)
+        self._inputs  = ray.get(self.actor.inputs.remote())
+        self._outputs = ray.get(self.actor.outputs.remote())
+
+    def inputs(self):
+        return self._inputs
+
+    def outputs(self):
+        return self._outputs
+
+    def update(self, state, interval):
+        # Blocking get: releases the GIL while the actor runs. ParallelComposite
+        # gives us N concurrent in-flight calls = N actors busy in parallel.
+        return ray.get(self.actor.update.remote(state, float(interval)))
+
+    def end(self):
+        # Pool actors persist across RayProcess instances — DON'T kill them
+        # here. Use shutdown_pools() to tear down explicitly.
+        pass
+
+
+# ---------------------------------------------------------------------------
+# Smoke test — wraps IncreaseProcess (a built-in toy Process) in a Ray pool
+# and runs a few updates. Useful as both a sanity check and an example.
+# ---------------------------------------------------------------------------
+if __name__ == "__main__":
+    from process_bigraph import allocate_core
+    from process_bigraph.processes.examples import IncreaseProcess
+
+    register_process_class("IncreaseProcess", IncreaseProcess)
+
+    proc_a = RayProcess(
+        {"process_class": "IncreaseProcess",
+         "process_config": {"rate": 0.5},
+         "pool_size": 2},
+        core=allocate_core(),
+    )
+    proc_b = RayProcess(
+        {"process_class": "IncreaseProcess",
+         "process_config": {"rate": 0.5},
+         "pool_size": 2},  # ignored — pool already exists
+        core=allocate_core(),
+    )
+    print("pool stats:", pool_stats())
+    for proc, label in [(proc_a, "A"), (proc_b, "B")]:
+        upd = proc.update({"level": 4.0}, interval=1.0)
+        print(f"{label} update :", upd)
+    shutdown_pools()
+    print("after shutdown:", pool_stats())

process_bigraph-1.4.2/process_bigraph/server/rest.py

@@ -0,0 +1,91 @@
+from typing import Any, Dict, Union
+import uuid
+
+from fastapi import FastAPI
+from fastapi_utils.cbv import cbv
+from fastapi_utils.inferring_router import InferringRouter
+
+from bigraph_schema import Edge
+
+
+def make_router(core):
+    router = InferringRouter()
+    processes = {}
+
+    @cbv(router)
+    class ProcessRouter():
+        def __init__(self):
+            self.core = core
+            self.processes = processes
+
+        def find_process_class(self, process):
+            return self.core.link_registry.get(process, Edge)
+
+        @router.get('/import-types')
+        def get_import_types(self):
+            pass
+
+        @router.get('/type-packages')
+        def get_type_packages(self):
+            pass
+
+        @router.get('/list-types')
+        def get_list_types(self):
+            return list(self.core.registry.keys())
+
+        @router.get('/list-processes')
+        def get_list_processes(self):
+            return list(self.core.link_registry.keys())
+
+        @router.get('/process/{process}/config-schema')
+        def get_config_schema(self, process: str):
+            process_class = self.find_process_class(process)
+            if process_class is None:
+                return {'process-not-found': 'true'}
+            else:
+                return process_class.config_schema
+
+        @router.post('/process/{process}/initialize')
+        def post_initialize(self, process: str, config: dict):
+            process_id = uuid.uuid4()
+            process_class = self.find_process_class(process)
+            process_instance = process_class(
+                config,
+                core=self.core)
+            self.processes[str(process_id)] = process_instance
+
+            print(self.processes)
+            print(process_id)
+            return process_id
+
+        @router.get('/process/{process}/inputs/{process_id}')
+        def get_inputs(self, process: str, process_id: str):
+            print(self.processes)
+            return self.processes[process_id].inputs()
+
+        @router.get('/process/{process}/outputs/{process_id}')
+        def get_outputs(self, process: str, process_id: str):
+            return self.processes[process_id].outputs()
+
+        @router.post('/process/{process}/update/{process_id}')
+        def post_update(self, process: str, process_id: str, data: dict):
+            state = data['state']
+            interval = data['interval']
+
+            return self.processes[process_id].update(
+                state,
+                interval)
+
+        @router.post('/process/{process}/end/{process_id}')
+        def post_end(self, process: str, process_id: str):
+            del self.processes[process_id]
+
+    return router
+
+
+def start_server(core):
+    app = FastAPI()
+    router = make_router(core)
+    app.include_router(router)
+
+    return app

process_bigraph-1.4.2/process_bigraph/server/start.py

@@ -0,0 +1,46 @@
+"""
+CLI entry point for hosting process-bigraph processes over a network protocol.
+
+Usage:
+    python -m process_bigraph.server.start --host 0.0.0.0 --port 22222
+    python -m process_bigraph.server.start --protocol rest --port 22222
+
+Currently supported protocols: rest (FastAPI/uvicorn). Future: grpc, etc.
+Each protocol's server-side dependencies are gated behind an optional extra.
+"""
+
+import fire
+
+
+def start(host: str = "0.0.0.0", port: int = 22222, protocol: str = "rest"):
+    """Start a process-bigraph protocol server.
+
+    Args:
+        host: bind address (default 0.0.0.0)
+        port: bind port (default 22222)
+        protocol: which transport to expose (default 'rest'). Each protocol
+            has its own server-side dependency extra:
+              rest: pip install process-bigraph[server-rest]
+    """
+    from process_bigraph import allocate_core
+
+    if protocol == "rest":
+        try:
+            import uvicorn
+            from process_bigraph.server.rest import start_server
+        except ImportError as e:
+            raise ImportError(
+                "REST server requires the [server-rest] extra: "
+                "pip install process-bigraph[server-rest]"
+            ) from e
+        core = allocate_core()
+        app = start_server(core)
+        uvicorn.run(app, host=host, port=port)
+    else:
+        raise ValueError(
+            f"Unknown protocol {protocol!r}. Supported: rest"
+        )
+
+
+if __name__ == "__main__":
+    fire.Fire(start)

{process_bigraph-1.3.1 → process_bigraph-1.4.2/process_bigraph.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: process-bigraph
-Version: 1.3.1
+Version: 1.4.2
 Summary: protocol and execution for compositional systems biology
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -12,6 +12,14 @@ Requires-Dist: pint>=0.24.4
 Requires-Dist: scipy>=1.8
 Requires-Dist: pandas
 Requires-Dist: sympy
+Provides-Extra: ray
+Requires-Dist: ray>=2.10; extra == "ray"
+Provides-Extra: server-rest
+Requires-Dist: fastapi>=0.116.1; extra == "server-rest"
+Requires-Dist: fastapi-utils>=0.8.0; extra == "server-rest"
+Requires-Dist: uvicorn>=0.35.0; extra == "server-rest"
+Requires-Dist: fire; extra == "server-rest"
+Requires-Dist: typing-inspect>=0.9.0; extra == "server-rest"
 Dynamic: license-file
 
 # Process-Bigraph

{process_bigraph-1.3.1 → process_bigraph-1.4.2}/process_bigraph.egg-info/SOURCES.txt

@@ -27,7 +27,11 @@ process_bigraph/processes/parameter_scan.py
 process_bigraph/processes/reaction.py
 process_bigraph/protocols/__init__.py
 process_bigraph/protocols/parallel.py
+process_bigraph/protocols/ray.py
 process_bigraph/protocols/rest.py
 process_bigraph/protocols/socket.py
+process_bigraph/server/__init__.py
+process_bigraph/server/rest.py
+process_bigraph/server/start.py
 process_bigraph/types/__init__.py
 process_bigraph/types/process.py

process_bigraph-1.4.2/process_bigraph.egg-info/requires.txt

@@ -0,0 +1,16 @@
+bigraph-schema>=1.2.3
+matplotlib
+pint>=0.24.4
+scipy>=1.8
+pandas
+sympy
+
+[ray]
+ray>=2.10
+
+[server-rest]
+fastapi>=0.116.1
+fastapi-utils>=0.8.0
+uvicorn>=0.35.0
+fire
+typing-inspect>=0.9.0

process_bigraph-1.4.2/pyproject.toml

@@ -0,0 +1,64 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "process-bigraph"
+version = "1.4.2"
+description = "protocol and execution for compositional systems biology"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "bigraph-schema>=1.2.3",
+    "matplotlib",
+    "pint>=0.24.4",
+    "scipy>=1.8",
+    "pandas",
+    "sympy",
+]
+
+[project.optional-dependencies]
+# Distributed Ray actor backend for processes (RayProcess + actor pool).
+# Install with: pip install process-bigraph[ray]
+ray = [
+    "ray>=2.10",
+]
+
+# REST server (FastAPI/uvicorn) that hosts processes over HTTP, paired with
+# the existing RestProcess client.
+# Install with: pip install process-bigraph[server-rest]
+server-rest = [
+    "fastapi>=0.116.1",
+    "fastapi-utils>=0.8.0",
+    "uvicorn>=0.35.0",
+    "fire",
+    "typing-inspect>=0.9.0",
+]
+
+[dependency-groups]
+dev = [
+    "ipdb>=0.13.13",
+    "ipykernel",
+    "jupyter",
+    "notebook",
+    "pytest",
+    "pytest-cov",
+    "httpx",
+    # Test the optional extras without forcing them on everyone.
+    "ray>=2.10",
+    "fastapi>=0.116.1",
+    "fastapi-utils>=0.8.0",
+    "uvicorn>=0.35.0",
+    "fire",
+    "typing-inspect>=0.9.0",
+]
+
+[tool.setuptools]
+packages = [
+    "process_bigraph",
+    "process_bigraph.processes",
+    "process_bigraph.protocols",
+    "process_bigraph.server",
+    "process_bigraph.experiments",
+    "process_bigraph.types",
+]

process_bigraph-1.3.1/process_bigraph.egg-info/requires.txt

@@ -1,6 +0,0 @@
-bigraph-schema>=1.2.3
-matplotlib
-pint>=0.24.4
-scipy>=1.8
-pandas
-sympy

process_bigraph-1.3.1/pyproject.toml

@@ -1,37 +0,0 @@
-[build-system]
-requires = ["setuptools>=68", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "process-bigraph"
-version = "1.3.1"
-description = "protocol and execution for compositional systems biology"
-readme = "README.md"
-requires-python = ">=3.11"
-dependencies = [
-    "bigraph-schema>=1.2.3",
-    "matplotlib",
-    "pint>=0.24.4",
-    "scipy>=1.8",
-    "pandas",
-    "sympy",
-]
-
-[dependency-groups]
-dev = [
-    "ipdb>=0.13.13",
-    "ipykernel",
-    "jupyter",
-    "notebook",
-    "pytest",
-    "pytest-cov",
-]
-
-[tool.setuptools]
-packages = [
-    "process_bigraph",
-    "process_bigraph.processes",
-    "process_bigraph.protocols",
-    "process_bigraph.experiments",
-    "process_bigraph.types",
-]