flixopt 2.1.6__py3-none-any.whl → 2.1.8__py3-none-any.whl

docs/examples/00-Minimal Example.md

@@ -2,4 +2,4 @@
 
 ```python
 {! ../examples/00_Minmal/minimal_example.py !}
-```
+```

docs/examples/01-Basic Example.md

@@ -2,4 +2,4 @@
 
 ```python
 {! ../examples/01_Simple/simple_example.py !}
-```
+```

docs/examples/02-Complex Example.md

@@ -7,4 +7,4 @@ This saves the results of a calculation to file and reloads them to analyze the
 ## Load the Results from file
 ```python
 {! ../examples/02_Complex/complex_example_results.py !}
-```
+```

docs/examples/index.md

@@ -2,4 +2,4 @@
 
 Here you can find a collection of examples that demonstrate how to use FlixOpt.
 
-We work on improving this gallery. If you have something to share, please contact us!
+We work on improving this gallery. If you have something to share, please contact us!

docs/faq/contribute.md

@@ -4,17 +4,29 @@ We warmly welcome contributions from the community! This guide will help you get
 
 ## Development Setup
 1. Clone the repository `git clone https://github.com/flixOpt/flixopt.git`
-2. Install the development dependencies `pip install -editable .[dev, docs]`
-3. Run `pytest` and `ruff check .` to ensure your code passes all tests
-
-## Documentation
-FlixOpt uses [mkdocs](https://www.mkdocs.org/) to generate documentation. To preview the documentation locally, run `mkdocs serve` in the root directory.
-
-## Helpful Commands
-- `mkdocs serve` to preview the documentation locally. Navigate to `http://127.0.0.1:8000/` to view the documentation.
-- `pytest` to run the test suite (You can also run the provided python script `run_all_test.py`)
-- `ruff check .` to run the linter
-- `ruff check . --fix` to automatically fix linting issues
+2. Install the development dependencies `pip install -e ".[dev]"`
+3. Install pre-commit hooks `pre-commit install` (one-time setup)
+4. Run `pytest` to ensure your code passes all tests
+
+## Code Quality
+We use [Ruff](https://github.com/astral-sh/ruff) for linting and formatting. After the one-time setup above, **code quality checks run automatically on every commit**.
+
+To run manually:
+- `ruff check --fix .` to check and fix linting issues
+- `ruff format .` to format code
+
+## Documentation (Optional)
+FlixOpt uses [mkdocs](https://www.mkdocs.org/) to generate documentation.
+To work on documentation:
+```bash
+pip install -e ".[docs]"
+mkdocs serve
+```
+Then navigate to http://127.0.0.1:8000/
+
+## Testing
+- `pytest` to run the test suite
+- You can also run the provided python script `run_all_test.py`
 
 ---
 # Best practices
@@ -30,8 +42,8 @@ FlixOpt uses [mkdocs](https://www.mkdocs.org/) to generate documentation. To pre
 ## Branches
 As we start to think FlixOpt in **Releases**, we decided to introduce multiple **dev**-branches instead of only one:
 Following the **Semantic Versioning** guidelines, we introduced:
-- `next/patch`: This is where all pull requests for the next patch release (1.0.x) go.  
-- `next/minor`: This is where all pull requests for the next minor release (1.x.0) go.  
+- `next/patch`: This is where all pull requests for the next patch release (1.0.x) go.
+- `next/minor`: This is where all pull requests for the next minor release (1.x.0) go.
 - `next/major`: This is where all pull requests for the next major release (x.0.0) go.
 
 Everything else remains in `feature/...`-branches.
@@ -44,6 +56,6 @@ At some point, `next/minor` or `next/major` will get merged into `main` using a
 ## Releases
 As stated, we follow **Semantic Versioning**.
 Right after one of the 3 [release branches](#branches) is merged into main, a **Tag** should be added to the merge commit and pushed to the main branch. The tag has the form `v1.2.3`.
-With this tag,  a release with **Release Notes** must be created. 
+With this tag,  a release with **Release Notes** must be created.
 
 *This is our current best practice*

docs/faq/index.md

@@ -1,3 +1,3 @@
 # Frequently Asked Questions
 
-## Work in progress
+## Work in progress

docs/javascripts/mathjax.js

@@ -15,4 +15,4 @@ document$.subscribe(() => {
   MathJax.typesetClear()
   MathJax.texReset()
   MathJax.typesetPromise()
-})
+})

docs/user-guide/Mathematical Notation/Bus.md

@@ -30,4 +30,4 @@ With:
 - $\phi_\text{in}(\text{t}_i)$ and $\phi_\text{out}(\text{t}_i)$ being the missing or excess flow-rate at time $\text{t}_i$, respectively
 - $\text{t}_i$ being the time step
 - $s_{b \rightarrow \Phi}(\text{t}_i)$ being the penalty term
-- $\text a_{b \rightarrow \Phi}(\text{t}_i)$ being the penalty coefficient (`excess_penalty_per_flow_hour`)
+- $\text a_{b \rightarrow \Phi}(\text{t}_i)$ being the penalty coefficient (`excess_penalty_per_flow_hour`)

docs/user-guide/Mathematical Notation/Effects, Penalty & Objective.md

@@ -1,24 +1,24 @@
 ## Effects
-[`Effects`][flixopt.effects.Effect] are used to allocate things like costs, emissions, or other "effects" occuring in the system.
+[`Effects`][flixopt.effects.Effect] are used to allocate things like costs, emissions, or other "effects" occurring in the system.
 These arise from so called **Shares**, which originate from **Elements** like [Flows](Flow.md).
 
 **Example:**
 
 [`Flows`][flixopt.elements.Flow] have an attribute called `effects_per_flow_hour`, defining the effect amount of per flow hour.
-Assiziated effects could be:
+Associated effects could be:
 - costs - given in [€/kWh]...
 - ...or emissions - given in [kg/kWh].
-- 
-Effects are allocated seperatly for investments and operation.
+-
+Effects are allocated separately for investments and operation.
 
 ### Shares to Effects
 
 $$ \label{eq:Share_invest}
-s_{l \rightarrow e, \text{inv}} = \sum_{v \in \mathcal{V}_{l, \text{inv}}} v \cdot \text a_{v \rightarrow e} 
+s_{l \rightarrow e, \text{inv}} = \sum_{v \in \mathcal{V}_{l, \text{inv}}} v \cdot \text a_{v \rightarrow e}
 $$
 
 $$ \label{eq:Share_operation}
-s_{l \rightarrow e, \text{op}}(\text{t}_i) = \sum_{v \in \mathcal{V}_{l,\text{op}}} v(\text{t}_i) \cdot \text a_{v \rightarrow e}(\text{t}_i)           
+s_{l \rightarrow e, \text{op}}(\text{t}_i) = \sum_{v \in \mathcal{V}_{l,\text{op}}} v(\text{t}_i) \cdot \text a_{v \rightarrow e}(\text{t}_i)
 $$
 
 With:
@@ -36,26 +36,26 @@ With:
 
 ### Shares between different Effects
 
-Furthermore, the Effect $x$ can contribute a share to another Effect ${e} \in \mathcal{E}\backslash x$. 
-This share is defined by the factor $\text r_{x \rightarrow e}$. 
+Furthermore, the Effect $x$ can contribute a share to another Effect ${e} \in \mathcal{E}\backslash x$.
+This share is defined by the factor $\text r_{x \rightarrow e}$.
 
-For example, the Effect "CO$_2$ emissions" (unit: kg) 
-can cause an additional share to Effect "monetary costs" (unit: €). 
+For example, the Effect "CO$_2$ emissions" (unit: kg)
+can cause an additional share to Effect "monetary costs" (unit: €).
 In this case, the factor $\text a_{x \rightarrow e}$ is the specific CO$_2$ price in €/kg. However, circular references have to be avoided.
 
-The overall sum of investment shares of an Effect $e$ is given by $\eqref{Effect_invest}$
+The overall sum of investment shares of an Effect $e$ is given by $\eqref{eq:Effect_invest}$
 
 $$ \label{eq:Effect_invest}
-E_{e, \text{inv}} = 
-\sum_{l \in \mathcal{L}} s_{l \rightarrow e,\text{inv}} + 
+E_{e, \text{inv}} =
+\sum_{l \in \mathcal{L}} s_{l \rightarrow e,\text{inv}} +
 \sum_{x \in \mathcal{E}\backslash e} E_{x, \text{inv}}  \cdot \text{r}_{x \rightarrow  e,\text{inv}}
 $$
 
 The overall sum of operation shares is given by $\eqref{eq:Effect_Operation}$
 
 $$ \label{eq:Effect_Operation}
-E_{e, \text{op}}(\text{t}_{i}) = 
-\sum_{l \in \mathcal{L}} s_{l \rightarrow e, \text{op}}(\text{t}_i) + 
+E_{e, \text{op}}(\text{t}_{i}) =
+\sum_{l \in \mathcal{L}} s_{l \rightarrow e, \text{op}}(\text{t}_i) +
 \sum_{x \in \mathcal{E}\backslash e} E_{x, \text{op}}(\text{t}_i) \cdot \text{r}_{x \rightarrow {e},\text{op}}(\text{t}_i)
 $$
 
@@ -68,8 +68,8 @@ With:
 
 - $\mathcal{L}$ being the set of all elements in the FlowSystem
 - $\mathcal{E}$ being the set of all effects in the FlowSystem
-- $\text r_{x \rightarrow e, \text{inv}}$ being the factor between the operation part of Effect $x$ and Effect $e$
-- $\text r_{x \rightarrow e, \text{op}}(\text{t}_i)$ being the factor between the invest part of Effect $x$ and Effect $e$
+- $\text r_{x \rightarrow e, \text{inv}}$ being the factor between the invest part of Effect $x$ and Effect $e$
+- $\text r_{x \rightarrow e, \text{op}}(\text{t}_i)$ being the factor between the operation part of Effect $x$ and Effect $e$
 
 - $\text{t}_i$ being the time step
 - $s_{l \rightarrow e, \text{inv}}$ being the share of element $l$ to the investment part of effect $e$
@@ -100,7 +100,7 @@ $$
 
 Additionally to the user defined [Effects](#effects), a Penalty $\Phi$ is part of every FlixOpt Model.
 Its used to prevent unsolvable problems and simplify troubleshooting.
-Shares to the penalty can originate from every Element and are constructed similarly to 
+Shares to the penalty can originate from every Element and are constructed similarly to
 $\eqref{Share_invest}$ and  $\eqref{Share_operation}$.
 
 $$ \label{eq:Penalty}
@@ -113,7 +113,7 @@ With:
 - $\mathcal{T}$ being the set of all timesteps
 - $s_{l \rightarrow \Phi}$ being the share of element $l$ to the penalty
 
-At the moment, penalties only occur in [Buses](#buses)
+At the moment, penalties only occur in [Buses](Bus.md)
 
 ## Objective
 
@@ -128,5 +128,5 @@ With:
 - $\Phi$ being the [Penalty](#penalty)
 
 This approach allows for a multi-criteria optimization using both...
- - ... the **Weigted Sum**Method, as the chosen **Objective Effect** can incorporate other Effects.
- - ... the ($\epsilon$-constraint method) by constraining effects.
+ - ... the **Weighted Sum** method, as the chosen **Objective Effect** can incorporate other Effects.
+ - ... the ($\epsilon$-constraint method) by constraining effects.

docs/user-guide/Mathematical Notation/Flow.md

@@ -21,6 +21,6 @@ $$
 $$
 
 
-This mathematical Formulation can be extended or changed when using [OnOffParameters](#onoffparameters)
-to define the On/Off state of the Flow, or [InvestParameters](#investments),
-which changes the size of the Flow from a constant to an optimization variable.
+This mathematical formulation can be extended by using [OnOffParameters](./OnOffParameters.md)
+to define the on/off state of the Flow, or by using [InvestParameters](./InvestParameters.md)
+to change the size of the Flow from a constant to an optimization variable.

docs/user-guide/Mathematical Notation/InvestParameters.md

@@ -0,0 +1,3 @@
+# InvestParameters
+
+This is a work in progress.

docs/user-guide/Mathematical Notation/LinearConverter.md

@@ -1,4 +1,4 @@
-[`LinearConverters`][flixopt.components.LinearConverter] define a ratio between incoming and outgoing [Flows](#flows).
+[`LinearConverters`][flixopt.components.LinearConverter] define a ratio between incoming and outgoing [Flows](Flow.md).
 
 $$ \label{eq:Linear-Transformer-Ratio}
     \sum_{f_{\text{in}} \in \mathcal F_{in}} \text a_{f_{\text{in}}}(\text{t}_i) \cdot p_{f_\text{in}}(\text{t}_i) = \sum_{f_{\text{out}} \in \mathcal F_{out}}  \text b_{f_\text{out}}(\text{t}_i) \cdot p_{f_\text{out}}(\text{t}_i)
@@ -10,12 +10,12 @@ With:
 - $p_{f_\text{in}}(\text{t}_i)$ and $p_{f_\text{out}}(\text{t}_i)$ being the flow-rate at time $\text{t}_i$ for flow $f_\text{in}$ and $f_\text{out}$, respectively
 - $\text a_{f_\text{in}}(\text{t}_i)$ and $\text b_{f_\text{out}}(\text{t}_i)$ being the ratio of the flow-rate at time $\text{t}_i$ for flow $f_\text{in}$ and $f_\text{out}$, respectively
 
-With one incoming **Flow** and one outgoing **Flow**, this can be simplified to: 
+With one incoming **Flow** and one outgoing **Flow**, this can be simplified to:
 
 $$ \label{eq:Linear-Transformer-Ratio-simple}
     \text a(\text{t}_i) \cdot p_{f_\text{in}}(\text{t}_i) = p_{f_\text{out}}(\text{t}_i)
 $$
 
-where $\text a$ can be interpreted as the conversion efficiency of the **LinearTransformer**.
-#### Piecewise Concersion factors
-The conversion efficiency can be defined as a piecewise linear approximation. See [Piecewise](Piecewise.md) for more details.
+where $\text a$ can be interpreted as the conversion efficiency of the **LinearConverter**.
+#### Piecewise Conversion factors
+The conversion efficiency can be defined as a piecewise linear approximation. See [Piecewise](Piecewise.md) for more details.

docs/user-guide/Mathematical Notation/OnOffParameters.md

@@ -0,0 +1,3 @@
+# OnOffParameters
+
+This is a work in progress.

docs/user-guide/Mathematical Notation/Piecewise.md

@@ -40,7 +40,7 @@ Which can also be described as $v \in \{0\} \cup [\text{v}_{\text{start_k}}, \te
 
 ## Combining multiple Piecewises
 
-Piecewise allows representing non-linear relationships. 
+Piecewise allows representing non-linear relationships.
 This is a powerful technique in linear optimization to model non-linear behaviors while maintaining the problem's linearity.
 
 Therefore, each Piecewise must have the same number of Pieces $k$.

docs/user-guide/Mathematical Notation/Storage.md

@@ -1,5 +1,5 @@
 # Storages
-**Storages** have one incoming and one outgoing **[Flow](#flows)** with a charging and discharging efficiency.
+**Storages** have one incoming and one outgoing **[Flow](Flow.md)** with a charging and discharging efficiency.
 A storage has a state of charge $c(\text{t}_i)$ which is limited by its `size` $\text C$ and relative bounds $\eqref{eq:Storage_Bounds}$.
 
 $$ \label{eq:Storage_Bounds}
@@ -41,4 +41,4 @@ Where:
 - $p_{f_\text{in}}(\text{t}_i)$ is the input flow rate at time $\text{t}_i$
 - $\eta_\text{in}(\text{t}_i)$ is the charging efficiency at time $\text{t}_i$
 - $p_{f_\text{out}}(\text{t}_i)$ is the output flow rate at time $\text{t}_i$
-- $\eta_\text{out}(\text{t}_i)$ is the discharging efficiency at time $\text{t}_i$
+- $\eta_\text{out}(\text{t}_i)$ is the discharging efficiency at time $\text{t}_i$

docs/user-guide/Mathematical Notation/index.md

@@ -14,7 +14,7 @@ FlixOpt uses the following naming conventions:
 
 ## Timesteps
 Time steps are defined as a sequence of discrete time steps $\text{t}_i \in \mathcal{T} \quad \text{for} \quad i \in \{1, 2, \dots, \text{n}\}$ (left-aligned in its timespan).
-From this sequence, the corresponding time intervals $\Delta \text{t}_i \in \Delta \mathcal{T}$ are derived as 
+From this sequence, the corresponding time intervals $\Delta \text{t}_i \in \Delta \mathcal{T}$ are derived as
 
 $$\Delta \text{t}_i = \text{t}_{i+1} - \text{t}_i \quad \text{for} \quad i \in \{1, 2, \dots, \text{n}-1\}$$
 

docs/user-guide/Mathematical Notation/others.md

@@ -1,3 +1,3 @@
 # Work in Progress
 
-This is a work in progress.
+This is a work in progress.

docs/user-guide/index.md

@@ -6,7 +6,7 @@ FlixOpt is built around a set of core concepts that work together to represent a
 
 ### FlowSystem
 
-The [`FlowSystem`][flixopt.flow_system.FlowSystem] is the central organizing unit in FlixOpt. 
+The [`FlowSystem`][flixopt.flow_system.FlowSystem] is the central organizing unit in FlixOpt.
 Every FlixOpt model starts with creating a FlowSystem. It:
 
 - Defines the timesteps for the optimization
@@ -40,7 +40,7 @@ Examples:
 [`Bus`][flixopt.elements.Bus] objects represent nodes or connection points in a FlowSystem. They:
 
 - Balance incoming and outgoing flows
-- Can represent physical networks like heat, electricity, or gas 
+- Can represent physical networks like heat, electricity, or gas
 - Handle infeasible balances gently by allowing the balance to be closed in return for a big Penalty (optional)
 
 ### Components

flixopt/__init__.py

@@ -2,6 +2,10 @@
 This module bundles all common functionality of flixopt and sets up the logging
 """
 
+from importlib.metadata import version
+
+__version__ = version('flixopt')
+
 from .commons import (
     CONFIG,
     AggregatedCalculation,

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,18 +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,
 )
 
 if TYPE_CHECKING:
+    import linopy
+    import pandas as pd
     import plotly.graph_objects as go
 
+    from .core import Scalar, TimeSeriesData
+    from .elements import Component
+    from .flow_system import FlowSystem
+
 logger = logging.getLogger('flixopt')
 
 
@@ -48,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:
@@ -75,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:
         """
@@ -140,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(
@@ -162,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.
@@ -192,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.
@@ -201,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 = []
@@ -237,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
@@ -264,24 +265,24 @@ 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]:
+    def labels_for_high_peaks(self) -> list[str]:
         return [ts.label for ts in self.time_series_for_high_peaks]
 
     @property
-    def labels_for_low_peaks(self) -> List[str]:
+    def labels_for_low_peaks(self) -> list[str]:
         return [ts.label 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):
@@ -295,7 +296,7 @@ class AggregationModel(Model):
         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
@@ -314,9 +315,9 @@ 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] = {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
 
         for component in components:
             if isinstance(component, Storage) and not self.aggregation_parameters.fix_storage_flows:
@@ -336,7 +337,7 @@ class AggregationModel(Model):
             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])