carnopy 0.1.0a1__py3-none-any.whl

carnopy/__init__.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from importlib import import_module
+from typing import TYPE_CHECKING, Any
+
+from carnopy._version import __version__
+
+if TYPE_CHECKING:
+    from carnopy.api import generate_dataset, load_config, validate_config
+    from carnopy.config.models import CarnopyConfig, NormalizedConfig
+    from carnopy.config.outputs import OutputConfig
+    from carnopy.config.visualization import VisualizationConfig, VisualizationPlotConfig
+    from carnopy.results import RunResult, ValidationResult, VisualizationSummary
+
+__all__ = [
+    "CarnopyConfig",
+    "NormalizedConfig",
+    "OutputConfig",
+    "RunResult",
+    "ValidationResult",
+    "VisualizationConfig",
+    "VisualizationPlotConfig",
+    "VisualizationSummary",
+    "__version__",
+    "generate_dataset",
+    "load_config",
+    "validate_config",
+]
+
+_LAZY_EXPORTS = {
+    "CarnopyConfig": ("carnopy.config.models", "CarnopyConfig"),
+    "NormalizedConfig": ("carnopy.config.models", "NormalizedConfig"),
+    "OutputConfig": ("carnopy.config.outputs", "OutputConfig"),
+    "RunResult": ("carnopy.results", "RunResult"),
+    "ValidationResult": ("carnopy.results", "ValidationResult"),
+    "VisualizationConfig": ("carnopy.config.visualization", "VisualizationConfig"),
+    "VisualizationPlotConfig": (
+        "carnopy.config.visualization",
+        "VisualizationPlotConfig",
+    ),
+    "VisualizationSummary": ("carnopy.results", "VisualizationSummary"),
+    "generate_dataset": ("carnopy.api", "generate_dataset"),
+    "load_config": ("carnopy.api", "load_config"),
+    "validate_config": ("carnopy.api", "validate_config"),
+}
+
+
+def __getattr__(name: str) -> Any:
+    try:
+        module_name, attribute_name = _LAZY_EXPORTS[name]
+    except KeyError as exc:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}") from exc
+    value = getattr(import_module(module_name), attribute_name)
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(__all__))

carnopy/__main__.py

@@ -0,0 +1,9 @@
+from carnopy.cli import app
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

carnopy/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0a1"

carnopy/api.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from carnopy.config.io import LoadedConfig, load_config_file
+from carnopy.pipeline import run_generation, validate_loaded_config
+from carnopy.results import RunResult, ValidationResult
+
+
+def load_config(path: str | Path) -> LoadedConfig:
+    return load_config_file(path)
+
+
+def validate_config(path: str | Path) -> ValidationResult:
+    loaded = load_config_file(path)
+    return validate_loaded_config(loaded).result
+
+
+def generate_dataset(
+    path: str | Path,
+    *,
+    output_root: str | Path = "outputs",
+    figures_root: str | Path = "figures",
+) -> RunResult:
+    loaded = load_config_file(path)
+    return run_generation(
+        loaded,
+        Path(output_root),
+        Path(figures_root),
+    )

carnopy/backends/__init__.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from importlib import import_module
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from carnopy.backends.base import PropertyBackend
+    from carnopy.backends.coolprop import CoolPropBackend
+
+__all__ = ["CoolPropBackend", "PropertyBackend"]
+
+_LAZY_EXPORTS = {
+    "CoolPropBackend": ("carnopy.backends.coolprop", "CoolPropBackend"),
+    "PropertyBackend": ("carnopy.backends.base", "PropertyBackend"),
+}
+
+
+def __getattr__(name: str) -> Any:
+    try:
+        module_name, attribute_name = _LAZY_EXPORTS[name]
+    except KeyError as exc:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}") from exc
+    value = getattr(import_module(module_name), attribute_name)
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(__all__))

carnopy/backends/base.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import Protocol
+
+from carnopy.domain.failures import BackendResult
+
+
+class PropertyBackend(Protocol):
+    @property
+    def name(self) -> str: ...
+
+    @property
+    def version(self) -> str: ...
+
+    def list_fluids(self) -> list[str]: ...
+
+    def aliases_for(self, canonical_fluid: str) -> list[str]: ...
+
+    def canonicalize_fluid(self, fluid: str) -> str: ...
+
+    def initialize_reference_states(self, fluids: list[str]) -> None: ...
+
+    def phase(
+        self,
+        fluid: str,
+        input1: str,
+        value1: float,
+        input2: str,
+        value2: float,
+    ) -> BackendResult[str]: ...
+
+    def property(
+        self,
+        output: str,
+        fluid: str,
+        input1: str,
+        value1: float,
+        input2: str,
+        value2: float,
+    ) -> BackendResult[float]: ...
+
+    def fluid_constant(self, output: str, fluid: str) -> BackendResult[float]: ...

carnopy/backends/coolprop.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from functools import cached_property
+
+import CoolProp
+import CoolProp.CoolProp as CP
+
+from carnopy.domain.failures import BackendInitializationError, BackendResult
+
+
+class CoolPropBackend:
+    @property
+    def name(self) -> str:
+        return "coolprop"
+
+    @property
+    def version(self) -> str:
+        return str(CoolProp.__version__)
+
+    @cached_property
+    def _aliases(self) -> dict[str, str]:
+        aliases: dict[str, str] = {}
+        for canonical in self.list_fluids():
+            raw_aliases = CP.get_fluid_param_string(canonical, "aliases")
+            names = [canonical, *raw_aliases.split(",")]
+            for name in names:
+                cleaned = name.strip()
+                if cleaned:
+                    aliases[cleaned.casefold()] = canonical
+        return aliases
+
+    def list_fluids(self) -> list[str]:
+        return sorted(str(fluid) for fluid in CP.FluidsList())
+
+    def aliases_for(self, canonical_fluid: str) -> list[str]:
+        raw = CP.get_fluid_param_string(canonical_fluid, "aliases")
+        aliases = {canonical_fluid}
+        aliases.update(name.strip() for name in raw.split(",") if name.strip())
+        return sorted(aliases)
+
+    def canonicalize_fluid(self, fluid: str) -> str:
+        if any(token in fluid for token in ("::", "&", "[", "]")):
+            raise ValueError(
+                f"mixtures and backend-prefixed fluid strings are unsupported: {fluid!r}"
+            )
+        try:
+            return self._aliases[fluid.strip().casefold()]
+        except KeyError as exc:
+            raise ValueError(f"unsupported CoolProp pure fluid {fluid!r}") from exc
+
+    def initialize_reference_states(self, fluids: list[str]) -> None:
+        for fluid in fluids:
+            try:
+                CP.set_reference_state(fluid, "DEF")
+            except Exception as exc:
+                raise BackendInitializationError(
+                    f"failed to set CoolProp DEF reference state for {fluid}: {exc}"
+                ) from exc
+
+    def phase(
+        self,
+        fluid: str,
+        input1: str,
+        value1: float,
+        input2: str,
+        value2: float,
+    ) -> BackendResult[str]:
+        try:
+            value = str(CP.PhaseSI(input1, value1, input2, value2, fluid))
+        except Exception as exc:
+            return BackendResult.failure(
+                layer="backend",
+                code="backend_phase_call_failed",
+                message="CoolProp phase evaluation failed",
+                error=exc,
+            )
+        return BackendResult.success(value)
+
+    def property(
+        self,
+        output: str,
+        fluid: str,
+        input1: str,
+        value1: float,
+        input2: str,
+        value2: float,
+    ) -> BackendResult[float]:
+        try:
+            value = float(CP.PropsSI(output, input1, value1, input2, value2, fluid))
+        except Exception as exc:
+            return BackendResult.failure(
+                layer="backend",
+                code="backend_property_call_failed",
+                message=f"CoolProp property evaluation failed for {output}",
+                error=exc,
+            )
+        return BackendResult.success(value)
+
+    def fluid_constant(self, output: str, fluid: str) -> BackendResult[float]:
+        try:
+            value = float(CP.PropsSI(output, fluid))
+        except Exception as exc:
+            return BackendResult.failure(
+                layer="backend",
+                code="backend_property_call_failed",
+                message=f"CoolProp fluid constant evaluation failed for {output}",
+                error=exc,
+            )
+        return BackendResult.success(value)