fram-core 0.0.0__py3-none-any.whl → 0.1.0a2__py3-none-any.whl

framcore/utils/loaders.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from framcore.events import send_warning_event
+
+if TYPE_CHECKING:
+    from framcore import Model
+    from framcore.loaders import Loader
+
+
+def add_loaders_if(loaders: set, value: object | None) -> None:
+    """Call value.add_loaders(loaders) if value is not None."""
+    _check_type(loaders, "loaders", set)
+    if value is None:
+        return
+    value.add_loaders(loaders)
+
+
+def add_loaders(loaders: set[Loader], model: Model) -> None:
+    """Add all loaders stored in Model to loaders set."""
+    from framcore import Model  # noqa: PLC0415
+    from framcore.components import Component, Flow, Node  # noqa: PLC0415
+    from framcore.curves import Curve  # noqa: PLC0415
+    from framcore.expressions import Expr  # noqa: PLC0415
+    from framcore.timevectors import TimeVector  # noqa: PLC0415
+    from framcore.utils import get_supported_components  # noqa: PLC0415
+
+    _check_type(loaders, "loaders", set)
+    _check_type(model, "model", Model)
+
+    data = model.get_data()
+    components = dict()
+
+    for key, value in data.items():
+        if isinstance(value, Expr):
+            value.add_loaders(loaders)
+
+        elif isinstance(value, TimeVector | Curve):
+            loader = value.get_loader()
+            if loader is not None:
+                loaders.add(loader)
+
+        elif isinstance(value, Component):
+            components[key] = value
+
+    graph: dict[str, Flow | Node] = get_supported_components(components, (Flow, Node), tuple())
+
+    for c in graph.values():
+        c.add_loaders(loaders)
+
+
+def replace_loader_path(loaders: set[Loader], old: Path, new: Path) -> None:
+    """Replace old path with new for all loaders using old path."""
+    from framcore.loaders import FileLoader  # noqa: PLC0415
+
+    _check_type(loaders, "loaders", set)
+
+    new = _check_path(new, "new", make_absolute=True)
+    old = _check_path(old, "old", error_if_not_absolute=True)
+
+    for loader in loaders:
+        try:
+            source = loader.get_source()
+        except Exception:
+            send_warning_event(f"loader.get_source() failed for {loader}. Skipping this one.")
+            continue
+
+        if isinstance(source, Path) and old in source.parents:
+            loader.set_source(new_source=new / source.relative_to(old))
+
+        if isinstance(loader, FileLoader) and not isinstance(source, Path):
+            send_warning_event(f"FileLoader.get_source() does not return Path as it should for loader {loader}. Instead of Path, got {source}")
+
+
+def _check_type(value, name, expected) -> None:  # noqa: ANN001
+    if not isinstance(value, expected):
+        message = f"Expected {name} to be {type(expected).__name__}. Got Got {type(value).__name__}"
+        raise TypeError(message)
+
+
+def _check_path(
+    path: Path,
+    new_old: str,
+    make_absolute: bool = False,
+    error_if_not_absolute: bool = False,
+) -> Path:
+    if not isinstance(path, Path):
+        message = f"{new_old} must be Path. Got {path}"
+        raise ValueError(message)
+    if make_absolute and not path.is_absolute():
+        path = path.resolve()
+    if error_if_not_absolute and not path.is_absolute():
+        message = f"{new_old} must be an absolute Path. Got {path}"
+        raise ValueError(message)
+    return path

framcore/utils/node_flow_utils.py

@@ -0,0 +1,236 @@
+from __future__ import annotations  # NB! added for type hint to work
+
+from collections import defaultdict
+from typing import TYPE_CHECKING
+
+from framcore import Base
+from framcore.components import Component, Flow, Node
+from framcore.utils import get_supported_components
+
+if TYPE_CHECKING:
+    from framcore import Model
+
+
+class FlowInfo(Base):
+    """Holds info about one or two related Arrows of a Flow."""
+
+    def __init__(
+        self,
+        category: str,
+        node_out: str | None = None,
+        commodity_out: str | None = None,
+        node_in: str | None = None,
+        commodity_in: str | None = None,
+    ) -> None:
+        """
+        Based on its arrows, we derive properties about a Flow.
+
+        We use this class to store such info.
+        """
+        self.category = category
+        self.node_out = node_out
+        self.commodity_out = commodity_out
+        self.node_in = node_in
+        self.commodity_in = commodity_in
+
+
+def _check_type(value: object, expected) -> None:  # noqa: ANN001
+    assert isinstance(value, expected), f"Expected {expected}. Got {type(value.__name__)}."
+
+
+def get_node_to_commodity(data: dict[str, object]) -> dict[str, str]:
+    """Return dict with commodity (str) for each node id (str) in data."""
+    _check_type(data, dict)
+
+    components = {k: v for k, v in data.items() if isinstance(v, Component)}
+    for k in components:
+        assert isinstance(k, str), f"Got invalid key {k}"
+
+    g = get_supported_components(components, (Node, Flow), tuple())
+
+    out = dict()
+    for k, v in g.items():
+        if isinstance(v, Node):
+            _check_type(k, str)
+            out[k] = v.get_commodity()
+    return out
+
+
+def get_flow_infos(flow: Flow, node_to_commodity: dict[str, str]) -> list[FlowInfo]:
+    """Get flow infos from analysis of all its arrows."""
+    _check_type(flow, Flow)
+    _check_type(node_to_commodity, dict)
+
+    arrows = flow.get_arrows()
+
+    if len(arrows) == 1:
+        arrow = next(iter(arrows))
+        node_id = arrow.get_node()
+
+        if node_id not in node_to_commodity:
+            message = f"node_id {node_id} missing from node_to_commodity for flow\n{flow}"
+            raise RuntimeError(message)
+
+        commodity = node_to_commodity[node_id]
+        if arrow.is_ingoing():
+            info = FlowInfo(
+                "direct_in",
+                node_in=node_id,
+                commodity_in=commodity,
+            )
+        else:
+            info = FlowInfo(
+                "direct_out",
+                node_out=node_id,
+                commodity_out=commodity,
+            )
+        return [info]
+
+    seen: set[tuple[str, str]] = set()
+    infos: list[FlowInfo] = []
+    for x in arrows:
+        for y in arrows:
+            if x is y:
+                continue
+
+            if x.is_ingoing() != y.is_ingoing():
+                arrow_in = x if x.is_ingoing() else y
+                arrow_out = x if y.is_ingoing() else y
+
+                node_in = arrow_in.get_node()
+                node_out = arrow_out.get_node()
+
+                if node_in not in node_to_commodity:
+                    message = f"node_in {node_in} missing from node_to_commodity for flow\n{flow}"
+                    raise RuntimeError(message)
+
+                if node_out not in node_to_commodity:
+                    message = f"node_out {node_out} missing from node_to_commodity for flow\n{flow}"
+                    raise RuntimeError(message)
+
+                commodity_in = node_to_commodity[node_in]
+                commodity_out = node_to_commodity[node_out]
+
+                info = FlowInfo(
+                    category="transport" if commodity_in == commodity_out else "conversion",
+                    node_in=node_in,
+                    commodity_in=commodity_in,
+                    node_out=node_out,
+                    commodity_out=commodity_out,
+                )
+                key = (node_in, node_out)
+                if key in seen:
+                    continue
+
+                infos.append(info)
+                seen.add(key)
+
+    for arrow in arrows:
+        node = arrow.get_node()
+        if any(node in [info.node_in, info.node_out] for info in infos):
+            continue
+        node_id = arrow.get_node()
+        commodity = node_to_commodity[node_id]
+        if arrow.is_ingoing():
+            info = FlowInfo(
+                "direct_in",
+                node_in=node_id,
+                commodity_in=commodity,
+            )
+        else:
+            info = FlowInfo(
+                "direct_out",
+                node_out=node_id,
+                commodity_out=commodity,
+            )
+        infos.append(info)
+
+    return infos
+
+
+def get_component_to_nodes(data: Model | dict[str, object]) -> dict[str, set[str]]:
+    """For each str key in data where value is a Comonent find all Node id str in data directly connected to the Component."""
+    from framcore import Model  # noqa: PLC0415
+
+    _check_type(data, Model | dict)
+
+    if isinstance(data, Model):
+        data = data.get_data()
+
+    components = {k: v for k, v in data.items() if isinstance(v, Component)}
+    for k in components:
+        assert isinstance(k, str), f"Got invalid key {k}"
+
+    g = get_supported_components(components, (Node, Flow), tuple())
+
+    nodes = {k: v for k, v in g.items() if isinstance(v, Node)}
+    flows = {k: v for k, v in g.items() if isinstance(v, Flow)}
+
+    domain_nodes = {k: v for k, v in nodes.items() if (k in components) and isinstance(v, Node)}
+    assert all(isinstance(v, Node) for v in domain_nodes.values())
+
+    parent_keys = {v: k for k, v in components.items()}
+
+    out = defaultdict(set)
+    for flow in flows.values():
+        parent_key = parent_keys[flow.get_top_parent()]
+        for a in flow.get_arrows():
+            node_id = a.get_node()
+            if node_id in domain_nodes:
+                out[parent_key].add(node_id)
+
+    return out
+
+
+def get_transports_by_commodity(data: Model | dict[str, object], commodity: str) -> dict[str, tuple[str, str]]:
+    """Return dict with key component_id and value (from_node_id, to_node_id) where both nodes belong to given commodity."""
+    from framcore import Model  # noqa: PLC0415
+
+    _check_type(data, Model | dict)
+    _check_type(commodity, str)
+
+    if isinstance(data, Model):
+        data = data.get_data()
+
+    components = {k: v for k, v in data.items() if isinstance(v, Component)}
+    for k in components:
+        assert isinstance(k, str), f"Got invalid key {k}"
+
+    node_to_commodity = get_node_to_commodity(components)
+
+    g = get_supported_components(components, (Node, Flow), tuple())
+
+    flows = {k: v for k, v in g.items() if isinstance(v, Flow)}
+
+    parent_keys = {v: k for k, v in components.items()}
+
+    out = dict()
+    for flow in flows.values():
+        parent_key = parent_keys[flow.get_top_parent()]
+        infos = get_flow_infos(flow, node_to_commodity)
+        if len(infos) != 1:
+            continue
+        info = infos[0]
+        if info.category != "transport":
+            continue
+        if info.commodity_in != commodity:
+            continue
+        out[parent_key] = (info.node_out, info.node_in)
+
+    return out
+
+
+def is_transport_by_commodity(flow: Flow, node_to_commodity: dict[str, str], commodity: str) -> bool:
+    """Return True if flow is a transport of the given commodity."""
+    _check_type(flow, Flow)
+    _check_type(node_to_commodity, dict)
+    arrows = flow.get_arrows()
+    try:
+        x, y = tuple(arrows)
+        opposite_directions = x.is_ingoing() != y.is_ingoing()
+        x_commodity = node_to_commodity[x.get_node()]
+        y_commodity = node_to_commodity[y.get_node()]
+        correct_commodity = x_commodity == y_commodity == commodity
+        return opposite_directions and correct_commodity
+    except Exception:
+        return False

framcore/utils/storage_subsystems.py

@@ -0,0 +1,107 @@
+from __future__ import annotations  # NB! added for type hint to work
+
+from collections import defaultdict
+
+from framcore import Model
+from framcore.components import Component, Flow, Node
+from framcore.utils import get_supported_components
+
+
+# TODO: Finish implementation, test and demo
+def get_storage_subsystems(domain_components: dict[str, Component] | Model) -> dict[str, set[str]]:
+    if isinstance(domain_components, Model):
+        domain_components = {k: v for k, v in domain_components.get_data() if isinstance(v, Component)}
+
+    # translate domain_components to graph consisting of just Flow and Node components
+    graph: dict[str, Flow | Node] = get_supported_components(
+        components=domain_components,
+        supported_types=(Node, Flow),
+    )
+
+    abstract_subsystems, __ = get_one_commodity_storage_subsystems(graph, include_boundaries=True)
+
+    # TODO: Use Component.get_top_level to lift abstract_subsystems back to domain_components
+    domain_subsystems = abstract_subsystems
+
+    return domain_subsystems
+
+
+def get_one_commodity_storage_subsystems(
+    graph: dict[str, Node | Flow],
+    include_boundaries: bool,
+) -> dict[str, tuple[str, set[str], set[str]]]:
+    """
+    Group all storage subsystems belonging to same commodity.
+
+    Returns dict[subsystem_id, (domain_commodity, member_component_ids, boundary_domain_commodities)]
+
+    The boundary_domain_commodities of the output is a set of boundary commodities.
+    Some algorithms can only handle one boundary commodity, so this output is useful
+    to verify that those conditions apply, and to derive conversion factor unit,
+    which need both storage_commodity unit and boundray_commodity unit.
+
+    If include_boundaries is False only nodes with same commodity as storage_node will
+    be included in the subsystem.
+    """
+    if not all(isinstance(c, Flow | Node) for c in graph.values()):
+        invalid = {k: v for k, v in graph.items() if not isinstance(v, Flow | Node)}
+        message = f"All values in graph must be Flow or Node objects. Found invalid objects: {invalid}"
+        raise ValueError(message)
+
+    flows: dict[str, Flow] = {k: v for k, v in graph.items() if isinstance(v, Flow)}
+    nodes: dict[str, Node] = {k: v for k, v in graph.items() if isinstance(v, Node)}
+
+    storage_nodes: dict[str, Node] = {k: v for k, v in nodes.items() if v.get_storage()}
+
+    node_to_flows: dict[str, set[str]] = defaultdict(set)
+    flow_to_nodes: dict[str, set[str]] = defaultdict(set)
+    for flow_id, flow in flows.items():
+        for arrow in flow.get_arrows():
+            node_id = arrow.get_node()
+            node_to_flows[node_id].add(flow_id)
+            flow_to_nodes[flow_id].add(node_id)
+
+    out = dict()
+    allocated: set[str] = set()
+    for storage_node_id, storage_node in storage_nodes.items():
+        if storage_node_id in allocated:
+            continue
+
+        subsystem_id = storage_node_id
+        storage_commodity = storage_node.get_commodity()
+
+        member_component_ids: set[str] = set()
+        boundary_commodities: set[str] = set()
+
+        visited: set[str] = set()
+        remaining: set[str] = set()
+
+        remaining.add(storage_node_id)
+
+        while remaining:
+            component_id = remaining.pop()
+            if component_id in visited:
+                continue
+
+            visited.add(component_id)
+
+            if component_id in nodes:
+                node: Node = nodes[component_id]
+                node_commodity = node.get_commodity()
+
+                if node_commodity == storage_commodity:
+                    allocated.add(component_id)
+                    remaining.update(node_to_flows.get(component_id, set()))
+                else:
+                    boundary_commodities.add(node_commodity)
+
+                if include_boundaries or node_commodity == storage_commodity:
+                    member_component_ids.add(component_id)
+
+            else:
+                remaining.update(flow_to_nodes.get(component_id, set()))
+                member_component_ids.add(component_id)
+
+        out[subsystem_id] = (storage_commodity, member_component_ids, boundary_commodities)
+
+    return out

fram_core-0.0.0.dist-info/METADATA

@@ -1,5 +0,0 @@
-Metadata-Version: 2.4
-Name: fram-core
-Version: 0.0.0
-Summary: Coming soon...
-Author-email: NVE <alro@nve.no>

fram_core-0.0.0.dist-info/RECORD

@@ -1,4 +0,0 @@
-fram_core-0.0.0.dist-info/METADATA,sha256=MXr1hQAqr_E4d7YDIhkuSeF-G0jYcTZJKTqr5fwOxPo,114
-fram_core-0.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fram_core-0.0.0.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-fram_core-0.0.0.dist-info/RECORD,,

fram_core-0.0.0.dist-info/top_level.txt

@@ -1 +0,0 @@
-