processforge 0.3.5__tar.gz → 0.3.8__tar.gz

{processforge-0.3.5/src/processforge.egg-info → processforge-0.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.3.5
+Version: 0.3.8
 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.5 → processforge-0.3.8}/flowsheets/openmc/msre_eigenvalue.json

@@ -17,7 +17,7 @@
       "id": 1,
       "density": 2.26,
       "density_units": "g/cm3",
-      "temperature": 0.0,
+      "temperature": 300.0,
       "elements": [
         { "element": "C", "percent": 1.0, "percent_type": "ao" }
       ]
@@ -26,7 +26,7 @@
       "id": 2,
       "density": 9.0,
       "density_units": "g/cm3",
-      "temperature": 0.0,
+      "temperature": 400.0,
       "elements": [
         { "element": "Ni", "percent": 0.72, "percent_type": "wo" },
         { "element": "Mo", "percent": 0.16, "percent_type": "wo" },
@@ -38,7 +38,7 @@
       "id": 3,
       "density": 2.2,
       "density_units": "g/cm3",
-      "temperature": 0.0,
+      "temperature": 300.0,
       "depletable": true,
       "nuclides": [
         { "name": "Li7",  "percent": 0.335000, "percent_type": "ao" },
@@ -55,7 +55,7 @@
       "id": 4,
       "density": 8.9,
       "density_units": "g/cm3",
-      "temperature": 0.0,
+      "temperature": 300.0,
       "elements": [
         { "element": "Ni", "percent": 0.72, "percent_type": "ao" },
         { "element": "Cr", "percent": 0.20, "percent_type": "ao" },
@@ -66,7 +66,7 @@
       "id": 5,
       "density": 1.0e-4,
       "density_units": "g/cm3",
-      "temperature": 0.0,
+      "temperature": 300.0,
       "nuclides": [
         { "name": "He4", "percent": 1.0, "percent_type": "ao" }
       ]

{processforge-0.3.5 → processforge-0.3.8}/pyproject.toml

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

{processforge-0.3.5 → processforge-0.3.8}/src/processforge/cli/__init__.py

@@ -31,7 +31,7 @@ def register_commands(app: typer.Typer) -> None:
     )(apply)
     app.command(
         "plan",
-        help="Validate a flowsheet, run DOF analysis, structural diff, and generate a Mermaid diagram",
+        help="Validate a flowsheet, run DOF analysis, structural diff, container health check, and generate a Mermaid diagram",
     )(plan)
     app.command("diagram", help="Generate a flowsheet diagram")(diagram)
     app.command(

{processforge-0.3.5 → processforge-0.3.8}/src/processforge/cli/apply.py

@@ -17,6 +17,7 @@ from .common import (
     build_divergence_report,
     build_run_metadata,
     check_providers,
+    display_backend,
     flowsheet_basename,
     load_state_manager,
     log_residual_breakdown,
@@ -132,7 +133,7 @@ def apply(
         logger.info("  Status       : CONVERGED")
         logger.info(f"  Final ||F||  : {fs.solver_stats.get('final_norm', '?'):.3e}")
         logger.info(f"  Iterations   : {fs.solver_stats.get('iterations', '?')}")
-        logger.info(f"  Backend      : {fs.backend}")
+        logger.info(f"  Backend      : {display_backend(config, fs.backend)}")
         logger.info(f"  Snapshot ID  : {snapshot_id}")
         logger.info(f"  Results zarr : {zarr_path}")
         logger.info(f"  Elapsed (s)  : {elapsed:.2f}")

{processforge-0.3.5 → processforge-0.3.8}/src/processforge/cli/common.py

@@ -98,6 +98,23 @@ def build_run_metadata(config: dict, solver_tol: float, solver_max_iter: int, ba
     }
 
 
+def display_backend(config: dict, eo_backend: str) -> str:
+    """Resolve the backend label shown in run/apply summaries.
+
+    When a flowsheet delegates its computation to one or more providers
+    (e.g. ``openmc``, ``cantera``), the provider type is the engine that
+    actually ran the simulation — report that rather than the EO solver
+    backend (which is a no-op for provider-driven flowsheets).  Falls back
+    to the EO solver backend when no providers are declared.
+    """
+    provider_types = sorted(
+        {p.get("type") for p in config.get("providers", {}).values() if p.get("type")}
+    )
+    if provider_types:
+        return "+".join(provider_types)
+    return eo_backend
+
+
 def extract_providers(flowsheet_path: str) -> dict:
     """Read flowsheet JSON and return the raw providers dict."""
     try:
@@ -128,6 +145,21 @@ def load_state_manager(outputs_dir: str, base_name: str) -> tuple[StateManager,
 # Provider checking
 # ---------------------------------------------------------------------------
 
+def is_local_provider_url(url: str | None) -> bool:
+    """Return True if *url* points at a locally-managed provider.
+
+    A provider is considered local — and thus a candidate for ``pf init`` to
+    generate docker-compose and pull its image — when it has no explicit URL
+    or its URL points at localhost / 127.0.0.1 / 0.0.0.0. Any other URL is
+    treated as an externally-managed (cloud / remote) provider that
+    ``pf init`` must not try to spin up or pull an image for.
+    """
+    if not url:
+        return True
+    lowered = url.lower()
+    return any(token in lowered for token in ("localhost", "127.0.0.1", "0.0.0.0"))
+
+
 def _resolve_provider_url(cfg: dict, ptype: str) -> str:
     """Build the provider URL, falling back to the default port."""
     from ..providers.registry import get_provider_default_port
@@ -139,6 +171,19 @@ def _resolve_provider_url(cfg: dict, ptype: str) -> str:
     return url
 
 
+def _ping_provider_health(url: str, timeout: int = 5) -> tuple[bool, "dict | str"]:
+    """GET ``{url}/health`` and return ``(ok, payload_or_error)``.
+
+    Returns the parsed JSON health payload on success, or the error string on
+    failure (unreachable service, timeout, or non-JSON response).
+    """
+    try:
+        with urllib.request.urlopen(f"{url.rstrip('/')}/health", timeout=timeout) as resp:
+            return True, json.loads(resp.read().decode())
+    except (urllib.error.URLError, OSError, TimeoutError, ValueError) as exc:
+        return False, str(exc)
+
+
 def check_providers(
     config: dict,
     flowsheet_path: str,

{processforge-0.3.5 → processforge-0.3.8}/src/processforge/cli/display.py

@@ -53,6 +53,61 @@ def print_unit_mismatches(mismatches: list[Any]) -> None:
             logger.warning(f"Unit annotation — stream '{m.stream_name}'.{m.property_name}: {m.message}")
 
 
+def print_provider_health(config: dict) -> list[str]:
+    """Log per-provider reachability for flowsheets using Docker containers.
+
+    For each provider declared in *config*:
+
+    * containerized providers are probed via ``GET /health`` and reported with
+      their URL, ``status``, and ``provider_type`` from the health payload;
+    * pip-installable providers are reported as importable or not.
+
+    Returns a list of failure messages — one per unreachable containerized
+    provider (empty means every provider is healthy/available).
+    """
+    import importlib
+
+    from ..providers.registry import is_containerized, _PROVIDER_CATALOG
+
+    providers = config.get("providers", {})
+    logger.info("=== Provider / Container Health ===")
+    failures: list[str] = []
+    if not providers:
+        logger.info("  No providers declared.")
+        return failures
+
+    for name, cfg in providers.items():
+        ptype = cfg.get("type", "")
+        if is_containerized(ptype):
+            from .common import _resolve_provider_url, _ping_provider_health
+
+            url = _resolve_provider_url(cfg, ptype)
+            ok, info = _ping_provider_health(url, timeout=5)
+            if ok:
+                payload = info if isinstance(info, dict) else {}
+                status = payload.get("status", "?")
+                provider_type = payload.get("provider_type", "?")
+                logger.info(
+                    f"  [OK] {name} [{ptype}] {url} — status={status} provider_type={provider_type}"
+                )
+            else:
+                msg = f"  [ERR] {name} [{ptype}] {url} — unreachable: {info}"
+                logger.error(msg)
+                failures.append(f"Provider '{name}' unreachable at {url}: {info}")
+        else:
+            catalog = _PROVIDER_CATALOG.get(ptype, {})
+            module = catalog.get("module", "")
+            try:
+                importlib.util.find_spec(module)
+                logger.info(f"  [OK] {name} [{ptype}] (pip — importable)")
+            except (ModuleNotFoundError, ValueError):
+                dep = catalog.get("optional_dep")
+                hint = f"pip install 'processforge[{dep}]'" if dep else "built-in"
+                logger.warning(f"  [WARN] {name} [{ptype}] — not installed ({hint})")
+
+    return failures
+
+
 def print_structural_diff(diff: dict) -> None:
     """Print a +/~/- structural diff of units."""
     logger.info("=== Structural Diff vs. Saved State ===")

{processforge-0.3.5 → processforge-0.3.8}/src/processforge/cli/init.py

@@ -11,7 +11,56 @@ import subprocess
 import typer
 from loguru import logger
 
-from .common import extract_providers
+from .common import extract_providers, is_local_provider_url
+from ..lock import flowsheet_env_dir, read_lock
+
+
+def _migrate_legacy_env(pf_dir: str) -> None:
+    """Move a legacy root-level lock.json / docker-compose.yml into a per-flowsheet dir.
+
+    Older processforge stored a single environment at ``.processforge/lock.json``
+    and ``.processforge/docker-compose.yml``. This relocates those into the hashed
+    env dir derived from the flowsheet recorded in the legacy lock, so an existing
+    repo keeps its provider environment after upgrading.
+    """
+    legacy_lock = os.path.join(pf_dir, "lock.json")
+    legacy_compose = os.path.join(pf_dir, "docker-compose.yml")
+    if not (os.path.exists(legacy_lock) or os.path.exists(legacy_compose)):
+        return
+
+    recorded = None
+    if os.path.exists(legacy_lock):
+        try:
+            recorded = read_lock(pf_dir).get("flowsheet")
+        except Exception:
+            recorded = None
+
+    if recorded and os.path.exists(recorded):
+        env_dir = flowsheet_env_dir(pf_dir, recorded)
+    else:
+        base = os.path.splitext(os.path.basename(recorded or "legacy"))[0] or "legacy"
+        env_dir = os.path.join(pf_dir, base)
+        logger.warning(
+            "Migrating legacy .processforge/lock.json + docker-compose.yml into "
+            f"'{os.path.relpath(env_dir, pf_dir)}/' (recorded flowsheet not found on "
+            "disk — re-run `pf init <flowsheet.json>` to restore the correct env dir)."
+        )
+
+    if os.path.exists(env_dir):
+        logger.warning(
+            f"Migration target {os.path.relpath(env_dir, pf_dir)}/ already exists — "
+            "skipping legacy migration."
+        )
+        return
+
+    os.makedirs(env_dir, exist_ok=True)
+    for src in (legacy_lock, legacy_compose):
+        if os.path.exists(src):
+            shutil.move(src, os.path.join(env_dir, os.path.basename(src)))
+    logger.info(
+        "Migrated legacy .processforge/ environment into per-flowsheet dir "
+        f"'{os.path.relpath(env_dir, pf_dir)}/'."
+    )
 
 
 def init(
@@ -42,6 +91,11 @@ def init(
     os.makedirs(pf_dir, exist_ok=True)
     os.makedirs(outputs_dir, exist_ok=True)
 
+    # Migrate a legacy single-environment layout (.processforge/lock.json and
+    # .processforge/docker-compose.yml at the root) into a per-flowsheet env
+    # dir so existing repos aren't silently broken by the new structure.
+    _migrate_legacy_env(pf_dir)
+
     # Remove stale .pfstate snapshot directories from outputs/
     stale_count = 0
     for entry in os.listdir(outputs_dir):
@@ -84,21 +138,32 @@ def init(
 
     # Categorize providers
     pip_providers: dict[str, dict] = {}
-    docker_providers: dict[str, dict] = {}
+    local_docker_providers: dict[str, dict] = {}
+    remote_docker_providers: dict[str, dict] = {}
     for name, cfg in providers.items():
         ptype = cfg.get("type", "")
         if is_containerized(ptype):
             url = cfg.get("url")
-            if not url:
+            if is_local_provider_url(url):
                 port = get_provider_default_port(ptype) or 9000
-                url = f"http://localhost:{port}"
-            docker_providers[name] = {
-                "type": ptype,
-                "url": url,
-                "docker_image": cfg.get("docker_image") or get_provider_docker_image(ptype),
-                "port": get_provider_default_port(ptype),
-            }
-            logger.info(f"  {name}: type={ptype}, url={url} (Docker)")
+                if not url:
+                    url = f"http://localhost:{port}"
+                local_docker_providers[name] = {
+                    "type": ptype,
+                    "url": url,
+                    "docker_image": cfg.get("docker_image") or get_provider_docker_image(ptype),
+                    "port": port,
+                }
+                logger.info(f"  {name}: type={ptype}, url={url} (Docker, local)")
+            else:
+                remote_docker_providers[name] = {
+                    "type": ptype,
+                    "url": url,
+                    "docker_image": cfg.get("docker_image") or get_provider_docker_image(ptype),
+                }
+                logger.info(
+                    f"  {name}: type={ptype}, url={url} (Docker, remote — skipping compose)"
+                )
         else:
             pip_providers[name] = {"type": ptype}
             logger.info(f"  {name}: type={ptype} (pip)")
@@ -116,15 +181,19 @@ def init(
             hint = f"pip install 'processforge[{dep}]'" if dep else "built-in"
             logger.warning(f"  {name} — not installed. Install with: {hint}")
 
-    # Generate compose for Docker providers
-    if docker_providers:
-        compose_path = os.path.join(pf_dir, "docker-compose.yml")
+    # Generate compose + pull images only for locally-managed Docker providers.
+    # Providers with an explicit remote URL are assumed to be running elsewhere
+    # (e.g. a cloud deployment of the ghcr.io image) and are not touched here.
+    if local_docker_providers:
+        compose_path = os.path.join(
+            flowsheet_env_dir(pf_dir, flowsheet_path), "docker-compose.yml"
+        )
         if os.path.exists(compose_path):
             logger.warning(
                 f"Environment already initialized — reinitializing from {flowsheet_path}"
             )
 
-        generate_compose(pf_dir, docker_providers, outputs_dir)
+        generate_compose(pf_dir, local_docker_providers, outputs_dir, flowsheet=flowsheet_path)
         logger.info(f"Generated {compose_path}")
 
         # Attempt docker compose pull — stream progress live
@@ -155,6 +224,10 @@ def init(
             )
         except subprocess.TimeoutExpired:
             logger.warning("docker compose pull timed out after 600s.")
+    elif remote_docker_providers:
+        logger.info(
+            "All containerized providers use remote URLs — skipping Docker setup."
+        )
     else:
         logger.info("No containerized providers — skipping Docker setup.")
 
@@ -177,5 +250,5 @@ def init(
     from .. import __version__ as pf_version
 
     write_lock(pf_dir, flowsheet_path, lock_providers, pf_version)
-    logger.info(f"Wrote {os.path.join(pf_dir, 'lock.json')}")
+    logger.info(f"Wrote {os.path.join(flowsheet_env_dir(pf_dir, flowsheet_path), 'lock.json')}")
     logger.info(".processforge/ initialised successfully.")

{processforge-0.3.5 → processforge-0.3.8}/src/processforge/cli/plan.py

@@ -18,7 +18,12 @@ from .common import (
     require_existing_file,
     validate_snapshot_config,
 )
-from .display import print_dof_report, print_structural_diff, print_unit_mismatches
+from .display import (
+    print_dof_report,
+    print_provider_health,
+    print_structural_diff,
+    print_unit_mismatches,
+)
 
 
 def plan(
@@ -116,7 +121,10 @@ def plan(
         logger.info("  Warm-start available : No snapshot found")
         logger.info("  Homotopy eligible    : No (cold start)")
 
-    # Step 7: Mermaid diagram
+    # Step 7: Provider / container health check
+    health_failures = print_provider_health(config)
+
+    # Step 8: Mermaid diagram
     if not no_diagram:
         diagram_output_dir = output_dir or "diagrams"
         os.makedirs(diagram_output_dir, exist_ok=True)
@@ -129,5 +137,5 @@ def plan(
 
     # Exit non-zero on hard errors
     hard_errors = [m for m in mismatches if not m.compatible]
-    if hard_errors or report.system_dof < 0:
+    if hard_errors or report.system_dof < 0 or health_failures:
         raise SystemExit(1)

{processforge-0.3.5 → processforge-0.3.8}/src/processforge/cli/run.py

@@ -14,6 +14,7 @@ from ..result import plot_results, plot_timeseries, save_results_zarr
 from ..state import StateManager
 from .common import (
     check_providers,
+    display_backend,
     flowsheet_basename,
     output_root,
     require_existing_file,
@@ -96,6 +97,7 @@ def run(
     os.makedirs(outputs_dir, exist_ok=True)
     zarr_path = os.path.join(outputs_dir, f"{base_name}_results.zarr")
     save_results_zarr(results, zarr_path, run_info=run_info)
+    logger.info(f"  Backend      : {display_backend(config, getattr(fs, 'backend', 'dynamic'))}")
     logger.info(f"Results saved to {zarr_path}")
 
     if export_images:

{processforge-0.3.5 → processforge-0.3.8}/src/processforge/compose.py

@@ -5,6 +5,8 @@ import os
 
 from loguru import logger
 
+from .lock import flowsheet_env_dir
+
 COMPOSE_FILENAME = "docker-compose.yml"
 COMPOSE_HEADER = (
     "# Auto-generated by pf init — do not edit manually.\n"
@@ -12,7 +14,9 @@ COMPOSE_HEADER = (
 )
 
 
-def _compose_path(pf_dir: str) -> str:
+def _compose_path(pf_dir: str, flowsheet: str | None = None) -> str:
+    if flowsheet is not None:
+        return os.path.join(flowsheet_env_dir(pf_dir, flowsheet), COMPOSE_FILENAME)
     return os.path.join(pf_dir, COMPOSE_FILENAME)
 
 
@@ -20,6 +24,7 @@ def generate_compose(
     pf_dir: str,
     containerized_providers: dict[str, dict],
     outputs_dir: str = "outputs",
+    flowsheet: str | None = None,
 ) -> None:
     """Generate docker-compose.yml for providers that need Docker.
 
@@ -27,6 +32,9 @@ def generate_compose(
         pf_dir: Path to .processforge/ directory.
         containerized_providers: Dict of provider_name -> {"url": ..., "docker_image": ..., "port": ...}.
         outputs_dir: Host directory to mount as /data in containers.
+        flowsheet: Flowsheet path. When given, the compose file is written into
+            that flowsheet's per-flowsheet environment directory; otherwise it
+            is written to the legacy root location.
     """
     if not containerized_providers:
         return
@@ -37,16 +45,20 @@ def generate_compose(
         port = info.get("port") or 9000
         lines.append(f"  {name}:")
         lines.append(f"    image: {image}")
-        # Bind directly to the host network so the provider is reachable at
-        # http://localhost:<port>. Docker bridge port-publishing is unreliable
-        # on some hosts (the published port is not reachable from the host),
-        # and host networking avoids that entirely.
-        lines.append(f"    network_mode: host")
+        # Publish the provider's API-contract port (host:container) so the
+        # service is reachable at http://localhost:<port>, matching the
+        # PORT/EXPOSE declared in the provider Dockerfile.
+        lines.append(f"    ports:")
+        lines.append(f'      - "{port}:{port}"')
         lines.append(f"    volumes:")
         lines.append(f'      - "${{OPENMC_DATA_ROOT:-{outputs_dir}}}:/data"')
         lines.append("")
 
-    os.makedirs(pf_dir, exist_ok=True)
-    path = _compose_path(pf_dir)
+    if flowsheet is not None:
+        target_dir = flowsheet_env_dir(pf_dir, flowsheet)
+    else:
+        target_dir = pf_dir
+    os.makedirs(target_dir, exist_ok=True)
+    path = os.path.join(target_dir, COMPOSE_FILENAME)
     with open(path, "w", encoding="utf-8") as f:
         f.write("\n".join(lines))

processforge-0.3.8/src/processforge/lock.py

@@ -0,0 +1,74 @@
+"""Lock file read/write for .processforge/<env-key>/lock.json.
+
+Each flowsheet gets its own environment directory under ``.processforge/``,
+keyed by a stable hash of the flowsheet's absolute path. This lets multiple
+flowsheets keep separate provider environments (lock + compose) without
+clobbering each other. The lock file is provenance metadata only.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from typing import Any
+
+LOCK_VERSION = 1
+LOCK_FILENAME = "lock.json"
+
+
+def flowsheet_env_key(flowsheet_path: str) -> str:
+    """Stable key for a flowsheet's environment dir.
+
+    Derived from the sha1 of the flowsheet's real (absolute) path so it is
+    collision-proof across folders and stable across re-inits.
+    """
+    abs_path = os.path.realpath(flowsheet_path)
+    return hashlib.sha1(abs_path.encode("utf-8")).hexdigest()[:12]
+
+
+def flowsheet_env_dir(pf_dir: str, flowsheet_path: str) -> str:
+    """Directory holding a flowsheet's lock.json and docker-compose.yml."""
+    return os.path.join(pf_dir, flowsheet_env_key(flowsheet_path))
+
+
+def _lock_path(pf_dir: str, flowsheet: str | None = None) -> str:
+    if flowsheet is not None:
+        return os.path.join(flowsheet_env_dir(pf_dir, flowsheet), LOCK_FILENAME)
+    return os.path.join(pf_dir, LOCK_FILENAME)
+
+
+def read_lock(pf_dir: str, flowsheet: str | None = None) -> dict[str, Any] | None:
+    """Read lock.json.
+
+    When *flowsheet* is given, reads that flowsheet's env dir. Otherwise falls
+    back to the legacy root ``.processforge/lock.json`` (used during migration).
+    Returns None if not found.
+    """
+    path = _lock_path(pf_dir, flowsheet)
+    if not os.path.exists(path):
+        if flowsheet is None and os.path.exists(os.path.join(pf_dir, LOCK_FILENAME)):
+            path = os.path.join(pf_dir, LOCK_FILENAME)
+        else:
+            return None
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def write_lock(
+    pf_dir: str,
+    flowsheet: str,
+    providers: dict[str, dict],
+    processforge_version: str,
+) -> None:
+    """Write lock.json into the flowsheet's environment directory."""
+    lock = {
+        "version": LOCK_VERSION,
+        "processforge_version": processforge_version,
+        "flowsheet": flowsheet,
+        "providers": providers,
+    }
+    env_dir = flowsheet_env_dir(pf_dir, flowsheet)
+    os.makedirs(env_dir, exist_ok=True)
+    path = os.path.join(env_dir, LOCK_FILENAME)
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(lock, f, indent=2)

{processforge-0.3.5 → processforge-0.3.8/src/processforge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.3.5
+Version: 0.3.8
 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.5 → processforge-0.3.8}/tests/test_cli.py

@@ -442,6 +442,48 @@ class TestCmdRun:
             run(flowsheet=str(flowsheet), export_images=False)
 
 
+class TestCmdPlan:
+    @pytest.fixture
+    def container_flowsheet(self, tmp_path):
+        """Write a minimal valid flowsheet using a Docker-containerized provider."""
+        flowsheet = {
+            "providers": {"openmc": {"type": "openmc"}},
+            "streams": {},
+            "units": {},
+            "simulation": {"mode": "steady"},
+        }
+        path = tmp_path / "container.json"
+        with open(path, "w") as f:
+            json.dump(flowsheet, f)
+        return path
+
+    def test_container_provider_health_ok(self, container_flowsheet, log_output):
+        import processforge.cli.common as common_mod
+        from processforge.cli.plan import plan
+
+        health = {"status": "ready", "provider_type": "openmc"}
+        with patch.object(
+            common_mod, "_ping_provider_health", return_value=(True, health)
+        ), patch.object(common_mod, "_resolve_provider_url", return_value="http://localhost:9001"):
+            plan(flowsheet=str(container_flowsheet), no_diagram=True)
+
+        assert any("Provider / Container Health" in m for m in log_output)
+        assert any("[OK] openmc" in m and "provider_type=openmc" in m for m in log_output)
+
+    def test_container_provider_health_failure_exits(self, container_flowsheet, log_output):
+        import processforge.cli.common as common_mod
+        from processforge.cli.plan import plan
+
+        with patch.object(
+            common_mod, "_ping_provider_health", return_value=(False, "Connection refused")
+        ), patch.object(common_mod, "_resolve_provider_url", return_value="http://localhost:9001"), \
+                pytest.raises(SystemExit) as exc_info:
+            plan(flowsheet=str(container_flowsheet), no_diagram=True)
+
+        assert exc_info.value.code == 1
+        assert any("[ERR] openmc" in m and "unreachable" in m for m in log_output)
+
+
 class TestCmdApply:
     def _containerized_config(self, flowsheet_path):
         return {

{processforge-0.3.5 → processforge-0.3.8}/tests/test_init.py

@@ -8,7 +8,7 @@ from unittest.mock import patch
 
 import pytest
 
-from processforge.lock import read_lock, write_lock, LOCK_VERSION
+from processforge.lock import read_lock, write_lock, LOCK_VERSION, flowsheet_env_dir
 from processforge.compose import generate_compose, COMPOSE_FILENAME
 from processforge.providers.registry import (
     _PROVIDER_CATALOG,
@@ -153,7 +153,7 @@ class TestLockFile:
             "coolprop": {"docker_image": None, "url": None},
         }
         write_lock(str(tmp_pf_dir), "test.json", providers, "0.2.34")
-        lock = read_lock(str(tmp_pf_dir))
+        lock = read_lock(str(tmp_pf_dir), "test.json")
 
         assert lock is not None
         assert lock["version"] == LOCK_VERSION
@@ -163,11 +163,27 @@ class TestLockFile:
         assert "coolprop" in lock["providers"]
         assert lock["providers"]["openmc"]["url"] == "http://localhost:9001"
 
+    def test_lock_written_to_per_flowsheet_dir(self, tmp_pf_dir):
+        write_lock(str(tmp_pf_dir), "a/test.json", {}, "0.2.34")
+        # No legacy root lock.json is written.
+        assert not (tmp_pf_dir / "lock.json").exists()
+        # Instead it lives in the hashed env dir.
+        assert (Path(flowsheet_env_dir(str(tmp_pf_dir), "a/test.json")) / "lock.json").exists()
+
+    def test_two_flowsheets_separate_dirs(self, tmp_pf_dir):
+        write_lock(str(tmp_pf_dir), "flows/a.json", {}, "0.2.34")
+        write_lock(str(tmp_pf_dir), "flows/b.json", {}, "0.2.34")
+        dir_a = Path(flowsheet_env_dir(str(tmp_pf_dir), "flows/a.json"))
+        dir_b = Path(flowsheet_env_dir(str(tmp_pf_dir), "flows/b.json"))
+        assert dir_a != dir_b
+        assert (dir_a / "lock.json").exists()
+        assert (dir_b / "lock.json").exists()
+
     def test_lock_creates_directory(self, tmp_path):
         pf_dir = tmp_path / ".processforge"
         providers = {"coolprop": {"docker_image": None, "url": None}}
         write_lock(str(pf_dir), "test.json", providers, "0.2.34")
-        assert read_lock(str(pf_dir)) is not None
+        assert read_lock(str(pf_dir), "test.json") is not None
 
 
 # ---------------------------------------------------------------------------
@@ -183,28 +199,30 @@ class TestComposeGeneration:
                 "port": 9001,
             },
         }
-        generate_compose(str(tmp_pf_dir), docker_providers)
-        compose_path = tmp_pf_dir / COMPOSE_FILENAME
-        assert compose_path.exists()
+        generate_compose(str(tmp_pf_dir), docker_providers, flowsheet="a.json")
+        compose_path = os.path.join(flowsheet_env_dir(str(tmp_pf_dir), "a.json"), COMPOSE_FILENAME)
+        assert os.path.exists(compose_path)
 
-        content = compose_path.read_text()
+        content = Path(compose_path).read_text()
         assert "services:" in content
         assert "openmc:" in content
         assert "ghcr.io/urjanova/processforge-openmc:latest" in content
         assert "9001:9001" in content
+        assert "ports:" in content
+        assert "network_mode" not in content
 
     def test_generate_compose_empty_when_no_docker(self, tmp_pf_dir):
-        generate_compose(str(tmp_pf_dir), {})
-        compose_path = tmp_pf_dir / COMPOSE_FILENAME
-        assert not compose_path.exists()
+        generate_compose(str(tmp_pf_dir), {}, flowsheet="a.json")
+        compose_path = os.path.join(flowsheet_env_dir(str(tmp_pf_dir), "a.json"), COMPOSE_FILENAME)
+        assert not os.path.exists(compose_path)
 
     def test_generate_compose_multiple_providers(self, tmp_pf_dir):
         docker_providers = {
             "openmc": {"docker_image": "ghcr.io/test/openmc:latest", "port": 9001},
             "festim": {"docker_image": "ghcr.io/test/festim:latest", "port": 9002},
         }
-        generate_compose(str(tmp_pf_dir), docker_providers)
-        content = (tmp_pf_dir / COMPOSE_FILENAME).read_text()
+        generate_compose(str(tmp_pf_dir), docker_providers, flowsheet="a.json")
+        content = Path(os.path.join(flowsheet_env_dir(str(tmp_pf_dir), "a.json"), COMPOSE_FILENAME)).read_text()
         assert "openmc:" in content
         assert "festim:" in content
 
@@ -215,8 +233,8 @@ class TestComposeGeneration:
                 "port": 9001,
             },
         }
-        generate_compose(str(tmp_pf_dir), docker_providers)
-        content = (tmp_pf_dir / COMPOSE_FILENAME).read_text()
+        generate_compose(str(tmp_pf_dir), docker_providers, flowsheet="a.json")
+        content = Path(os.path.join(flowsheet_env_dir(str(tmp_pf_dir), "a.json"), COMPOSE_FILENAME)).read_text()
         assert "my-org/custom-openmc:v2" in content
         assert "ghcr.io/urjanova/processforge-openmc" not in content
 

processforge-0.3.5/src/processforge/lock.py

@@ -1,41 +0,0 @@
-"""Lock file read/write for .processforge/lock.json."""
-from __future__ import annotations
-
-import json
-import os
-from typing import Any
-
-LOCK_VERSION = 1
-LOCK_FILENAME = "lock.json"
-
-
-def _lock_path(pf_dir: str) -> str:
-    return os.path.join(pf_dir, LOCK_FILENAME)
-
-
-def read_lock(pf_dir: str) -> dict[str, Any] | None:
-    """Read lock.json from .processforge/. Returns None if not found."""
-    path = _lock_path(pf_dir)
-    if not os.path.exists(path):
-        return None
-    with open(path, "r", encoding="utf-8") as f:
-        return json.load(f)
-
-
-def write_lock(
-    pf_dir: str,
-    flowsheet: str,
-    providers: dict[str, dict],
-    processforge_version: str,
-) -> None:
-    """Write lock.json to .processforge/."""
-    lock = {
-        "version": LOCK_VERSION,
-        "processforge_version": processforge_version,
-        "flowsheet": flowsheet,
-        "providers": providers,
-    }
-    os.makedirs(pf_dir, exist_ok=True)
-    path = _lock_path(pf_dir)
-    with open(path, "w", encoding="utf-8") as f:
-        json.dump(lock, f, indent=2)