flixopt 2.2.0b0__py3-none-any.whl → 3.0.0__py3-none-any.whl

flixopt/__init__.py

@@ -2,6 +2,15 @@
 This module bundles all common functionality of flixopt and sets up the logging
 """
 
+import warnings
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version('flixopt')
+except PackageNotFoundError:
+    # Package is not installed (development mode without editable install)
+    __version__ = '0.0.0.dev0'
+
 from .commons import (
     CONFIG,
     AggregatedCalculation,
@@ -32,4 +41,29 @@ from .commons import (
     solvers,
 )
 
-CONFIG.load_config()
+# === Runtime warning suppression for third-party libraries ===
+# These warnings are from dependencies and cannot be fixed by end users.
+# They are suppressed at runtime to provide a cleaner user experience.
+# These filters match the test configuration in pyproject.toml for consistency.
+
+# tsam: Time series aggregation library
+# - UserWarning: Informational message about minimal value constraints during clustering.
+warnings.filterwarnings('ignore', category=UserWarning, message='.*minimal value.*exceeds.*', module='tsam')
+# TODO: Might be able to fix it in flixopt?
+
+# linopy: Linear optimization library
+# - UserWarning: Coordinate mismatch warnings that don't affect functionality and are expected.
+warnings.filterwarnings(
+    'ignore', category=UserWarning, message='Coordinates across variables not equal', module='linopy'
+)
+# - FutureWarning: join parameter default will change in future versions
+warnings.filterwarnings(
+    'ignore',
+    category=FutureWarning,
+    message="In a future version of xarray the default value for join will change from join='outer' to join='exact'",
+    module='linopy',
+)
+
+# numpy: Core numerical library
+# - RuntimeWarning: Binary incompatibility warnings from compiled extensions (safe to ignore). numpy 1->2
+warnings.filterwarnings('ignore', category=RuntimeWarning, message='numpy\\.ndarray size changed')

flixopt/aggregation.py

@@ -3,16 +3,15 @@ This module contains the Aggregation functionality for the flixopt framework.
 Through this, aggregating TimeSeriesData is possible.
 """
 
+from __future__ import annotations
+
 import copy
 import logging
 import pathlib
 import timeit
-import warnings
-from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple, Union
+from typing import TYPE_CHECKING
 
-import linopy
 import numpy as np
-import pandas as pd
 
 try:
     import tsam.timeseriesaggregation as tsam
@@ -22,19 +21,20 @@ except ImportError:
     TSAM_AVAILABLE = False
 
 from .components import Storage
-from .core import Scalar, TimeSeriesData
-from .elements import Component
-from .flow_system import FlowSystem
 from .structure import (
-    Element,
-    Model,
-    SystemModel,
+    FlowSystemModel,
+    Submodel,
 )
 
 if TYPE_CHECKING:
+    import linopy
+    import pandas as pd
     import plotly.graph_objects as go
 
-warnings.filterwarnings('ignore', category=DeprecationWarning)
+    from .core import Scalar, TimeSeriesData
+    from .elements import Component
+    from .flow_system import FlowSystem
+
 logger = logging.getLogger('flixopt')
 
 
@@ -49,9 +49,9 @@ class Aggregation:
         hours_per_time_step: Scalar,
         hours_per_period: Scalar,
         nr_of_periods: int = 8,
-        weights: Dict[str, float] = None,
-        time_series_for_high_peaks: List[str] = None,
-        time_series_for_low_peaks: List[str] = None,
+        weights: dict[str, float] | None = None,
+        time_series_for_high_peaks: list[str] | None = None,
+        time_series_for_low_peaks: list[str] | None = None,
     ):
         """
         Args:
@@ -76,9 +76,9 @@ class Aggregation:
         self.time_series_for_high_peaks = time_series_for_high_peaks or []
         self.time_series_for_low_peaks = time_series_for_low_peaks or []
 
-        self.aggregated_data: Optional[pd.DataFrame] = None
+        self.aggregated_data: pd.DataFrame | None = None
         self.clustering_duration_seconds = None
-        self.tsam: Optional[tsam.TimeSeriesAggregation] = None
+        self.tsam: tsam.TimeSeriesAggregation | None = None
 
     def cluster(self) -> None:
         """
@@ -141,7 +141,7 @@ class Aggregation:
     def use_extreme_periods(self):
         return self.time_series_for_high_peaks or self.time_series_for_low_peaks
 
-    def plot(self, colormap: str = 'viridis', show: bool = True, save: Optional[pathlib.Path] = None) -> 'go.Figure':
+    def plot(self, colormap: str = 'viridis', show: bool = True, save: pathlib.Path | None = None) -> go.Figure:
         from . import plotting
 
         df_org = self.original_data.copy().rename(
@@ -163,14 +163,14 @@ class Aggregation:
             figure_like=fig,
             default_path=pathlib.Path('aggregated data.html'),
             default_filetype='.html',
-            user_path=None if isinstance(save, bool) else pathlib.Path(save),
+            user_path=save,
             show=show,
-            save=True if save else False,
+            save=save is not None,
         )
 
         return fig
 
-    def get_cluster_indices(self) -> Dict[str, List[np.ndarray]]:
+    def get_cluster_indices(self) -> dict[str, list[np.ndarray]]:
         """
         Generates a dictionary that maps each cluster to a list of index vectors representing the time steps
         assigned to that cluster for each period.
@@ -193,7 +193,7 @@ class Aggregation:
 
         return index_vectors
 
-    def get_equation_indices(self, skip_first_index_of_period: bool = True) -> Tuple[np.ndarray, np.ndarray]:
+    def get_equation_indices(self, skip_first_index_of_period: bool = True) -> tuple[np.ndarray, np.ndarray]:
         """
         Generates pairs of indices for the equations by comparing index vectors of the same cluster.
         If `skip_first_index_of_period` is True, the first index of each period is skipped.
@@ -202,7 +202,7 @@ class Aggregation:
             skip_first_index_of_period (bool): Whether to include or skip the first index of each period.
 
         Returns:
-            Tuple[np.ndarray, np.ndarray]: Two arrays of indices.
+            tuple[np.ndarray, np.ndarray]: Two arrays of indices.
         """
         idx_var1 = []
         idx_var2 = []
@@ -238,8 +238,8 @@ class AggregationParameters:
         aggregate_data_and_fix_non_binary_vars: bool,
         percentage_of_period_freedom: float = 0,
         penalty_of_period_freedom: float = 0,
-        time_series_for_high_peaks: List[TimeSeriesData] = None,
-        time_series_for_low_peaks: List[TimeSeriesData] = None,
+        time_series_for_high_peaks: list[TimeSeriesData] | None = None,
+        time_series_for_low_peaks: list[TimeSeriesData] | None = None,
     ):
         """
         Initializes aggregation parameters for time series data
@@ -265,43 +265,43 @@ class AggregationParameters:
         self.aggregate_data_and_fix_non_binary_vars = aggregate_data_and_fix_non_binary_vars
         self.percentage_of_period_freedom = percentage_of_period_freedom
         self.penalty_of_period_freedom = penalty_of_period_freedom
-        self.time_series_for_high_peaks: List[TimeSeriesData] = time_series_for_high_peaks or []
-        self.time_series_for_low_peaks: List[TimeSeriesData] = time_series_for_low_peaks or []
+        self.time_series_for_high_peaks: list[TimeSeriesData] = time_series_for_high_peaks or []
+        self.time_series_for_low_peaks: list[TimeSeriesData] = time_series_for_low_peaks or []
 
     @property
     def use_extreme_periods(self):
         return self.time_series_for_high_peaks or self.time_series_for_low_peaks
 
     @property
-    def labels_for_high_peaks(self) -> List[str]:
-        return [ts.label for ts in self.time_series_for_high_peaks]
+    def labels_for_high_peaks(self) -> list[str]:
+        return [ts.name for ts in self.time_series_for_high_peaks]
 
     @property
-    def labels_for_low_peaks(self) -> List[str]:
-        return [ts.label for ts in self.time_series_for_low_peaks]
+    def labels_for_low_peaks(self) -> list[str]:
+        return [ts.name for ts in self.time_series_for_low_peaks]
 
     @property
-    def use_low_peaks(self):
-        return self.time_series_for_low_peaks is not None
+    def use_low_peaks(self) -> bool:
+        return bool(self.time_series_for_low_peaks)
 
 
-class AggregationModel(Model):
-    """The AggregationModel holds equations and variables related to the Aggregation of a FLowSystem.
+class AggregationModel(Submodel):
+    """The AggregationModel holds equations and variables related to the Aggregation of a FlowSystem.
     It creates Equations that equates indices of variables, and introduces penalties related to binary variables, that
     escape the equation to their related binaries in other periods"""
 
     def __init__(
         self,
-        model: SystemModel,
+        model: FlowSystemModel,
         aggregation_parameters: AggregationParameters,
         flow_system: FlowSystem,
         aggregation_data: Aggregation,
-        components_to_clusterize: Optional[List[Component]],
+        components_to_clusterize: list[Component] | None,
     ):
         """
         Modeling-Element for "index-equating"-equations
         """
-        super().__init__(model, label_of_element='Aggregation', label_full='Aggregation')
+        super().__init__(model, label_of_element='Aggregation', label_of_model='Aggregation')
         self.flow_system = flow_system
         self.aggregation_parameters = aggregation_parameters
         self.aggregation_data = aggregation_data
@@ -315,40 +315,39 @@ class AggregationModel(Model):
 
         indices = self.aggregation_data.get_equation_indices(skip_first_index_of_period=True)
 
-        time_variables: Set[str] = {k for k, v in self._model.variables.data.items() if 'time' in v.indexes}
-        binary_variables: Set[str] = {k for k, v in self._model.variables.data.items() if k in self._model.binaries}
-        binary_time_variables: Set[str] = time_variables & binary_variables
+        time_variables: set[str] = {
+            name for name in self._model.variables if 'time' in self._model.variables[name].dims
+        }
+        binary_variables: set[str] = set(self._model.variables.binaries)
+        binary_time_variables: set[str] = time_variables & binary_variables
 
         for component in components:
             if isinstance(component, Storage) and not self.aggregation_parameters.fix_storage_flows:
                 continue  # Fix Nothing in The Storage
 
-            all_variables_of_component = set(component.model.variables)
+            all_variables_of_component = set(component.submodel.variables)
 
             if self.aggregation_parameters.aggregate_data_and_fix_non_binary_vars:
-                relevant_variables = component.model.variables[all_variables_of_component & time_variables]
+                relevant_variables = component.submodel.variables[all_variables_of_component & time_variables]
             else:
-                relevant_variables = component.model.variables[all_variables_of_component & binary_time_variables]
+                relevant_variables = component.submodel.variables[all_variables_of_component & binary_time_variables]
             for variable in relevant_variables:
-                self._equate_indices(component.model.variables[variable], indices)
+                self._equate_indices(component.submodel.variables[variable], indices)
 
         penalty = self.aggregation_parameters.penalty_of_period_freedom
         if (self.aggregation_parameters.percentage_of_period_freedom > 0) and penalty != 0:
             for variable in self.variables_direct.values():
                 self._model.effects.add_share_to_penalty('Aggregation', variable * penalty)
 
-    def _equate_indices(self, variable: linopy.Variable, indices: Tuple[np.ndarray, np.ndarray]) -> None:
+    def _equate_indices(self, variable: linopy.Variable, indices: tuple[np.ndarray, np.ndarray]) -> None:
         assert len(indices[0]) == len(indices[1]), 'The length of the indices must match!!'
         length = len(indices[0])
 
         # Gleichung:
         # eq1: x(p1,t) - x(p3,t) = 0 # wobei p1 und p3 im gleichen Cluster sind und t = 0..N_p
-        con = self.add(
-            self._model.add_constraints(
-                variable.isel(time=indices[0]) - variable.isel(time=indices[1]) == 0,
-                name=f'{self.label_full}|equate_indices|{variable.name}',
-            ),
-            f'equate_indices|{variable.name}',
+        con = self.add_constraints(
+            variable.isel(time=indices[0]) - variable.isel(time=indices[1]) == 0,
+            short_name=f'equate_indices|{variable.name}',
         )
 
         # Korrektur: (bisher nur für Binärvariablen:)
@@ -356,23 +355,11 @@ class AggregationModel(Model):
             variable.name in self._model.variables.binaries
             and self.aggregation_parameters.percentage_of_period_freedom > 0
         ):
-            var_k1 = self.add(
-                self._model.add_variables(
-                    binary=True,
-                    coords={'time': variable.isel(time=indices[0]).indexes['time']},
-                    name=f'{self.label_full}|correction1|{variable.name}',
-                ),
-                f'correction1|{variable.name}',
-            )
+            sel = variable.isel(time=indices[0])
+            coords = {d: sel.indexes[d] for d in sel.dims}
+            var_k1 = self.add_variables(binary=True, coords=coords, short_name=f'correction1|{variable.name}')
 
-            var_k0 = self.add(
-                self._model.add_variables(
-                    binary=True,
-                    coords={'time': variable.isel(time=indices[0]).indexes['time']},
-                    name=f'{self.label_full}|correction0|{variable.name}',
-                ),
-                f'correction0|{variable.name}',
-            )
+            var_k0 = self.add_variables(binary=True, coords=coords, short_name=f'correction0|{variable.name}')
 
             # equation extends ...
             # --> On(p3) can be 0/1 independent of On(p1,t)!
@@ -383,21 +370,13 @@ class AggregationModel(Model):
             con.lhs += 1 * var_k1 - 1 * var_k0
 
             # interlock var_k1 and var_K2:
-            # eq: var_k0(t)+var_k1(t) <= 1.1
-            self.add(
-                self._model.add_constraints(
-                    var_k0 + var_k1 <= 1.1, name=f'{self.label_full}|lock_k0_and_k1|{variable.name}'
-                ),
-                f'lock_k0_and_k1|{variable.name}',
-            )
+            # eq: var_k0(t)+var_k1(t) <= 1
+            self.add_constraints(var_k0 + var_k1 <= 1, short_name=f'lock_k0_and_k1|{variable.name}')
 
             # Begrenzung der Korrektur-Anzahl:
             # eq: sum(K) <= n_Corr_max
-            self.add(
-                self._model.add_constraints(
-                    sum(var_k0) + sum(var_k1)
-                    <= round(self.aggregation_parameters.percentage_of_period_freedom / 100 * length),
-                    name=f'{self.label_full}|limit_corrections|{variable.name}',
-                ),
-                f'limit_corrections|{variable.name}',
+            limit = int(np.floor(self.aggregation_parameters.percentage_of_period_freedom / 100 * length))
+            self.add_constraints(
+                var_k0.sum(dim='time') + var_k1.sum(dim='time') <= limit,
+                short_name=f'limit_corrections|{variable.name}',
             )