processforge 0.3.17__tar.gz → 0.3.19__tar.gz

{processforge-0.3.17 → processforge-0.3.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.3.17
+Version: 0.3.19
 Summary: A Python-based process simulation framework for chemical engineering applications.
 Author-email: Processforge Team <team@processforge.dev>
 License-Expression: BSD-3-Clause
@@ -114,12 +114,18 @@ uv tool install "processforge[modelica]"
 
 4. **Look at the output**
 
-   `pf apply` writes results under `outputs/`:
-   - `*_results.zarr` — simulation results store (per-variable arrays, composition flattened)
-   - `*_results.zarr.schema.json` — schema file describing streams, variables, dtypes, units, shapes, and run provenance
-   - `*.pfstate/` — versioned snapshot store with a `latest` pointer
+    `pf apply` (and `pf run`) write a single unified archive under `outputs/`:
 
-   For flowsheets with Tank units (dynamic), use `pf run` instead of `pf apply` to solve with the SM solver.
+    - `outputs/<base>.pfarchive/` — the unified store for a flowsheet's solved state and outputs:
+      - `snapshots/` — Zarr store of converged state vectors (one group per successful `pf apply`), each with `x`/`x_delta` arrays and config/var-name/metadata attributes, plus a `latest` pointer (powers warm-start, drift detection, and homotopy).
+      - `runs/<run_id>.json` — the run manifest: every stream and unit engine output (values, units, dtypes, shapes) and run provenance (backend, version, flowsheet hash).
+      - `outputs/streams/<name>.json` — per-stream timeseries from the solve.
+      - `artifacts.json` — content-addressed registry of all output artifacts (local + remote URIs).
+      - `index.json` — `field_name → occurrences` index for fast cross-run lookups.
+      - `latest_run` — plain-text pointer to the most recent run.
+    - `outputs/<base>_divergence.json` — written only when both direct and homotopy solves fail on `pf apply`, capturing drifted params, solver stats, and top residual violators.
+
+    For dynamic flowsheets with Tank units, use `pf run` (not `pf apply`, which is steady-state EO only) to solve with the dynamic engine.
 
 ## Python API
 

{processforge-0.3.17 → processforge-0.3.19}/README.md

@@ -52,12 +52,18 @@ uv tool install "processforge[modelica]"
 
 4. **Look at the output**
 
-   `pf apply` writes results under `outputs/`:
-   - `*_results.zarr` — simulation results store (per-variable arrays, composition flattened)
-   - `*_results.zarr.schema.json` — schema file describing streams, variables, dtypes, units, shapes, and run provenance
-   - `*.pfstate/` — versioned snapshot store with a `latest` pointer
-
-   For flowsheets with Tank units (dynamic), use `pf run` instead of `pf apply` to solve with the SM solver.
+    `pf apply` (and `pf run`) write a single unified archive under `outputs/`:
+
+    - `outputs/<base>.pfarchive/` — the unified store for a flowsheet's solved state and outputs:
+      - `snapshots/` — Zarr store of converged state vectors (one group per successful `pf apply`), each with `x`/`x_delta` arrays and config/var-name/metadata attributes, plus a `latest` pointer (powers warm-start, drift detection, and homotopy).
+      - `runs/<run_id>.json` — the run manifest: every stream and unit engine output (values, units, dtypes, shapes) and run provenance (backend, version, flowsheet hash).
+      - `outputs/streams/<name>.json` — per-stream timeseries from the solve.
+      - `artifacts.json` — content-addressed registry of all output artifacts (local + remote URIs).
+      - `index.json` — `field_name → occurrences` index for fast cross-run lookups.
+      - `latest_run` — plain-text pointer to the most recent run.
+    - `outputs/<base>_divergence.json` — written only when both direct and homotopy solves fail on `pf apply`, capturing drifted params, solver stats, and top residual violators.
+
+    For dynamic flowsheets with Tank units, use `pf run` (not `pf apply`, which is steady-state EO only) to solve with the dynamic engine.
 
 ## Python API
 

{processforge-0.3.17 → processforge-0.3.19}/flowsheets/openmc/msre_eigenvalue.json

@@ -7,7 +7,7 @@
   "providers": {
     "openmc": {
       "type": "openmc",
-      "url": "http://localhost:9001",
+      "url": "https://processforge-openmc-production.up.railway.app",
       "output_dir": "openmc/msre_run",
       "cross_sections": "${OPENMC_DATA_ROOT}/cross_sections/cross_sections.xml"
     }

{processforge-0.3.17 → processforge-0.3.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "processforge"
-version = "0.3.17"
+version = "0.3.19"
 description = "A Python-based process simulation framework for chemical engineering applications."
 readme = "README.md"
 license = "BSD-3-Clause"

{processforge-0.3.17 → processforge-0.3.19}/src/processforge/__init__.py

@@ -29,7 +29,7 @@ from .units.flash import Flash
 from .units.heater import Heater
 from .eo import EOFlowsheet, EOSolver
 
-__version__ = "0.3.16"
+__version__ = "0.3.19"
 
 __all__ = [
     "Flowsheet",

{processforge-0.3.17 → processforge-0.3.19}/src/processforge/api/serve.py

@@ -99,7 +99,31 @@ def run(body: dict):
         provider.teardown()
 
 
+def _log_startup() -> None:
+    """Report where runs are kept and the S3 upload status at server start."""
+    root = os.environ.get("PROCESSFORGE_OUTPUT_DIR", "outputs")
+    logger.info(
+        f"Provider run outputs (scratch) are kept locally in: {root} "
+        f"(per-provider subdirs: outputs/openmc, outputs/festim)."
+    )
+    if os.environ.get("S3_BUCKET"):
+        bucket = os.environ["S3_BUCKET"]
+        logger.info(f"Remote artifact upload enabled → S3 bucket '{bucket}'.")
+        from processforge.utils.s3_upload import validate_s3
+
+        validate_s3()  # fail fast on misconfigured credentials
+    else:
+        logger.warning(
+            "S3_BUCKET not set — remote upload disabled; runs are ephemeral "
+            "on this container."
+        )
+
+
+_log_startup()
+
+
 if __name__ == "__main__":
     import uvicorn
 
     uvicorn.run(app, host="0.0.0.0", port=DEFAULT_PORT)
+

{processforge-0.3.17 → processforge-0.3.19}/src/processforge/cli/apply.py

@@ -27,6 +27,20 @@ def _persist_run(archive, fs, results, run_info, config, base_name, snapshot_id)
     manifest.snapshot_id = snapshot_id
     stream_results = {k: v for k, v in results.items() if not hasattr(v, "fields")}
     archive.save_run(manifest, stream_results=stream_results)
+
+    # Always persist a Zarr copy of the standardized outputs (fields + artifacts)
+    # inside the archive, mirroring `pf run`.
+    try:
+        from ..result import save_results_zarr
+
+        save_results_zarr(
+            results,
+            os.path.join(archive.path, "results.zarr"),
+            run_info,
+        )
+    except Exception as e:
+        logger.warning(f"Failed to write results.zarr: {type(e).__name__}: {e}")
+
     logger.info(f"Run saved    : {run_id}")
     return run_id
 

{processforge-0.3.17 → processforge-0.3.19}/src/processforge/cli/run.py

@@ -134,6 +134,21 @@ def run(
     }
     archive.save_run(manifest, stream_results=stream_results)
 
+    # Always persist a Zarr copy of the standardized outputs (fields + artifacts)
+    # inside the archive. Works for every provider (OpenMC, CoolProp, FESTIM,
+    # Cantera) and for both local and remote docker runs — remote artifacts
+    # reference their S3 remote_uris.
+    try:
+        from ..result import save_results_zarr
+
+        save_results_zarr(
+            results,
+            os.path.join(archive.path, "results.zarr"),
+            run_info,
+        )
+    except Exception as e:
+        logger.warning(f"Failed to write results.zarr: {type(e).__name__}: {e}")
+
     logger.info(f"Backend      : {display_backend(config, getattr(fs, 'backend', 'dynamic'))}")
     logger.info(f"Run saved    : {os.path.join(archive_path, 'runs', run_id + '.json')}")
 

{processforge-0.3.17 → processforge-0.3.19}/src/processforge/persistence/artifact_store.py

@@ -1,7 +1,6 @@
 """Content-addressed artifact storage for simulation outputs.
 
-Replaces the old ``upload_directory_to_s3`` whole-directory dump.  Providers
-declare their output files as :class:`~processforge.types.OutputArtifact`
+Providers declare their output files as :class:`~processforge.types.OutputArtifact`
 records (with ``local_path``); the :class:`ArtifactStore` computes a content
 hash, uploads each to object storage under a deterministic, reproducible key,
 and fills in ``remote_uris``.  The CLI and the container server both use this
@@ -120,13 +119,58 @@ class ArtifactStore:
     # Container-side convenience: persist all artifacts in engine outputs
     # ------------------------------------------------------------------
     def persist_outputs(self, outputs, *, run_id: str = "", flowsheet_hash: str = "", unit: str = ""):
-        """Upload every artifact referenced by *outputs*.
+        """Upload every artifact referenced by *outputs* to object storage.
 
-        Mutates the artifacts in place, filling ``remote_uris``.  ``outputs``
-        may be a single object or an iterable of them.
+        Uploads the explicitly-declared artifacts, then sweeps each output's
+        ``run_dir`` for any remaining files so *all* model outputs (not just the
+        ones a provider happened to declare) reach S3.  Newly swept files are
+        appended to ``out.artifacts`` with ``remote_uris`` filled.  Mutates the
+        artifacts in place.  ``outputs`` may be a single object or an iterable.
         """
+        if not self.bucket:
+            logger.debug(
+                "Remote artifact upload disabled (S3_BUCKET not set); provider "
+                "run outputs remain in the container's local scratch only."
+            )
+            return
+
         items = outputs if isinstance(outputs, (list, tuple)) else [outputs]
+        uploaded = 0
+        local_only = 0
         for out in items:
+            seen_paths: set[str] = set()
             for art in getattr(out, "artifacts", []):
-                if art.local_path and (self.bucket or os.environ.get("S3_BUCKET")):
-                    self.upload(art, run_id=run_id, flowsheet_hash=flowsheet_hash, unit=unit)
+                if not art.local_path:
+                    continue
+                seen_paths.add(os.path.abspath(art.local_path))
+                self.upload(art, run_id=run_id, flowsheet_hash=flowsheet_hash, unit=unit)
+                if art.remote_uris:
+                    uploaded += 1
+                else:
+                    local_only += 1
+
+            run_dir = getattr(out, "run_dir", "") or ""
+            if run_dir and os.path.isdir(run_dir):
+                for root, _dirs, files in os.walk(run_dir):
+                    for name in files:
+                        path = os.path.abspath(os.path.join(root, name))
+                        if path in seen_paths:
+                            continue
+                        seen_paths.add(path)
+                        art = OutputArtifact(
+                            name=name,
+                            kind=_artifact_kind(name),
+                            local_path=path,
+                            source="local",
+                        )
+                        self.upload(art, run_id=run_id, flowsheet_hash=flowsheet_hash, unit=unit)
+                        if art.remote_uris:
+                            out.artifacts.append(art)
+                            uploaded += 1
+                        else:
+                            local_only += 1
+
+        logger.info(
+            f"Artifact persistence: {uploaded} uploaded to S3, {local_only} local-only."
+        )
+

{processforge-0.3.17 → processforge-0.3.19}/src/processforge/providers/container_client.py

@@ -10,14 +10,13 @@ as a thin HTTP wrapper around that server.
 Request/response contract (matches ``processforge.api.serve``)
 ----------------------------------------------------------------
 * ``POST /run`` with a JSON body
-  ``{"unit_config", "materials", "inlet", "output_dir", "provider_config"}``.
+  ``{"unit_config", "materials", "inlet", "provider_config"}``.
 * JSON response ``{"status", "sim_type", <scalars…>, "metadata"}`` deserialised
   into a :class:`~processforge.types.SimulationResult`.
 """
 from __future__ import annotations
 
 import json
-import os
 import urllib.error
 import urllib.request
 from typing import TYPE_CHECKING, Optional
@@ -54,7 +53,6 @@ class ContainerProviderClient(AbstractProvider):
     def __init__(self, provider_type: str):
         self._ptype = provider_type
         self._url: Optional[str] = None
-        self._provider_output_dir: str = "outputs"
         self._provider_config: Optional["ProviderConfig"] = None
         self._materials: dict = {}
         self._initialized: bool = False
@@ -123,14 +121,6 @@ class ContainerProviderClient(AbstractProvider):
         """Store config, resolve URL, verify the Docker service is reachable."""
         self._url = self._resolve_url(provider_config)
 
-        out_dir = os.path.expandvars(
-            getattr(provider_config, "output_dir", "outputs") or "outputs"
-        )
-        if not os.path.isabs(out_dir):
-            root = os.environ.get("PROCESSFORGE_OUTPUT_DIR", "outputs")
-            out_dir = os.path.join(root, out_dir)
-        self._provider_output_dir = out_dir
-
         # Material registry — serialised into /run and used by validate_material().
         self._materials = dict(flowsheet_config.materials)
         self._provider_config = provider_config
@@ -191,7 +181,6 @@ class ContainerProviderClient(AbstractProvider):
             "unit_config": self._serialize_unit_config(unit_config),
             "materials": self._serialize_materials(self._materials),
             "inlet": inlet,
-            "output_dir": self._provider_output_dir,
             "provider_config": provider_config_dump,
             "run_id": run_id,
             "flowsheet_hash": flowsheet_hash,

{processforge-0.3.17 → processforge-0.3.19}/src/processforge/providers/errors.py

@@ -236,6 +236,7 @@ def make_failed_output(
         sim_type=sim_type,
         unit=unit,
         error=err,
+        run_dir=str(getattr(run_dir, "resolve", lambda: run_dir)()),
         diagnostics={
             "run_dir": str(getattr(run_dir, "resolve", lambda: run_dir)()),
             "error": err.detail,

{processforge-0.3.17 → processforge-0.3.19}/src/processforge/providers/festim_provider.py

@@ -788,6 +788,7 @@ class FestimProvider(AbstractProvider):
             artifacts=artifacts,
             diagnostics=diagnostics,
             provenance=OutputProvenance(),
+            run_dir=str(run_dir),
         )
 
     def _resolve_run_dir(self) -> pathlib.Path:

{processforge-0.3.17 → processforge-0.3.19}/src/processforge/providers/openmc_provider.py

@@ -832,6 +832,7 @@ class OpenMCProvider(AbstractProvider):
                 fields=fields,
                 artifacts=artifacts,
                 diagnostics=diagnostics,
+                run_dir=str(run_dir),
             )
 
         return EngineOutput(
@@ -842,6 +843,7 @@ class OpenMCProvider(AbstractProvider):
             artifacts=artifacts,
             diagnostics=diagnostics,
             provenance=OutputProvenance(),
+            run_dir=str(run_dir),
         )
 
     def _resolve_run_dir(self) -> pathlib.Path:

{processforge-0.3.17 → processforge-0.3.19}/src/processforge/result.py

@@ -1,3 +1,4 @@
+import json
 import os
 import shutil
 from datetime import datetime, timezone
@@ -27,6 +28,8 @@ def _ensure_array(value):
 
 def _is_dynamic(results):
     for stream in results.values():
+        if not hasattr(stream, "get"):
+            continue
         time_series = stream.get("time")
         if isinstance(time_series, (list, tuple, np.ndarray)):
             return True
@@ -51,6 +54,34 @@ def _store_solver_unit(group, data):
         group.attrs[k] = v
 
 
+def _store_engine_output(group, obj):
+    """Persist an ``EngineOutput``/``StreamOutput`` to a Zarr group.
+
+    Stores ``status``/``engine``/``sim_type`` as group attrs, each field as a
+    unit-bearing array, and a nested ``artifacts`` subgroup whose attrs hold the
+    serialized :class:`OutputArtifact` (local path for local runs, S3
+    ``remote_uris`` for remote docker providers).
+    """
+    group.attrs["status"] = getattr(obj, "status", "")
+    group.attrs["engine"] = getattr(obj, "engine", "")
+    group.attrs["sim_type"] = getattr(obj, "sim_type", "")
+
+    for f in getattr(obj, "fields", []):
+        val = _ensure_array(f.quantity.value)
+        arr = group.create_array(f.name, data=val)
+        arr.attrs["unit"] = f.quantity.unit or ""
+        if getattr(f.quantity, "std_dev", None) is not None:
+            arr.attrs["std_dev"] = f.quantity.std_dev
+        if getattr(f, "source", ""):
+            arr.attrs["source"] = f.source
+
+    arts = getattr(obj, "artifacts", [])
+    if arts:
+        ag = group.create_group("artifacts")
+        for art in arts:
+            ag.attrs[art.name] = json.dumps(art.model_dump())
+
+
 def _normalize_run_info(run_info: RunInfo | dict) -> dict:
     """Normalize dataclass or dict run_info input to a plain dict."""
     if isinstance(run_info, RunInfo):
@@ -212,8 +243,11 @@ def save_results_zarr(results, fname="results.zarr", run_info: RunInfo | dict |
 
     streams = {}
     solver_units = {}
+    engine_outputs = {}
     for name, data in results.items():
-        if isinstance(data, dict) and "status" in data:
+        if hasattr(data, "fields"):
+            engine_outputs[name] = data
+        elif isinstance(data, dict) and "status" in data:
             solver_units[name] = data
         else:
             streams[name] = data
@@ -226,6 +260,10 @@ def save_results_zarr(results, fname="results.zarr", run_info: RunInfo | dict |
         group = root.create_group(name)
         _store_solver_unit(group, data)
 
+    for name, data in engine_outputs.items():
+        group = root.create_group(name)
+        _store_engine_output(group, data)
+
     if run_info is not None:
         _store_run_info(root, run_info)
 
@@ -270,8 +308,11 @@ def save_results_zarr_s3(results, s3_uri: str, run_info: RunInfo | dict | None =
 
     streams = {}
     solver_units = {}
+    engine_outputs = {}
     for name, data in results.items():
-        if isinstance(data, dict) and "status" in data:
+        if hasattr(data, "fields"):
+            engine_outputs[name] = data
+        elif isinstance(data, dict) and "status" in data:
             solver_units[name] = data
         else:
             streams[name] = data
@@ -284,6 +325,10 @@ def save_results_zarr_s3(results, s3_uri: str, run_info: RunInfo | dict | None =
         group = root.create_group(name)
         _store_solver_unit(group, data)
 
+    for name, data in engine_outputs.items():
+        group = root.create_group(name)
+        _store_engine_output(group, data)
+
     if run_info is not None:
         _store_run_info(root, run_info)
 

{processforge-0.3.17 → processforge-0.3.19}/src/processforge/types.py

@@ -477,6 +477,10 @@ class EngineOutput(BaseModel):
     # status == "failed"). source is always "provider" so a runtime engine error
     # is distinguishable from a flowsheet/setup validation error.
     error: Optional["ProviderRunError"] = None
+    # Local directory the run was executed in (provider scratch). Surfaced so
+    # the container server can sweep it for artifacts to upload to object
+    # storage, and so forensics can trace where outputs were produced.
+    run_dir: str = ""
 
     # -- convenience accessors -------------------------------------------
     def get_field(self, name: str) -> Optional[OutputField]:

processforge-0.3.19/src/processforge/utils/s3_upload.py

@@ -0,0 +1,66 @@
+"""S3 storage-options helper.
+
+Builds s3fs storage options (credentials, endpoint, region) from the
+container environment for use by :class:`processforge.persistence.artifact_store.ArtifactStore`.
+"""
+
+from __future__ import annotations
+
+import os
+
+
+def s3_storage_options() -> dict:
+    """Build s3fs storage options from environment variables.
+
+    Returns an empty dict when no credentials are configured so s3fs falls
+    back to its default credential chain (e.g. instance/role-based auth).
+    """
+    opts: dict = {}
+    key = os.environ.get("S3_ACCESS_KEY")
+    secret = os.environ.get("S3_SECRET_KEY")
+    if key:
+        opts["key"] = key
+    if secret:
+        opts["secret"] = secret
+    client_kwargs = {
+        k: v
+        for k, v in {
+            "endpoint_url": os.environ.get("S3_ENDPOINT_URL"),
+            "region_name": os.environ.get("S3_REGION_NAME", "ams3"),
+        }.items()
+        if v
+    }
+    if client_kwargs:
+        opts["client_kwargs"] = client_kwargs
+    return opts
+
+
+def validate_s3() -> None:
+    """Fail fast if S3 upload is requested but storage is unreachable.
+
+    Only acts when ``S3_BUCKET`` is set. Raises ``RuntimeError`` naming any
+    missing credentials/env vars when the bucket cannot be reached, so a
+    misconfigured container deployment surfaces the problem at startup rather
+    than silently producing outputs with no ``remote_uris``.
+    """
+    bucket = os.environ.get("S3_BUCKET")
+    if not bucket:
+        return
+    try:
+        import s3fs
+
+        fs = s3fs.S3FileSystem(**s3_storage_options())
+        fs.ls(bucket)
+    except Exception as exc:  # noqa: BLE001
+        missing = [
+            v
+            for v in ("S3_ACCESS_KEY", "S3_SECRET_KEY", "S3_ENDPOINT_URL")
+            if not os.environ.get(v)
+        ]
+        hint = f" Missing env vars: {missing}." if missing else ""
+        raise RuntimeError(
+            f"S3 upload requested (S3_BUCKET='{bucket}') but storage is "
+            f"unreachable: {exc}.{hint} Set S3_BUCKET + credentials, or unset "
+            f"S3_BUCKET to disable remote upload."
+        ) from exc
+

{processforge-0.3.17 → processforge-0.3.19}/src/processforge.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.3.17
+Version: 0.3.19
 Summary: A Python-based process simulation framework for chemical engineering applications.
 Author-email: Processforge Team <team@processforge.dev>
 License-Expression: BSD-3-Clause
@@ -114,12 +114,18 @@ uv tool install "processforge[modelica]"
 
 4. **Look at the output**
 
-   `pf apply` writes results under `outputs/`:
-   - `*_results.zarr` — simulation results store (per-variable arrays, composition flattened)
-   - `*_results.zarr.schema.json` — schema file describing streams, variables, dtypes, units, shapes, and run provenance
-   - `*.pfstate/` — versioned snapshot store with a `latest` pointer
+    `pf apply` (and `pf run`) write a single unified archive under `outputs/`:
 
-   For flowsheets with Tank units (dynamic), use `pf run` instead of `pf apply` to solve with the SM solver.
+    - `outputs/<base>.pfarchive/` — the unified store for a flowsheet's solved state and outputs:
+      - `snapshots/` — Zarr store of converged state vectors (one group per successful `pf apply`), each with `x`/`x_delta` arrays and config/var-name/metadata attributes, plus a `latest` pointer (powers warm-start, drift detection, and homotopy).
+      - `runs/<run_id>.json` — the run manifest: every stream and unit engine output (values, units, dtypes, shapes) and run provenance (backend, version, flowsheet hash).
+      - `outputs/streams/<name>.json` — per-stream timeseries from the solve.
+      - `artifacts.json` — content-addressed registry of all output artifacts (local + remote URIs).
+      - `index.json` — `field_name → occurrences` index for fast cross-run lookups.
+      - `latest_run` — plain-text pointer to the most recent run.
+    - `outputs/<base>_divergence.json` — written only when both direct and homotopy solves fail on `pf apply`, capturing drifted params, solver stats, and top residual violators.
+
+    For dynamic flowsheets with Tank units, use `pf run` (not `pf apply`, which is steady-state EO only) to solve with the dynamic engine.
 
 ## Python API
 

{processforge-0.3.17 → processforge-0.3.19}/src/processforge.egg-info/SOURCES.txt

@@ -131,6 +131,7 @@ tests/test_init.py
 tests/test_openmc_provider.py
 tests/test_provider_errors.py
 tests/test_providers.py
+tests/test_result_zarr.py
 tests/test_s3_upload.py
 tests/test_state.py
 tests/test_types.py

{processforge-0.3.17 → processforge-0.3.19}/tests/test_cli.py

@@ -388,7 +388,8 @@ class TestCmdRun:
                           return_value=self._containerized_config(flowsheet)), \
              patch.object(run_mod, "check_providers"), \
              patch.object(run_mod, "EOFlowsheet", return_value=mock_fs), \
-             patch.object(run_mod, "ProcessStateArchive", MagicMock()):
+             patch.object(run_mod, "ProcessStateArchive", MagicMock()), \
+             patch("processforge.result.save_results_zarr", lambda *a, **k: None):
             run(flowsheet=str(flowsheet), export_images=False)
 
     def test_coolprop_flowsheet_no_lifecycle(self, tmp_path):
@@ -414,7 +415,8 @@ class TestCmdRun:
                                         "_config_path": str(flowsheet)}), \
              patch.object(run_mod, "check_providers"), \
              patch.object(run_mod, "EOFlowsheet", return_value=mock_fs), \
-             patch.object(run_mod, "ProcessStateArchive", MagicMock()):
+             patch.object(run_mod, "ProcessStateArchive", MagicMock()), \
+             patch("processforge.result.save_results_zarr", lambda *a, **k: None):
             run(flowsheet=str(flowsheet), export_images=False)
 
     def test_no_compose_no_lifecycle(self, tmp_path):
@@ -437,7 +439,8 @@ class TestCmdRun:
                           return_value=self._containerized_config(flowsheet)), \
              patch.object(run_mod, "check_providers"), \
              patch.object(run_mod, "EOFlowsheet", return_value=mock_fs), \
-             patch.object(run_mod, "ProcessStateArchive", MagicMock()):
+             patch.object(run_mod, "ProcessStateArchive", MagicMock()), \
+             patch("processforge.result.save_results_zarr", lambda *a, **k: None):
             mock_os.path.exists.return_value = False  # no compose file
             run(flowsheet=str(flowsheet), export_images=False)
 
@@ -523,7 +526,8 @@ class TestCmdApply:
              patch.object(apply_mod, "check_providers"), \
              patch.object(apply_mod, "EOFlowsheet", return_value=mock_fs), \
              patch.object(apply_mod, "save_snapshot", return_value="snap-1"), \
-             patch.object(apply_mod, "load_state_manager", return_value=(MagicMock(), None)):
+             patch.object(apply_mod, "load_state_manager", return_value=(MagicMock(), None)), \
+             patch("processforge.result.save_results_zarr", lambda *a, **k: None):
             apply(flowsheet=str(flowsheet))
 
     def test_coolprop_flowsheet_no_lifecycle(self, tmp_path):
@@ -552,7 +556,8 @@ class TestCmdApply:
              patch.object(apply_mod, "check_providers"), \
              patch.object(apply_mod, "EOFlowsheet", return_value=mock_fs), \
              patch.object(apply_mod, "save_snapshot", return_value="snap-1"), \
-             patch.object(apply_mod, "load_state_manager", return_value=(MagicMock(), None)):
+             patch.object(apply_mod, "load_state_manager", return_value=(MagicMock(), None)), \
+             patch("processforge.result.save_results_zarr", lambda *a, **k: None):
             apply(flowsheet=str(flowsheet))