processforge 0.3.19__tar.gz → 0.3.21__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.3.19
+Version: 0.3.21
 Summary: A Python-based process simulation framework for chemical engineering applications.
 Author-email: Processforge Team <team@processforge.dev>
 License-Expression: BSD-3-Clause

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

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

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

@@ -18,6 +18,7 @@ from .utils.validate_flowsheet import validate_flowsheet
 from .result import (
     plot_results,
     plot_timeseries,
+    relink_latest_results,
     save_results_zarr,
 )
 from .units.pump import Pump
@@ -29,7 +30,7 @@ from .units.flash import Flash
 from .units.heater import Heater
 from .eo import EOFlowsheet, EOSolver
 
-__version__ = "0.3.19"
+__version__ = "0.3.21"
 
 __all__ = [
     "Flowsheet",
@@ -41,6 +42,7 @@ __all__ = [
     "plot_results",
     "plot_timeseries",
     "save_results_zarr",
+    "relink_latest_results",
     "build_run_info",
     "Pump",
     "Valve",

{processforge-0.3.19 → processforge-0.3.21}/src/processforge/cli/__init__.py

@@ -11,6 +11,7 @@ def register_commands(app: typer.Typer) -> None:
     from .validate import validate
     from .run import run
     from .apply import apply
+    from .runs import runs
     from .plan import plan
     from .diagram import diagram
     from .export_fmu import export_fmu
@@ -29,6 +30,10 @@ def register_commands(app: typer.Typer) -> None:
         "apply",
         help="Apply flowsheet using state-based warm start and homotopy fallback",
     )(apply)
+    app.command(
+        "runs",
+        help="List runs for a flowsheet, or show one run's full manifest (pf runs <flowsheet> [<run_id>])",
+    )(runs)
     app.command(
         "plan",
         help="Validate a flowsheet, run DOF analysis, structural diff, container health check, and generate a Mermaid diagram",

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

@@ -31,13 +31,15 @@ def _persist_run(archive, fs, results, run_info, config, base_name, snapshot_id)
     # Always persist a Zarr copy of the standardized outputs (fields + artifacts)
     # inside the archive, mirroring `pf run`.
     try:
-        from ..result import save_results_zarr
+        from ..result import relink_latest_results, save_results_zarr
 
+        run_results_dir = os.path.join(archive.path, "results", run_id)
         save_results_zarr(
             results,
-            os.path.join(archive.path, "results.zarr"),
+            os.path.join(run_results_dir, "results.zarr"),
             run_info,
         )
+        relink_latest_results(archive.path, run_id)
     except Exception as e:
         logger.warning(f"Failed to write results.zarr: {type(e).__name__}: {e}")
 

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

@@ -102,6 +102,7 @@ def run(
             raise SystemExit(1)
 
         run_info = build_run_info(config, x0=x0, var_names=var_names)
+        snap_x, snap_vn, snap_backend, snap_ok = x0, var_names, "dynamic", True
     else:
         # Pass None so EOFlowsheet resolves backend from config (with scipy default).
         fs = EOFlowsheet(config, backend=None)
@@ -117,6 +118,9 @@ def run(
                 logger.warning("Steady-state simulation did NOT converge. Results may be unreliable.")
 
         run_info = build_run_info(config, x0=fs.x0, var_names=fs.var_names)
+        snap_x, snap_vn = fs.x_converged, fs.var_names
+        snap_backend = getattr(fs, "backend", "scipy")
+        snap_ok = bool(getattr(fs, "converged", False))
 
     # Propagate run context to any containerized providers so their S3 uploads
     # are keyed by the same run_id/flowsheet_hash as this archive run.
@@ -134,18 +138,35 @@ def run(
     }
     archive.save_run(manifest, stream_results=stream_results)
 
+    # Persist a StateManager snapshot so `pf plan` (and `pf apply`) can diff
+    # against this run as a baseline. Without it, `pf plan` always reports
+    # "No prior state found" and never surfaces flowsheet edits.
+    if (is_dynamic or snap_ok) and snap_x is not None:
+        try:
+            from .common import build_run_metadata, save_snapshot
+
+            meta = build_run_metadata(config, 1e-6, 50, snap_backend)
+            save_snapshot(
+                archive, config, snap_x, snap_vn,
+                metadata=meta, parent_snapshot_id=None, label="run state",
+            )
+        except Exception as e:
+            logger.warning(f"Failed to save state snapshot: {type(e).__name__}: {e}")
+
     # 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
+        from ..result import relink_latest_results, save_results_zarr
 
+        run_results_dir = os.path.join(archive.path, "results", run_id)
         save_results_zarr(
             results,
-            os.path.join(archive.path, "results.zarr"),
+            os.path.join(run_results_dir, "results.zarr"),
             run_info,
         )
+        relink_latest_results(archive.path, run_id)
     except Exception as e:
         logger.warning(f"Failed to write results.zarr: {type(e).__name__}: {e}")
 

processforge-0.3.21/src/processforge/cli/runs.py

@@ -0,0 +1,96 @@
+"""``pf runs`` — list runs for a flowsheet, or show one run's full manifest."""
+
+from __future__ import annotations
+
+import json
+import os
+
+import typer
+from loguru import logger
+
+from .common import flowsheet_basename, output_root
+from ..persistence.archive import ProcessStateArchive
+
+
+def _summary_for(manifest) -> str:
+    """One-line summary of a run's primary unit fields (e.g. keff)."""
+    parts = []
+    for unit_name, out in manifest.units.items():
+        for f in out.fields:
+            val = f.quantity.value
+            unit = f.quantity.unit or ""
+            parts.append(f"{unit_name}.{f.name}={val}{(' ' + unit) if unit else ''}")
+    return "  ".join(parts) if parts else "-"
+
+
+def _zarr_status(archive_path: str, run_id: str) -> str:
+    zarr_path = os.path.join(archive_path, "results", run_id, "results.zarr")
+    return "✓" if os.path.exists(zarr_path) else "✗"
+
+
+def runs(
+    flowsheet: str = typer.Argument(..., help="Path to the flowsheet JSON"),
+    run_id: str = typer.Argument(
+        None,
+        help="Show this run's full manifest instead of listing all runs",
+    ),
+):
+    """List runs stored in a flowsheet's ``.pfarchive`` (or show one run)."""
+    base = flowsheet_basename(flowsheet)
+    archive_path = os.path.join(output_root(), f"{base}.pfarchive")
+
+    if not os.path.isdir(archive_path):
+        logger.error(
+            f"No archive found for '{flowsheet}' at {archive_path}. "
+            "Run 'pf run' first."
+        )
+        raise typer.Exit(code=1)
+
+    archive = ProcessStateArchive(archive_path)
+    latest = archive.latest_run()
+    latest_id = latest.run_id if latest is not None else None
+
+    if run_id is not None:
+        if run_id not in archive.list_runs():
+            logger.error(f"Run '{run_id}' not found in {archive_path}/runs.")
+            raise typer.Exit(code=1)
+        manifest = archive.load_run(run_id)
+        typer.echo(json.dumps(manifest.model_dump(), indent=2, default=str))
+        typer.echo("\nArtifacts on disk:")
+        for unit_name, out in manifest.units.items():
+            for art in out.artifacts:
+                present = os.path.exists(art.local_path) if art.local_path else False
+                remote = bool(art.remote_uris)
+                status = (
+                    "local✓" if present else ("remote-only" if remote else "missing")
+                )
+                loc = art.local_path or "no local path"
+                typer.echo(f"  [{unit_name}] {art.name}: {status} ({loc})")
+        return
+
+    run_ids = archive.list_runs()
+    if not run_ids:
+        typer.echo(f"No runs found for '{flowsheet}'.")
+        return
+
+    header = (
+        f"{'RUN ID':<28} {'TIMESTAMP':<22} {'MODE':<8} "
+        f"{'ZARR':<5} {'LATEST':<6} SUMMARY"
+    )
+    typer.echo(header)
+    typer.echo("-" * len(header))
+    for rid in run_ids:
+        manifest = archive.load_run(rid)
+        if manifest is None:
+            continue
+        marker = "*" if rid == latest_id else " "
+        typer.echo(
+            f"{rid:<28} {manifest.timestamp:<22} {manifest.mode:<8} "
+            f"{_zarr_status(archive_path, rid):<5} {marker:<6} "
+            f"{_summary_for(manifest)}"
+        )
+    typer.echo("")
+    typer.echo(
+        "Zarr: ✓ present on disk, ✗ deleted/missing. '*' marks the latest run. "
+        "'pf runs <flowsheet> <run_id>' prints the full manifest."
+    )

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

@@ -272,6 +272,34 @@ def save_results_zarr(results, fname="results.zarr", run_info: RunInfo | dict |
     return store_path
 
 
+def relink_latest_results(archive_path: str, run_id: str) -> None:
+    """Point ``<archive>/results.zarr`` at the latest per-run zarr.
+
+    Each run now writes its zarr to ``<archive>/results/<run_id>/results.zarr``
+    (see `save_results_zarr`). To keep backward compatibility with tooling that
+    reads a single ``results.zarr`` at the archive root, we make that path a
+    symlink to the newest run. Falls back to a copy on platforms/filesystems
+    without symlink support (or when the existing target is a real directory).
+    """
+    latest = os.path.join(archive_path, "results", run_id, "results.zarr")
+    if not os.path.exists(latest):
+        return
+    link_path = os.path.join(archive_path, "results.zarr")
+
+    # Remove any existing target (real dir or stale/broken symlink) without
+    # following the link.
+    if os.path.islink(link_path):
+        os.unlink(link_path)
+    elif os.path.exists(link_path):
+        shutil.rmtree(link_path)
+
+    try:
+        os.symlink(latest, link_path)
+    except (OSError, NotImplementedError):
+        # Non-POSIX / restricted filesystem: keep a physical copy instead.
+        shutil.copytree(latest, link_path)
+
+
 def save_results_zarr_s3(results, s3_uri: str, run_info: RunInfo | dict | None = None):
     """Write simulation results directly to an S3-backed Zarr store.
 

{processforge-0.3.19 → processforge-0.3.21}/src/processforge/state.py

@@ -302,27 +302,47 @@ class StateManager:
                 if ov != nv:
                     changes.append(f"{key}: {ov!r} → {nv!r}")
 
-            # Parameter changes (scalar unit params, not nested "parameters" dict)
-            all_keys = set(old_cfg) | set(new_cfg)
-            skip = {"type", "in", "out", "out_vap", "out_liq", "provider", "parameters"}
-            for k in all_keys - skip:
-                ov, nv = old_cfg.get(k), new_cfg.get(k)
-                if ov != nv:
-                    changes.append(f"{k}: {ov} → {nv}")
-
-            # Nested "parameters" dict
-            old_params = old_cfg.get("parameters", {})
-            new_params = new_cfg.get("parameters", {})
-            for pk in set(old_params) | set(new_params):
-                ov, nv = old_params.get(pk), new_params.get(pk)
-                if ov != nv:
-                    changes.append(f"parameters.{pk}: {ov} → {nv}")
+            # Parameter changes — recurse into nested dicts so leaf values
+            # (e.g. solver_config.batches) are reported individually rather
+            # than dumping the whole dict.
+            changes.extend(
+                StateManager._diff_params(old_cfg, new_cfg)
+            )
 
             if changes:
                 modified[name] = {"type": new_cfg.get("type", "?"), "changes": changes}
 
         return {"added": added, "removed": removed, "modified": modified}
 
+    # ------------------------------------------------------------------
+    # Structural-diff helpers
+    # ------------------------------------------------------------------
+    @staticmethod
+    def _diff_params(
+        old_cfg: dict, new_cfg: dict, prefix: str = "", skip: set | None = None
+    ) -> list[str]:
+        """Recursively collect changed scalar/leaf params between two dicts.
+
+        Nested dicts are descended (``solver_config.batches: 25 → 999``) so the
+        structural diff reports leaf-level changes instead of whole-dict blobs.
+        """
+        if skip is None:
+            skip = {"type", "in", "out", "out_vap", "out_liq", "provider"}
+        all_keys = set(old_cfg) | set(new_cfg)
+        if not prefix:
+            all_keys -= skip
+        changes: list[str] = []
+        for k in all_keys:
+            ov, nv = old_cfg.get(k), new_cfg.get(k)
+            label = f"{prefix}{k}"
+            if isinstance(ov, dict) and isinstance(nv, dict):
+                changes.extend(
+                    StateManager._diff_params(ov, nv, prefix=f"{label}.", skip=set())
+                )
+            elif ov != nv:
+                changes.append(f"{label}: {ov} → {nv}")
+        return changes
+
     # ------------------------------------------------------------------
     # State → stream dict conversion (for dynamic t=0 initialisation)
     # ------------------------------------------------------------------

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.3.19
+Version: 0.3.21
 Summary: A Python-based process simulation framework for chemical engineering applications.
 Author-email: Processforge Team <team@processforge.dev>
 License-Expression: BSD-3-Clause

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

@@ -47,6 +47,7 @@ src/processforge/cli/export_modelica.py
 src/processforge/cli/init.py
 src/processforge/cli/plan.py
 src/processforge/cli/run.py
+src/processforge/cli/runs.py
 src/processforge/cli/validate.py
 src/processforge/eo/__init__.py
 src/processforge/eo/flowsheet.py
@@ -132,6 +133,7 @@ tests/test_openmc_provider.py
 tests/test_provider_errors.py
 tests/test_providers.py
 tests/test_result_zarr.py
+tests/test_runs_command.py
 tests/test_s3_upload.py
 tests/test_state.py
 tests/test_types.py

processforge-0.3.21/tests/test_runs_command.py

@@ -0,0 +1,122 @@
+"""Tests for per-run Zarr outputs and the ``pf runs`` listing command."""
+import json
+import os
+
+import zarr
+from typer.testing import CliRunner
+
+import typer
+
+from processforge.cli.runs import runs
+from processforge.result import relink_latest_results, save_results_zarr
+from processforge.types import (
+    EngineOutput,
+    OutputArtifact,
+    OutputField,
+    Quantity,
+    RunManifest,
+)
+
+
+def _eo(run_id_suffix: str, keff: float) -> EngineOutput:
+    return EngineOutput(
+        engine="openmc",
+        sim_type="eigenvalue_reactor",
+        status="completed",
+        fields=[
+            OutputField(
+                name="k_eff",
+                quantity=Quantity(value=keff, unit=""),
+                kind="scalar",
+                source="keff",
+            )
+        ],
+        artifacts=[
+            OutputArtifact(
+                name="statepoint",
+                kind="h5",
+                local_path=f"/data/openmc/msre_run/{run_id_suffix}/statepoint.h5",
+                remote_uris=[],
+                source="local",
+            )
+        ],
+    )
+
+
+def test_relink_latest_results_symlinks_to_latest(tmp_path):
+    d = str(tmp_path)
+    rid_a = "20260101T000000Z_aaaaaa"
+    rid_b = "20260102T000000Z_bbbbbb"
+
+    save_results_zarr({"openmc_solver": _eo("a", 1.04)},
+                      os.path.join(d, "results", rid_a, "results.zarr"), None)
+    relink_latest_results(d, rid_a)
+    link = os.path.join(d, "results.zarr")
+    assert os.path.islink(link)
+    assert os.path.realpath(link) == os.path.realpath(
+        os.path.join(d, "results", rid_a, "results.zarr"))
+
+    # A second run re-points the symlink without clobbering run A's zarr.
+    save_results_zarr({"openmc_solver": _eo("b", 1.06)},
+                      os.path.join(d, "results", rid_b, "results.zarr"), None)
+    relink_latest_results(d, rid_b)
+    assert os.path.realpath(link) == os.path.realpath(
+        os.path.join(d, "results", rid_b, "results.zarr"))
+    assert os.path.isdir(os.path.join(d, "results", rid_a, "results.zarr"))
+
+    root = zarr.open_group(link, mode="r")
+    assert abs(root["openmc_solver"]["k_eff"][0] - 1.06) < 1e-9
+
+
+def test_pf_runs_lists_runs_with_disk_status(tmp_path, monkeypatch):
+    monkeypatch.setenv("PROCESSFORGE_OUTPUT_DIR", str(tmp_path))
+    base = "test_flowsheet"
+    archive_path = tmp_path / f"{base}.pfarchive"
+    runs_dir = archive_path / "runs"
+    results_dir = archive_path / "results"
+    runs_dir.mkdir(parents=True)
+
+    rid_a = "20260101T000000Z_aaaaaa"
+    rid_b = "20260102T000000Z_bbbbbb"
+
+    # Run A has its zarr on disk; run B does not (deleted).
+    save_results_zarr({"openmc_solver": _eo("a", 1.04)},
+                      str(results_dir / rid_a / "results.zarr"), None)
+    for rid, keff in ((rid_a, 1.04), (rid_b, 1.06)):
+        manifest = RunManifest(
+            run_id=rid, timestamp=rid.split("_")[0], mode="steady",
+            units={"openmc_solver": _eo(rid[-6:], keff)},
+        )
+        (runs_dir / f"{rid}.json").write_text(manifest.model_dump_json())
+    (archive_path / "latest_run").write_text(rid_b)
+
+    app = typer.Typer()
+    app.command()(runs)
+    result = CliRunner().invoke(app, [f"/tmp/{base}.json"])
+    assert result.exit_code == 0, result.output
+    assert rid_a in result.output
+    assert rid_b in result.output
+    assert "✓" in result.output and "✗" in result.output
+    assert "*" in result.output  # latest marker on run B
+
+
+def test_pf_runs_shows_manifest_and_artifacts(tmp_path, monkeypatch):
+    monkeypatch.setenv("PROCESSFORGE_OUTPUT_DIR", str(tmp_path))
+    base = "test_flowsheet"
+    archive_path = tmp_path / f"{base}.pfarchive"
+    runs_dir = archive_path / "runs"
+    runs_dir.mkdir(parents=True)
+
+    rid = "20260101T000000Z_aaaaaa"
+    manifest = RunManifest(
+        run_id=rid, timestamp=rid.split("_")[0], mode="steady",
+        units={"openmc_solver": _eo(rid[-6:], 1.04)},
+    )
+    (runs_dir / f"{rid}.json").write_text(manifest.model_dump_json())
+
+    app = typer.Typer()
+    app.command()(runs)
+    result = CliRunner().invoke(app, [f"/tmp/{base}.json", rid])
+    assert result.exit_code == 0, result.output
+    assert "k_eff" in result.output
+    assert "Artifacts on disk:" in result.output