process-bigraph 1.2.1__tar.gz → 1.2.3__tar.gz

{process_bigraph-1.2.1/process_bigraph.egg-info → process_bigraph-1.2.3}/PKG-INFO

@@ -1,21 +1,17 @@
 Metadata-Version: 2.4
 Name: process-bigraph
-Version: 1.2.1
+Version: 1.2.3
 Summary: protocol and execution for compositional systems biology
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: AUTHORS.md
-Requires-Dist: bigraph-schema
-Requires-Dist: ipdb>=0.13.13
+Requires-Dist: bigraph-schema>=1.2.3
 Requires-Dist: matplotlib
 Requires-Dist: pint>=0.24.4
 Requires-Dist: scipy>=1.8
 Requires-Dist: pandas
 Requires-Dist: sympy
-Requires-Dist: ipykernel
-Requires-Dist: jupyter
-Requires-Dist: notebook
 Dynamic: license-file
 
 # Process-Bigraph

{process_bigraph-1.2.1 → process_bigraph-1.2.3}/process_bigraph/composite.py

@@ -1454,11 +1454,11 @@ class Composite(Process):
             - self.process_paths
             - self.step_paths
         """
-        # Structural change incoming — drop the compiled-apply cache:
+        # Structural change incoming — drop schema-derived caches:
         # ``apply(dict)`` mutates schemas in place for ``_divide``
-        # sentinels, so cached compiled functions may now reference
-        # stale schema layouts.
-        self.core.invalidate_compiled_apply()
+        # sentinels, so the promote() memo may now key off stale
+        # schema layouts.
+        self.core.invalidate_caches()
         self.process_paths = find_instance_paths(state, 'process_bigraph.composite.Process')
         if hasattr(self, 'step_paths'):
             previous_step_paths = self.step_paths.keys()
@@ -1479,6 +1479,97 @@ class Composite(Process):
             # do we want to do anything with these?
             removed_front = self.front.pop(removed_key)
 
+    def _realize_merge_subtrees(self, paths: List[tuple]) -> None:
+        """Realize only the subtrees touched by ``port_merges``.
+
+        ``apply_updates`` collects every path that gained new schema
+        info from a process's port defaults. The full-state realize
+        that previously followed walked the whole tree on every tick
+        with merges; on the brownian-particles test that meant ~2000
+        full walks for 200s of sim. Incremental realize over just the
+        affected paths is bounded by the merge count (~ports per tick).
+        """
+        for path in paths:
+            try:
+                sub_schema, sub_state = self.core.traverse(
+                    self.schema, self.state, list(path))
+            except Exception:
+                continue
+            if sub_schema is None:
+                continue
+            new_sub_schema, new_sub_state = self.core.realize(
+                sub_schema, sub_state, path=tuple(path))
+            if not path:
+                self.state = new_sub_state
+                continue
+            parent_state = self.state
+            missing = False
+            for key in path[:-1]:
+                if not isinstance(parent_state, dict) or key not in parent_state:
+                    missing = True
+                    break
+                parent_state = parent_state[key]
+            if missing or not isinstance(parent_state, dict):
+                continue
+            parent_state[path[-1]] = new_sub_state
+
+    def _realize_structural_subtrees(self, events: List[Any]) -> None:
+        """Realize only the subtrees that structural events touched.
+
+        After ``apply`` emits ``NodeAdded`` / ``Divided`` events, the new
+        subtrees contain raw process declarations (config dicts) that
+        need realizing into Process instances. The rest of the tree is
+        already realized — re-walking it is wasted work that scales
+        O(N) per division and so O(N²) over the simulation.
+
+        This walks each affected subtree via ``core.traverse`` to fetch
+        its (sub_schema, sub_state), realizes that pair, and splices the
+        realized state back into ``self.state``. ``NodeRemoved`` is a
+        no-op here — there's nothing to realize at a removed path.
+        ``self.schema`` is left untouched: container schemas (Map,
+        Tree) don't change shape on add/divide; dict containers were
+        already mutated in place by ``apply``'s divide handler.
+        """
+        affected_paths: List[tuple] = []
+        for event in events:
+            if isinstance(event, NodeAdded):
+                affected_paths.append(event.path + (event.key,))
+            elif isinstance(event, Divided):
+                for d_key in event.daughter_keys:
+                    affected_paths.append(event.path + (d_key,))
+
+        for path in affected_paths:
+            try:
+                sub_schema, sub_state = self.core.traverse(
+                    self.schema, self.state, list(path))
+            except Exception:
+                continue
+            if sub_schema is None:
+                continue
+            new_sub_schema, new_sub_state = self.core.realize(
+                sub_schema, sub_state, path=tuple(path))
+            # Splice the realized state back at its path. The parent
+            # container is a mutable dict (Map keys are dict-keyed at
+            # state level), so we rewrite the leaf entry. Schema dicts
+            # may have been mutated by apply's divide handler already.
+            #
+            # Skip if any intermediate key has vanished — events on the
+            # same tick can interact (e.g. an added daughter immediately
+            # divided again, or a divided daughter removed by a step
+            # cascade), leaving the path stale by the time we splice.
+            # The corresponding NodeRemoved/Divided event covers the
+            # cleanup; nothing to realize here.
+            parent_state = self.state
+            missing = False
+            for key in path[:-1]:
+                if not isinstance(parent_state, dict) or key not in parent_state:
+                    missing = True
+                    break
+                parent_state = parent_state[key]
+            if missing or not isinstance(parent_state, dict):
+                continue
+            parent_state[path[-1]] = new_sub_state
+
     def _apply_structural_events(self, events: List[Any]) -> None:
         """Update process/step indexes from apply-emitted structural events.
 
@@ -1490,14 +1581,14 @@ class Composite(Process):
         - ``Divided``: drop the mother's entries, scan each daughter
           subtree.
 
-        The compiled-apply cache is invalidated unconditionally because
+        Schema-derived caches are invalidated unconditionally because
         ``apply(dict)``'s ``_divide`` branch mutates schemas in place.
 
         Step network rebuild is conditional on step_paths actually
         changing — value-only structural events that don't add/remove
         any Step instances skip the rebuild.
         """
-        self.core.invalidate_compiled_apply()
+        self.core.invalidate_caches()
 
         previous_step_paths = (set(self.step_paths.keys())
                                if hasattr(self, 'step_paths') else set())
@@ -1876,7 +1967,21 @@ class Composite(Process):
         # ``link_state`` pass would re-add. Combining ``initial_state()``
         # on top here would clobber correctly-divided values (e.g. a
         # daughter's halved bulk array) with mother-shaped originals.
-        config = {'skip_process_state': True, **document, **kwargs}
+        #
+        # ``run_steps_on_init`` fires derivers (mass listeners,
+        # post-division-mass-listener) at startup, mirroring v1's
+        # ``Engine.run_steps()`` call in ``__init__``. The bundle was
+        # saved with mother's pre-divide derived state (the post-divide
+        # cascade halts at the structural change to match v1's
+        # DivisionDetected exception). Running derivers on load
+        # refreshes those values from the daughter's halved bulk before
+        # any process reads them.
+        config = {
+            'skip_process_state': True,
+            'run_steps_on_init': True,
+            **document,
+            **kwargs,
+        }
         return cls(config, core=core)
 
 
@@ -2181,6 +2286,16 @@ class Composite(Process):
             update_paths = self.apply_updates(updates)
             self.expire_process_paths(update_paths)
 
+            # Opt-in halt: caller (e.g. EcoliSim) sets
+            # ``_halt_after_structural`` to abort the post-divide step
+            # cascade so daughters save with mother's pre-divide derived
+            # state — mirroring v1 vivarium's ``DivisionDetected``
+            # behavior. Default behavior continues cascading for
+            # dynamic-structure tests that rely on spawn chains.
+            if (getattr(self, '_halt_after_structural', False)
+                    and getattr(self, '_last_apply_structural', False)):
+                return
+
             to_run = self.cycle_step_state()
 
             if to_run:
@@ -2252,6 +2367,14 @@ class Composite(Process):
                 update_paths.append(('global_time',)) # updated global time can trigger steps
                 self.expire_process_paths(update_paths)
                 self.steps_run = set()  # Reset for new timestep
+                # Opt-in halt after structural change. EcoliSim sets
+                # ``_halt_after_structural=True`` to mirror v1's halt
+                # via DivisionDetected. Dynamic-structure tests leave
+                # the flag unset for natural cascading.
+                if (getattr(self, '_halt_after_structural', False)
+                        and getattr(self, '_last_apply_structural', False)):
+                    self.framework_time += _time.monotonic() - fw_start
+                    return
                 self.trigger_steps(update_paths)
                 self.framework_time += _time.monotonic() - fw_start
 
@@ -2527,29 +2650,39 @@ class Composite(Process):
                 had_structural_sentinels = True
 
             if combined_update:
-                # An update that lands inside an existing process's
-                # path — wires, config, anything — is just as structural
-                # as _add/_remove: the link's compiled cache is stale
-                # and apply must see the full ProcessLink schema (else
-                # the stripped combined_schema falls through to
-                # apply(Node) and clobbers the link state). The same
-                # post-apply pipeline reuses the existing instance via
-                # realize_link's "instance already exists" branch.
-                if (not had_structural_sentinels
-                        and self._update_touches_process_path(update_paths)):
-                    had_structural_sentinels = True
-
-                # Apply needs the live state schema for structural
-                # sentinels (_divide, _add, _remove) — they must see
-                # the mother's existing schema to split/remove it.
-                # For non-structural updates the combined_schema is
-                # fine; resolving would drag in the entire state
-                # schema and make apply walk everything.
+                # NOTE: previously this path also forced
+                # ``had_structural_sentinels = True`` whenever an
+                # update touched a process subtree, because the older
+                # code applied with the stripped ``combined_schema``
+                # and would clobber link state. With ``promote``
+                # supplying typed nodes (Array, Map, ProcessLink, ...)
+                # at each apply path, value-only updates into a
+                # process's path apply correctly without a full
+                # realize. Only true sentinels (_add/_remove/_divide,
+                # detected by the reconcile sink above) flip the
+                # structural flag.
+                pass
+
+                # Apply needs the live state schema so dispatch sees
+                # the underlying types (Array, Map, ProcessLink, etc.)
+                # at each path. ``combined_schema`` alone reflects the
+                # update's wire shape (often dict-of-int-keys for
+                # array-cell projections) and loses the typed
+                # information present in ``self.schema``. Without
+                # promoting, an update of shape ``{i: {j: delta}}``
+                # would land at apply with a dict schema but an
+                # ndarray state — bypassing the Array-aware overload.
+                # ``promote`` walks only the paths combined_schema
+                # touches (vs ``resolve`` which walks all of
+                # self.schema each tick); structural sentinels still
+                # use the full resolve so divide/add/remove see the
+                # mother's existing schema.
                 if had_structural_sentinels:
                     apply_schema = self.core.resolve(
                         self.schema, combined_schema)
                 else:
-                    apply_schema = combined_schema
+                    apply_schema = self.core.promote(
+                        self.schema, combined_schema)
                 # Collect structural events (NodeAdded/NodeRemoved/
                 # Divided) emitted by sentinel handlers during apply.
                 # On structural ticks, used to update process_paths/
@@ -2562,18 +2695,36 @@ class Composite(Process):
                     combined_update,
                     update_has_structural=had_structural_sentinels,
                     events=structural_events)
-                # For structural sentinels, apply may have mutated
-                # apply_schema in place (e.g. _divide pops/inserts
-                # keys in a dict schema). Propagate back to self.schema
-                # so downstream realize sees the split.
+                # For structural sentinels, apply mutates the
+                # access-normalized form of ``apply_schema`` in place
+                # (e.g. ``_divide`` pops the mother key and inserts
+                # daughter keys in a dict subschema). ``apply_schema``
+                # itself is the un-normalized input — it does NOT see
+                # those mutations. Pull the cached normalized form
+                # via ``access`` (cache hit since ``core.apply`` just
+                # populated it) so ``self.schema`` reflects the post-
+                # divide structure for downstream consumers.
                 if had_structural_sentinels:
-                    self.schema = apply_schema
+                    self.schema = self.core.access(apply_schema)
 
                 if merges:
                     had_structural_changes = True
                     self.schema = self.core.resolve_merges(
                         self.schema,
                         merges)
+                    # Track exactly which paths gained new schema info so
+                    # we can realize only those subtrees instead of the
+                    # whole tree (full realize was the dominant per-tick
+                    # framework cost on tests with port_merges every tick,
+                    # e.g. brownian_particles' 2000 ticks each triggering
+                    # a full-state walk).
+                    if not hasattr(self, '_merge_paths_pending'):
+                        self._merge_paths_pending = []
+                    for entry in merges:
+                        # merges are (path, subschema, link_path); we
+                        # only need the path prefix.
+                        if entry and entry[0] is not None:
+                            self._merge_paths_pending.append(tuple(entry[0]))
 
         # Schema merges (from process outputs introducing new fields)
         # require realize to fill defaults but do NOT add/remove
@@ -2581,23 +2732,42 @@ class Composite(Process):
         # Only actual structural sentinels (_add/_remove/_divide)
         # require find_instance_paths + build_step_network.
         if had_structural_changes:
-            self.schema, self.state = self.core.realize(self.schema, self.state)
+            merge_paths = getattr(self, '_merge_paths_pending', None)
+            if merge_paths:
+                # Realize only the affected subtrees. Each merge path is
+                # already covered by the incremental walk; deduplicate
+                # under shortest-prefix containment so we don't visit
+                # ancestor and descendant separately.
+                unique = []
+                for p in sorted(set(merge_paths), key=len):
+                    if any(p[:len(u)] == u for u in unique):
+                        continue
+                    unique.append(p)
+                self._realize_merge_subtrees(unique)
+                self._merge_paths_pending = []
+            else:
+                # Fallback: no path info available — full realize.
+                self.schema, self.state = self.core.realize(
+                    self.schema, self.state)
             self._build_view_project_cache()
 
         if had_structural_sentinels:
             # Real structural change: processes may have been
-            # added/removed/replaced. Realize new state (to
-            # instantiate added process declarations) then update
-            # the process/step indexes from the events apply emitted.
-            self.schema, self.state = self.core.realize(
-                self.schema, self.state)
+            # added/removed/replaced. Realize the affected subtrees
+            # only (instantiating new daughter processes) instead of
+            # re-walking the entire schema — full realize scales O(N)
+            # per division and so O(N²) over a sim with N divisions.
             if structural_events:
+                self._realize_structural_subtrees(structural_events)
                 self._apply_structural_events(structural_events)
             else:
                 # Fallback: had_structural_sentinels was set but no
                 # events emitted (e.g. _update_touches_process_path
                 # detected an in-process update with no _add/_remove/
-                # _divide sentinel). Full rescan is correct here.
+                # _divide sentinel). Full realize + rescan is correct
+                # here — we don't know which subtrees changed.
+                self.schema, self.state = self.core.realize(
+                    self.schema, self.state)
                 self.find_instance_paths(self.state)
             self._build_view_project_cache()
             if hasattr(self, 'expire_layer_walk_cache'):
@@ -2612,52 +2782,23 @@ class Composite(Process):
         """
         Invalidate and refresh process paths if affected by recent updates.
 
-        This is used to ensure that processes are rediscovered if a state update
-        altered a region where a process instance may be added, removed, or replaced.
-
-        Fast path: skip entirely on value-only ticks. apply_updates already
-        runs find_instance_paths + _build_view_project_cache when it
-        detects structural changes (`_add` / `_remove` / `_type` keys),
-        and value-only updates can never add / remove / replace a process
-        slot. The walk is only needed if a structural change targeted a
-        process-adjacent path.
+        Now a no-op: ``apply_updates`` already maintains ``process_paths``,
+        ``step_paths``, and the view-project cache via either
+        ``_apply_structural_events`` (incremental, when structural
+        sentinels emit events) or its fallback ``find_instance_paths``
+        + ``_build_view_project_cache`` (when the sentinel was detected
+        but no events surfaced). On value-only ticks no structural
+        change occurred, so there is nothing to re-discover. Repeating
+        the work here was the dominant framework cost on
+        particle/division-heavy tests — ``find_instance_paths`` is a
+        full-state walk that scaled with population, turning each
+        division into O(N) work and the simulation into O(N²) overall.
 
         Args:
-            update_paths: A list of hierarchical paths that were modified.
+            update_paths: A list of hierarchical paths that were
+                modified. Retained for caller compatibility; unused.
         """
-        # Skip the walk on value-only ticks. apply_updates exposes
-        # `_last_apply_structural` so we know whether to bother.
-        if not getattr(self, '_last_apply_structural', True):
-            return
-
-        # Quick check: if no update path shares a first element with any process path,
-        # then no overlap is possible and we can skip the expensive scan.
-        if not hasattr(self, '_process_path_roots'):
-            self._process_path_roots = set()
-        process_roots = self._process_path_roots
-        if not process_roots:
-            process_roots = {p[0] for p in self.process_paths if p}
-            self._process_path_roots = process_roots
-
-        # Fast rejection: check if any update touches a process-adjacent path
-        needs_check = False
-        for update_path in update_paths:
-            if update_path and update_path[0] in process_roots:
-                needs_check = True
-                break
-
-        if not needs_check:
-            return
-
-        for update_path in update_paths:
-            for process_path in self.process_paths.copy():
-                # Match if update path completely overlaps the process path prefix
-                updated = all(update == process for update, process in zip(update_path, process_path))
-                if updated:
-                    self.find_instance_paths(self.state)
-                    self._build_view_project_cache()
-                    self._process_path_roots = set()  # Reset for rebuild
-                    return  # Exit early after one match, as paths are re-evaluated
+        return
 
 
     # ====================

{process_bigraph-1.2.1 → process_bigraph-1.2.3}/process_bigraph/emitter.py

@@ -37,13 +37,19 @@ def anyize_paths(tree):
     else:
         return 'node'
 
-def emitter_from_wires(wires, address='local:RAMEmitter'):
-    '''Create an emitter step spec from wire mappings.'''
+def emitter_from_wires(wires, address='local:RAMEmitter', subsample=1):
+    '''Create an emitter step spec from wire mappings.
+
+    ``subsample`` (RAMEmitter / SQLiteEmitter only): record every
+    Nth composite tick. Default 1 records every tick.
+    '''
+    config = {'emit': anyize_paths(wires)}
+    if subsample is not None and int(subsample) > 1:
+        config['subsample'] = int(subsample)
     return {
         '_type': 'step',
         'address': address,
-        'config': {
-            'emit': anyize_paths(wires)},
+        'config': config,
         'inputs': wires}
 
 def collect_input_ports(state, path=None):
@@ -180,12 +186,35 @@ def tree_copy(state):
 
 
 class RAMEmitter(Emitter):
-    '''Store historical states in memory.'''
+    '''Store historical states in memory.
+
+    ``subsample`` records only every Nth composite tick (default 1 =
+    every tick). Use this for long runs or composites with heavy
+    state (large fields, many agents) to keep RAM bounded — the
+    saved time-series still reflects the simulation's true cadence
+    via each row's ``global_time`` field.
+    '''
+    config_schema = {
+        **Emitter.config_schema,
+        'subsample': {'_type': 'integer', '_default': 1},
+    }
+
     def __init__(self, config, core):
         super().__init__(config, core)
+        subsample = config.get('subsample')
+        self.subsample = 1 if subsample is None else int(subsample)
+        if self.subsample < 1:
+            raise ValueError(
+                f'RAMEmitter subsample must be >= 1, got {self.subsample}'
+            )
         self.history = []
+        self._step = 0
 
     def update(self, state) -> Dict:
+        step = self._step
+        self._step += 1
+        if step % self.subsample != 0:
+            return {}
         self.history.append(tree_copy(state))
         return {}
 

{process_bigraph-1.2.1 → process_bigraph-1.2.3/process_bigraph.egg-info}/PKG-INFO

@@ -1,21 +1,17 @@
 Metadata-Version: 2.4
 Name: process-bigraph
-Version: 1.2.1
+Version: 1.2.3
 Summary: protocol and execution for compositional systems biology
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: AUTHORS.md
-Requires-Dist: bigraph-schema
-Requires-Dist: ipdb>=0.13.13
+Requires-Dist: bigraph-schema>=1.2.3
 Requires-Dist: matplotlib
 Requires-Dist: pint>=0.24.4
 Requires-Dist: scipy>=1.8
 Requires-Dist: pandas
 Requires-Dist: sympy
-Requires-Dist: ipykernel
-Requires-Dist: jupyter
-Requires-Dist: notebook
 Dynamic: license-file
 
 # Process-Bigraph

{process_bigraph-1.2.1 → process_bigraph-1.2.3}/process_bigraph.egg-info/SOURCES.txt

@@ -1,18 +1,7 @@
-.gitignore
 AUTHORS.md
-CLA.md
-CODE_OF_CONDUCT.md
-CONTRIBUTING.md
 LICENSE
 README.md
 pyproject.toml
-pytest.ini
-release.sh
-.github/workflows/notebook_to_html.yml
-.github/workflows/pytest.yml
-doc/_static/process-bigraph.png
-notebooks/process-bigraphs.ipynb
-notebooks/visualize_processes.ipynb
 process_bigraph/__init__.py
 process_bigraph/bundle.py
 process_bigraph/composite.py

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

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

{process_bigraph-1.2.1 → process_bigraph-1.2.3}/pyproject.toml

@@ -1,20 +1,30 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
 [project]
 name = "process-bigraph"
-version = "1.2.1"
+version = "1.2.3"
 description = "protocol and execution for compositional systems biology"
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
-    "bigraph-schema",
-    "ipdb>=0.13.13",
+    "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]
@@ -25,6 +35,3 @@ packages = [
     "process_bigraph.experiments",
     "process_bigraph.types",
 ]
-
-[tool.uv.sources]
-bigraph-schema = { path = "../bigraph-schema", editable = true }

process_bigraph-1.2.1/.github/workflows/notebook_to_html.yml

@@ -1,43 +0,0 @@
-name: Convert Jupyter Notebook to HTML
-
-on:
-  push:
-    paths:
-      - 'notebooks/process-bigraphs.ipynb'
-
-jobs:
-  convert:
-    runs-on: ubuntu-latest
-    steps:
-    - name: Check out repository
-      uses: actions/checkout@main
-      with:
-        ref: main
-        fetch-depth: 0 # Fetch all history to have access to the gh-pages branch
-
-    - name: Set up Python
-      uses: actions/setup-python@main
-      with:
-        python-version: 3.x
-
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install nbconvert
-
-    - name: Convert Jupyter Notebook to HTML
-      run: |
-        jupyter nbconvert --to html notebooks/process-bigraphs.ipynb
-
-    - name: Commit and push HTML to gh-pages branch
-      run: |
-        git config --local user.email "eagmon@github.com"
-        git config --local user.name "GitHub Action"
-        git fetch origin
-        mv notebooks/process-bigraphs.html /tmp/process-bigraphs.html
-        git checkout gh-pages || git checkout -b gh-pages
-        git pull origin gh-pages
-        mv /tmp/process-bigraphs.html notebooks/process-bigraphs.html
-        git add notebooks/process-bigraphs.html
-        git diff-index --quiet HEAD || git commit -m "Update HTML file"
-        git push origin gh-pages || true

process_bigraph-1.2.1/.github/workflows/pytest.yml

@@ -1,29 +0,0 @@
-name: Run Pytest
-
-on:
-  pull_request:
-    branches:
-      - main
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-    - name: Check out repository
-      uses: actions/checkout@v2
-
-    - name: Set up Python
-      uses: actions/setup-python@v2
-      with:
-        python-version: 3.x
-
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install pytest pytest-cov
-        pip install -e .
-
-    - name: Run pytest
-      run: |
-        pip install pytest
-        pytest --cov=process_bigraph --cov-report=term