processforge 0.3.4__tar.gz → 0.3.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.3.4
+Version: 0.3.5
 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.4 → processforge-0.3.5}/pyproject.toml

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

processforge-0.3.5/src/processforge/cli/apply.py

@@ -0,0 +1,209 @@
+"""``pf apply`` — state-based warm start with homotopy fallback."""
+
+from __future__ import annotations
+
+import os
+import time
+from typing import Literal
+
+import typer
+from loguru import logger
+
+from ..eo import EOFlowsheet
+from ..provenance import build_run_info
+from ..result import save_results_zarr
+from ..state import StateManager
+from .common import (
+    build_divergence_report,
+    build_run_metadata,
+    check_providers,
+    flowsheet_basename,
+    load_state_manager,
+    log_residual_breakdown,
+    output_root,
+    require_existing_file,
+    save_snapshot,
+    validate_runtime_flowsheet,
+    write_divergence_report,
+)
+
+from .display import print_structural_diff
+
+
+def apply(
+    flowsheet: str = typer.Argument(help="Path to the flowsheet JSON file"),
+    backend: Literal["scipy", "pyomo", "casadi"] | None = typer.Option(
+        None,
+        "--backend",
+        help="Override the flowsheet's simulation.backend",
+    ),
+    tolerance: float = typer.Option(
+        1e-6,
+        "--tolerance",
+        help="Newton solver convergence tolerance (default: 1e-6)",
+    ),
+    max_iter: int = typer.Option(
+        50,
+        "--max-iter",
+        help="Max Newton iterations (default: 50)",
+    ),
+    skip_homotopy: bool = typer.Option(
+        False,
+        "--skip-homotopy",
+        help="Disable homotopy fallback; cold-start only",
+    ),
+) -> None:
+    """Apply flowsheet: drift detection, warm-start, homotopy fallback, convergence guardrails."""
+    require_existing_file(flowsheet)
+    config = validate_runtime_flowsheet(flowsheet)
+
+    # Check provider availability (assumes any containers are already running)
+    check_providers(config, flowsheet)
+
+    base_name = flowsheet_basename(flowsheet)
+
+    sim_cfg = config.get("simulation", {})
+    mode = sim_cfg.get("mode", "steady")
+    if mode != "steady":
+        logger.error("pf apply is only supported for steady-state EO flowsheets.")
+        raise SystemExit(1)
+
+    outputs_dir = output_root()
+    os.makedirs(outputs_dir, exist_ok=True)
+    sm, state = load_state_manager(outputs_dir, base_name)
+
+    # Structural diff: detect topology changes
+    topology_changed = False
+    if state is not None:
+        diff = sm.detect_structural_diff(config, state)
+        print_structural_diff(diff)
+        topology_changed = bool(diff.get("added") or diff.get("removed"))
+        if topology_changed:
+            logger.warning(
+                "Topology changed (units added/removed). "
+                "Homotopy requires identical topology — falling back to cold start."
+            )
+
+    # Parameter drift (only meaningful when topology is unchanged)
+    drifted: list[str] = []
+    current_metadata = build_run_metadata(config, tolerance, max_iter, backend or "scipy")
+    if state is not None and not topology_changed:
+        mismatches = sm.validate_metadata(current_metadata, state)
+        if mismatches:
+            logger.warning(f"Metadata mismatch: {mismatches}")
+        drifted = sm.detect_drift(config, state)
+        if not drifted:
+            logger.info("No drift detected. System is already at the desired state.")
+            return
+        stream_drifts = [d for d in drifted if d.startswith("streams.")]
+        unit_drifts = [d for d in drifted if d.startswith("units.")]
+        logger.warning("Drift detected:")
+        if stream_drifts:
+            logger.warning(f"  Stream drift : {stream_drifts}")
+        if unit_drifts:
+            logger.warning(f"  Unit drift   : {unit_drifts}")
+
+    # Build flowsheet; attach saved state for warm-start unless topology changed
+    fs = EOFlowsheet(config, backend=backend)
+    fs.saved_state = state if not topology_changed else None
+    fs.solver_tol = tolerance
+    fs.solver_max_iter = max_iter
+
+    logger.info("=== Running Apply (Steady-State EO) ===")
+    t0 = time.perf_counter()
+    results = fs.run()
+    elapsed = time.perf_counter() - t0
+
+    logger.info(
+        f"Direct solve completed in {elapsed:.2f}s (converged={fs.converged})."
+    )
+
+    if fs.converged:
+        snapshot_id = save_snapshot(
+            sm, config, fs.x_converged, fs.var_names,
+            metadata=current_metadata,
+            parent_snapshot_id=state.snapshot_id if state is not None and not topology_changed else None,
+            label="converged state",
+        )
+        run_info = build_run_info(config, x0=fs.x0, var_names=fs.var_names)
+        zarr_path = os.path.join(outputs_dir, f"{base_name}_results.zarr")
+        save_results_zarr(results, zarr_path, run_info=run_info)
+        logger.info("=== Apply Summary ===")
+        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"  Snapshot ID  : {snapshot_id}")
+        logger.info(f"  Results zarr : {zarr_path}")
+        logger.info(f"  Elapsed (s)  : {elapsed:.2f}")
+        return
+
+    # Direct solve failed — try homotopy (only when topology is same and state exists)
+    if state is not None and not topology_changed and drifted and not skip_homotopy:
+        logger.warning("Direct solve failed. Attempting homotopy continuation...")
+        from ..eo.solver import EOSolver, solve_with_homotopy
+        from ..eo.flowsheet import EOFlowsheet as _EO
+        from ..providers.manager import teardown_providers
+
+        solver = EOSolver(backend=fs.backend, tol=tolerance, max_iter=max_iter)
+        tmp_fs = _EO(config, backend=backend)
+        manager = tmp_fs._build()
+        try:
+            x_hom, hom_converged, hom_stats = solve_with_homotopy(
+                tmp_fs, manager, solver, state, drifted
+            )
+        finally:
+            teardown_providers(tmp_fs._provider_map)
+
+        if hom_converged:
+            logger.info(
+                f"Homotopy converged: ||F||={hom_stats.get('final_norm', '?'):.3e}, "
+                f"iterations={hom_stats.get('iterations', '?')}"
+            )
+            save_snapshot(
+                sm, config, x_hom, fs.var_names,
+                metadata=current_metadata,
+                parent_snapshot_id=state.snapshot_id if state is not None and not topology_changed else None,
+                label="homotopy solution",
+            )
+            run_info = build_run_info(config, x0=fs.x0, var_names=fs.var_names)
+            save_results_zarr(
+                results,
+                os.path.join(outputs_dir, f"{base_name}_results.zarr"),
+                run_info=run_info,
+            )
+            logger.info("Homotopy apply succeeded. New snapshot saved.")
+            return
+
+        # Both failed — auto-revert and write divergence report
+        logger.error("Homotopy also failed to converge.")
+        prev_id = state.snapshot_id if state is not None else "unknown"
+        sm.rollback(1)
+        logger.warning(f"Reverted .pfstate to snapshot before {prev_id}.")
+        breakdown = log_residual_breakdown(fs)
+        divergence = build_divergence_report(
+            drifted_params=drifted,
+            solver_stats=hom_stats,
+            x_last=x_hom,
+            var_names=fs.var_names,
+            breakdown=breakdown,
+        )
+    else:
+        # Cold start also failed; no rollback (nothing to revert to)
+        if not drifted and state is None:
+            logger.error("Cold-start solve failed to converge (no prior snapshot).")
+        elif skip_homotopy:
+            logger.error("Cold-start solve failed to converge (--skip-homotopy).")
+        else:
+            logger.error("Cold-start solve failed to converge.")
+        breakdown = log_residual_breakdown(fs)
+        divergence = build_divergence_report(
+            drifted_params=[],
+            solver_stats=fs.solver_stats,
+            x_last=getattr(fs, "x_converged", []),
+            var_names=getattr(fs, "var_names", []),
+            breakdown=breakdown,
+        )
+
+    write_divergence_report(outputs_dir, base_name, divergence)
+    raise SystemExit(1)

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

@@ -203,50 +203,6 @@ def check_providers(
         raise SystemExit(1)
 
 
-def has_containerized_providers(config: dict) -> bool:
-    """Return True if any declared provider runs in a Docker container."""
-    from ..providers.registry import is_containerized
-
-    return any(
-        is_containerized(cfg.get("type", ""))
-        for cfg in config.get("providers", {}).values()
-    )
-
-
-def wait_for_provider_health(config: dict, timeout: int = 30) -> None:
-    """Poll ``/health`` for each localhost containerized provider until ready.
-
-    Only providers whose resolved URL host is ``localhost``/``127.0.0.1`` are
-    waited on — remote providers are assumed to be managed elsewhere.
-    """
-    import time
-    import urllib.parse
-
-    from ..providers.registry import is_containerized
-
-    providers = config.get("providers", {})
-    deadline = time.time() + timeout
-    for name, cfg in providers.items():
-        if not is_containerized(cfg.get("type", "")):
-            continue
-        url = _resolve_provider_url(cfg, cfg.get("type", ""))
-        host = urllib.parse.urlparse(url).hostname
-        if host not in ("localhost", "127.0.0.1"):
-            continue
-        health = f"{url}/health"
-        while time.time() < deadline:
-            try:
-                urllib.request.urlopen(health, timeout=2)
-                logger.info(f"Provider '{name}' ready at {url}")
-                break
-            except (urllib.error.URLError, OSError):
-                time.sleep(1)
-        else:
-            logger.warning(
-                f"Provider '{name}' not ready at {url} after {timeout}s."
-            )
-
-
 # ---------------------------------------------------------------------------
 # Divergence reports
 # ---------------------------------------------------------------------------

processforge-0.3.5/src/processforge/cli/run.py

@@ -0,0 +1,107 @@
+"""``pf run`` — run a process simulation from a flowsheet JSON file."""
+
+from __future__ import annotations
+
+import os
+
+import typer
+from loguru import logger
+
+from ..flowsheet import Flowsheet
+from ..eo import EOFlowsheet
+from ..provenance import build_dynamic_x0, build_run_info
+from ..result import plot_results, plot_timeseries, save_results_zarr
+from ..state import StateManager
+from .common import (
+    check_providers,
+    flowsheet_basename,
+    output_root,
+    require_existing_file,
+    validate_runtime_flowsheet,
+)
+
+
+def run(
+    flowsheet: str = typer.Argument(help="Path to the flowsheet JSON file"),
+    export_images: bool = typer.Option(
+        False,
+        "--export-images",
+        help="Generate PNG plots for simulation outputs",
+    ),
+) -> None:
+    """Run a process simulation from a flowsheet JSON file."""
+    require_existing_file(flowsheet)
+    config = validate_runtime_flowsheet(flowsheet)
+
+    # Check provider availability (assumes any containers are already running)
+    check_providers(config, flowsheet)
+
+    base_name = flowsheet_basename(flowsheet)
+    outputs_dir = output_root()
+
+    sim_cfg = config.get("simulation", {})
+    mode = sim_cfg.get("mode", "steady")
+    is_dynamic = mode == "dynamic"
+
+    if is_dynamic:
+        # Load .pfstate as t=0 if available
+        state_path = os.path.join(outputs_dir, f"{base_name}.pfstate")
+        sm = StateManager(state_path)
+        state = sm.load_state()
+        if state is not None:
+            stream_inits = sm.state_to_stream_dicts(state)
+            streams_cfg = config.get("streams", {})
+            for s_name, s_vals in stream_inits.items():
+                if s_name in streams_cfg:
+                    streams_cfg[s_name].update(s_vals)
+                else:
+                    logger.debug(
+                        f"Stream '{s_name}' from snapshot not in current flowsheet — skipped."
+                    )
+            logger.info("Using .pfstate converged state as dynamic t=0.")
+        else:
+            logger.debug("No .pfstate found — starting dynamic run from flowsheet defaults.")
+
+        fs = Flowsheet(config)
+        logger.info("=== Dynamic Results ===")
+        results = fs.run()
+
+        if hasattr(fs, "converged"):
+            if fs.converged:
+                logger.info("Dynamic simulation converged.")
+            else:
+                logger.warning("Dynamic simulation did NOT converge. Results may be unreliable.")
+
+        try:
+            x0, var_names = build_dynamic_x0(config)
+        except Exception as e:
+            logger.error(f"Failed to build initial state vector: {type(e).__name__}: {e}")
+            raise SystemExit(1)
+
+        run_info = build_run_info(config, x0=x0, var_names=var_names)
+    else:
+        # Pass None so EOFlowsheet resolves backend from config (with scipy default).
+        fs = EOFlowsheet(config, backend=None)
+        logger.info("=== Steady-State EO Results ===")
+        results = fs.run()
+
+        if hasattr(fs, "converged"):
+            if fs.converged:
+                logger.info("Steady-state simulation converged.")
+            else:
+                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)
+
+    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"Results saved to {zarr_path}")
+
+    if export_images:
+        try:
+            plot_results(results, fname=f"{base_name}_results.png")
+            plot_timeseries(results, fname=f"{base_name}_timeseries.png")
+            logger.info(f"Plots saved: {base_name}_results.png, {base_name}_timeseries.png")
+        except Exception as e:
+            logger.warning(f"Failed to generate plots: {type(e).__name__}: {e}")

processforge-0.3.5/src/processforge/compose.py

@@ -0,0 +1,52 @@
+"""Generate and manage docker-compose.yml for containerized providers."""
+from __future__ import annotations
+
+import os
+
+from loguru import logger
+
+COMPOSE_FILENAME = "docker-compose.yml"
+COMPOSE_HEADER = (
+    "# Auto-generated by pf init — do not edit manually.\n"
+    "# Re-generate: pf init <flowsheet.json>\n"
+)
+
+
+def _compose_path(pf_dir: str) -> str:
+    return os.path.join(pf_dir, COMPOSE_FILENAME)
+
+
+def generate_compose(
+    pf_dir: str,
+    containerized_providers: dict[str, dict],
+    outputs_dir: str = "outputs",
+) -> None:
+    """Generate docker-compose.yml for providers that need Docker.
+
+    Args:
+        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.
+    """
+    if not containerized_providers:
+        return
+
+    lines = [COMPOSE_HEADER, "services:"]
+    for name, info in containerized_providers.items():
+        image = info["docker_image"]
+        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")
+        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)
+    with open(path, "w", encoding="utf-8") as f:
+        f.write("\n".join(lines))

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

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

@@ -3,7 +3,6 @@ from __future__ import annotations
 
 import json
 import os
-import subprocess
 from pathlib import Path
 from unittest.mock import MagicMock, patch
 
@@ -371,7 +370,7 @@ class TestCmdRun:
         mock_os.path.join = real_os.path.join
         return mock_os
 
-    def test_starts_and_stops_containers(self, tmp_path, log_output):
+    def test_containerized_flowsheet_runs_without_lifecycle(self, tmp_path, log_output):
         import processforge.cli.run as run_mod
         from processforge.cli.run import run
 
@@ -385,9 +384,6 @@ class TestCmdRun:
         mock_fs.var_names = []
 
         with patch.object(run_mod, "os", self._patch_run_os(run_mod)), \
-             patch.object(run_mod, "start_provider_containers", return_value=True) as mock_start, \
-             patch.object(run_mod, "stop_provider_containers") as mock_stop, \
-             patch.object(run_mod, "wait_for_provider_health"), \
              patch.object(run_mod, "validate_runtime_flowsheet",
                           return_value=self._containerized_config(flowsheet)), \
              patch.object(run_mod, "check_providers"), \
@@ -395,36 +391,6 @@ class TestCmdRun:
              patch.object(run_mod, "save_results_zarr"):
             run(flowsheet=str(flowsheet), export_images=False)
 
-        mock_start.assert_called_once()
-        mock_stop.assert_called_once()
-
-    def test_keep_containers_skips_stop(self, tmp_path):
-        import processforge.cli.run as run_mod
-        from processforge.cli.run import run
-
-        flowsheet = tmp_path / "fs.json"
-        flowsheet.write_text(json.dumps(self._containerized_config(flowsheet)["providers"]))
-
-        mock_fs = MagicMock()
-        mock_fs.run.return_value = {}
-        mock_fs.converged = True
-        mock_fs.x0 = []
-        mock_fs.var_names = []
-
-        with patch.object(run_mod, "os", self._patch_run_os(run_mod)), \
-             patch.object(run_mod, "start_provider_containers", return_value=True) as mock_start, \
-             patch.object(run_mod, "stop_provider_containers") as mock_stop, \
-             patch.object(run_mod, "wait_for_provider_health"), \
-             patch.object(run_mod, "validate_runtime_flowsheet",
-                          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, "save_results_zarr"):
-            run(flowsheet=str(flowsheet), export_images=False, keep_containers=True)
-
-        mock_start.assert_called_once()
-        mock_stop.assert_not_called()
-
     def test_coolprop_flowsheet_no_lifecycle(self, tmp_path):
         import processforge.cli.run as run_mod
         from processforge.cli.run import run
@@ -441,8 +407,6 @@ class TestCmdRun:
         # A stale docker-compose.yml is present, but the flowsheet only uses
         # pip providers — Docker must never be touched.
         with patch.object(run_mod, "os", self._patch_run_os(run_mod)), \
-             patch.object(run_mod, "start_provider_containers") as mock_start, \
-             patch.object(run_mod, "stop_provider_containers") as mock_stop, \
              patch.object(run_mod, "validate_runtime_flowsheet",
                           return_value={"providers": {"coolprop": {"type": "coolprop"}},
                                         "streams": {}, "units": {},
@@ -453,9 +417,6 @@ class TestCmdRun:
              patch.object(run_mod, "save_results_zarr"):
             run(flowsheet=str(flowsheet), export_images=False)
 
-        mock_start.assert_not_called()
-        mock_stop.assert_not_called()
-
     def test_no_compose_no_lifecycle(self, tmp_path):
         import processforge.cli.run as run_mod
         from processforge.cli.run import run
@@ -469,10 +430,9 @@ class TestCmdRun:
         mock_fs.x0 = []
         mock_fs.var_names = []
 
-        # Containerized flowsheet but no compose file -> warn and skip.
+        # Containerized flowsheet but no compose file — run still proceeds
+        # (containers are assumed already running).
         with patch.object(run_mod, "os") as mock_os, \
-             patch.object(run_mod, "start_provider_containers") as mock_start, \
-             patch.object(run_mod, "stop_provider_containers") as mock_stop, \
              patch.object(run_mod, "validate_runtime_flowsheet",
                           return_value=self._containerized_config(flowsheet)), \
              patch.object(run_mod, "check_providers"), \
@@ -481,66 +441,6 @@ class TestCmdRun:
             mock_os.path.exists.return_value = False  # no compose file
             run(flowsheet=str(flowsheet), export_images=False)
 
-        mock_start.assert_not_called()
-        mock_stop.assert_not_called()
-
-
-class TestComposeLifecycle:
-    def _write_compose(self, tmp_path):
-        pf = tmp_path / ".processforge"
-        pf.mkdir()
-        (pf / "docker-compose.yml").write_text("services: {}\n")
-        return str(pf)
-
-    def test_start_success(self, tmp_path, log_output):
-        from processforge.compose import start_provider_containers
-
-        pf = self._write_compose(tmp_path)
-        with patch("processforge.compose.subprocess.run") as mock_run:
-            mock_run.return_value = subprocess.CompletedProcess([], 0, "", "")
-            assert start_provider_containers(pf) is True
-        mock_run.assert_called_once()
-        assert any("Started provider container" in m for m in log_output)
-
-    def test_start_no_compose(self, tmp_path):
-        from processforge.compose import start_provider_containers
-
-        assert start_provider_containers(str(tmp_path / "nope")) is False
-
-    def test_start_docker_missing(self, tmp_path, log_output):
-        from processforge.compose import start_provider_containers
-
-        pf = self._write_compose(tmp_path)
-        with patch("processforge.compose.subprocess.run", side_effect=FileNotFoundError):
-            assert start_provider_containers(pf) is False
-        assert any("Docker not found" in m for m in log_output)
-
-    def test_start_compose_failure(self, tmp_path, log_output):
-        from processforge.compose import start_provider_containers
-
-        pf = self._write_compose(tmp_path)
-        with patch("processforge.compose.subprocess.run") as mock_run:
-            mock_run.return_value = subprocess.CompletedProcess([], 1, "", "boom")
-            assert start_provider_containers(pf) is False
-        assert any("docker compose up failed" in m for m in log_output)
-
-    def test_stop_success(self, tmp_path, log_output):
-        from processforge.compose import stop_provider_containers
-
-        pf = self._write_compose(tmp_path)
-        with patch("processforge.compose.subprocess.run") as mock_run:
-            mock_run.return_value = subprocess.CompletedProcess([], 0, "", "")
-            stop_provider_containers(pf)
-        mock_run.assert_called_once()
-        assert any("Stopped provider container" in m for m in log_output)
-
-    def test_stop_no_compose(self, tmp_path):
-        from processforge.compose import stop_provider_containers
-
-        with patch("processforge.compose.subprocess.run") as mock_run:
-            stop_provider_containers(str(tmp_path / "nope"))
-        mock_run.assert_not_called()
-
 
 class TestCmdApply:
     def _containerized_config(self, flowsheet_path):
@@ -560,7 +460,7 @@ class TestCmdApply:
         mock_os.path.join = real_os.path.join
         return mock_os
 
-    def test_starts_and_stops_containers(self, tmp_path, log_output):
+    def test_containerized_flowsheet_runs_without_lifecycle(self, tmp_path, log_output):
         import processforge.cli.apply as apply_mod
         from processforge.cli.apply import apply
 
@@ -576,9 +476,6 @@ class TestCmdApply:
         mock_fs.solver_stats = {"final_norm": 0.0}
 
         with patch.object(apply_mod, "os", self._patch_apply_os(apply_mod)), \
-             patch.object(apply_mod, "start_provider_containers", return_value=True) as mock_start, \
-             patch.object(apply_mod, "stop_provider_containers") as mock_stop, \
-             patch.object(apply_mod, "wait_for_provider_health"), \
              patch.object(apply_mod, "validate_runtime_flowsheet",
                           return_value=self._containerized_config(flowsheet)), \
              patch.object(apply_mod, "check_providers"), \
@@ -587,39 +484,6 @@ class TestCmdApply:
              patch.object(apply_mod, "save_results_zarr"):
             apply(flowsheet=str(flowsheet))
 
-        mock_start.assert_called_once()
-        mock_stop.assert_called_once()
-
-    def test_keep_containers_skips_stop(self, tmp_path):
-        import processforge.cli.apply as apply_mod
-        from processforge.cli.apply import apply
-
-        flowsheet = tmp_path / "fs.json"
-        flowsheet.write_text(json.dumps(self._containerized_config(flowsheet)["providers"]))
-
-        mock_fs = MagicMock()
-        mock_fs.run.return_value = {}
-        mock_fs.converged = True
-        mock_fs.x0 = []
-        mock_fs.x_converged = []
-        mock_fs.var_names = []
-        mock_fs.solver_stats = {"final_norm": 0.0}
-
-        with patch.object(apply_mod, "os", self._patch_apply_os(apply_mod)), \
-             patch.object(apply_mod, "start_provider_containers", return_value=True) as mock_start, \
-             patch.object(apply_mod, "stop_provider_containers") as mock_stop, \
-             patch.object(apply_mod, "wait_for_provider_health"), \
-             patch.object(apply_mod, "validate_runtime_flowsheet",
-                          return_value=self._containerized_config(flowsheet)), \
-             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, "save_results_zarr"):
-            apply(flowsheet=str(flowsheet), keep_containers=True)
-
-        mock_start.assert_called_once()
-        mock_stop.assert_not_called()
-
     def test_coolprop_flowsheet_no_lifecycle(self, tmp_path):
         import processforge.cli.apply as apply_mod
         from processforge.cli.apply import apply
@@ -638,9 +502,6 @@ class TestCmdApply:
         # A stale docker-compose.yml is present, but the flowsheet only uses
         # pip providers — Docker must never be touched.
         with patch.object(apply_mod, "os", self._patch_apply_os(apply_mod)), \
-             patch.object(apply_mod, "start_provider_containers") as mock_start, \
-             patch.object(apply_mod, "stop_provider_containers") as mock_stop, \
-             patch.object(apply_mod, "wait_for_provider_health"), \
              patch.object(apply_mod, "validate_runtime_flowsheet",
                           return_value={"providers": {"coolprop": {"type": "coolprop"}},
                                         "streams": {}, "units": {},
@@ -652,9 +513,6 @@ class TestCmdApply:
              patch.object(apply_mod, "save_results_zarr"):
             apply(flowsheet=str(flowsheet))
 
-        mock_start.assert_not_called()
-        mock_stop.assert_not_called()
-
 
 # ---------------------------------------------------------------------------
 # cli/diagram.py