processforge 0.3.3__tar.gz → 0.3.4__tar.gz

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

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

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

{processforge-0.3.3 → processforge-0.3.4}/src/processforge/cli/init.py

@@ -127,24 +127,34 @@ def init(
         generate_compose(pf_dir, docker_providers, outputs_dir)
         logger.info(f"Generated {compose_path}")
 
-        # Attempt docker compose pull
+        # Attempt docker compose pull — stream progress live
         try:
-            result = subprocess.run(
+            logger.info("Pulling Docker images (this may take a while)...")
+            process = subprocess.Popen(
                 ["docker", "compose", "-f", compose_path, "pull"],
-                capture_output=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
                 text=True,
-                timeout=120,
+                bufsize=1,
             )
-            if result.returncode == 0:
+            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:
-                logger.warning(f"docker compose pull failed: {result.stderr}")
+                logger.warning(
+                    f"docker compose pull failed with exit code {returncode}."
+                )
         except FileNotFoundError:
             logger.warning(
                 "Docker not found. Install Docker to use containerized providers."
             )
         except subprocess.TimeoutExpired:
-            logger.warning("docker compose pull timed out after 120s.")
+            logger.warning("docker compose pull timed out after 600s.")
     else:
         logger.info("No containerized providers — skipping Docker setup.")
 

processforge-0.3.4/src/processforge/providers/container_client.py

@@ -0,0 +1,218 @@
+"""CLI-side HTTP client for containerized providers (OpenMC, FESTIM, …).
+
+A provider that runs in a Docker container does its real work inside the
+container (in ``docker/provider_server.py``).  The CLI side must NOT import the
+backend library (OpenMC, FESTIM, …) locally — instead it speaks HTTP to the
+container's ``provider_server.py`` instance.  :class:`ContainerProviderClient`
+implements the :class:`~processforge.providers.base.AbstractProvider` contract
+as a thin HTTP wrapper around that server.
+
+Request/response contract (matches ``docker/provider_server.py``)
+----------------------------------------------------------------
+* ``POST /run`` with a JSON body
+  ``{"unit_config", "materials", "inlet", "output_dir", "provider_config"}``.
+* JSON response ``{"status", "sim_type", <scalars…>, "metadata"}`` deserialised
+  into a :class:`~processforge.types.SimulationResult`.
+"""
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.request
+from typing import TYPE_CHECKING, Optional
+
+from loguru import logger
+
+from .base import AbstractProvider
+from .registry import get_provider_default_port
+
+if TYPE_CHECKING:
+    from processforge.types import (
+        FlowsheetConfig,
+        MaterialDef,
+        ProviderConfig,
+        SimulationResult,
+        UnitConfig,
+    )
+
+
+class ContainerProviderClient(AbstractProvider):
+    """CLI-side HTTP client for a provider running in a Docker container.
+
+    Responsibilities
+    ----------------
+    * **Health check** — ``initialize()`` verifies the container is reachable
+      via ``GET /health``.
+    * **Simulation dispatch** — ``run_simulation()`` serialises the unit config
+      and material registry and ``POST``s them to the container's ``/run``
+      endpoint, then deserialises the JSON response into a ``SimulationResult``.
+    * **Material validation** — delegated to the provider class via
+      ``validate_material()`` (it is a classmethod and needs no local backend).
+    """
+
+    def __init__(self, provider_type: str):
+        self._ptype = provider_type
+        self._url: Optional[str] = None
+        self._provider_output_dir: str = "outputs"
+        self._provider_config: Optional["ProviderConfig"] = None
+        self._materials: dict = {}
+        self._initialized: bool = False
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    def _resolve_url(self, provider_config: "ProviderConfig") -> str:
+        """Return the service URL, deriving a default from the catalog if needed."""
+        url = getattr(provider_config, "url", None)
+        if not url:
+            port = get_provider_default_port(self._ptype) or 9000
+            url = f"http://localhost:{port}"
+        return url.rstrip("/")
+
+    @staticmethod
+    def _serialize_unit_config(unit_config: "UnitConfig") -> dict:
+        """Serialise a ``UnitConfig`` into the ``unit_config`` block of the body."""
+        return {
+            "type": unit_config.type,
+            "in": unit_config.inputs,
+            "material": unit_config.material,
+            "provider": unit_config.provider,
+            "out": unit_config.out,
+            "sim_type": unit_config.sim_type,
+            "solver_config": unit_config.solver_config,
+            **unit_config.extra,
+        }
+
+    @staticmethod
+    def _serialize_materials(materials: dict[str, "MaterialDef"]) -> dict:
+        """Serialise the material registry into the ``materials`` block of the body."""
+        out: dict = {}
+        for name, mat in materials.items():
+            out[name] = {
+                "id": mat.id,
+                "density": mat.density,
+                "density_units": mat.density_units,
+                "temperature": mat.temperature,
+                "depletable": mat.depletable,
+                "nuclides": mat.nuclides,
+                **mat.extra,
+            }
+        return out
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+
+    def initialize(
+        self,
+        provider_config: "ProviderConfig",
+        flowsheet_config: "FlowsheetConfig",
+    ) -> None:
+        """Store config, resolve URL, verify the Docker service is reachable."""
+        self._url = self._resolve_url(provider_config)
+
+        out_dir = os.path.expandvars(
+            getattr(provider_config, "output_dir", "outputs") or "outputs"
+        )
+        if not os.path.isabs(out_dir):
+            root = os.environ.get("PROCESSFORGE_OUTPUT_DIR", "outputs")
+            out_dir = os.path.join(root, out_dir)
+        self._provider_output_dir = out_dir
+
+        # Material registry — serialised into /run and used by validate_material().
+        self._materials = dict(flowsheet_config.materials)
+        self._provider_config = provider_config
+
+        try:
+            req = urllib.request.Request(f"{self._url}/health", method="GET")
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                health = json.loads(resp.read().decode())
+            logger.info(
+                f"ContainerProviderClient connected to {self._url} — "
+                f"status={health.get('status')}"
+            )
+        except (urllib.error.URLError, OSError, TimeoutError) as exc:
+            raise RuntimeError(
+                f"Provider '{self._ptype}' service unreachable at {self._url}. "
+                f"Ensure the container is running: pf init <flowsheet>"
+            ) from exc
+
+        self._initialized = True
+
+    def get_thermo_properties(self, stream: dict) -> dict:
+        raise NotImplementedError(
+            "ContainerProviderClient does not support stream thermodynamics."
+        )
+
+    def compute_unit(self, unit_type: str, config: dict, inlet: dict):
+        """Return ``None`` — the container provider uses ``run_simulation``."""
+        return None
+
+    def teardown(self) -> None:
+        """Release provider state."""
+        self._initialized = False
+
+    def run_simulation(self, unit_config: "UnitConfig", inlet: dict) -> "SimulationResult":
+        """Serialise the request, POST it to the container, return the result."""
+        from processforge.types import SimulationResult
+
+        if not self._url:
+            raise RuntimeError(
+                "ContainerProviderClient has not been initialized — call initialize() first."
+            )
+
+        provider_config_dump = (
+            self._provider_config.model_dump()
+            if self._provider_config is not None
+            else {"type": unit_config.provider or self._ptype, "url": self._url}
+        )
+
+        body = {
+            "unit_config": self._serialize_unit_config(unit_config),
+            "materials": self._serialize_materials(self._materials),
+            "inlet": inlet,
+            "output_dir": self._provider_output_dir,
+            "provider_config": provider_config_dump,
+        }
+
+        logger.info(
+            f"ContainerProviderClient: POST {self._url}/run "
+            f"sim_type='{unit_config.sim_type}'"
+        )
+
+        payload = json.dumps(body).encode()
+        req = urllib.request.Request(
+            f"{self._url}/run",
+            data=payload,
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+
+        try:
+            with urllib.request.urlopen(req, timeout=900) as resp:
+                data = json.loads(resp.read().decode())
+        except urllib.error.HTTPError as exc:
+            detail = exc.read().decode() if exc.fp else str(exc)
+            raise RuntimeError(
+                f"Provider '{self._ptype}' service returned HTTP {exc.code}: {detail}"
+            ) from exc
+        except (urllib.error.URLError, OSError, TimeoutError) as exc:
+            raise RuntimeError(
+                f"Provider '{self._ptype}' service unreachable at {self._url}: {exc}"
+            ) from exc
+
+        scalars = {
+            k: v
+            for k, v in data.items()
+            if k not in ("status", "sim_type", "metadata")
+        }
+        return SimulationResult(
+            status=data.get("status", "completed"),
+            sim_type=data.get("sim_type", unit_config.sim_type or ""),
+            scalars=scalars,
+            metadata=data.get("metadata", {}),
+        )
+
+

{processforge-0.3.3 → processforge-0.3.4}/src/processforge/providers/manager.py

@@ -19,7 +19,7 @@ from pydantic import BaseModel, ConfigDict
 from processforge.types import CoolPropProviderConfig, FlowsheetConfig, ProviderConfig
 
 from .coolprop_provider import CoolPropProvider
-from .registry import get_provider_class
+from .registry import get_provider_class, is_containerized
 
 _BUILTIN_DEFAULT_KEY = "__coolprop__"
 _DEFAULT_KEY = "__default__"
@@ -136,11 +136,22 @@ def build_provider_map(
     # Step 2: instantiate every declared provider.
     for name, cfg in providers_config.items():
         ptype = cfg.type
-        cls = get_provider_class(ptype)
-        instance = cls()
+        if is_containerized(ptype):
+            # Containerized providers (OpenMC, FESTIM, …) run their backend
+            # inside a Docker container; the CLI only needs a thin HTTP client
+            # that talks to the container's provider_server.py.
+            from .container_client import ContainerProviderClient
+
+            instance = ContainerProviderClient(ptype)
+            logger.info(
+                f"Initialized provider '{name}' (type='{ptype}') via container client"
+            )
+        else:
+            cls = get_provider_class(ptype)
+            instance = cls()
+            logger.info(f"Initialized provider '{name}' (type='{ptype}')")
         instance.initialize(cfg, flowsheet_config)
         providers[name] = instance
-        logger.info(f"Initialized provider '{name}' (type='{ptype}')")
 
     # Step 3: resolve the active default.
     default = None

{processforge-0.3.3 → processforge-0.3.4}/src/processforge/providers/openmc_provider.py

@@ -37,6 +37,7 @@ from __future__ import annotations
 import math
 import os
 import pathlib
+import tempfile
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Optional
 
@@ -506,7 +507,18 @@ class OpenMCProvider(AbstractProvider):
 
         # --- Working directory management ---
         run_dir = pathlib.Path(self._provider_output_dir)
-        run_dir.mkdir(parents=True, exist_ok=True)
+        try:
+            run_dir.mkdir(parents=True, exist_ok=True)
+        except (PermissionError, OSError) as exc:
+            # The configured output dir (often the mounted /data volume) may not
+            # be writable by the container user. Fall back to a temp dir so the
+            # simulation can still run; only the persisted XML artifacts are lost.
+            run_dir = pathlib.Path(tempfile.mkdtemp(prefix="processforge_openmc_"))
+            logger.warning(
+                f"OpenMCProvider: cannot use output dir "
+                f"'{self._provider_output_dir}' ({exc}); "
+                f"falling back to '{run_dir}'."
+            )
         original_cwd = pathlib.Path.cwd()
 
         # --- Cross-section override ---

{processforge-0.3.3 → processforge-0.3.4}/src/processforge/providers/registry.py

@@ -171,8 +171,15 @@ def get_provider_default_port(provider_type: str) -> int | None:
 
 
 def is_containerized(provider_type: str) -> bool:
-    """Return True if the provider runs in a Docker container."""
-    return get_provider_docker_image(provider_type) is not None
+    """Return True if the provider runs in a Docker container.
+
+    Returns False for unknown provider types rather than raising, so callers
+    can cleanly fall through to the local/import path.
+    """
+    try:
+        return get_provider_docker_image(provider_type) is not None
+    except ValueError:
+        return False
 
 
 # Seed the registry with the always-available CoolProp provider.

{processforge-0.3.3 → processforge-0.3.4}/src/processforge/types.py

@@ -194,6 +194,7 @@ class OpenMCProviderConfig(BaseModel):
     """
 
     type: str = "openmc"
+    url: Optional[str] = None
     output_dir: str = "outputs/openmc"
     cross_sections: Optional[str] = None
     docker_image: Optional[str] = None
@@ -201,6 +202,7 @@ class OpenMCProviderConfig(BaseModel):
     @classmethod
     def from_dict(cls, d: dict) -> "OpenMCProviderConfig":
         return cls(
+            url=d.get("url"),
             output_dir=d.get("output_dir", "outputs/openmc"),
             cross_sections=d.get("cross_sections"),
             docker_image=d.get("docker_image"),

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.3.3
+Version: 0.3.4
 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.3 → processforge-0.3.4}/src/processforge.egg-info/SOURCES.txt

@@ -76,6 +76,7 @@ src/processforge/providers/base.py
 src/processforge/providers/base_jacobian_mixin.py
 src/processforge/providers/cantera_jacobian.py
 src/processforge/providers/cantera_provider.py
+src/processforge/providers/container_client.py
 src/processforge/providers/coolprop_provider.py
 src/processforge/providers/festim_provider.py
 src/processforge/providers/jacobian_contributor.py