processforge 0.3.21__tar.gz → 0.3.25__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.3.21
+Version: 0.3.25
 Summary: A Python-based process simulation framework for chemical engineering applications.
 Author-email: Processforge Team <team@processforge.dev>
 License-Expression: BSD-3-Clause
@@ -31,6 +31,7 @@ Requires-Dist: zarr>=3.0
 Requires-Dist: pint<1.0,>=0.24
 Requires-Dist: coolprop>=7.2.0
 Requires-Dist: typer>=0.12
+Requires-Dist: arrow>=1.3
 Provides-Extra: api
 Requires-Dist: fastapi>=0.110; extra == "api"
 Requires-Dist: uvicorn>=0.29; extra == "api"

{processforge-0.3.21 → processforge-0.3.25}/flowsheets/hydraulic-chain.json

@@ -105,7 +105,7 @@
   "simulation": {
     "mode": "steady",
     "t0": 0.0,
-    "tf": 20.0,
+    "tf": 15.0,
     "dt": 1.0
   }
 }

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "processforge"
-version = "0.3.21"
+version = "0.3.25"
 description = "A Python-based process simulation framework for chemical engineering applications."
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -37,6 +37,7 @@ dependencies = [
     "pint>=0.24,<1.0",
     "coolprop>=7.2.0",
     "typer>=0.12",
+    "arrow>=1.3",
 ]
 
 [project.optional-dependencies]

{processforge-0.3.21 → processforge-0.3.25}/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.21"
+__version__ = "0.3.25"
 
 __all__ = [
     "Flowsheet",

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

@@ -63,7 +63,7 @@ from .common import (
     write_divergence_report,
 )
 
-from .display import print_structural_diff
+from .display import print_param_drift, print_structural_diff
 
 
 def apply(
@@ -131,13 +131,9 @@ def apply(
         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}")
+        old_config = state.config if hasattr(state, "config") else state.get("config", {})
+        print_param_drift(drifted, old_config, config)
 
     # Build flowsheet; attach saved state for warm-start unless topology changed
     fs = EOFlowsheet(config, backend=backend)

{processforge-0.3.21 → processforge-0.3.25}/src/processforge/cli/common.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import datetime
 import hashlib
-import importlib
+import importlib.util
 import json
 import os
 import urllib.error
@@ -145,6 +145,13 @@ def load_state_manager(outputs_dir: str, base_name: str) -> tuple[ProcessStateAr
 # Provider checking
 # ---------------------------------------------------------------------------
 
+# Retry/poll settings for containerized provider health checks. A container
+# spun up by ``pf init`` may take a few seconds to become ready; poll rather
+# than failing immediately so ``pf run`` waits for readiness with visible text.
+HEALTH_MAX_ATTEMPTS = 6
+HEALTH_RETRY_DELAY = 5  # seconds between attempts
+
+
 def is_local_provider_url(url: str | None) -> bool:
     """Return True if *url* points at a locally-managed provider.
 
@@ -184,6 +191,85 @@ def _ping_provider_health(url: str, timeout: int = 5) -> tuple[bool, "dict | str
         return False, str(exc)
 
 
+def _check_container_provider(
+    name: str,
+    ptype: str,
+    url: str,
+    flowsheet_path: str,
+    *,
+    fail_fast: bool,
+    errors: list[str],
+) -> None:
+    """Probe a containerized provider's ``/health`` endpoint with a retry/poll.
+
+    Polls up to ``HEALTH_MAX_ATTEMPTS`` times (``HEALTH_RETRY_DELAY`` apart) so a
+    container that is still booting after ``pf init`` gets a chance to become
+    ready before we give up. Logs a visible ``[OK]``/``[ERR]`` line (matching the
+    ``pf plan`` convention) so ``pf run`` never silently waits.
+    """
+    import time
+
+    ok, info = False, "not probed"
+    for attempt in range(1, HEALTH_MAX_ATTEMPTS + 1):
+        ok, info = _ping_provider_health(url, timeout=5)
+        if ok:
+            break
+        if attempt < HEALTH_MAX_ATTEMPTS:
+            logger.info(
+                f"  Waiting for '{name}' container to become healthy at {url}… "
+                f"(attempt {attempt}/{HEALTH_MAX_ATTEMPTS})"
+            )
+            time.sleep(HEALTH_RETRY_DELAY)
+
+    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}"
+        )
+        return
+
+    msg = (
+        f"  [ERR] {name} [{ptype}] {url} — unreachable after "
+        f"{HEALTH_MAX_ATTEMPTS} attempt(s): {info}. "
+        f"Run: pf init {flowsheet_path}"
+    )
+    logger.error(msg)
+    if fail_fast:
+        raise SystemExit(1)
+    errors.append(f"Provider '{name}' unreachable at {url}: {info}")
+
+
+def _check_pip_provider(
+    name: str,
+    ptype: str,
+    flowsheet_path: str,
+    *,
+    fail_fast: bool,
+    errors: list[str],
+) -> None:
+    """Verify a pip-installable provider's module is importable."""
+    from ..providers.registry import _PROVIDER_CATALOG
+
+    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"
+        msg = (
+            f"  [WARN] {name} [{ptype}] — not installed. "
+            f"Run: pf init {flowsheet_path}  (install with: {hint})"
+        )
+        logger.warning(msg)
+        if fail_fast:
+            raise SystemExit(1)
+        errors.append(f"Provider '{name}' not installed ({hint})")
+
+
 def check_providers(
     config: dict,
     flowsheet_path: str,
@@ -193,56 +279,41 @@ def check_providers(
 ) -> None:
     """Verify all declared providers are reachable or importable.
 
+    For containerized providers this pings the container's ``/health`` endpoint
+    (with a short retry/poll so a still-booting container can become ready) and
+    logs a visible ``[OK]``/``[ERR]`` line — so ``pf run`` shows a clear health
+    check instead of silently waiting. Pip-installable providers are checked for
+    importability and reported the same way.
+
     Parameters
     ----------
     fail_fast:
         If ``True`` (default), raise ``SystemExit`` on the first failure.
         If ``False``, accumulate errors and raise once at the end.
     verbose:
-        If ``True``, log per-provider success messages.
+        Accepted for compatibility; the health check is always logged.
     """
-    from ..providers.registry import is_containerized, _PROVIDER_CATALOG
+    from ..providers.registry import is_containerized
 
     providers = config.get("providers", {})
     errors: list[str] = []
 
+    if providers:
+        logger.info("=== Provider / Container Health ===")
+
     for name, cfg in providers.items():
         ptype = cfg.get("type", "")
         if is_containerized(ptype):
             url = _resolve_provider_url(cfg, ptype)
-            try:
-                urllib.request.urlopen(f"{url}/health", timeout=5)
-                if verbose:
-                    logger.info(f"Provider '{name}' — reachable at {url}")
-            except (urllib.error.URLError, OSError, TimeoutError) as exc:
-                msg = (
-                    f"Provider '{name}' unreachable at {url}. "
-                    f"Run: pf init {flowsheet_path}"
-                )
-                if fail_fast:
-                    logger.error(msg)
-                    raise SystemExit(1)
-                logger.error(msg)
-                errors.append(msg)
+            _check_container_provider(
+                name, ptype, url, flowsheet_path,
+                fail_fast=fail_fast, errors=errors,
+            )
         else:
-            catalog = _PROVIDER_CATALOG.get(ptype, {})
-            module = catalog.get("module", "")
-            try:
-                importlib.util.find_spec(module)
-                if verbose:
-                    logger.info(f"Provider '{name}' — importable (pip)")
-            except (ModuleNotFoundError, ValueError):
-                dep = catalog.get("optional_dep")
-                hint = f"pip install 'processforge[{dep}]'" if dep else "built-in"
-                msg = (
-                    f"Provider '{name}' not installed. "
-                    f"Run: pf init {flowsheet_path}  (install with: {hint})"
-                )
-                if fail_fast:
-                    logger.error(msg)
-                    raise SystemExit(1)
-                logger.error(msg)
-                errors.append(msg)
+            _check_pip_provider(
+                name, ptype, flowsheet_path,
+                fail_fast=fail_fast, errors=errors,
+            )
 
     if errors:
         raise SystemExit(1)

{processforge-0.3.21 → processforge-0.3.25}/src/processforge/cli/display.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 from typing import Any
 
+import importlib.util
+
 from loguru import logger
 
 
@@ -53,7 +55,7 @@ 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]:
+def print_provider_health(config: dict, strict: bool = False) -> list[str]:
     """Log per-provider reachability for flowsheets using Docker containers.
 
     For each provider declared in *config*:
@@ -63,10 +65,9 @@ def print_provider_health(config: dict) -> list[str]:
     * 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).
+    provider (empty means every provider is healthy/available). When *strict*
+    is True, a missing pip-installable provider is also appended to failures.
     """
-    import importlib
-
     from ..providers.registry import is_containerized, _PROVIDER_CATALOG
 
     providers = config.get("providers", {})
@@ -104,6 +105,10 @@ def print_provider_health(config: dict) -> list[str]:
                 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})")
+                if strict:
+                    failures.append(
+                        f"Provider '{name}' not installed ({hint})"
+                    )
 
     return failures
 
@@ -122,3 +127,26 @@ def print_structural_diff(diff: dict) -> None:
         logger.info(f"  - {name:<20} [{unit_type}]  (removed)")
     if not any(diff.get(k) for k in ("added", "modified", "removed")):
         logger.info("  (no structural changes)")
+
+
+def _resolve_path(cfg: dict, path: str) -> object:
+    """Resolve a dotted config path (e.g. ``simulation.tf``) to its value."""
+    cur: object = cfg
+    for part in path.split("."):
+        if isinstance(cur, dict) and part in cur:
+            cur = cur[part]
+        else:
+            return "<missing>"
+    return cur
+
+
+def print_param_drift(drifted: list[str], old_config: dict, new_config: dict) -> None:
+    """Log parameter drift paths with their old → new values."""
+    logger.info("=== Parameter Drift vs. Saved State ===")
+    if not drifted:
+        logger.info("  (no parameter changes)")
+        return
+    for path in drifted:
+        old_val = _resolve_path(old_config, path)
+        new_val = _resolve_path(new_config, path)
+        logger.info(f"  ~ {path}: {old_val!r} → {new_val!r}")

{processforge-0.3.21 → processforge-0.3.25}/src/processforge/cli/init.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-import importlib
+import importlib.util
 import json
 import os
 import shutil
@@ -11,8 +11,18 @@ import subprocess
 import typer
 from loguru import logger
 
-from .common import extract_providers, is_local_provider_url
-from ..lock import flowsheet_env_dir, read_lock
+from .common import (
+    extract_providers,
+    is_local_provider_url,
+)
+from ..lock import flowsheet_env_dir, read_lock, write_lock
+from ..providers.registry import (
+    get_provider_docker_image,
+    get_provider_default_port,
+    is_containerized,
+    _PROVIDER_CATALOG,
+)
+from ..utils.validate_flowsheet import validate_flowsheet
 
 
 def _migrate_legacy_env(pf_dir: str) -> None:
@@ -21,7 +31,9 @@ def _migrate_legacy_env(pf_dir: str) -> None:
     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.
+    repo keeps its provider environment after upgrading. The target always uses the
+    same hashed env dir that ``pf init``/``read_lock`` locate, so the migrated env
+    is never orphaned.
     """
     legacy_lock = os.path.join(pf_dir, "lock.json")
     legacy_compose = os.path.join(pf_dir, "docker-compose.yml")
@@ -35,15 +47,19 @@ def _migrate_legacy_env(pf_dir: str) -> None:
         except Exception:
             recorded = None
 
-    if recorded and os.path.exists(recorded):
-        env_dir = flowsheet_env_dir(pf_dir, recorded)
+    # Always target the hashed env dir keyed by the recorded flowsheet path so it
+    # matches what `pf init <flowsheet>` / `read_lock` expect on subsequent runs.
+    env_dir = flowsheet_env_dir(pf_dir, recorded or "legacy")
+    if recorded:
+        logger.info(
+            f"Migrating legacy .processforge/lock.json + docker-compose.yml into "
+            f"'{os.path.relpath(env_dir, pf_dir)}/'."
+        )
     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)."
+            f"'{os.path.relpath(env_dir, pf_dir)}/' (no recorded flowsheet found — "
+            "re-run `pf init <flowsheet.json>` to restore the correct env dir)."
         )
 
     if os.path.exists(env_dir):
@@ -73,15 +89,19 @@ def init(
         "--path",
         help="Root directory to initialise in (default: current directory)",
     ),
+    no_pull: bool = typer.Option(
+        False,
+        "--no-pull",
+        help="Generate docker-compose.yml but skip pulling provider images",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Re-initialise even if the environment already exists",
+    ),
 ) -> None:
     """Initialise the .processforge/ project directory."""
-    from ..providers.registry import (
-        is_containerized,
-        get_provider_docker_image,
-        get_provider_default_port,
-        _PROVIDER_CATALOG,
-    )
-    from ..lock import write_lock
     from ..compose import generate_compose
 
     root = path or "."
@@ -96,17 +116,6 @@ def init(
     # 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):
-        if entry.endswith(".pfstate"):
-            stale = os.path.join(outputs_dir, entry)
-            if os.path.isdir(stale):
-                shutil.rmtree(stale)
-                stale_count += 1
-    if stale_count:
-        logger.info(f"Removed {stale_count} stale snapshot(s) from {outputs_dir}/.")
-
     # Write config.json (always)
     config_path = os.path.join(pf_dir, "config.json")
     if not os.path.exists(config_path):
@@ -121,6 +130,26 @@ def init(
     else:
         logger.info(f"{config_path} already exists — skipped.")
 
+    # Honour a configured outputs_dir for the rest of init.
+    outputs_dir_name = "outputs"
+    try:
+        with open(config_path, encoding="utf-8") as f:
+            outputs_dir_name = json.load(f).get("outputs_dir", "outputs")
+    except Exception:
+        pass
+    outputs_dir = os.path.join(root, outputs_dir_name)
+
+    # Remove stale .pfstate snapshot directories from outputs/
+    stale_count = 0
+    for entry in os.listdir(outputs_dir):
+        if entry.endswith(".pfstate"):
+            stale = os.path.join(outputs_dir, entry)
+            if os.path.isdir(stale):
+                shutil.rmtree(stale)
+                stale_count += 1
+    if stale_count:
+        logger.info(f"Removed {stale_count} stale snapshot(s) from {outputs_dir}/.")
+
     # No flowsheet → scaffold only
     if not flowsheet:
         logger.info(".processforge/ initialised successfully.")
@@ -131,15 +160,21 @@ def init(
     flowsheet_path = flowsheet
     if not os.path.exists(flowsheet_path):
         logger.error(f"Flowsheet '{flowsheet_path}' not found.")
-        raise SystemExit(1)
+        raise typer.Exit(code=1)
+
+    try:
+        validate_flowsheet(flowsheet_path)
+    except Exception as e:
+        logger.error(f"Failed to validate flowsheet '{flowsheet_path}': {e}")
+        raise typer.Exit(code=1)
 
     providers = extract_providers(flowsheet_path)
     logger.info(f"Reading providers from {flowsheet_path}...")
 
-    # Categorize providers
-    pip_providers: dict[str, dict] = {}
+    # Categorize providers, reusing the shared local/remote/pip classification.
     local_docker_providers: dict[str, dict] = {}
     remote_docker_providers: dict[str, dict] = {}
+    pip_providers: dict[str, dict] = {}
     for name, cfg in providers.items():
         ptype = cfg.get("type", "")
         if is_containerized(ptype):
@@ -151,7 +186,8 @@ def init(
                 local_docker_providers[name] = {
                     "type": ptype,
                     "url": url,
-                    "docker_image": cfg.get("docker_image") or get_provider_docker_image(ptype),
+                    "docker_image": cfg.get("docker_image")
+                    or get_provider_docker_image(ptype),
                     "port": port,
                 }
                 logger.info(f"  {name}: type={ptype}, url={url} (Docker, local)")
@@ -159,7 +195,8 @@ def init(
                 remote_docker_providers[name] = {
                     "type": ptype,
                     "url": url,
-                    "docker_image": cfg.get("docker_image") or get_provider_docker_image(ptype),
+                    "docker_image": cfg.get("docker_image")
+                    or get_provider_docker_image(ptype),
                 }
                 logger.info(
                     f"  {name}: type={ptype}, url={url} (Docker, remote — skipping compose)"
@@ -185,45 +222,48 @@ def init(
     # 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):
+        env_dir = flowsheet_env_dir(pf_dir, flowsheet_path)
+        compose_path = os.path.join(env_dir, "docker-compose.yml")
+        if os.path.exists(compose_path) and not force:
             logger.warning(
                 f"Environment already initialized — reinitializing from {flowsheet_path}"
             )
 
-        generate_compose(pf_dir, local_docker_providers, outputs_dir, flowsheet=flowsheet_path)
+        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
-        try:
-            logger.info("Pulling Docker images (this may take a while)...")
-            process = subprocess.Popen(
-                ["docker", "compose", "-f", compose_path, "pull"],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.STDOUT,
-                text=True,
-                bufsize=1,
-            )
-            assert process.stdout is not None
-            for line in process.stdout:
-                line = line.rstrip()
-                if line:
-                    logger.info(line)
-            returncode = process.wait(timeout=600)
-            if returncode == 0:
-                logger.info("Pulled Docker images.")
-            else:
+        if no_pull:
+            logger.info("Skipping Docker image pull (--no-pull).")
+        else:
+            # Attempt docker compose pull. Capture output and stream it via the
+            # logger; on timeout the child is reaped (subprocess.run kills it)
+            # so no orphaned/blocked process is left behind.
+            try:
+                logger.info("Pulling Docker images (this may take a while)...")
+                result = subprocess.run(
+                    ["docker", "compose", "-f", compose_path, "pull"],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.STDOUT,
+                    text=True,
+                    timeout=600,
+                )
+                for line in result.stdout.splitlines():
+                    if line.strip():
+                        logger.info(line)
+                if result.returncode == 0:
+                    logger.info("Pulled Docker images.")
+                else:
+                    logger.warning(
+                        f"docker compose pull failed with exit code {result.returncode}."
+                    )
+            except FileNotFoundError:
                 logger.warning(
-                    f"docker compose pull failed with exit code {returncode}."
+                    "Docker not found. Install Docker to use containerized providers."
                 )
-        except FileNotFoundError:
-            logger.warning(
-                "Docker not found. Install Docker to use containerized providers."
-            )
-        except subprocess.TimeoutExpired:
-            logger.warning("docker compose pull timed out after 600s.")
+            except subprocess.TimeoutExpired:
+                logger.warning("docker compose pull timed out after 600s.")
 
         logger.info(
             "To start the containerized provider(s), run:\n"
@@ -242,15 +282,19 @@ def init(
     else:
         logger.info("No containerized providers — skipping Docker setup.")
 
-    # Write lock file
+    # Write lock file, reusing the shared URL resolution for the recorded url.
     lock_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:
+                port = get_provider_default_port(ptype) or 9000
+                url = f"http://localhost:{port}"
             lock_providers[name] = {
-                "docker_image": cfg.get("docker_image") or get_provider_docker_image(ptype),
-                "url": cfg.get("url")
-                or f"http://localhost:{get_provider_default_port(ptype) or 9000}",
+                "docker_image": cfg.get("docker_image")
+                or get_provider_docker_image(ptype),
+                "url": url,
             }
         else:
             lock_providers[name] = {
@@ -261,5 +305,7 @@ 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(flowsheet_env_dir(pf_dir, flowsheet_path), 'lock.json')}")
+    logger.info(
+        f"Wrote {os.path.join(flowsheet_env_dir(pf_dir, flowsheet_path), 'lock.json')}"
+    )
     logger.info(".processforge/ initialised successfully.")