flixopt 1.0.12__py3-none-any.whl

flixOpt/config.py

@@ -0,0 +1,258 @@
+import logging
+import os
+import types
+from dataclasses import dataclass, fields, is_dataclass
+from typing import Annotated, Literal, Optional
+
+import yaml
+from rich.console import Console
+from rich.logging import RichHandler
+
+logger = logging.getLogger('flixOpt')
+
+
+def merge_configs(defaults: dict, overrides: dict) -> dict:
+    """
+    Merge the default configuration with user-provided overrides.
+
+    :param defaults: Default configuration dictionary.
+    :param overrides: User configuration dictionary.
+    :return: Merged configuration dictionary.
+    """
+    for key, value in overrides.items():
+        if isinstance(value, dict) and key in defaults and isinstance(defaults[key], dict):
+            # Recursively merge nested dictionaries
+            defaults[key] = merge_configs(defaults[key], value)
+        else:
+            # Override the default value
+            defaults[key] = value
+    return defaults
+
+
+def dataclass_from_dict_with_validation(cls, data: dict):
+    """
+    Recursively initialize a dataclass from a dictionary.
+    """
+    if not is_dataclass(cls):
+        raise TypeError(f'{cls} must be a dataclass')
+
+    # Build kwargs for the dataclass constructor
+    kwargs = {}
+    for field in fields(cls):
+        field_name = field.name
+        field_type = field.type
+        field_value = data.get(field_name)
+
+        # If the field type is a dataclass and the value is a dict, recursively initialize
+        if is_dataclass(field_type) and isinstance(field_value, dict):
+            kwargs[field_name] = dataclass_from_dict_with_validation(field_type, field_value)
+        else:
+            kwargs[field_name] = field_value  # Pass as-is if no special handling is needed
+
+    return cls(**kwargs)
+
+
+@dataclass()
+class ValidatedConfig:
+    def __setattr__(self, name, value):
+        if field := self.__dataclass_fields__.get(name):
+            if metadata := getattr(field.type, '__metadata__', None):
+                assert metadata[0](value), f'Invalid value passed to {name!r}: {value=}'
+        super().__setattr__(name, value)
+
+
+@dataclass
+class LoggingConfig(ValidatedConfig):
+    level: Annotated[
+        Literal['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'],
+        lambda level: level in ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'],
+    ]
+    file: Annotated[str, lambda file: isinstance(file, str)]
+    rich: Annotated[bool, lambda rich: isinstance(rich, bool)]
+
+
+@dataclass
+class ModelingConfig(ValidatedConfig):
+    BIG: Annotated[int, lambda x: isinstance(x, int)]
+    EPSILON: Annotated[float, lambda x: isinstance(x, float)]
+    BIG_BINARY_BOUND: Annotated[int, lambda x: isinstance(x, int)]
+
+
+@dataclass
+class ConfigSchema(ValidatedConfig):
+    config_name: Annotated[str, lambda x: isinstance(x, str)]
+    logging: LoggingConfig
+    modeling: ModelingConfig
+
+
+class CONFIG:
+    """
+    A configuration class that stores global configuration values as class attributes.
+    """
+
+    config_name: str = None
+    modeling: ModelingConfig = None
+    logging: LoggingConfig = None
+
+    @classmethod
+    def load_config(cls, user_config_file: Optional[str] = None):
+        """
+        Initialize configuration using defaults or user-specified file.
+        """
+        # Default config file
+        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:
+                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:
+                new_config = yaml.safe_load(user_file)
+
+        # Convert the merged config to ConfigSchema
+        config_data = dataclass_from_dict_with_validation(ConfigSchema, new_config)
+
+        # Store the configuration in the class as class attributes
+        cls.logging = config_data.logging
+        cls.modeling = config_data.modeling
+        cls.config_name = config_data.config_name
+
+        setup_logging(default_level=cls.logging.level, log_file=cls.logging.file, use_rich_handler=cls.logging.rich)
+
+    @classmethod
+    def to_dict(cls):
+        """
+        Convert the configuration class into a dictionary for JSON serialization.
+        Handles dataclasses and simple types like str, int, etc.
+        """
+        config_dict = {}
+        for attribute, value in cls.__dict__.items():
+            # Only consider attributes (not methods, etc.)
+            if (
+                not attribute.startswith('_')
+                and not isinstance(value, (types.FunctionType, types.MethodType))
+                and not isinstance(value, classmethod)
+            ):
+                if is_dataclass(value):
+                    config_dict[attribute] = value.__dict__
+                else:  # Assuming only basic types here!
+                    config_dict[attribute] = value
+
+        return config_dict
+
+
+class MultilineFormater(logging.Formatter):
+    def format(self, record):
+        message_lines = record.getMessage().split('\n')
+
+        # Prepare the log prefix (timestamp + log level)
+        timestamp = self.formatTime(record, self.datefmt)
+        log_level = record.levelname.ljust(8)  # Align log levels for consistency
+        log_prefix = f'{timestamp} | {log_level} |'
+
+        # Format all lines
+        first_line = [f'{log_prefix} {message_lines[0]}']
+        if len(message_lines) > 1:
+            lines = first_line + [f'{log_prefix} {line}' for line in message_lines[1:]]
+        else:
+            lines = first_line
+
+        return '\n'.join(lines)
+
+
+class ColoredMultilineFormater(MultilineFormater):
+    # ANSI escape codes for colors
+    COLORS = {
+        'DEBUG': '\033[32m',  # Green
+        'INFO': '\033[34m',  # Blue
+        'WARNING': '\033[33m',  # Yellow
+        'ERROR': '\033[31m',  # Red
+        'CRITICAL': '\033[1m\033[31m',  # Bold Red
+    }
+    RESET = '\033[0m'
+
+    def format(self, record):
+        lines = super().format(record).splitlines()
+        log_color = self.COLORS.get(record.levelname, self.RESET)
+
+        # Create a formatted message for each line separately
+        formatted_lines = []
+        for line in lines:
+            formatted_lines.append(f'{log_color}{line}{self.RESET}')
+
+        return '\n'.join(formatted_lines)
+
+
+def _get_logging_handler(log_file: Optional[str] = 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
+        console = Console(width=120)
+        rich_handler = RichHandler(
+            console=console,
+            rich_tracebacks=True,
+            omit_repeated_times=True,
+            show_path=False,
+            log_time_format='%Y-%m-%d %H:%M:%S',
+        )
+        rich_handler.setFormatter(logging.Formatter('%(message)s'))  # Simplified formatting
+
+        return rich_handler
+    elif log_file is None:
+        # Regular Logger with custom formating enabled
+        file_handler = logging.StreamHandler()
+        file_handler.setFormatter(
+            ColoredMultilineFormater(
+                fmt='%(message)s',
+                datefmt='%Y-%m-%d %H:%M:%S',
+            )
+        )
+        return file_handler
+    else:
+        # FileHandler for file output
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setFormatter(
+            MultilineFormater(
+                fmt='%(message)s',
+                datefmt='%Y-%m-%d %H:%M:%S',
+            )
+        )
+        return file_handler
+
+
+def setup_logging(
+    default_level: Literal['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'] = 'INFO',
+    log_file: Optional[str] = 'flixOpt.log',
+    use_rich_handler: bool = False,
+):
+    """Setup logging configuration"""
+    logger = logging.getLogger('flixOpt')  # Use a specific logger name for your package
+    logger.setLevel(get_logging_level_by_name(default_level))
+    # Clear existing handlers
+    if logger.hasHandlers():
+        logger.handlers.clear()
+
+    logger.addHandler(_get_logging_handler(use_rich_handler=use_rich_handler))
+    if log_file is not None:
+        logger.addHandler(_get_logging_handler(log_file, use_rich_handler=False))
+
+    return logger
+
+
+def get_logging_level_by_name(level_name: Literal['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']) -> int:
+    possible_logging_levels = ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']
+    if level_name.upper() not in possible_logging_levels:
+        raise ValueError(f'Invalid logging level {level_name}')
+    else:
+        logging_level = getattr(logging, level_name.upper(), logging.WARNING)
+        return logging_level
+
+
+def change_logging_level(level_name: Literal['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']):
+    logger = logging.getLogger('flixOpt')
+    logging_level = get_logging_level_by_name(level_name)
+    logger.setLevel(logging_level)
+    for handler in logger.handlers:
+        handler.setLevel(logging_level)

flixOpt/config.yaml

@@ -0,0 +1,10 @@
+# Default configuration of flixOpt
+config_name: flixOpt  # Name of the config file. This has no effect on the configuration itself.
+logging:
+  level: INFO
+  file: flixOpt.log
+  rich: false  # logging output is formatted using rich. This is only advisable when using a proper terminal
+modeling:
+  BIG: 10000000  # 1e notation not possible in yaml
+  EPSILON: 0.00001
+  BIG_BINARY_BOUND: 100000

flixOpt/core.py

@@ -0,0 +1,182 @@
+"""
+This module contains the core functionality of the flixOpt framework.
+It provides Datatypes, logging functionality, and some functions to transform data structures.
+"""
+
+import inspect
+import logging
+from typing import Any, Dict, List, Optional, Union
+
+import numpy as np
+
+from . import utils
+
+logger = logging.getLogger('flixOpt')
+
+Skalar = Union[int, float]  # Datatype
+Numeric = Union[int, float, np.ndarray]  # Datatype
+
+
+class TimeSeriesData:
+    # TODO: Move to Interface.py
+    def __init__(self, data: Numeric, 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)
+
+        Parameters
+        ----------
+        data : Union[int, float, np.ndarray]
+            The timeseries data, which can be a scalar, array, or numpy array.
+        agg_group : str, optional
+            The group this TimeSeriesData is a part of. agg_weight is split between members of a group. Default is None.
+        agg_weight : float, optional
+            The weight for calculation_type 'aggregated', should be between 0 and 1. Default is None.
+
+        Raises
+        ------
+        Exception
+            If both agg_group and agg_weight are set, an exception is raised.
+        """
+        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 Exception('Either <agg_group> or explicit <agg_weigth> can be used. Not both!')
+        self.label: Optional[str] = None
+
+    def __repr__(self):
+        # Get the constructor arguments and their current values
+        init_signature = inspect.signature(self.__init__)
+        init_args = init_signature.parameters
+
+        # Create a dictionary with argument names and their values
+        args_str = ', '.join(f'{name}={repr(getattr(self, name, None))}' for name in init_args if name != 'self')
+        return f'{self.__class__.__name__}({args_str})'
+
+    def __str__(self):
+        return str(self.data)
+
+
+Numeric_TS = Union[
+    Skalar, np.ndarray, TimeSeriesData
+]  # TODO: This is not really correct throughozt the codebase. Sometimes its used for TimeSeries aswell?
+
+
+class TimeSeries:
+    """
+    Class for data that applies to time series, stored as vector (np.ndarray) or scalar.
+
+    This class represents a vector or scalar value that makes the handling of time series easier.
+    It supports various operations such as activation of specific time indices, setting explicit active data, and
+    aggregation weight management.
+
+    Attributes
+    ----------
+    label : str
+        The label for the time series.
+    data : Optional[Numeric]
+        The actual data for the time series. Can be None.
+    aggregated_data : Optional[Numeric]
+        aggregated_data to use instead of data if provided.
+    active_indices : Optional[np.ndarray]
+        Indices of the time steps to activate.
+    aggregation_weight : float
+        Weight for aggregation method, between 0 and 1, normally 1.
+    aggregation_group : str
+        Group for calculating the aggregation weigth for aggregation method.
+    """
+
+    def __init__(self, label: str, data: Optional[Numeric_TS]):
+        self.label: str = label
+        if isinstance(data, TimeSeriesData):
+            self.data = self.make_scalar_if_possible(data.data)
+            self.aggregation_weight, self.aggregation_group = data.agg_weight, data.agg_group
+            data.label = self.label  # Connecting User_time_series to real Time_series
+        else:
+            self.data = self.make_scalar_if_possible(data)
+            self.aggregation_weight, self.aggregation_group = None, None
+
+        self.active_indices: Optional[Union[range, List[int]]] = None
+        self.aggregated_data: Optional[Numeric] = None
+
+    def activate_indices(self, indices: Optional[Union[range, List[int]]], aggregated_data: Optional[Numeric] = None):
+        self.active_indices = indices
+
+        if aggregated_data is not None:
+            assert len(aggregated_data) == len(self.active_indices) or len(aggregated_data) == 1, (
+                f'The aggregated_data has the wrong length for TimeSeries {self.label}. '
+                f'Length should be: {len(self.active_indices)} or 1, but is {len(aggregated_data)}'
+            )
+            self.aggregated_data = self.make_scalar_if_possible(aggregated_data)
+
+    def clear_indices_and_aggregated_data(self):
+        self.active_indices = None
+        self.aggregated_data = None
+
+    @property
+    def active_data(self) -> Numeric:
+        if self.aggregated_data is not None:  # Aggregated data is always active, if present
+            return self.aggregated_data
+
+        indices_not_applicable = np.isscalar(self.data) or (self.data is None) or (self.active_indices is None)
+        if indices_not_applicable:
+            return self.data
+        else:
+            return self.data[self.active_indices]
+
+    @property
+    def active_data_vector(self) -> np.ndarray:
+        # Always returns the active data as a vector.
+        return utils.as_vector(self.active_data, len(self.active_indices))
+
+    @property
+    def is_scalar(self) -> bool:
+        return np.isscalar(self.data)
+
+    @property
+    def is_array(self) -> bool:
+        return not self.is_scalar and self.data is not None
+
+    def __repr__(self):
+        # Retrieve all attributes and their values
+        attrs = vars(self)
+        # Format each attribute as 'key=value'
+        attrs_str = ', '.join(f'{key}={value!r}' for key, value in attrs.items())
+        # Format the output as 'ClassName(attr1=value1, attr2=value2, ...)'
+        return f'{self.__class__.__name__}({attrs_str})'
+
+    def __str__(self):
+        return str(self.active_data)
+
+    @staticmethod
+    def make_scalar_if_possible(data: Optional[Numeric]) -> Optional[Numeric]:
+        """
+        Convert an array to a scalar if all values are equal, or return the array as-is.
+        Can Return None if the passed data is None
+
+        Parameters
+        ----------
+        data : Numeric, None
+            The data to process.
+
+        Returns
+        -------
+        Numeric
+            A scalar if all values in the array are equal, otherwise the array itself. None, if the passed value is None
+        """
+        # TODO: Should this really return None Values?
+        if np.isscalar(data) or data is None:
+            return data
+        data = np.array(data)
+        if np.all(data == data[0]):
+            return data[0]
+        return data