processforge 0.3.23__tar.gz → 0.3.25__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.3.23
+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

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

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

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

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

{processforge-0.3.23 → 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.23"
+__version__ = "0.3.25"
 
 __all__ = [
     "Flowsheet",

{processforge-0.3.23 → 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,16 +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.")]
-        other_drifts = [d for d in drifted if not d.startswith(("streams.", "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}")
-        if other_drifts:
-            logger.warning(f"  Config drift : {other_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.23 → 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

{processforge-0.3.23 → 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.23 → 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.")

processforge-0.3.25/src/processforge/cli/plan.py

@@ -0,0 +1,198 @@
+"""``pf plan`` — validate, DOF analysis, structural diff, and Mermaid diagram."""
+
+from __future__ import annotations
+
+import json
+import os
+
+import typer
+from loguru import logger
+
+from ..analysis.dof import analyze_dof
+from ..utils.validate_flowsheet import validate_flowsheet_dict
+from ..utils.unit_consistency import check_unit_consistency, strip_units_annotations
+from ..pcl import load_pcl, PCLCompileError
+from ..utils.mermaid_diagram import generate_mermaid
+from .common import (
+    flowsheet_basename,
+    load_state_manager,
+    output_root,
+    require_existing_file,
+    validate_snapshot_config,
+)
+from .display import (
+    print_dof_report,
+    print_param_drift,
+    print_provider_health,
+    print_structural_diff,
+    print_unit_mismatches,
+)
+
+
+def _find_processforge_root(start: str) -> str | None:
+    """Walk up from *start*'s directory to find the dir holding `.processforge`."""
+    d = os.path.dirname(os.path.abspath(start))
+    while True:
+        if os.path.isdir(os.path.join(d, ".processforge")):
+            return d
+        parent = os.path.dirname(d)
+        if parent == d:
+            return None
+        d = parent
+
+
+def plan(
+    flowsheet: str = typer.Argument(help="Path to .pcl or .json flowsheet file"),
+    output_dir: str = typer.Option(
+        "diagrams",
+        "--output-dir",
+        "-o",
+        help="Output directory for the Mermaid diagram (default: diagrams)",
+    ),
+    no_diagram: bool = typer.Option(
+        False,
+        "--no-diagram",
+        help="Skip Mermaid diagram generation",
+    ),
+    no_dof: bool = typer.Option(
+        False,
+        "--no-dof",
+        help="Skip Degrees-of-Freedom analysis",
+    ),
+    no_health: bool = typer.Option(
+        False,
+        "--no-health",
+        help="Skip provider/container health check (faster, for CI/quick plans)",
+    ),
+    strict: bool = typer.Option(
+        False,
+        "--strict",
+        help="Treat missing pip providers as hard failures (in addition to unreachable containers)",
+    ),
+) -> None:
+    """Parse a PCL or JSON flowsheet, run validators, DOF analysis, structural diff, and emit a Mermaid diagram."""
+    require_existing_file(flowsheet, label="File")
+
+    # Step 1: Load config
+    if flowsheet.endswith(".pcl"):
+        try:
+            json_config = load_pcl(flowsheet)
+        except PCLCompileError as e:
+            logger.error(f"PCL compile error: {e}")
+            raise typer.Exit(code=1)
+    else:
+        try:
+            with open(flowsheet, "r", encoding="utf-8") as f:
+                json_config = json.load(f)
+        except json.JSONDecodeError as e:
+            logger.error(f"JSON parse error in '{flowsheet}': {e}")
+            raise typer.Exit(code=1)
+        except OSError as e:
+            logger.error(f"Failed to read '{flowsheet}': {e}")
+            raise typer.Exit(code=1)
+
+    # Step 2: Pint unit consistency check (before _units are stripped)
+    mismatches = check_unit_consistency(json_config)
+    print_unit_mismatches(mismatches)
+
+    # Step 3: Strip _units annotations before schema validation
+    strip_units_annotations(json_config)
+
+    # Step 4: Schema + connectivity validation
+    try:
+        config = validate_flowsheet_dict(json_config, source_name=flowsheet)
+    except Exception as e:
+        logger.error(f"Validation failed: {type(e).__name__}: {e}")
+        raise typer.Exit(code=1)
+
+    # Step 5: DOF analysis
+    if no_dof:
+        logger.info("=== Degrees of Freedom Analysis ===")
+        logger.info("  Skipped (--no-dof).")
+    else:
+        report = analyze_dof(config)
+        print_dof_report(report)
+
+        # Step 5b: DOF fix suggestions
+        if report.system_dof != 0:
+            logger.warning("=== DOF Fix Suggestions ===")
+            for r in report.per_unit:
+                if r.dof > 0:
+                    for issue in r.issues:
+                        logger.warning(
+                            f"  Unit '{r.unit_name}' [{r.unit_type}]: {issue}"
+                        )
+                elif r.dof < 0:
+                    logger.warning(
+                        f"  Unit '{r.unit_name}' [{r.unit_type}]: "
+                        f"possibly over-specified by {abs(r.dof)} equation(s)"
+                    )
+
+    # Step 6: Structural diff vs. saved state
+    base_name = flowsheet_basename(flowsheet)
+    outputs_dir = output_root()
+    sm, state = load_state_manager(outputs_dir, base_name)
+    diff = None
+    if state is not None:
+        validate_snapshot_config(state, base_name)
+        diff = sm.detect_structural_diff(config, state)
+        print_structural_diff(diff)
+        # Step 6b: Parameter drift (non-structural value changes)
+        old_config = state.config
+        drifted = sm.detect_drift(config, state)
+        print_param_drift(drifted, old_config, config)
+    else:
+        logger.info("=== Structural Diff vs. Saved State ===")
+        logger.info("  No prior state found — this will be a cold start.")
+
+    # Step 7: Warm-start and homotopy eligibility
+    logger.info("=== Warm-Start Status ===")
+    if state is not None:
+        snap_id = state.snapshot_id
+        snap_ts = state.timestamp
+        logger.info(f"  Warm-start available : Yes  (snapshot {snap_id}, {snap_ts})")
+        topology_ok = diff is None or not bool(diff.get("added") or diff.get("removed"))
+        logger.info(
+            f"  Homotopy eligible    : {'Yes' if topology_ok else 'No (topology changed)'}"
+        )
+    else:
+        logger.info("  Warm-start available : No snapshot found")
+        logger.info("  Homotopy eligible    : No (cold start)")
+
+    # Step 8: Provider / container health check
+    health_failures: list[str] = []
+    if no_health:
+        logger.info("=== Provider / Container Health ===")
+        logger.info("  Skipped (--no-health).")
+    else:
+        health_failures = print_provider_health(config, strict=strict)
+
+    # Step 9: Mermaid diagram
+    if not no_diagram:
+        diagram_output_dir = output_dir or "diagrams"
+        os.makedirs(diagram_output_dir, exist_ok=True)
+        out_path = os.path.join(diagram_output_dir, f"{base_name}_plan.mmd")
+        try:
+            src = generate_mermaid(config)
+            existing = None
+            if os.path.exists(out_path):
+                try:
+                    with open(out_path, encoding="utf-8") as f:
+                        existing = f.read()
+                except OSError:
+                    existing = None
+            if existing == src:
+                logger.info(f"Mermaid diagram unchanged: {out_path}")
+            else:
+                with open(out_path, "w", encoding="utf-8") as f:
+                    f.write(src)
+                logger.info(f"Mermaid diagram -> {out_path}")
+        except Exception as e:
+            logger.warning(
+                f"Failed to generate Mermaid diagram: {type(e).__name__}: {e}"
+            )
+
+    # Exit non-zero on hard errors
+    hard_errors = [m for m in mismatches if not m.compatible]
+    if hard_errors or (not no_dof and report.system_dof < 0) or health_failures:
+        raise typer.Exit(code=1)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.3.23
+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

{processforge-0.3.23 → processforge-0.3.25}/src/processforge.egg-info/SOURCES.txt

@@ -126,6 +126,7 @@ src/processforge/utils/validation.py
 tests/test_cli.py
 tests/test_container_client.py
 tests/test_coupling.py
+tests/test_display.py
 tests/test_festim_provider.py
 tests/test_festim_schema.py
 tests/test_init.py