fram-core 0.1.0a1__py3-none-any.whl → 0.1.1__py3-none-any.whl

framcore/timevectors/ListTimeVector.py

@@ -8,7 +8,7 @@ from framcore.timevectors.TimeVector import TimeVector  # NB! full import path n
 
 
 class ListTimeVector(TimeVector):
-    """ListTimeVector class for TimeVectors with a numpy array of values. Subclass of TimeVector."""
+    """TimeVector with a numpy array of values paired with a timeindex."""
 
     def __init__(
         self,
@@ -37,18 +37,13 @@ class ListTimeVector(TimeVector):
         Raises:
             ValueError: When both is_max_level and is_zero_one_profile is not None. This would mean the TimeVector
                         represents both a level and a profile, which is not allowed.
+            ValueError: When the shape of the vector does not match the number of periods in the timeindex.
 
         """
-        if (is_max_level is not None and is_zero_one_profile is not None) or (is_max_level is None and is_zero_one_profile is None):
-            message = (
-                f"Input arguments for {self}: Must have exactly one 'non-None'"
-                "value for is_max_level and is_zero_one_profile. "
-                "A TimeVector is either a level or a profile."
-            )
-            raise ValueError(message)
-        # assert vector.shape == (timeindex.get_num_periods(),), (
-        #     f"Vector shape {vector.shape} does not match timeindex num_periods {timeindex.get_num_periods()}"
-        # )
+        if vector.shape != (timeindex.get_num_periods(),):
+            msg = f"Vector shape {vector.shape} does not match number of periods {timeindex.get_num_periods()} of timeindex ({timeindex})."
+            raise ValueError(msg)
+
         self._timeindex = timeindex
         self._vector = vector
         self._unit = unit
@@ -56,7 +51,16 @@ class ListTimeVector(TimeVector):
         self._is_max_level = is_max_level
         self._is_zero_one_profile = is_zero_one_profile
 
-    def __eq__(self, other):
+        self._check_type(timeindex, TimeIndex)
+        self._check_type(vector, np.ndarray)
+        self._check_type(unit, (str, type(None)))
+        self._check_type(is_max_level, (bool, type(None)))
+        self._check_type(is_zero_one_profile, (bool, type(None)))
+        self._check_type(reference_period, (ReferencePeriod, type(None)))
+
+        self._check_is_level_or_profile()
+
+    def __eq__(self, other: object) -> None:
         """Check equality between two ListTimeVector objects."""
         if not isinstance(other, ListTimeVector):
             return NotImplemented
@@ -73,9 +77,9 @@ class ListTimeVector(TimeVector):
         """Return hash of ListTimeVector object."""
         return hash((self._timeindex, self._vector.tobytes(), self._unit, self._is_max_level, self._is_zero_one_profile, self._reference_period))
 
-    def __repr__(self) -> str:  # TODO: Also timeindex and reference_period
+    def __repr__(self) -> str:
         """Return the string representation of the ListTimeVector."""
-        return f"ListTimeVector(timeindex={self._timeindex}, vector={self._vector}, unit={self._unit})"
+        return f"ListTimeVector(timeindex={self._timeindex}, vector={self._vector}, unit={self._unit}, reference_period={self._reference_period})"
 
     def get_vector(self, is_float32: bool) -> NDArray:
         """Get the vector of the TimeVector as a numpy array."""

framcore/timevectors/LoadedTimeVector.py

@@ -30,19 +30,12 @@ class LoadedTimeVector(TimeVector):
         self._loader = loader
         self._check_type(self._vector_id, str)
         self._check_type(self._loader, TimeVectorLoader)
-
         self._is_max_level = self._loader.is_max_level(self._vector_id)
         self._is_zero_one_profile = self._loader.is_zero_one_profile(self._vector_id)
         self._unit = self._loader.get_unit(self._vector_id)
         self._reference_period = self._loader.get_reference_period(self._vector_id)
 
-        if (self._is_max_level is not None and self._is_zero_one_profile is not None) or (self._is_max_level is None and self._is_zero_one_profile is None):
-            message = (
-                f"Values for {self._loader} is_max_level ({self._is_max_level}) and is_zero_one_profile"
-                f" ({self._is_zero_one_profile}) with time vector {self} Must have exactly one 'non-None' value."
-                " A TimeVector is either a level or a profile."
-            )
-            raise ValueError(message)
+        self._check_is_level_or_profile()
 
     def __repr__(self) -> str:
         """Overwrite string representation of LoadedTimeVector objects."""

framcore/timevectors/ReferencePeriod.py

@@ -5,15 +5,25 @@ class ReferencePeriod(Base):
     """ReferencePeriod class represents a period of one or more years."""
 
     def __init__(self, start_year: int, num_years: int) -> None:
-        """Initialize a ReferencePeriod with the start year and number of years."""
+        """
+        Initialize a ReferencePeriod with the start year and number of years.
+
+        Args:
+            start_year (int): The first year in the reference period. Must be a positive integer.
+            num_years (int): The number of years in the reference period. Must be a positive non-zero integer.
+
+        """
         self._check_type(start_year, int)
         self._check_type(num_years, int)
+
         if start_year < 0:
             message = f"start_year must be a positive integer. Got {start_year}."
             raise ValueError(message)
-        if num_years < 0:
-            message = f"num_years must be a positive integer. Got {num_years}."
+
+        if num_years <= 0:
+            message = f"num_years must be a positive non-zero integer. Got {num_years}."
             raise ValueError(message)
+
         self._start_year = start_year
         self._num_years = num_years
 

framcore/timevectors/TimeVector.py

@@ -16,7 +16,7 @@ if TYPE_CHECKING:
 
 # TODO: Floating point precision
 class TimeVector(Base, ABC):
-    """TimeVector interface class."""
+    """TimeVector interface class for defining timeseries data."""
 
     def __init__(self) -> None:
         """Initialize the TimeVector class."""
@@ -50,12 +50,9 @@ class TimeVector(Base, ABC):
     @abstractmethod
     def is_max_level(self) -> bool | None:
         """
-        Check if TimeVector is a level representing max Volume/Capacity.
+        Whether the TimeVector represents the maximum level, average level given a reference period, or not a level at all.
 
-        Returns:
-            True - vector is a level representing max Volume/Capacity.
-            False - vector is a level representing average Volume/Capacity over a given reference period.
-            None - vector is not a level.
+        See LevelProfile for a description of Level (max or avg) and Profile (max one or mean one), and their formats.
 
         """
         pass
@@ -63,12 +60,9 @@ class TimeVector(Base, ABC):
     @abstractmethod
     def is_zero_one_profile(self) -> bool | None:
         """
-        Check if TimeVector is a profile with values between zero and one.
+        Whether the TimeVector represents a profile with values between 0 and 1, a profile with average 1 over a given reference period, or is not a profile.
 
-        Returns:
-            True - vector is a profile with values between zero and one.
-            False - vector is a profile where the mean value is 1 given a reference period.
-            None - vector is not a profile.
+        See LevelProfile for a description of Level (max or avg) and Profile (max one or mean one), and their formats.
 
         """
         pass
@@ -90,5 +84,25 @@ class TimeVector(Base, ABC):
 
     @abstractmethod
     def get_loader(self) -> TimeVectorLoader | None:
-        """Get the TimeVectorLoader of the TimeVector if self has one."""
+        """
+        Get the TimeVectorLoader of the TimeVector if self has one.
+
+        TimeVectors can store timeseries data in Loaders that point to databases. Data is only retrieved and cached when the TimeVector is queried.
+        """
         pass
+
+    """
+    Checks that the TimeVector is either a level or a profile.
+
+    Raises:
+        ValueError: If both is_max_level and is_zero_one_profile are None or both are not None.
+    """
+
+    def _check_is_level_or_profile(self) -> None:
+        """Ensure that the TimeVector is either a level or a profile."""
+        if (self.is_max_level() is not None and self.is_zero_one_profile() is not None) or (self.is_max_level() is None and self.is_zero_one_profile() is None):
+            message = (
+                f"Invalid input arguments for {self}: Must have exactly one 'non-None' value for "
+                "is_max_level and is_zero_one_profile. A TimeVector is either a level or a profile."
+            )
+            raise ValueError(message)

framcore/utils/__init__.py

@@ -1,6 +1,5 @@
 # framcore/lib/__init__.py
 
-
 from framcore.utils.get_supported_components import get_supported_components
 from framcore.utils.node_flow_utils import (
     FlowInfo,

framcore/utils/get_regional_volumes.py

@@ -176,11 +176,11 @@ def _get_vector(
 # TODO: More options: node_category, consumption_category, production_category, with_trade_partners
 
 
-def _check_category(category, flow_id, flow_info) -> None:
+def _check_category(category: str, flow_id: str, flow_info: FlowInfo) -> None:
     pass
 
 
-def get_regional_volumes(
+def get_regional_volumes(  # noqa C901
     db: Model | QueryDB,
     commodity: str,
     node_category: str,
@@ -191,7 +191,25 @@ def get_regional_volumes(
     unit: str,
     is_float32: bool = True,
 ) -> RegionalVolumes:
-    """Calculate aggregated production, consumption, import and export."""
+    """
+    Calculate aggregated production, consumption, import and export for member in node_category.
+
+    Decompose the model components into nodes and flows. Analyze the flows to determine their contribution to production, consumption, import, and export if
+    they are associated with the specified commodity. Group these contributions based on the provided node_category, production_category, and
+    consumption_category metadata.
+
+    Args:
+        db (Model | QueryDB): Model or QueryDB to use
+        commodity (str): Commodity to consider
+        node_category (str): Meta key for node category to group the results by
+        production_category (str): Meta key for production category to group the results by
+        consumption_category (str): Meta key for consumption category to group the results by
+        data_period (SinglePeriodTimeIndex): Consider results for this data period
+        scenario_period (FixedFrequencyTimeIndex): Consider results for this scenario period
+        unit (str): Unit to use for the results
+        is_float32 (bool): Use float32 for calculations and results if True
+
+    """
     db = _load_model_and_create_model_db(db)
 
     if not isinstance(is_float32, bool):

framcore/utils/get_supported_components.py

@@ -6,7 +6,7 @@ def get_supported_components(
     supported_types: tuple[type[Component]],
     forbidden_types: tuple[type[Component]],
 ) -> dict[str, Component]:
-    """Return simplified version of components in compliance with specified component types."""
+    """Return simplified version of components in compliance with specified component types.See description in Component."""
     output: dict[str, Component] = {}
     errors: list[str] = []
 

framcore/utils/global_energy_equivalent.py

@@ -11,23 +11,31 @@ def get_hydro_downstream_energy_equivalent(
     power_node: str | None = None,
 ) -> Expr:
     """
-    Get the sum downstream energy equivalent for a hydro module.
+    Get the expression for the sum downstream energy equivalent for a hydro module.
+
+    - If power node is given, only count downstream energy equivalents that are connected to the power node.
+    - Energy equivalents are collected from hydro generators downstream, and the main topology follows the release_to attribute.
+    - Transport pumps are included in the downstream topology, but counted as negative energy equivalents.
+
+    Args:
+        data (dict[str, Component | TimeVector | Curve | Expr]): The dict containing the components.
+        module_name (str): The name of the hydro module to start from.
+        power_node (str): Optional power node to filter energy equivalents.
 
-    Either count all downstream energy equivalents, or only those that are connected to the given power_node.
     """
     if data[module_name].get_pump() and data[module_name].get_pump().get_from_module() == module_name:  # transport pump
         pump_power_node = data[module_name].get_pump().get_power_node()
         pump_to = data[module_name].get_pump().get_to_module()
         energy_equivalent = get_hydro_downstream_energy_equivalent(data, pump_to, power_node)  # continue downstream of pump_to module
         if power_node in (pump_power_node, None):
-            return energy_equivalent - data[module_name].get_pump().get_energy_eq().get_level()  # pumps has negative energy equivalents
+            return energy_equivalent - data[module_name].get_pump().get_energy_equivalent().get_level()  # pumps has negative energy equivalents
         return energy_equivalent
 
     energy_equivalent = 0
     if data[module_name].get_generator():  # hydro generator
         module_power_node = data[module_name].get_generator().get_power_node()
         if power_node in (module_power_node, None):
-            energy_equivalent += data[module_name].get_generator().get_energy_eq().get_level()
+            energy_equivalent += data[module_name].get_generator().get_energy_equivalent().get_level()
     if data[module_name].get_release_to():  # continue from release_to module
         release_to = data[module_name].get_release_to()
         energy_equivalent += get_hydro_downstream_energy_equivalent(data, release_to, power_node)
@@ -35,7 +43,16 @@ def get_hydro_downstream_energy_equivalent(
 
 
 def set_global_energy_equivalent(data: dict[str, Component | TimeVector | Curve | Expr], metakey_energy_eq_downstream: str) -> None:
-    """Set the downstream energy equivalent of all HydroModules. Set to 1 for other types of components?."""
+    """
+    Loop through data dict and set the downstream energy equivalent for all HydroModules.
+
+    Send a warning event if a HydroModule has no downstream energy equivalents.
+
+    Args:
+        data (dict[str, Component | TimeVector | Curve | Expr]): The dict containing the components.
+        metakey_energy_eq_downstream (str): The meta key to use for storing the downstream energy equivalent.
+
+    """
     for module_name, module in data.items():
         if isinstance(module, HydroModule) and module.get_reservoir():
             energy_equivalent = get_hydro_downstream_energy_equivalent(data, module_name)

framcore/utils/isolate_subnodes.py

@@ -22,11 +22,20 @@ def _is_member(node: Node, meta_key: str, members: set[str]) -> bool:
     return value in members
 
 
-def isolate_subnodes(model: Model, commodity: str, meta_key: str, members: list[str]) -> None:
+def isolate_subnodes(model: Model, commodity: str, meta_key: str, members: list[str]) -> None:  # noqa: PLR0915, C901
     """
-    Delete nodes of commodity named using meta_key except members and boundary nodes and flows.
+    For components in model, delete all nodes of commodity except member nodes, and their flows and boundary nodes.
+
+    - Keep member nodes and all flows between them.
+    - Set boundary nodes exogenous and keep boundary flows into or out from member nodes.
+    - Delete all other nodes of commodity and all other flows pointing to them.
+
+    Args:
+        model (Model): Model to modify
+        commodity (str): Commodity of nodes to consider
+        meta_key (str): Meta key to use to identify members
+        members (List[str]): List of meta key values identifying member nodes
 
-    Boudary nodes are set exogenous and all flows pointing to them except boundary flows into or out from member nodes.
     """
     t = time()
 

framcore/utils/loaders.py

@@ -20,12 +20,12 @@ def add_loaders_if(loaders: set, value: object | None) -> None:
 
 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
+    from framcore import Model
+    from framcore.components import Component, Flow, Node
+    from framcore.curves import Curve
+    from framcore.expressions import Expr
+    from framcore.timevectors import TimeVector
+    from framcore.utils import get_supported_components
 
     _check_type(loaders, "loaders", set)
     _check_type(model, "model", Model)
@@ -53,7 +53,7 @@ def add_loaders(loaders: set[Loader], model: Model) -> None:
 
 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
+    from framcore.loaders import FileLoader
 
     _check_type(loaders, "loaders", set)
 

framcore/utils/node_flow_utils.py

@@ -56,7 +56,7 @@ def get_node_to_commodity(data: dict[str, object]) -> dict[str, str]:
     return out
 
 
-def get_flow_infos(flow: Flow, node_to_commodity: dict[str, str]) -> list[FlowInfo]:
+def get_flow_infos(flow: Flow, node_to_commodity: dict[str, str]) -> list[FlowInfo]:  # noqa: C901
     """Get flow infos from analysis of all its arrows."""
     _check_type(flow, Flow)
     _check_type(node_to_commodity, dict)
@@ -149,8 +149,8 @@ def get_flow_infos(flow: Flow, node_to_commodity: dict[str, str]) -> list[FlowIn
 
 
 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
+    """For each str key in data where value is a Component find all Node id str in data directly connected to the Component."""
+    from framcore import Model
 
     _check_type(data, Model | dict)
 
@@ -184,7 +184,7 @@ def get_component_to_nodes(data: Model | dict[str, object]) -> dict[str, set[str
 
 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
+    from framcore import Model
 
     _check_type(data, Model | dict)
     _check_type(commodity, str)

framcore/utils/storage_subsystems.py

@@ -8,7 +8,7 @@ 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]]:
+def get_storage_subsystems(domain_components: dict[str, Component] | Model) -> dict[str, set[str]]:  # noqa: D103
     if isinstance(domain_components, Model):
         domain_components = {k: v for k, v in domain_components.get_data() if isinstance(v, Component)}
 
@@ -21,12 +21,11 @@ def get_storage_subsystems(domain_components: dict[str, Component] | Model) -> d
     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 abstract_subsystems
 
-    return domain_subsystems
 
 
-def get_one_commodity_storage_subsystems(
+def get_one_commodity_storage_subsystems(  # noqa: C901
     graph: dict[str, Node | Flow],
     include_boundaries: bool,
 ) -> dict[str, tuple[str, set[str], set[str]]]:

fram_core-0.1.0a1.dist-info/RECORD

@@ -1,100 +0,0 @@
-framcore/Base.py,sha256=2MP0T1HAjU3gqkSvdGnbvd3t1JZmdXGCcwueETIhrrs,5326
-framcore/Model.py,sha256=TraN6dRQoJgm4veePEVszpdGAMGiTJA1dKSG4s_DtZg,2580
-framcore/__init__.py,sha256=5Ryn1oUwtxaPX95dfleE5GVYo9_QSBAwMG8UiUNrg74,128
-framcore/aggregators/Aggregator.py,sha256=n9jL4iAGk_N0An80BJNntkYYaXaQzGW1xGD3oFjUYzk,6473
-framcore/aggregators/HydroAggregator.py,sha256=ubV16QcJ63Uh8g_HzSexsHDFdUszODpBiEfaUhWZ8ko,47174
-framcore/aggregators/NodeAggregator.py,sha256=Zz4D1H42EmDU0jgYJtAR4C0_eRDN6nacLA3guRt_r2M,20716
-framcore/aggregators/WindSolarAggregator.py,sha256=3cHIxYZixTIH8kmkuR8GL6eROd8oU7z5txRVCMOvOrg,19620
-framcore/aggregators/__init__.py,sha256=ZoBqilfv0XhFkYVROBPQhJHzSY1IcvhJmJ_FOo_Z5Pw,426
-framcore/aggregators/_utils.py,sha256=EoRLeGmPC2ds-egPdvDewtaYbRozi6Psyf9DD1PRajk,8337
-framcore/attributes/Arrow.py,sha256=7P5xpXD6MdlIuERGQn9f0ia4-tQVYNiSP6CfMbX3K7Q,10863
-framcore/attributes/ElasticDemand.py,sha256=sG5wUTw17PQA_8YESaPMnRjUbr7nm6mSmkmuHoGlqJU,3024
-framcore/attributes/ReservoirCurve.py,sha256=EVzCMPM5OELB9U9_BAYmDOEFF4Pd6LwwmDOzRpkRVME,813
-framcore/attributes/SoftBound.py,sha256=7bW6KlSsKFvh8F6UPjC5PoLMGI7gClNo-dQrwAQHD5k,417
-framcore/attributes/StartUpCost.py,sha256=WLZ8mcQWdSyyA0GKIJ2rhMbAU17pHAREBP1Tb-3_4rU,1831
-framcore/attributes/Storage.py,sha256=x6njOhmkR3VvFI3Umn1Jjjd4F6yHWx-ZNNOYYv0lcZs,5335
-framcore/attributes/TargetBound.py,sha256=DHl8CCPynhrcRqTHPhFo9HddhEt489mGqrqUHQPkPhg,433
-framcore/attributes/__init__.py,sha256=SPzgyK4TQSMJ5tWOUmYfUpvWliCbQF8AVQkf6JeEGos,1552
-framcore/attributes/hydro/HydroBypass.py,sha256=ZiAfOiukGvlckCRIlccFqjnAwLiGn1SnN1uqtSgN9H4,1342
-framcore/attributes/hydro/HydroGenerator.py,sha256=ed0jMP808qchxkc4mXrVdtSO0LAGY6ihrjLN8xvdzN0,3207
-framcore/attributes/hydro/HydroPump.py,sha256=Yi54d259CzKpcu44hhWoX3ZxTBqhzlWun1WC5pGfVKw,5915
-framcore/attributes/hydro/HydroReservoir.py,sha256=7rYu530BTX9dJmTYrd_02uPddj290E-ziiZzjh_3Q3k,879
-framcore/attributes/hydro/__init__.py,sha256=isOSLP2TdHOaPcr16EXIkdtx80LVe8ztFPiuGJPC4ao,381
-framcore/attributes/level_profile_attributes.py,sha256=hZEBy_yjTJ4BIDM0qiNsQeO7Kcvr1CNMlv8Oyck7lkM,23340
-framcore/components/Component.py,sha256=GT_scqmDwSE8eLB3ZHcDMGfenRbko7xj4cenm_6Io-Q,3820
-framcore/components/Demand.py,sha256=vUP3hWobtk_Qe7ZGD2bXkLR_9zhaGrB8tKu3SvcvQp0,5399
-framcore/components/Flow.py,sha256=wuqKZ76uIw-OfdEVC-55wok7PmoeRs7KEAR-o2wUC6A,5887
-framcore/components/HydroModule.py,sha256=qpu0Fo4bFJs9kgwHtfwlInOX2UvwB1khdvRHWFWgmYQ,11352
-framcore/components/Node.py,sha256=Kh8Glu0M0UjmEpJhlATXD9xqc7QZEd5HxFdE2EVT58s,2280
-framcore/components/Thermal.py,sha256=MY0iOD870NSptZWpynKUEd8CuLt50s3_265GIiMG4Qc,7666
-framcore/components/Transmission.py,sha256=DlVrkKT8rNTUyQXaO3375S1zKfE1OOkl3QYGB7BhhMU,6842
-framcore/components/_PowerPlant.py,sha256=zDJ5LtYQN2GLa__BaqCLz54mZJil3dOYjICMPurh-U8,2787
-framcore/components/__init__.py,sha256=0N4UMrYi7cYYaZHMIS6HSOli2jEbtct6LsZ0JcwGz5A,568
-framcore/components/wind_solar.py,sha256=YsIPMZQEP81tijneFkeMEfprttu7lX7T5loVmSjSM90,2060
-framcore/curves/Curve.py,sha256=89CsAJpCa_GkQtsBGclUcK8D3ttCyYhs583-_6zE0is,934
-framcore/curves/LoadedCurve.py,sha256=8DiyLeJzydx6Q6MNQonxNGujl3zPma3vINDUN7E8_As,3891
-framcore/curves/__init__.py,sha256=BnzdAZVjPwJcjduramRPPX6NJag-g6aKXPho2PwmGco,170
-framcore/events/__init__.py,sha256=O3lOZukd_ixwbkoOmf2ei_--lKJLVXvyhSHjUDfaXEE,401
-framcore/events/events.py,sha256=mNcHUjWraKyb-gwxeKr5ryOtcN8dCKptRWIYgcxM1p4,1683
-framcore/expressions/Expr.py,sha256=I3m8cy-PNomN6p9088QQf1c4Egei5XEj7JoxwqZC0cY,20614
-framcore/expressions/__init__.py,sha256=J8bNtWRfIpwIi6yZIjFazQXU9ymJbKsYLqPlMUoH028,628
-framcore/expressions/_get_constant_from_expr.py,sha256=bqq-_xRhOrly6GB9Z868icgNqxrrUzobN1zXCq8B6lg,16596
-framcore/expressions/_time_vector_operations.py,sha256=kIMmQYR-U2aAxB5KPWx-zaqLvjvlmiwa2yCnmeNvvRY,29031
-framcore/expressions/_utils.py,sha256=mtruqnHcwpkIufbTFjJvT3iUfN98gN51SQ9e9hS9cUc,2123
-framcore/expressions/queries.py,sha256=PLJVL0CJoJp3okIYyG1QOrR3s9HHfBdZdxuCzrCBHa0,16258
-framcore/expressions/units.py,sha256=9X243DutWfkCbRNzy65frQNKN8tlLLzLvWYtiEyhHcg,6863
-framcore/fingerprints/__init__.py,sha256=YpIj-t6DRrSOmdidchC4qjLHSoZwsdkf9980nHUsnsw,256
-framcore/fingerprints/fingerprint.py,sha256=-e8aweHfPj8VURJqEra14xydVw3E1heB17LWcPFzIZo,9191
-framcore/juliamodels/JuliaModel.py,sha256=S-W_t4Pv-xuzz6lrULmxNPu0No6Zs1CPpb9WW3ECZK0,6596
-framcore/juliamodels/__init__.py,sha256=2ia9EGUQAZD0_f2o0NWdhD0d2z80K_bweohnGNfnpGA,124
-framcore/loaders/__init__.py,sha256=iwlnauyXhH_BAuVIKVmX2vMvU94i_bXI57CE82eM7VA,209
-framcore/loaders/loaders.py,sha256=EYqKeItQS5-zI-n-yOJf_7C_Ojo5VBk143f76joINYA,11254
-framcore/metadata/Div.py,sha256=fIIB9W9fVJEUNzqIWXOJ9ZN3tWE8dB8ap2BdULT2fJw,2428
-framcore/metadata/ExprMeta.py,sha256=zM5u7TXnImEIIVQbUGmcz74LbvNybMIkRYB4913cdiE,1556
-framcore/metadata/LevelExprMeta.py,sha256=AcE4DfJLtMFY69A8H7hzKYSR454O6Z9JTpOQpNnqG1I,567
-framcore/metadata/Member.py,sha256=7dcjqNWCcoGlOqXtqCBXYeN4z_5cIPBFUngcBVKAeas,1877
-framcore/metadata/Meta.py,sha256=P9ESFJlrxxhcY9PNSnnccrsLBulu1v3Kir6agzSrv0I,1173
-framcore/metadata/__init__.py,sha256=rf2oJ5SjlmdD4Fk0svPxHbNZlnzUdt-FPyjjhA8wbhc,350
-framcore/populators/Populator.py,sha256=SraN4QOTsA3yXEVG4z9ohWfPKokssl3uvDJPGh56lrU,4077
-framcore/populators/__init__.py,sha256=jE6tHIvTaPTWcD-yVpBOjDBxI3xFqJh0QASfQexBLCE,119
-framcore/querydbs/CacheDB.py,sha256=vzLEJM8SsvQYMXDE_TdjzicHM6yfJJefzp6u-Qyneys,1707
-framcore/querydbs/ModelDB.py,sha256=XD4jHlmRQHqF7L2euDIMrPZREhr3SXgv0UnqkADLzRw,1039
-framcore/querydbs/QueryDB.py,sha256=IV96mtslktpJMrdxgrwQetVx4R1HAP1GxtKgx9WLPZA,1233
-framcore/querydbs/__init__.py,sha256=oPX2sqAMoEMxWL9b_sRg4z4Q_b80iDm_jk-W_qmpEME,231
-framcore/solvers/Solver.py,sha256=dtxguoJAYHQCFsDXU9bbCZJGEaFJhS4Bpk-JGvI2g_o,1302
-framcore/solvers/SolverConfig.py,sha256=E181Jm9mJvEb2wMN7zE2AUzHwhQp_OLiKfSK6bEGF8s,10585
-framcore/solvers/__init__.py,sha256=q9HLYJkRdvJeFgAM1NBGIaFI8APmsZCDTy1AkIKw_Zs,179
-framcore/timeindexes/AverageYearRange.py,sha256=nAc-GxtPm9Hm-aEkDCkaKIfB4WC8jUJ_jgbPZjKi838,834
-framcore/timeindexes/ConstantTimeIndex.py,sha256=mufAI-lqdKyRw7kOzYZW1RbH9MfMfCNKnJPK7Em_3jk,601
-framcore/timeindexes/DailyIndex.py,sha256=SqKfnCisENPlt9gU7FTmjP7D_F3wNcLULqyyEoe5Cas,644
-framcore/timeindexes/FixedFrequencyTimeIndex.py,sha256=7DI_TRfaVCr2o402Mz4Wd1oOjluE1Xfr1-ItUrhPGbg,31479
-framcore/timeindexes/HourlyIndex.py,sha256=Xvqo41KZHIl1bsh0g1uSmH5TLG80UUt9vm3ZArNWa08,648
-framcore/timeindexes/IsoCalendarDay.py,sha256=5zffRr-uIg_mrwraBUWjD1LwhiYNU0pAl6-oGgQgvl8,991
-framcore/timeindexes/ListTimeIndex.py,sha256=XsYXkGG-wA6uPo-50zkp_R1_l9SII8dq7S_kGV060vY,8389
-framcore/timeindexes/ModelYear.py,sha256=Yh8jKizsRLNJRkkjCGQbxMETkDOMZq2zPEXNSmbAbqc,699
-framcore/timeindexes/ModelYears.py,sha256=ACNNNFeM6MycYNAQnYVVdXrjhqCgtdQ7DHyCXPimbzI,718
-framcore/timeindexes/OneYearProfileTimeIndex.py,sha256=HzjILknONIbGdw6rN_Ro5_r4ywFDXMoMP1bEgVzGuHo,773
-framcore/timeindexes/ProfileTimeIndex.py,sha256=Da_A-4NO8vgu9Z6Uax6rjKL0D03KnDCnroI5L90ZauU,1302
-framcore/timeindexes/SinglePeriodTimeIndex.py,sha256=mM-dHDEHdEOgaRLHQ2Q6NbjDoz9wYl3rC46EkLeHQpI,1447
-framcore/timeindexes/TimeIndex.py,sha256=kLQMiAi6ddQfzdKxyQbNRxmocwRmiLWz7SxUxCZ8wbw,2552
-framcore/timeindexes/WeeklyIndex.py,sha256=fZr0OMDKc5yUlsMa--D7d8FxWg-fkeHH5oclXP_a4mI,648
-framcore/timeindexes/__init__.py,sha256=2LmQFuMR1DffqHk5O2zd8o9g8QsazxSSykxOE7WGP4o,1351
-framcore/timevectors/ConstantTimeVector.py,sha256=S9fMSna_xOzJwu_Q9B_wNJtm9QYlEC3DmbkutOtMofU,6012
-framcore/timevectors/LinearTransformTimeVector.py,sha256=fcXQJ0Sn-m1K56j-5p78p1sFwxrEvgjq00x-THevTF4,4189
-framcore/timevectors/ListTimeVector.py,sha256=rQyCY2o7BsutS6kSFnV-CVzgoJCIPccmUugoeo-cwoI,5324
-framcore/timevectors/LoadedTimeVector.py,sha256=Igg045J6oFF8ocSUC1khbA98y_niww759FLFa-umzXk,4493
-framcore/timevectors/ReferencePeriod.py,sha256=eB7DQYIsyq273D7jQEG_-b-x3S5mpY8pCkATik5DKE8,1456
-framcore/timevectors/TimeVector.py,sha256=yH68GReHw19VjScOWBf9u0krRPlHzmOnbvDAyM-pLno,2598
-framcore/timevectors/__init__.py,sha256=Wd3gXGatwpbe2yMKSCq7O9My5wbveuK23iYO2ykkUIk,603
-framcore/utils/__init__.py,sha256=9M80LjgkJQ53Lbe5jiRro2tHUR4MQp2JPGiKF57wOr4,1222
-framcore/utils/get_regional_volumes.py,sha256=QqQ3Ik8VIHFomEIA3krcGJkeyDZFecbaNRtIm7_n8KE,14956
-framcore/utils/get_supported_components.py,sha256=F1AxTFuh4pLQTCwg8oYBhus0HOhKjkKYiRf9Ok1ttB4,1856
-framcore/utils/global_energy_equivalent.py,sha256=R3I1XVIIaYkagr_BPuKaAj9eS7gNzaff5v1tk7hzQuY,2614
-framcore/utils/isolate_subnodes.py,sha256=iRiqgTU_c6W1jLmIBGO7fQoK_abPA3N8beGJbroC2V8,6527
-framcore/utils/loaders.py,sha256=8llunmOC6XkbqNXSxL1XVNipGj7OpjIZ-2AyJUj-5v8,3320
-framcore/utils/node_flow_utils.py,sha256=4Z6eB4oUqhOWWeHFNYRZY0c0UQlJ8tM9duYvLzkJQ3k,7800
-framcore/utils/storage_subsystems.py,sha256=PmkV9rhiVUrmPz1zsyKcEwjJzYUkXQUcGM511tttsXc,4158
-fram_core-0.1.0a1.dist-info/METADATA,sha256=3PisZPX4tBGbm57LLFn_qEmV70e9HqsiMwBxO3sms1c,1204
-fram_core-0.1.0a1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-fram_core-0.1.0a1.dist-info/licenses/LICENSE.md,sha256=fxh4ZxuR8dM2HDs-pIUitPrJdxQ4fEFh1GvEYZA2m1E,1075
-fram_core-0.1.0a1.dist-info/RECORD,,