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

flixopt/config.py

@@ -1,8 +1,10 @@
+from __future__ import annotations
+
 import logging
 import os
 import types
 from dataclasses import dataclass, fields, is_dataclass
-from typing import Annotated, Literal, Optional
+from typing import Annotated, Literal, get_type_hints
 
 import yaml
 from rich.console import Console
@@ -37,11 +39,15 @@ def dataclass_from_dict_with_validation(cls, data: dict):
     if not is_dataclass(cls):
         raise TypeError(f'{cls} must be a dataclass')
 
+    # Get resolved type hints to handle postponed evaluation
+    type_hints = get_type_hints(cls)
+
     # Build kwargs for the dataclass constructor
     kwargs = {}
     for field in fields(cls):
         field_name = field.name
-        field_type = field.type
+        # Use resolved type from get_type_hints instead of field.type
+        field_type = type_hints.get(field_name, field.type)
         field_value = data.get(field_name)
 
         # If the field type is a dataclass and the value is a dict, recursively initialize
@@ -57,7 +63,10 @@ def dataclass_from_dict_with_validation(cls, data: dict):
 class ValidatedConfig:
     def __setattr__(self, name, value):
         if field := self.__dataclass_fields__.get(name):
-            if metadata := getattr(field.type, '__metadata__', None):
+            # Get resolved type hints to handle postponed evaluation
+            type_hints = get_type_hints(self.__class__, include_extras=True)
+            field_type = type_hints.get(name, field.type)
+            if metadata := getattr(field_type, '__metadata__', None):
                 assert metadata[0](value), f'Invalid value passed to {name!r}: {value=}'
         super().__setattr__(name, value)
 
@@ -96,7 +105,7 @@ class CONFIG:
     logging: LoggingConfig = None
 
     @classmethod
-    def load_config(cls, user_config_file: Optional[str] = None):
+    def load_config(cls, user_config_file: str | None = None):
         """
         Initialize configuration using defaults or user-specified file.
         """
@@ -104,12 +113,12 @@ class CONFIG:
         default_config_path = os.path.join(os.path.dirname(__file__), 'config.yaml')
 
         if user_config_file is None:
-            with open(default_config_path, 'r') as file:
+            with open(default_config_path) as file:
                 new_config = yaml.safe_load(file)
         elif not os.path.exists(user_config_file):
             raise FileNotFoundError(f'Config file not found: {user_config_file}')
         else:
-            with open(user_config_file, 'r') as user_file:
+            with open(user_config_file) as user_file:
                 new_config = yaml.safe_load(user_file)
 
         # Convert the merged config to ConfigSchema
@@ -186,7 +195,7 @@ class ColoredMultilineFormater(MultilineFormater):
         return '\n'.join(formatted_lines)
 
 
-def _get_logging_handler(log_file: Optional[str] = None, use_rich_handler: bool = False) -> logging.Handler:
+def _get_logging_handler(log_file: str | None = None, use_rich_handler: bool = False) -> logging.Handler:
     """Returns a logging handler for the given log file."""
     if use_rich_handler and log_file is None:
         # RichHandler for console output
@@ -225,7 +234,7 @@ def _get_logging_handler(log_file: Optional[str] = None, use_rich_handler: bool
 
 def setup_logging(
     default_level: Literal['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'] = 'INFO',
-    log_file: Optional[str] = 'flixopt.log',
+    log_file: str | None = 'flixopt.log',
     use_rich_handler: bool = False,
 ):
     """Setup logging configuration"""

flixopt/core.py

@@ -8,7 +8,8 @@ import json
 import logging
 import pathlib
 from collections import Counter
-from typing import Any, Dict, Iterator, List, Literal, Optional, Tuple, Union
+from collections.abc import Iterator
+from typing import Any, Literal, Optional
 
 import numpy as np
 import pandas as pd
@@ -16,15 +17,12 @@ import xarray as xr
 
 logger = logging.getLogger('flixopt')
 
-Scalar = Union[int, float]
+Scalar = int | float
 """A type representing a single number, either integer or float."""
 
-NumericData = Union[int, float, np.integer, np.floating, np.ndarray, pd.Series, pd.DataFrame, xr.DataArray]
+NumericData = int | float | np.integer | np.floating | np.ndarray | pd.Series | pd.DataFrame | xr.DataArray
 """Represents any form of numeric data, from simple scalars to complex data structures."""
 
-NumericDataTS = Union[NumericData, 'TimeSeriesData']
-"""Represents either standard numeric data or TimeSeriesData."""
-
 
 class PlausibilityError(Exception):
     """Error for a failing Plausibility check."""
@@ -101,34 +99,38 @@ class DataConverter:
 
 
 class TimeSeriesData:
-    # TODO: Move to Interface.py
-    def __init__(self, data: NumericData, agg_group: Optional[str] = None, agg_weight: Optional[float] = None):
-        """
-        timeseries class for transmit timeseries AND special characteristics of timeseries,
-        i.g. to define weights needed in calculation_type 'aggregated'
-            EXAMPLE solar:
-            you have several solar timeseries. These should not be overweighted
-            compared to the remaining timeseries (i.g. heat load, price)!
-            fixed_relative_profile_solar1 = TimeSeriesData(sol_array_1, type = 'solar')
-            fixed_relative_profile_solar2 = TimeSeriesData(sol_array_2, type = 'solar')
-            fixed_relative_profile_solar3 = TimeSeriesData(sol_array_3, type = 'solar')
-            --> this 3 series of same type share one weight, i.e. internally assigned each weight = 1/3
-            (instead of standard weight = 1)
-
-        Args:
-            data: The timeseries data, which can be a scalar, array, or numpy array.
-            agg_group: The group this TimeSeriesData is a part of. agg_weight is split between members of a group. Default is None.
-            agg_weight: The weight for calculation_type 'aggregated', should be between 0 and 1. Default is None.
+    """
+    TimeSeriesData wraps time series data with aggregation metadata for optimization.
+
+    This class combines time series data with special characteristics needed for aggregated calculations.
+    It allows grouping related time series to prevent overweighting in optimization models.
+
+    Example:
+        When you have multiple solar time series, they should share aggregation weight:
+        ```python
+        solar1 = TimeSeriesData(sol_array_1, agg_group='solar')
+        solar2 = TimeSeriesData(sol_array_2, agg_group='solar')
+        solar3 = TimeSeriesData(sol_array_3, agg_group='solar')
+        # These 3 series share one weight (each gets weight = 1/3 instead of 1)
+        ```
+
+    Args:
+        data: The timeseries data, which can be a scalar, array, or numpy array.
+        agg_group: The group this TimeSeriesData belongs to. agg_weight is split between group members. Default is None.
+        agg_weight: The weight for calculation_type 'aggregated', should be between 0 and 1. Default is None.
+
+    Raises:
+        ValueError: If both agg_group and agg_weight are set.
+    """
 
-        Raises:
-            Exception: If both agg_group and agg_weight are set, an exception is raised.
-        """
+    # TODO: Move to Interface.py
+    def __init__(self, data: NumericData, agg_group: str | None = None, agg_weight: float | None = None):
         self.data = data
         self.agg_group = agg_group
         self.agg_weight = agg_weight
         if (agg_group is not None) and (agg_weight is not None):
             raise ValueError('Either <agg_group> or explicit <agg_weigth> can be used. Not both!')
-        self.label: Optional[str] = None
+        self.label: str | None = None
 
     def __repr__(self):
         # Get the constructor arguments and their current values
@@ -143,6 +145,10 @@ class TimeSeriesData:
         return str(self.data)
 
 
+NumericDataTS = NumericData | TimeSeriesData
+"""Represents either standard numeric data or TimeSeriesData."""
+
+
 class TimeSeries:
     """
     A class representing time series data with active and stored states.
@@ -163,8 +169,8 @@ class TimeSeries:
         data: NumericData,
         name: str,
         timesteps: pd.DatetimeIndex,
-        aggregation_weight: Optional[float] = None,
-        aggregation_group: Optional[str] = None,
+        aggregation_weight: float | None = None,
+        aggregation_group: str | None = None,
         needs_extra_timestep: bool = False,
     ) -> 'TimeSeries':
         """
@@ -190,7 +196,7 @@ class TimeSeries:
         )
 
     @classmethod
-    def from_json(cls, data: Optional[Dict[str, Any]] = None, path: Optional[str] = None) -> 'TimeSeries':
+    def from_json(cls, data: dict[str, Any] | None = None, path: str | None = None) -> 'TimeSeries':
         """
         Load a TimeSeries from a dictionary or json file.
 
@@ -208,7 +214,7 @@ class TimeSeries:
             raise ValueError("Exactly one of 'path' or 'data' must be provided")
 
         if path is not None:
-            with open(path, 'r') as f:
+            with open(path) as f:
                 data = json.load(f)
 
         # Convert ISO date strings to datetime objects
@@ -227,8 +233,8 @@ class TimeSeries:
         self,
         data: xr.DataArray,
         name: str,
-        aggregation_weight: Optional[float] = None,
-        aggregation_group: Optional[str] = None,
+        aggregation_weight: float | None = None,
+        aggregation_group: str | None = None,
         needs_extra_timestep: bool = False,
     ):
         """
@@ -274,7 +280,7 @@ class TimeSeries:
         self._stored_data = self._backup.copy(deep=True)
         self.reset()
 
-    def to_json(self, path: Optional[pathlib.Path] = None) -> Dict[str, Any]:
+    def to_json(self, path: pathlib.Path | None = None) -> dict[str, Any]:
         """
         Save the TimeSeries to a dictionary or JSON file.
 
@@ -330,7 +336,7 @@ class TimeSeries:
         return self._active_timesteps
 
     @active_timesteps.setter
-    def active_timesteps(self, timesteps: Optional[pd.DatetimeIndex]):
+    def active_timesteps(self, timesteps: pd.DatetimeIndex | None):
         """
         Set active_timesteps and refresh active_data.
 
@@ -542,8 +548,8 @@ class TimeSeriesCollection:
     def __init__(
         self,
         timesteps: pd.DatetimeIndex,
-        hours_of_last_timestep: Optional[float] = None,
-        hours_of_previous_timesteps: Optional[Union[float, np.ndarray]] = None,
+        hours_of_last_timestep: float | None = None,
+        hours_of_previous_timesteps: float | np.ndarray | None = None,
     ):
         """
         Args:
@@ -571,22 +577,22 @@ class TimeSeriesCollection:
         self._active_hours_per_timestep = None
 
         # Dictionary of time series by name
-        self.time_series_data: Dict[str, TimeSeries] = {}
+        self.time_series_data: dict[str, TimeSeries] = {}
 
         # Aggregation
-        self.group_weights: Dict[str, float] = {}
-        self.weights: Dict[str, float] = {}
+        self.group_weights: dict[str, float] = {}
+        self.weights: dict[str, float] = {}
 
     @classmethod
     def with_uniform_timesteps(
-        cls, start_time: pd.Timestamp, periods: int, freq: str, hours_per_step: Optional[float] = None
+        cls, start_time: pd.Timestamp, periods: int, freq: str, hours_per_step: float | None = None
     ) -> 'TimeSeriesCollection':
         """Create a collection with uniform timesteps."""
         timesteps = pd.date_range(start_time, periods=periods, freq=freq, name='time')
         return cls(timesteps, hours_of_previous_timesteps=hours_per_step)
 
     def create_time_series(
-        self, data: Union[NumericData, TimeSeriesData], name: str, needs_extra_timestep: bool = False
+        self, data: NumericData | TimeSeriesData, name: str, needs_extra_timestep: bool = False
     ) -> TimeSeries:
         """
         Creates a TimeSeries from the given data and adds it to the collection.
@@ -595,7 +601,6 @@ class TimeSeriesCollection:
             data: The data to create the TimeSeries from.
             name: The name of the TimeSeries.
             needs_extra_timestep: Whether to create an additional timestep at the end of the timesteps.
-            The data to create the TimeSeries from.
 
         Returns:
             The created TimeSeries.
@@ -630,7 +635,7 @@ class TimeSeriesCollection:
 
         return time_series
 
-    def calculate_aggregation_weights(self) -> Dict[str, float]:
+    def calculate_aggregation_weights(self) -> dict[str, float]:
         """Calculate and return aggregation weights for all time series."""
         self.group_weights = self._calculate_group_weights()
         self.weights = self._calculate_weights()
@@ -640,7 +645,7 @@ class TimeSeriesCollection:
 
         return self.weights
 
-    def activate_timesteps(self, active_timesteps: Optional[pd.DatetimeIndex] = None):
+    def activate_timesteps(self, active_timesteps: pd.DatetimeIndex | None = None):
         """
         Update active timesteps for the collection and all time series.
         If no arguments are provided, the active timesteps are reset.
@@ -816,7 +821,7 @@ class TimeSeriesCollection:
 
     @staticmethod
     def _create_timesteps_with_extra(
-        timesteps: pd.DatetimeIndex, hours_of_last_timestep: Optional[float]
+        timesteps: pd.DatetimeIndex, hours_of_last_timestep: float | None
     ) -> pd.DatetimeIndex:
         """Create timesteps with an extra step at the end."""
         if hours_of_last_timestep is not None:
@@ -831,8 +836,8 @@ class TimeSeriesCollection:
 
     @staticmethod
     def _calculate_hours_of_previous_timesteps(
-        timesteps: pd.DatetimeIndex, hours_of_previous_timesteps: Optional[Union[float, np.ndarray]]
-    ) -> Union[float, np.ndarray]:
+        timesteps: pd.DatetimeIndex, hours_of_previous_timesteps: float | np.ndarray | None
+    ) -> float | np.ndarray:
         """Calculate duration of regular timesteps."""
         if hours_of_previous_timesteps is not None:
             return hours_of_previous_timesteps
@@ -851,7 +856,7 @@ class TimeSeriesCollection:
             data=hours_per_step, coords={'time': timesteps_extra[:-1]}, dims=('time',), name='hours_per_step'
         )
 
-    def _calculate_group_weights(self) -> Dict[str, float]:
+    def _calculate_group_weights(self) -> dict[str, float]:
         """Calculate weights for aggregation groups."""
         # Count series in each group
         groups = [ts.aggregation_group for ts in self.time_series_data.values() if ts.aggregation_group is not None]
@@ -860,7 +865,7 @@ class TimeSeriesCollection:
         # Calculate weight for each group (1/count)
         return {group: 1 / count for group, count in group_counts.items()}
 
-    def _calculate_weights(self) -> Dict[str, float]:
+    def _calculate_weights(self) -> dict[str, float]:
         """Calculate weights for all time series."""
         # Calculate weight for each time series
         weights = {}
@@ -902,7 +907,7 @@ class TimeSeriesCollection:
         """Get the number of TimeSeries in the collection."""
         return len(self.time_series_data)
 
-    def __contains__(self, item: Union[str, TimeSeries]) -> bool:
+    def __contains__(self, item: str | TimeSeries) -> bool:
         """Check if a TimeSeries exists in the collection."""
         if isinstance(item, str):
             return item in self.time_series_data
@@ -911,12 +916,12 @@ class TimeSeriesCollection:
         return False
 
     @property
-    def non_constants(self) -> List[TimeSeries]:
+    def non_constants(self) -> list[TimeSeries]:
         """Get time series with varying values."""
         return [ts for ts in self.time_series_data.values() if not ts.all_equal]
 
     @property
-    def constants(self) -> List[TimeSeries]:
+    def constants(self) -> list[TimeSeries]:
         """Get time series with constant values."""
         return [ts for ts in self.time_series_data.values() if ts.all_equal]