processforge 0.3.26__tar.gz → 0.4.1__tar.gz

{processforge-0.3.26/src/processforge.egg-info → processforge-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.3.26
+Version: 0.4.1
 Summary: A Python-based process simulation framework for chemical engineering applications.
 Author-email: Processforge Team <team@processforge.dev>
 License-Expression: BSD-3-Clause
@@ -43,9 +43,13 @@ Requires-Dist: pyomo>=6.7; extra == "eo-casadi"
 Requires-Dist: casadi>=3.6; extra == "eo-casadi"
 Provides-Extra: fmu
 Requires-Dist: pythonfmu>=0.6; extra == "fmu"
+Requires-Dist: fmpy>=0.3; extra == "fmu"
 Provides-Extra: modelica
 Requires-Dist: OMPython>=4.0.0; extra == "modelica"
 Requires-Dist: fmpy>=0.3; extra == "modelica"
+Provides-Extra: pathsim
+Requires-Dist: pathsim>=0.9; extra == "pathsim"
+Requires-Dist: fmpy>=0.3; extra == "pathsim"
 Provides-Extra: cantera
 Requires-Dist: cantera>=3.0; extra == "cantera"
 Provides-Extra: coolprop

{processforge-0.3.26 → processforge-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "processforge"
-version = "0.3.26"
+version = "0.4.1"
 description = "A Python-based process simulation framework for chemical engineering applications."
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -55,11 +55,16 @@ eo-casadi = [
 ]
 fmu = [
     "pythonfmu>=0.6",
+    "fmpy>=0.3",
 ]
 modelica = [
     "OMPython>=4.0.0",
     "fmpy>=0.3",
 ]
+pathsim = [
+    "pathsim>=0.9",
+    "fmpy>=0.3",
+]
 cantera = [
     "cantera>=3.0",
 ]

{processforge-0.3.26 → processforge-0.4.1}/src/processforge/__init__.py

@@ -30,7 +30,7 @@ from .units.flash import Flash
 from .units.heater import Heater
 from .eo import EOFlowsheet, EOSolver
 
-__version__ = "0.3.26"
+__version__ = "0.4.1"
 
 __all__ = [
     "Flowsheet",

{processforge-0.3.26 → processforge-0.4.1}/src/processforge/cli/__init__.py

@@ -32,7 +32,7 @@ def register_commands(app: typer.Typer) -> None:
     )(apply)
     app.command(
         "runs",
-        help="List runs for a flowsheet, or show one run's full manifest (pf runs <flowsheet> [<run_id>])",
+        help="List runs for a flowsheet, or inspect one run's Zarr result summary (pf runs <flowsheet> [<run_id>|latest] [--schema])",
     )(runs)
     app.command(
         "plan",

processforge-0.4.1/src/processforge/cli/export_fmu.py

@@ -0,0 +1,88 @@
+"""``pf export-fmu`` — export flowsheet as FMI 2.0 co-simulation FMU."""
+
+from __future__ import annotations
+
+import os
+from typing import Literal
+
+import typer
+from loguru import logger
+
+from .common import require_existing_file
+
+
+def export_fmu(
+    flowsheet: str = typer.Argument(help="Path to the flowsheet JSON file"),
+    output_dir: str = typer.Option(
+        "outputs",
+        "--output-dir",
+        "-o",
+        help="Directory for the output FMU (default: outputs/)",
+    ),
+    backend: Literal["scipy", "pyomo", "casadi"] = typer.Option(
+        "scipy",
+        "--backend",
+        help="EO solver backend for steady-state mode (default: scipy)",
+    ),
+    pathsim: bool = typer.Option(
+        False,
+        "--pathsim",
+        help="Also emit the fmu_interface.json manifest and a PathSim wiring example",
+    ),
+) -> None:
+    """Export a flowsheet as an FMI 2.0 co-simulation FMU."""
+    require_existing_file(flowsheet)
+
+    from ..fmu import build_fmu  # local import — pythonfmu is optional
+
+    output_dir = output_dir or "outputs"
+    backend = backend or "scipy"
+
+    try:
+        fmu_path = build_fmu(
+            flowsheet,
+            output_dir=output_dir,
+            backend=backend,
+            write_manifest=pathsim,
+        )
+        logger.info(f"FMU written to: {fmu_path}")
+        if pathsim:
+            base = os.path.splitext(os.path.basename(fmu_path))[0]
+            manifest_path = os.path.join(output_dir, f"{base}_fmu_interface.json")
+            example_path = os.path.join(output_dir, f"{base}_pathsim.py")
+            _write_pathsim_example(example_path, fmu_path, manifest_path)
+            logger.info(f"Manifest written to: {manifest_path}")
+            logger.info(f"PathSim example written to: {example_path}")
+    except Exception as e:
+        logger.error(f"FMU export failed: {type(e).__name__}: {e}")
+        logger.debug("FMU export traceback:", exc_info=True)
+        raise SystemExit(1)
+
+
+def _write_pathsim_example(example_path: str, fmu_path: str, manifest_path: str) -> None:
+    """Write a minimal PathSim wiring example next to the exported FMU."""
+    content = f'''"""Auto-generated PathSim wiring example."""
+import pathsim as ps
+from processforge.pathsim import ProcessForgeFMU
+
+plant = ProcessForgeFMU(
+    fmu_path={fmu_path!r},
+    manifest_path={manifest_path!r},
+)
+
+# Inspect available ports:
+# print(plant.inputs)
+# print(plant.outputs)
+
+# Example: drive an input with a constant setpoint and read an output.
+setpoint = ps.Constant(val=1.0)
+sim = ps.Simulation(
+    blocks=[setpoint, plant],
+    connections=[
+        # ps.Connection(setpoint, plant["<unit>.<input>"]),
+    ],
+)
+sim.run(time_span=(0, 10))
+'''
+    with open(example_path, "w", encoding="utf-8") as f:
+        f.write(content)

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

@@ -0,0 +1,201 @@
+"""``pf runs`` — list runs and inspect their Zarr result summaries."""
+
+from __future__ import annotations
+
+import json
+import os
+
+import arrow
+import typer
+from loguru import logger
+
+from .common import flowsheet_basename, output_root
+from ..persistence.archive import ProcessStateArchive
+from ..result import _fmt_scientific, _one_line_summary, summarize_zarr_store
+
+
+def _humanize_timestamp(ts: str) -> str:
+    """Render a stored timestamp as a human-readable relative string.
+
+    Falls back to the raw string for values that aren't parseable ISO-8601
+    (e.g. ``20260101T000000Z`` used in some test fixtures).
+    """
+    try:
+        return arrow.get(ts).humanize()
+    except (arrow.parser.ParserError, ValueError, TypeError):
+        return ts
+
+
+def _zarr_path(archive_path: str, run_id: str) -> str:
+    """Return the per-run Zarr store path."""
+    return os.path.join(archive_path, "results", run_id, "results.zarr")
+
+
+def _artifact_status(artifact: dict) -> str:
+    """Return a short presence marker for an artifact dict."""
+    local_path = artifact.get("local_path")
+    remote_uris = artifact.get("remote_uris") or []
+    if local_path and os.path.exists(local_path):
+        return "local✓"
+    if remote_uris:
+        return "remote-only"
+    return "missing"
+
+
+def _format_run_details(manifest, summary: dict) -> str:
+    """Format a detailed, human-readable result summary for a single run."""
+    lines = [
+        f"Run: {manifest.run_id}",
+        f"Timestamp: {manifest.timestamp}",
+        f"Mode: {summary.get('mode', manifest.mode)}",
+        "",
+        "Results:",
+        "────────",
+    ]
+
+    engine_outputs = summary.get("engine_outputs", {})
+    if engine_outputs:
+        for name, eo in engine_outputs.items():
+            engine = eo.get("engine", "")
+            sim_type = eo.get("sim_type", "")
+            status = eo.get("status", "")
+            lines.append(f"{name} ({engine} / {sim_type}) [{status}]")
+            for fname, fdata in eo.get("fields", {}).items():
+                val = _fmt_scientific(fdata.get("value"))
+                unit = fdata.get("unit", "")
+                std = fdata.get("std_dev")
+                if std is not None:
+                    lines.append(f"  {fname}: {val} ± {_fmt_scientific(std)} {unit}".strip())
+                else:
+                    lines.append(f"  {fname}: {val} {unit}".strip())
+            if eo.get("attrs") and not eo.get("fields"):
+                for k, v in eo["attrs"].items():
+                    if not k.startswith("_") and k not in ("engine", "sim_type", "status"):
+                        lines.append(f"  {k}: {_fmt_scientific(v)}")
+            lines.append("")
+    else:
+        lines.append("  (no solver/engine outputs)")
+        lines.append("")
+
+    streams = summary.get("streams", {})
+    if streams:
+        lines.append("Streams:")
+        all_vars: set[str] = set()
+        for sdata in streams.values():
+            all_vars.update(sdata.get("variables", []))
+        all_vars = sorted(all_vars)
+
+        header_parts = ["stream".ljust(20)] + [v.rjust(14) for v in all_vars]
+        lines.append("  " + " ".join(header_parts))
+        lines.append("  " + "-" * len("  ".join(header_parts)))
+        for sname in sorted(streams):
+            sdata = streams[sname]
+            fields = sdata.get("fields", {})
+            row = [sname.ljust(20)]
+            for var in all_vars:
+                fdata = fields.get(var, {})
+                val = fdata.get("value")
+                row.append(_fmt_scientific(val).rjust(14))
+            lines.append("  " + " ".join(row))
+        lines.append("")
+
+    artifacts = summary.get("artifacts", [])
+    if artifacts:
+        lines.append("Artifacts:")
+        for art in artifacts:
+            name = art.get("name", "unknown")
+            kind = art.get("kind", "")
+            status = _artifact_status(art)
+            loc = art.get("local_path") or (art.get("remote_uris") or ["no location"])[0]
+            lines.append(f"  [{kind}] {name}: {status} ({loc})")
+    else:
+        lines.append("Artifacts: none")
+
+    zarr_path = summary.get("_zarr_path")
+    if zarr_path:
+        lines.append("")
+        lines.append(f"Zarr store: {zarr_path}")
+
+    return "\n".join(lines)
+
+
+def runs(
+    flowsheet: str = typer.Argument(..., help="Path to the flowsheet JSON"),
+    run_id: str = typer.Argument(
+        None,
+        help="Show this run's result summary. Use 'latest' for the most recent run.",
+    ),
+    schema: bool = typer.Option(
+        False,
+        "--schema",
+        help="Print the result schema JSON instead of the summary.",
+    ),
+):
+    """List runs for a flowsheet, or inspect one run's Zarr result summary."""
+    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:
+        resolved_id = latest_id if run_id == "latest" and latest_id else run_id
+        if resolved_id != run_id and latest_id is None:
+            logger.error(f"No latest run found in {archive_path}.")
+            raise typer.Exit(code=1)
+
+        if resolved_id not in archive.list_runs():
+            logger.error(f"Run '{resolved_id}' not found in {archive_path}/runs.")
+            raise typer.Exit(code=1)
+
+        zarr_path = _zarr_path(archive_path, resolved_id)
+
+        if schema:
+            schema_path = zarr_path + ".schema.json"
+            if not os.path.isfile(schema_path):
+                logger.error(f"No schema found for run '{resolved_id}'.")
+                raise typer.Exit(code=1)
+            with open(schema_path, "r", encoding="utf-8") as f:
+                typer.echo(f.read())
+            return
+
+        manifest = archive.load_run(resolved_id)
+        summary = summarize_zarr_store(zarr_path)
+        summary["_zarr_path"] = zarr_path
+        typer.echo(_format_run_details(manifest, summary))
+        return
+
+    # List all runs with a one-line summary.
+    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} {'LATEST':<7} {'SUMMARY':<30}"
+    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 " "
+        zarr_path = _zarr_path(archive_path, rid)
+        summary = summarize_zarr_store(zarr_path)
+        one_liner = _one_line_summary(summary)
+        typer.echo(
+            f"{rid:<28} {_humanize_timestamp(manifest.timestamp):<22} {marker:<7} {one_liner:<30}"
+        )
+    typer.echo("")
+    typer.echo(
+        "'*' marks the latest run. "
+        "'pf runs <flowsheet> <run_id>' shows the result summary. "
+        "Use 'latest' as the run id for the most recent run."
+    )

{processforge-0.3.26 → processforge-0.4.1}/src/processforge/fmu/_fmi_vars.py

@@ -3,12 +3,45 @@ from __future__ import annotations
 
 import re
 
+from .interface import SolverUnitPort
+
 
 def _sanitize_name(s: str) -> str:
     """Replace characters invalid in Python identifiers with underscores."""
     return re.sub(r"[^a-zA-Z0-9_]", "_", s)
 
 
+def solverunit_port_to_spec(port: SolverUnitPort) -> dict:
+    """Convert a :class:`SolverUnitPort` to the internal spec dict format."""
+    return {
+        "attr_name": port.attr_name,
+        "initial_value": float(port.initial_value),
+        "causality": port.causality,
+        "variability": port.variability,
+        "description": port.description,
+        "unit": port.unit,
+        "logical_name": f"{port.unit_name}.{port.path}",
+    }
+
+
+def ensure_unique_attr_names(specs: list[dict]) -> list[dict]:
+    """Deduplicate ``attr_name`` values by appending a counter.
+
+    Preserves order and returns a new list of specs.
+    """
+    seen: dict[str, int] = {}
+    out: list[dict] = []
+    for spec in specs:
+        name = spec["attr_name"]
+        count = seen.get(name, 0)
+        if count:
+            new_name = f"{name}_{count}"
+            spec = {**spec, "attr_name": new_name}
+        seen[name] = count + 1
+        out.append(spec)
+    return out
+
+
 def get_fmi_variable_specs(
     feed_streams: list[str],
     output_streams: list[str],
@@ -115,8 +148,8 @@ def get_fmi_variable_specs(
                 "description": f"Parameter '{key}' of unit '{unit_name}'",
             })
 
-    # --- Tank state outputs (dynamic mode only) ---
-    if mode == "dynamic":
+    # --- Tank state outputs (dynamic / solverunit_dynamic modes only) ---
+    if mode in ("dynamic", "solverunit_dynamic"):
         for unit_name, unit_cfg in config["units"].items():
             if unit_cfg.get("type") != "Tank":
                 continue

{processforge-0.3.26 → processforge-0.4.1}/src/processforge/fmu/builder.py

@@ -7,9 +7,17 @@ import shutil
 import subprocess
 import tempfile
 
+import json
+
 from ..utils.validate_flowsheet import validate_flowsheet
 from ..utils.topology import TOPOLOGY_KEYS, get_outlets
-from ._fmi_vars import _sanitize_name
+from ._fmi_vars import (
+    _sanitize_name,
+    ensure_unique_attr_names,
+    get_fmi_variable_specs,
+    solverunit_port_to_spec,
+)
+from .interface import build_solverunit_interface, build_fmu_interface_manifest
 from .slave_template import render_slave_source
 
 
@@ -17,6 +25,7 @@ def build_fmu(
     config_path: str,
     output_dir: str = "outputs",
     backend: str = "scipy",
+    write_manifest: bool = True,
 ) -> str:
     """Build an FMI 2.0 co-simulation FMU from a Processforge flowsheet JSON.
 
@@ -25,6 +34,8 @@ def build_fmu(
         output_dir:  Directory where the ``.fmu`` file will be written.
         backend:     EO solver backend for steady-state mode
                      (``"scipy"``, ``"pyomo"``, or ``"casadi"``).
+        write_manifest: If ``True`` (default), write ``fmu_interface.json`` next
+                        to the ``.fmu`` file.
 
     Returns:
         Absolute path to the generated ``.fmu`` file.
@@ -42,6 +53,26 @@ def build_fmu(
     interface = _analyze_config(config)
     slave_class_name = _get_slave_class_name(config, config_path)
 
+    solverunit_ports: dict = {}
+    if interface.get("has_solverunit"):
+        solverunit_ports = build_solverunit_interface(config)
+        interface["solverunit_ports"] = solverunit_ports
+
+    stream_specs = get_fmi_variable_specs(
+        interface["feed_streams"],
+        interface["output_streams"],
+        interface["components"],
+        interface["unit_params"],
+        config,
+        interface["mode"],
+    )
+    solverunit_specs = [
+        solverunit_port_to_spec(port)
+        for ports in solverunit_ports.values()
+        for port in ports
+    ]
+    specs = ensure_unique_attr_names(stream_specs + solverunit_specs)
+
     os.makedirs(output_dir, exist_ok=True)
 
     with tempfile.TemporaryDirectory() as staging_dir:
@@ -58,6 +89,8 @@ def build_fmu(
             output_streams=interface["output_streams"],
             components=interface["components"],
             unit_params=interface["unit_params"],
+            solverunit_ports=solverunit_ports,
+            specs=specs,
             config=config,
         )
 
@@ -86,6 +119,19 @@ def build_fmu(
     fmu_path = os.path.abspath(
         os.path.join(output_dir, f"{slave_class_name}.fmu")
     )
+
+    if write_manifest:
+        parameter_specs = [spec for spec in specs if spec["causality"] == "parameter"]
+        non_param_specs = [spec for spec in specs if spec["causality"] != "parameter"]
+        manifest = build_fmu_interface_manifest(
+            config, non_param_specs, interface.get("solverunit_ports", {}), parameter_specs
+        )
+        manifest_path = os.path.join(
+            output_dir, f"{slave_class_name}_fmu_interface.json"
+        )
+        with open(manifest_path, "w", encoding="utf-8") as f:
+            json.dump(manifest, f, indent=2)
+
     return fmu_path
 
 
@@ -140,12 +186,21 @@ def _analyze_config(config: dict) -> dict:
         if params:
             unit_params[unit_name] = params
 
-    # Simulation mode — force "dynamic" if any Tank is present
+    # Simulation mode
     mode = config.get("simulation", {}).get("mode", "steady")
     has_tank = any(
         cfg.get("type") == "Tank" for cfg in config["units"].values()
     )
-    if has_tank:
+    has_solverunit = any(
+        cfg.get("type") == "SolverUnit" for cfg in config["units"].values()
+    )
+    if has_solverunit and has_tank:
+        # Both dynamic Tank(s) and SolverUnit(s) require a mixed slave.
+        mode = "solverunit_dynamic"
+    elif has_solverunit:
+        # SolverUnit flowsheets are driven by the Flowsheet-based slave.
+        mode = "solverunit"
+    elif has_tank:
         mode = "dynamic"
 
     return {
@@ -154,6 +209,8 @@ def _analyze_config(config: dict) -> dict:
         "components": components,
         "unit_params": unit_params,
         "mode": mode,
+        "has_solverunit": has_solverunit,
+        "has_tank": has_tank,
     }
 
 def _get_slave_class_name(config: dict, config_path: str) -> str: