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

flixopt/structure.py

@@ -3,13 +3,18 @@ This module contains the core structure of the flixopt framework.
 These classes are not directly used by the end user, but are used by other modules.
 """
 
+from __future__ import annotations
+
 import inspect
 import json
 import logging
-import pathlib
-from datetime import datetime
+from dataclasses import dataclass
 from io import StringIO
-from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, Tuple, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Literal,
+)
 
 import linopy
 import numpy as np
@@ -18,10 +23,13 @@ import xarray as xr
 from rich.console import Console
 from rich.pretty import Pretty
 
-from .config import CONFIG
-from .core import Scalar, TimeSeries, TimeSeriesCollection, TimeSeriesData, TimestepData
+from . import io as fx_io
+from .core import TimeSeriesData, get_dataarray_stats
 
 if TYPE_CHECKING:  # for type checking and preventing circular imports
+    import pathlib
+    from collections.abc import Collection, ItemsView, Iterator
+
     from .effects import EffectCollectionModel
     from .flow_system import FlowSystem
 
@@ -43,271 +51,812 @@ def register_class_for_io(cls):
     return cls
 
 
-class SystemModel(linopy.Model):
+class SubmodelsMixin:
+    """Mixin that provides submodel functionality for both FlowSystemModel and Submodel."""
+
+    submodels: Submodels
+
+    @property
+    def all_submodels(self) -> list[Submodel]:
+        """Get all submodels including nested ones recursively."""
+        direct_submodels = list(self.submodels.values())
+
+        # Recursively collect nested sub-models
+        nested_submodels = []
+        for submodel in direct_submodels:
+            nested_submodels.extend(submodel.all_submodels)
+
+        return direct_submodels + nested_submodels
+
+    def add_submodels(self, submodel: Submodel, short_name: str = None) -> Submodel:
+        """Register a sub-model with the model"""
+        if short_name is None:
+            short_name = submodel.__class__.__name__
+        if short_name in self.submodels:
+            raise ValueError(f'Short name "{short_name}" already assigned to model')
+        self.submodels.add(submodel, name=short_name)
+
+        return submodel
+
+
+class FlowSystemModel(linopy.Model, SubmodelsMixin):
     """
-    The SystemModel is the linopy Model that is used to create the mathematical model of the flow_system.
+    The FlowSystemModel is the linopy Model that is used to create the mathematical model of the flow_system.
     It is used to create and store the variables and constraints for the flow_system.
+
+    Args:
+        flow_system: The flow_system that is used to create the model.
+        normalize_weights: Whether to automatically normalize the weights to sum up to 1 when solving.
     """
 
-    def __init__(self, flow_system: 'FlowSystem'):
-        """
-        Args:
-            flow_system: The flow_system that is used to create the model.
-        """
+    def __init__(self, flow_system: FlowSystem, normalize_weights: bool):
         super().__init__(force_dim_names=True)
         self.flow_system = flow_system
-        self.time_series_collection = flow_system.time_series_collection
-        self.effects: Optional[EffectCollectionModel] = None
-        self.scenario_weights = self._calculate_scenario_weights(flow_system.scenario_weights)
+        self.normalize_weights = normalize_weights
+        self.effects: EffectCollectionModel | None = None
+        self.submodels: Submodels = Submodels({})
 
     def do_modeling(self):
         self.effects = self.flow_system.effects.create_model(self)
-        self.effects.do_modeling()
-        component_models = [component.create_model(self) for component in self.flow_system.components.values()]
-        bus_models = [bus.create_model(self) for bus in self.flow_system.buses.values()]
-        for component_model in component_models:
-            component_model.do_modeling()
-        for bus_model in bus_models:  # Buses after Components, because FlowModels are created in ComponentModels
-            bus_model.do_modeling()
-
-    def _calculate_scenario_weights(self, weights: Optional[TimeSeries] = None) -> xr.DataArray:
-        """Calculates the weights of the scenarios. If None, all scenarios have the same weight. All weights are normalized to 1.
-        If no scenarios are present, s single weight of 1 is returned.
-        """
-        if weights is not None and not isinstance(weights, TimeSeries):
-            raise TypeError(f'Weights must be a TimeSeries or None, got {type(weights)}')
-        if self.time_series_collection.scenarios is None:
-            return xr.DataArray(1)
-        if weights is None:
-            weights = xr.DataArray(
-                np.ones(len(self.time_series_collection.scenarios)),
-                coords={'scenario': self.time_series_collection.scenarios}
+        for component in self.flow_system.components.values():
+            component.create_model(self)
+        for bus in self.flow_system.buses.values():
+            bus.create_model(self)
+
+        # Add scenario equality constraints after all elements are modeled
+        self._add_scenario_equality_constraints()
+
+    def _add_scenario_equality_for_parameter_type(
+        self,
+        parameter_type: Literal['flow_rate', 'size'],
+        config: bool | list[str],
+    ):
+        """Add scenario equality constraints for a specific parameter type.
+
+        Args:
+            parameter_type: The type of parameter ('flow_rate' or 'size')
+            config: Configuration value (True = equalize all, False = equalize none, list = equalize these)
+        """
+        if config is False:
+            return  # All vary per scenario, no constraints needed
+
+        suffix = f'|{parameter_type}'
+        if config is True:
+            # All should be scenario-independent
+            vars_to_constrain = [var for var in self.variables if var.endswith(suffix)]
+        else:
+            # Only those in the list should be scenario-independent
+            all_vars = [var for var in self.variables if var.endswith(suffix)]
+            to_equalize = {f'{element}{suffix}' for element in config}
+            vars_to_constrain = [var for var in all_vars if var in to_equalize]
+
+        # Validate that all specified variables exist
+        missing_vars = [v for v in vars_to_constrain if v not in self.variables]
+        if missing_vars:
+            param_name = 'scenario_independent_sizes' if parameter_type == 'size' else 'scenario_independent_flow_rates'
+            raise ValueError(f'{param_name} contains invalid labels: {missing_vars}')
+
+        logger.debug(f'Adding scenario equality constraints for {len(vars_to_constrain)} {parameter_type} variables')
+        for var in vars_to_constrain:
+            self.add_constraints(
+                self.variables[var].isel(scenario=0) == self.variables[var].isel(scenario=slice(1, None)),
+                name=f'{var}|scenario_independent',
             )
-        elif isinstance(weights, TimeSeries):
-            weights = weights.selected_data
 
-        return weights / weights.sum()
+    def _add_scenario_equality_constraints(self):
+        """Add equality constraints to equalize variables across scenarios based on FlowSystem configuration."""
+        # Only proceed if we have scenarios
+        if self.flow_system.scenarios is None or len(self.flow_system.scenarios) <= 1:
+            return
+
+        self._add_scenario_equality_for_parameter_type('flow_rate', self.flow_system.scenario_independent_flow_rates)
+        self._add_scenario_equality_for_parameter_type('size', self.flow_system.scenario_independent_sizes)
 
     @property
     def solution(self):
         solution = super().solution
+        solution['objective'] = self.objective.value
         solution.attrs = {
             'Components': {
-                comp.label_full: comp.model.results_structure()
+                comp.label_full: comp.submodel.results_structure()
                 for comp in sorted(
                     self.flow_system.components.values(), key=lambda component: component.label_full.upper()
                 )
             },
             'Buses': {
-                bus.label_full: bus.model.results_structure()
+                bus.label_full: bus.submodel.results_structure()
                 for bus in sorted(self.flow_system.buses.values(), key=lambda bus: bus.label_full.upper())
             },
             'Effects': {
-                effect.label_full: effect.model.results_structure()
+                effect.label_full: effect.submodel.results_structure()
                 for effect in sorted(self.flow_system.effects, key=lambda effect: effect.label_full.upper())
             },
             'Flows': {
-                flow.label_full: flow.model.results_structure()
+                flow.label_full: flow.submodel.results_structure()
                 for flow in sorted(self.flow_system.flows.values(), key=lambda flow: flow.label_full.upper())
             },
         }
-        return solution.reindex(time=self.time_series_collection.timesteps_extra)
+        return solution.reindex(time=self.flow_system.timesteps_extra)
 
     @property
     def hours_per_step(self):
-        return self.time_series_collection.hours_per_timestep
+        return self.flow_system.hours_per_timestep
 
     @property
     def hours_of_previous_timesteps(self):
-        return self.time_series_collection.hours_of_previous_timesteps
+        return self.flow_system.hours_of_previous_timesteps
 
     def get_coords(
-        self, scenario_dim=True, time_dim=True, extra_timestep=False
-    ) -> Optional[Union[Tuple[pd.Index], Tuple[pd.Index, pd.Index]]]:
+        self,
+        dims: Collection[str] | None = None,
+        extra_timestep: bool = False,
+    ) -> xr.Coordinates | None:
         """
         Returns the coordinates of the model
 
         Args:
-            scenario_dim: If True, the scenario dimension is included in the coordinates
-            time_dim: If True, the time dimension is included in the coordinates
-            extra_timestep: If True, the extra timesteps are used instead of the regular timesteps
+            dims: The dimensions to include in the coordinates. If None, includes all dimensions
+            extra_timestep: If True, uses extra timesteps instead of regular timesteps
 
         Returns:
-            The coordinates of the model. Might also be None if no scenarios are present and time_dim is False
+            The coordinates of the model, or None if no coordinates are available
+
+        Raises:
+            ValueError: If extra_timestep=True but 'time' is not in dims
         """
-        if not scenario_dim and not time_dim:
-            return None
-        scenarios = self.time_series_collection.scenarios
-        timesteps = (
-            self.time_series_collection.timesteps if not extra_timestep else self.time_series_collection.timesteps_extra
-        )
+        if extra_timestep and dims is not None and 'time' not in dims:
+            raise ValueError('extra_timestep=True requires "time" to be included in dims')
+
+        if dims is None:
+            coords = dict(self.flow_system.coords)
+        else:
+            coords = {k: v for k, v in self.flow_system.coords.items() if k in dims}
+
+        if extra_timestep and coords:
+            coords['time'] = self.flow_system.timesteps_extra
 
-        if scenario_dim and time_dim:
-            if scenarios is None:
-                return (timesteps,)
-            return timesteps, scenarios
+        return xr.Coordinates(coords) if coords else None
 
-        if scenario_dim and not time_dim:
-            if scenarios is None:
-                return None
-            return (scenarios,)
-        if time_dim and not scenario_dim:
-            return (timesteps,)
+    @property
+    def weights(self) -> int | xr.DataArray:
+        """Returns the weights of the FlowSystem. Normalizes to 1 if normalize_weights is True"""
+        if self.flow_system.weights is not None:
+            weights = self.flow_system.weights
+        else:
+            weights = self.flow_system.fit_to_model_coords('weights', 1, dims=['period', 'scenario'])
+
+        if not self.normalize_weights:
+            return weights
+
+        return weights / weights.sum()
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of the FlowSystemModel, borrowed from linopy.Model.
+        """
+        # Extract content from existing representations
+        sections = {
+            f'Variables: [{len(self.variables)}]': self.variables.__repr__().split('\n', 2)[2],
+            f'Constraints: [{len(self.constraints)}]': self.constraints.__repr__().split('\n', 2)[2],
+            f'Submodels: [{len(self.submodels)}]': self.submodels.__repr__().split('\n', 2)[2],
+            'Status': self.status,
+        }
 
-        raise ValueError(f'Cannot get coordinates with both {scenario_dim=} and {time_dim=}')
+        # Format sections with headers and underlines
+        formatted_sections = []
+        for section_header, section_content in sections.items():
+            formatted_sections.append(f'{section_header}\n{"-" * len(section_header)}\n{section_content}')
+
+        title = f'FlowSystemModel ({self.type})'
+        all_sections = '\n'.join(formatted_sections)
+
+        return f'{title}\n{"=" * len(title)}\n\n{all_sections}'
 
 
 class Interface:
     """
-    This class is used to collect arguments about a Model. Its the base class for all Elements and Models in flixopt.
+    Base class for all Elements and Models in flixopt that provides serialization capabilities.
+
+    This class enables automatic serialization/deserialization of objects containing xarray DataArrays
+    and nested Interface objects to/from xarray Datasets and NetCDF files. It uses introspection
+    of constructor parameters to automatically handle most serialization scenarios.
+
+    Key Features:
+        - Automatic extraction and restoration of xarray DataArrays
+        - Support for nested Interface objects
+        - NetCDF and JSON export/import
+        - Recursive handling of complex nested structures
+
+    Subclasses must implement:
+        transform_data(flow_system): Transform data to match FlowSystem dimensions
     """
 
-    def transform_data(self, flow_system: 'FlowSystem'):
-        """Transforms the data of the interface to match the FlowSystem's dimensions"""
-        raise NotImplementedError('Every Interface needs a transform_data() method')
+    def transform_data(self, flow_system: FlowSystem, name_prefix: str = '') -> None:
+        """Transform the data of the interface to match the FlowSystem's dimensions.
+
+        Args:
+            flow_system: The FlowSystem containing timing and dimensional information
+            name_prefix: The prefix to use for the names of the variables. Defaults to '', which results in no prefix.
 
-    def infos(self, use_numpy: bool = True, use_element_label: bool = False) -> Dict:
+        Raises:
+            NotImplementedError: Must be implemented by subclasses
         """
-        Generate a dictionary representation of the object's constructor arguments.
-        Excludes default values and empty dictionaries and lists.
-        Converts data to be compatible with JSON.
+        raise NotImplementedError('Every Interface subclass needs a transform_data() method')
 
-        Args:
-            use_numpy: Whether to convert NumPy arrays to lists. Defaults to True.
-                If True, numeric numpy arrays (`np.ndarray`) are preserved as-is.
-                If False, they are converted to lists.
-            use_element_label: Whether to use the element label instead of the infos of the element. Defaults to False.
-                Note that Elements used as keys in dictionaries are always converted to their labels.
+    def _create_reference_structure(self) -> tuple[dict, dict[str, xr.DataArray]]:
+        """
+        Convert all DataArrays to references and extract them.
+        This is the core method that both to_dict() and to_dataset() build upon.
 
         Returns:
-            A dictionary representation of the object's constructor arguments.
+            Tuple of (reference_structure, extracted_arrays_dict)
 
+        Raises:
+            ValueError: If DataArrays don't have unique names or are duplicated
         """
-        # Get the constructor arguments and their default values
-        init_params = sorted(
-            inspect.signature(self.__init__).parameters.items(),
-            key=lambda x: (x[0].lower() != 'label', x[0].lower()),  # Prioritize 'label'
-        )
-        # Build a dict of attribute=value pairs, excluding defaults
-        details = {'class': ':'.join([cls.__name__ for cls in self.__class__.__mro__])}
-        for name, param in init_params:
-            if name == 'self':
+        # Get constructor parameters using caching for performance
+        if not hasattr(self, '_cached_init_params'):
+            self._cached_init_params = list(inspect.signature(self.__init__).parameters.keys())
+
+        # Process all constructor parameters
+        reference_structure = {'__class__': self.__class__.__name__}
+        all_extracted_arrays = {}
+
+        for name in self._cached_init_params:
+            if name == 'self':  # Skip self and timesteps. Timesteps are directly stored in Datasets
+                continue
+
+            value = getattr(self, name, None)
+
+            if value is None:
                 continue
-            value, default = getattr(self, name, None), param.default
-            # Ignore default values and empty dicts and list
-            if np.all(value == default) or (isinstance(value, (dict, list)) and not value):
+            if isinstance(value, pd.Index):
+                logger.debug(f'Skipping {name=} because it is an Index')
                 continue
-            details[name] = copy_and_convert_datatypes(value, use_numpy, use_element_label)
-        return details
 
-    def to_json(self, path: Union[str, pathlib.Path]):
+            # Extract arrays and get reference structure
+            processed_value, extracted_arrays = self._extract_dataarrays_recursive(value, name)
+
+            # Check for array name conflicts
+            conflicts = set(all_extracted_arrays.keys()) & set(extracted_arrays.keys())
+            if conflicts:
+                raise ValueError(
+                    f'DataArray name conflicts detected: {conflicts}. '
+                    f'Each DataArray must have a unique name for serialization.'
+                )
+
+            # Add extracted arrays to the collection
+            all_extracted_arrays.update(extracted_arrays)
+
+            # Only store in structure if it's not None/empty after processing
+            if processed_value is not None and not self._is_empty_container(processed_value):
+                reference_structure[name] = processed_value
+
+        return reference_structure, all_extracted_arrays
+
+    @staticmethod
+    def _is_empty_container(obj) -> bool:
+        """Check if object is an empty container (dict, list, tuple, set)."""
+        return isinstance(obj, (dict, list, tuple, set)) and len(obj) == 0
+
+    def _extract_dataarrays_recursive(self, obj, context_name: str = '') -> tuple[Any, dict[str, xr.DataArray]]:
         """
-        Saves the element to a json file.
-        This not meant to be reloaded and recreate the object, but rather used to document or compare the object.
+        Recursively extract DataArrays from nested structures.
 
         Args:
-            path: The path to the json file.
-        """
-        data = get_compact_representation(self.infos(use_numpy=True, use_element_label=True))
-        with open(path, 'w', encoding='utf-8') as f:
-            json.dump(data, f, indent=4, ensure_ascii=False)
+            obj: Object to process
+            context_name: Name context for better error messages
 
-    def to_dict(self) -> Dict:
-        """Convert the object to a dictionary representation."""
-        data = {'__class__': self.__class__.__name__}
+        Returns:
+            Tuple of (processed_object_with_references, extracted_arrays_dict)
 
-        # Get the constructor parameters
-        init_params = inspect.signature(self.__init__).parameters
+        Raises:
+            ValueError: If DataArrays don't have unique names
+        """
+        extracted_arrays = {}
+
+        # Handle DataArrays directly - use their unique name
+        if isinstance(obj, xr.DataArray):
+            if not obj.name:
+                raise ValueError(
+                    f'DataArrays must have a unique name for serialization. '
+                    f'Unnamed DataArray found in {context_name}. Please set array.name = "unique_name"'
+                )
 
-        for name in init_params:
-            if name == 'self':
-                continue
+            array_name = str(obj.name)  # Ensure string type
+            if array_name in extracted_arrays:
+                raise ValueError(
+                    f'DataArray name "{array_name}" is duplicated in {context_name}. '
+                    f'Each DataArray must have a unique name for serialization.'
+                )
 
-            value = getattr(self, name, None)
-            data[name] = self._serialize_value(value)
-
-        return data
-
-    def _serialize_value(self, value: Any):
-        """Helper method to serialize a value based on its type."""
-        if value is None:
-            return None
-        elif isinstance(value, Interface):
-            return value.to_dict()
-        elif isinstance(value, (list, tuple)):
-            return self._serialize_list(value)
-        elif isinstance(value, dict):
-            return self._serialize_dict(value)
+            extracted_arrays[array_name] = obj
+            return f':::{array_name}', extracted_arrays
+
+        # Handle Interface objects - extract their DataArrays too
+        elif isinstance(obj, Interface):
+            try:
+                interface_structure, interface_arrays = obj._create_reference_structure()
+                extracted_arrays.update(interface_arrays)
+                return interface_structure, extracted_arrays
+            except Exception as e:
+                raise ValueError(f'Failed to process nested Interface object in {context_name}: {e}') from e
+
+        # Handle sequences (lists, tuples)
+        elif isinstance(obj, (list, tuple)):
+            processed_items = []
+            for i, item in enumerate(obj):
+                item_context = f'{context_name}[{i}]' if context_name else f'item[{i}]'
+                processed_item, nested_arrays = self._extract_dataarrays_recursive(item, item_context)
+                extracted_arrays.update(nested_arrays)
+                processed_items.append(processed_item)
+            return processed_items, extracted_arrays
+
+        # Handle dictionaries
+        elif isinstance(obj, dict):
+            processed_dict = {}
+            for key, value in obj.items():
+                key_context = f'{context_name}.{key}' if context_name else str(key)
+                processed_value, nested_arrays = self._extract_dataarrays_recursive(value, key_context)
+                extracted_arrays.update(nested_arrays)
+                processed_dict[key] = processed_value
+            return processed_dict, extracted_arrays
+
+        # Handle sets (convert to list for JSON compatibility)
+        elif isinstance(obj, set):
+            processed_items = []
+            for i, item in enumerate(obj):
+                item_context = f'{context_name}.set_item[{i}]' if context_name else f'set_item[{i}]'
+                processed_item, nested_arrays = self._extract_dataarrays_recursive(item, item_context)
+                extracted_arrays.update(nested_arrays)
+                processed_items.append(processed_item)
+            return processed_items, extracted_arrays
+
+        # For all other types, serialize to basic types
         else:
-            return value
+            return self._serialize_to_basic_types(obj), extracted_arrays
+
+    def _handle_deprecated_kwarg(
+        self,
+        kwargs: dict,
+        old_name: str,
+        new_name: str,
+        current_value: Any = None,
+        transform: callable = None,
+        check_conflict: bool = True,
+    ) -> Any:
+        """
+        Handle a deprecated keyword argument by issuing a warning and returning the appropriate value.
+
+        This centralizes the deprecation pattern used across multiple classes (Source, Sink, InvestParameters, etc.).
+
+        Args:
+            kwargs: Dictionary of keyword arguments to check and modify
+            old_name: Name of the deprecated parameter
+            new_name: Name of the replacement parameter
+            current_value: Current value of the new parameter (if already set)
+            transform: Optional callable to transform the old value before returning (e.g., lambda x: [x] to wrap in list)
+            check_conflict: Whether to check if both old and new parameters are specified (default: True).
+                Note: For parameters with non-None default values (e.g., bool parameters with default=False),
+                set check_conflict=False since we cannot distinguish between an explicit value and the default.
+
+        Returns:
+            The value to use (either from old parameter or current_value)
+
+        Raises:
+            ValueError: If both old and new parameters are specified and check_conflict is True
+
+        Example:
+            # For parameters where None is the default (conflict checking works):
+            value = self._handle_deprecated_kwarg(kwargs, 'old_param', 'new_param', current_value)
+
+            # For parameters with non-None defaults (disable conflict checking):
+            mandatory = self._handle_deprecated_kwarg(
+                kwargs, 'optional', 'mandatory', mandatory,
+                transform=lambda x: not x,
+                check_conflict=False  # Cannot detect if mandatory was explicitly passed
+            )
+        """
+        import warnings
+
+        old_value = kwargs.pop(old_name, None)
+        if old_value is not None:
+            warnings.warn(
+                f'The use of the "{old_name}" argument is deprecated. Use the "{new_name}" argument instead.',
+                DeprecationWarning,
+                stacklevel=3,  # Stack: this method -> __init__ -> caller
+            )
+            # Check for conflicts: only raise error if both were explicitly provided
+            if check_conflict and current_value is not None:
+                raise ValueError(f'Either {old_name} or {new_name} can be specified, but not both.')
+
+            # Apply transformation if provided
+            if transform is not None:
+                return transform(old_value)
+            return old_value
+
+        return current_value
+
+    def _validate_kwargs(self, kwargs: dict, class_name: str = None) -> None:
+        """
+        Validate that no unexpected keyword arguments are present in kwargs.
+
+        This method uses inspect to get the actual function signature and filters out
+        any parameters that are not defined in the __init__ method, while also
+        handling the special case of 'kwargs' itself which can appear during deserialization.
+
+        Args:
+            kwargs: Dictionary of keyword arguments to validate
+            class_name: Optional class name for error messages. If None, uses self.__class__.__name__
+
+        Raises:
+            TypeError: If unexpected keyword arguments are found
+        """
+        if not kwargs:
+            return
+
+        import inspect
 
-    def _serialize_list(self, items):
-        """Serialize a list of items."""
-        return [self._serialize_value(item) for item in items]
+        sig = inspect.signature(self.__init__)
+        known_params = set(sig.parameters.keys()) - {'self', 'kwargs'}
+        # Also filter out 'kwargs' itself which can appear during deserialization
+        extra_kwargs = {k: v for k, v in kwargs.items() if k not in known_params and k != 'kwargs'}
 
-    def _serialize_dict(self, d):
-        """Serialize a dictionary of items."""
-        return {k: self._serialize_value(v) for k, v in d.items()}
+        if extra_kwargs:
+            class_name = class_name or self.__class__.__name__
+            unexpected_params = ', '.join(f"'{param}'" for param in extra_kwargs.keys())
+            raise TypeError(f'{class_name}.__init__() got unexpected keyword argument(s): {unexpected_params}')
 
     @classmethod
-    def _deserialize_dict(cls, data: Dict) -> Union[Dict, 'Interface']:
-        if '__class__' in data:
-            class_name = data.pop('__class__')
-            try:
-                class_type = CLASS_REGISTRY[class_name]
-                if issubclass(class_type, Interface):
-                    # Use _deserialize_dict to process the arguments
-                    processed_data = {k: cls._deserialize_value(v) for k, v in data.items()}
-                    return class_type(**processed_data)
-                else:
-                    raise ValueError(f'Class "{class_name}" is not an Interface.')
-            except (AttributeError, KeyError) as e:
-                raise ValueError(f'Class "{class_name}" could not get reconstructed.') from e
-        else:
-            return {k: cls._deserialize_value(v) for k, v in data.items()}
+    def _resolve_dataarray_reference(
+        cls, reference: str, arrays_dict: dict[str, xr.DataArray]
+    ) -> xr.DataArray | TimeSeriesData:
+        """
+        Resolve a single DataArray reference (:::name) to actual DataArray or TimeSeriesData.
+
+        Args:
+            reference: Reference string starting with ":::"
+            arrays_dict: Dictionary of available DataArrays
+
+        Returns:
+            Resolved DataArray or TimeSeriesData object
+
+        Raises:
+            ValueError: If referenced array is not found
+        """
+        array_name = reference[3:]  # Remove ":::" prefix
+        if array_name not in arrays_dict:
+            raise ValueError(f"Referenced DataArray '{array_name}' not found in dataset")
+
+        array = arrays_dict[array_name]
+
+        # Handle null values with warning
+        if array.isnull().any():
+            logger.error(f"DataArray '{array_name}' contains null values. Dropping all-null along present dims.")
+            if 'time' in array.dims:
+                array = array.dropna(dim='time', how='all')
+
+        # Check if this should be restored as TimeSeriesData
+        if TimeSeriesData.is_timeseries_data(array):
+            return TimeSeriesData.from_dataarray(array)
+
+        return array
 
     @classmethod
-    def _deserialize_list(cls, data: List) -> List:
-        return [cls._deserialize_value(value) for value in data]
+    def _resolve_reference_structure(cls, structure, arrays_dict: dict[str, xr.DataArray]):
+        """
+        Convert reference structure back to actual objects using provided arrays.
+
+        Args:
+            structure: Structure containing references (:::name) or special type markers
+            arrays_dict: Dictionary of available DataArrays
+
+        Returns:
+            Structure with references resolved to actual DataArrays or objects
+
+        Raises:
+            ValueError: If referenced arrays are not found or class is not registered
+        """
+        # Handle DataArray references
+        if isinstance(structure, str) and structure.startswith(':::'):
+            return cls._resolve_dataarray_reference(structure, arrays_dict)
+
+        elif isinstance(structure, list):
+            resolved_list = []
+            for item in structure:
+                resolved_item = cls._resolve_reference_structure(item, arrays_dict)
+                if resolved_item is not None:  # Filter out None values from missing references
+                    resolved_list.append(resolved_item)
+            return resolved_list
+
+        elif isinstance(structure, dict):
+            if structure.get('__class__'):
+                class_name = structure['__class__']
+                if class_name not in CLASS_REGISTRY:
+                    raise ValueError(
+                        f"Class '{class_name}' not found in CLASS_REGISTRY. "
+                        f'Available classes: {list(CLASS_REGISTRY.keys())}'
+                    )
+
+                # This is a nested Interface object - restore it recursively
+                nested_class = CLASS_REGISTRY[class_name]
+                # Remove the __class__ key and process the rest
+                nested_data = {k: v for k, v in structure.items() if k != '__class__'}
+                # Resolve references in the nested data
+                resolved_nested_data = cls._resolve_reference_structure(nested_data, arrays_dict)
+
+                try:
+                    return nested_class(**resolved_nested_data)
+                except Exception as e:
+                    raise ValueError(f'Failed to create instance of {class_name}: {e}') from e
+            else:
+                # Regular dictionary - resolve references in values
+                resolved_dict = {}
+                for key, value in structure.items():
+                    resolved_value = cls._resolve_reference_structure(value, arrays_dict)
+                    if resolved_value is not None or value is None:  # Keep None values if they were originally None
+                        resolved_dict[key] = resolved_value
+                return resolved_dict
+
+        else:
+            return structure
+
+    def _serialize_to_basic_types(self, obj):
+        """
+        Convert object to basic Python types only (no DataArrays, no custom objects).
+
+        Args:
+            obj: Object to serialize
+
+        Returns:
+            Object converted to basic Python types (str, int, float, bool, list, dict)
+        """
+        if obj is None or isinstance(obj, (str, int, float, bool)):
+            return obj
+        elif isinstance(obj, np.integer):
+            return int(obj)
+        elif isinstance(obj, np.floating):
+            return float(obj)
+        elif isinstance(obj, np.bool_):
+            return bool(obj)
+        elif isinstance(obj, (np.ndarray, pd.Series, pd.DataFrame)):
+            return obj.tolist() if hasattr(obj, 'tolist') else list(obj)
+        elif isinstance(obj, dict):
+            return {k: self._serialize_to_basic_types(v) for k, v in obj.items()}
+        elif isinstance(obj, (list, tuple)):
+            return [self._serialize_to_basic_types(item) for item in obj]
+        elif isinstance(obj, set):
+            return [self._serialize_to_basic_types(item) for item in obj]
+        elif hasattr(obj, 'isoformat'):  # datetime objects
+            return obj.isoformat()
+        elif hasattr(obj, '__dict__'):  # Custom objects with attributes
+            logger.warning(f'Converting custom object {type(obj)} to dict representation: {obj}')
+            return {str(k): self._serialize_to_basic_types(v) for k, v in obj.__dict__.items()}
+        else:
+            # For any other object, try to convert to string as fallback
+            logger.error(f'Converting unknown type {type(obj)} to string: {obj}')
+            return str(obj)
+
+    def to_dataset(self) -> xr.Dataset:
+        """
+        Convert the object to an xarray Dataset representation.
+        All DataArrays become dataset variables, everything else goes to attrs.
+
+        Its recommended to only call this method on Interfaces with all numeric data stored as xr.DataArrays.
+        Interfaces inside a FlowSystem are automatically converted this form after connecting and transforming the FlowSystem.
+
+        Returns:
+            xr.Dataset: Dataset containing all DataArrays with basic objects only in attributes
+
+        Raises:
+            ValueError: If serialization fails due to naming conflicts or invalid data
+        """
+        try:
+            reference_structure, extracted_arrays = self._create_reference_structure()
+            # Create the dataset with extracted arrays as variables and structure as attrs
+            return xr.Dataset(extracted_arrays, attrs=reference_structure)
+        except Exception as e:
+            raise ValueError(
+                f'Failed to convert {self.__class__.__name__} to dataset. Its recommended to only call this method on '
+                f'a fully connected and transformed FlowSystem, or Interfaces inside such a FlowSystem.'
+                f'Original Error: {e}'
+            ) from e
+
+    def to_netcdf(self, path: str | pathlib.Path, compression: int = 0):
+        """
+        Save the object to a NetCDF file.
+
+        Args:
+            path: Path to save the NetCDF file
+            compression: Compression level (0-9)
+
+        Raises:
+            ValueError: If serialization fails
+            IOError: If file cannot be written
+        """
+        try:
+            ds = self.to_dataset()
+            fx_io.save_dataset_to_netcdf(ds, path, compression=compression)
+        except Exception as e:
+            raise OSError(f'Failed to save {self.__class__.__name__} to NetCDF file {path}: {e}') from e
 
     @classmethod
-    def _deserialize_value(cls, value: Any):
-        """Helper method to deserialize a value based on its type."""
-        if value is None:
-            return None
-        elif isinstance(value, dict):
-            return cls._deserialize_dict(value)
-        elif isinstance(value, list):
-            return cls._deserialize_list(value)
-        return value
+    def from_dataset(cls, ds: xr.Dataset) -> Interface:
+        """
+        Create an instance from an xarray Dataset.
+
+        Args:
+            ds: Dataset containing the object data
+
+        Returns:
+            Interface instance
+
+        Raises:
+            ValueError: If dataset format is invalid or class mismatch
+        """
+        try:
+            # Get class name and verify it matches
+            class_name = ds.attrs.get('__class__')
+            if class_name and class_name != cls.__name__:
+                logger.warning(f"Dataset class '{class_name}' doesn't match target class '{cls.__name__}'")
+
+            # Get the reference structure from attrs
+            reference_structure = dict(ds.attrs)
+
+            # Remove the class name since it's not a constructor parameter
+            reference_structure.pop('__class__', None)
+
+            # Create arrays dictionary from dataset variables
+            arrays_dict = {name: array for name, array in ds.data_vars.items()}
+
+            # Resolve all references using the centralized method
+            resolved_params = cls._resolve_reference_structure(reference_structure, arrays_dict)
+
+            return cls(**resolved_params)
+        except Exception as e:
+            raise ValueError(f'Failed to create {cls.__name__} from dataset: {e}') from e
 
     @classmethod
-    def from_dict(cls, data: Dict) -> 'Interface':
+    def from_netcdf(cls, path: str | pathlib.Path) -> Interface:
         """
-        Create an instance from a dictionary representation.
+        Load an instance from a NetCDF file.
 
         Args:
-            data: Dictionary containing the data for the object.
+            path: Path to the NetCDF file
+
+        Returns:
+            Interface instance
+
+        Raises:
+            IOError: If file cannot be read
+            ValueError: If file format is invalid
         """
-        return cls._deserialize_dict(data)
+        try:
+            ds = fx_io.load_dataset_from_netcdf(path)
+            return cls.from_dataset(ds)
+        except Exception as e:
+            raise OSError(f'Failed to load {cls.__name__} from NetCDF file {path}: {e}') from e
 
-    def __repr__(self):
-        # Get the constructor arguments and their current values
-        init_signature = inspect.signature(self.__init__)
-        init_args = init_signature.parameters
+    def get_structure(self, clean: bool = False, stats: bool = False) -> dict:
+        """
+        Get object structure as a dictionary.
+
+        Args:
+            clean: If True, remove None and empty dicts and lists.
+            stats: If True, replace DataArray references with statistics
 
-        # 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})'
+        Returns:
+            Dictionary representation of the object structure
+        """
+        reference_structure, extracted_arrays = self._create_reference_structure()
+
+        if stats:
+            # Replace references with statistics
+            reference_structure = self._replace_references_with_stats(reference_structure, extracted_arrays)
+
+        if clean:
+            return fx_io.remove_none_and_empty(reference_structure)
+        return reference_structure
+
+    def _replace_references_with_stats(self, structure, arrays_dict: dict[str, xr.DataArray]):
+        """Replace DataArray references with statistical summaries."""
+        if isinstance(structure, str) and structure.startswith(':::'):
+            array_name = structure[3:]
+            if array_name in arrays_dict:
+                return get_dataarray_stats(arrays_dict[array_name])
+            return structure
+
+        elif isinstance(structure, dict):
+            return {k: self._replace_references_with_stats(v, arrays_dict) for k, v in structure.items()}
+
+        elif isinstance(structure, list):
+            return [self._replace_references_with_stats(item, arrays_dict) for item in structure]
+
+        return structure
+
+    def to_json(self, path: str | pathlib.Path):
+        """
+        Save the object to a JSON file.
+        This is meant for documentation and comparison, not for reloading.
+
+        Args:
+            path: The path to the JSON file.
+
+        Raises:
+            IOError: If file cannot be written
+        """
+        try:
+            # Use the stats mode for JSON export (cleaner output)
+            data = self.get_structure(clean=True, stats=True)
+            with open(path, 'w', encoding='utf-8') as f:
+                json.dump(data, f, indent=4, ensure_ascii=False)
+        except Exception as e:
+            raise OSError(f'Failed to save {self.__class__.__name__} to JSON file {path}: {e}') from e
+
+    def __repr__(self):
+        """Return a detailed string representation for debugging."""
+        try:
+            # 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, with better formatting
+            args_parts = []
+            for name in init_args:
+                if name == 'self':
+                    continue
+                value = getattr(self, name, None)
+                # Truncate long representations
+                value_repr = repr(value)
+                if len(value_repr) > 50:
+                    value_repr = value_repr[:47] + '...'
+                args_parts.append(f'{name}={value_repr}')
+
+            args_str = ', '.join(args_parts)
+            return f'{self.__class__.__name__}({args_str})'
+        except Exception:
+            # Fallback if introspection fails
+            return f'{self.__class__.__name__}(<repr_failed>)'
 
     def __str__(self):
-        return get_str_representation(self.infos(use_numpy=True, use_element_label=True))
+        """Return a user-friendly string representation."""
+        try:
+            data = self.get_structure(clean=True, stats=True)
+            with StringIO() as output_buffer:
+                console = Console(file=output_buffer, width=1000)  # Adjust width as needed
+                console.print(Pretty(data, expand_all=True, indent_guides=True))
+                return output_buffer.getvalue()
+        except Exception:
+            # Fallback if structure generation fails
+            return f'{self.__class__.__name__} instance'
+
+    def copy(self) -> Interface:
+        """
+        Create a copy of the Interface object.
+
+        Uses the existing serialization infrastructure to ensure proper copying
+        of all DataArrays and nested objects.
+
+        Returns:
+            A new instance of the same class with copied data.
+        """
+        # Convert to dataset, copy it, and convert back
+        dataset = self.to_dataset().copy(deep=True)
+        return self.__class__.from_dataset(dataset)
+
+    def __copy__(self):
+        """Support for copy.copy()."""
+        return self.copy()
+
+    def __deepcopy__(self, memo):
+        """Support for copy.deepcopy()."""
+        return self.copy()
 
 
 class Element(Interface):
     """This class is the basic Element of flixopt. Every Element has a label"""
 
-    def __init__(self, label: str, meta_data: Dict = None):
+    def __init__(self, label: str, meta_data: dict | None = None):
         """
         Args:
             label: The label of the element
@@ -315,13 +864,14 @@ class Element(Interface):
         """
         self.label = Element._valid_label(label)
         self.meta_data = meta_data if meta_data is not None else {}
-        self.model: Optional[ElementModel] = None
+        self.submodel: ElementModel | None = None
 
     def _plausibility_checks(self) -> None:
-        """This function is used to do some basic plausibility checks for each Element during initialization"""
+        """This function is used to do some basic plausibility checks for each Element during initialization.
+        This is run after all data is transformed to the correct format/type"""
         raise NotImplementedError('Every Element needs a _plausibility_checks() method')
 
-    def create_model(self, model: SystemModel) -> 'ElementModel':
+    def create_model(self, model: FlowSystemModel) -> ElementModel:
         raise NotImplementedError('Every Element needs a create_model() method')
 
     @property
@@ -345,71 +895,105 @@ class Element(Interface):
                 f'Use any other symbol instead'
             )
         if label.endswith(' '):
-            logger.warning(f'Label "{label}" ends with a space. This will be removed.')
+            logger.error(f'Label "{label}" ends with a space. This will be removed.')
             return label.rstrip()
         return label
 
 
-class Model:
-    """Stores Variables and Constraints."""
+class Submodel(SubmodelsMixin):
+    """Stores Variables and Constraints. Its a subset of a FlowSystemModel.
+    Variables and constraints are stored in the main FlowSystemModel, and are referenced here.
+    Can have other Submodels assigned, and can be a Submodel of another Submodel.
+    """
 
-    def __init__(
-        self, model: SystemModel, label_of_element: str, label: str = '', label_full: Optional[str] = None
-    ):
+    def __init__(self, model: FlowSystemModel, label_of_element: str, label_of_model: str | None = None):
         """
         Args:
-            model: The SystemModel that is used to create the model.
+            model: The FlowSystemModel that is used to create the model.
             label_of_element: The label of the parent (Element). Used to construct the full label of the model.
-            label: The label of the model. Used to construct the full label of the model.
-            label_full: The full label of the model. Can overwrite the full label constructed from the other labels.
+            label_of_model: The label of the model. Used as a prefix in all variables and constraints.
         """
         self._model = model
         self.label_of_element = label_of_element
-        self._label = label
-        self._label_full = label_full
+        self.label_of_model = label_of_model if label_of_model is not None else self.label_of_element
+
+        self._variables: dict[str, linopy.Variable] = {}  # Mapping from short name to variable
+        self._constraints: dict[str, linopy.Constraint] = {}  # Mapping from short name to constraint
+        self.submodels: Submodels = Submodels({})
+
+        logger.debug(f'Creating {self.__class__.__name__}  "{self.label_full}"')
+        self._do_modeling()
+
+    def add_variables(self, short_name: str = None, **kwargs) -> linopy.Variable:
+        """Create and register a variable in one step"""
+        if kwargs.get('name') is None:
+            if short_name is None:
+                raise ValueError('Short name must be provided when no name is given')
+            kwargs['name'] = f'{self.label_of_model}|{short_name}'
+
+        variable = self._model.add_variables(**kwargs)
+        self.register_variable(variable, short_name)
+        return variable
+
+    def add_constraints(self, expression, short_name: str = None, **kwargs) -> linopy.Constraint:
+        """Create and register a constraint in one step"""
+        if kwargs.get('name') is None:
+            if short_name is None:
+                raise ValueError('Short name must be provided when no name is given')
+            kwargs['name'] = f'{self.label_of_model}|{short_name}'
+
+        constraint = self._model.add_constraints(expression, **kwargs)
+        self.register_constraint(constraint, short_name)
+        return constraint
+
+    def register_variable(self, variable: linopy.Variable, short_name: str = None) -> linopy.Variable:
+        """Register a variable with the model"""
+        if short_name is None:
+            short_name = variable.name
+        elif short_name in self._variables:
+            raise ValueError(f'Short name "{short_name}" already assigned to model variables')
+
+        self._variables[short_name] = variable
+        return variable
+
+    def register_constraint(self, constraint: linopy.Constraint, short_name: str = None) -> linopy.Constraint:
+        """Register a constraint with the model"""
+        if short_name is None:
+            short_name = constraint.name
+        elif short_name in self._constraints:
+            raise ValueError(f'Short name "{short_name}" already assigned to model constraint')
+
+        self._constraints[short_name] = constraint
+        return constraint
+
+    def __getitem__(self, key: str) -> linopy.Variable:
+        """Get a variable by its short name"""
+        if key in self._variables:
+            return self._variables[key]
+        raise KeyError(f'Variable "{key}" not found in model "{self.label_full}"')
+
+    def __contains__(self, name: str) -> bool:
+        """Check if a variable exists in the model"""
+        return name in self._variables or name in self.variables
+
+    def get(self, name: str, default=None):
+        """Get variable by short name, returning default if not found"""
+        try:
+            return self[name]
+        except KeyError:
+            return default
 
-        self._variables_direct: List[str] = []
-        self._constraints_direct: List[str] = []
-        self.sub_models: List[Model] = []
-
-        self._variables_short: Dict[str, str] = {}
-        self._constraints_short: Dict[str, str] = {}
-        self._sub_models_short: Dict[str, str] = {}
-        logger.debug(f'Created {self.__class__.__name__}  "{self.label_full}"')
-
-    def do_modeling(self):
-        raise NotImplementedError('Every Model needs a do_modeling() method')
-
-    def add(
-        self, item: Union[linopy.Variable, linopy.Constraint, 'Model'], short_name: Optional[str] = None
-    ) -> Union[linopy.Variable, linopy.Constraint, 'Model']:
-        """
-        Add a variable, constraint or sub-model to the model
-
-        Args:
-            item: The variable, constraint or sub-model to add to the model
-            short_name: The short name of the variable, constraint or sub-model. If not provided, the full name is used.
-        """
-        # TODO: Check uniquenes of short names
-        if isinstance(item, linopy.Variable):
-            self._variables_direct.append(item.name)
-            self._variables_short[item.name] = short_name or item.name
-        elif isinstance(item, linopy.Constraint):
-            self._constraints_direct.append(item.name)
-            self._constraints_short[item.name] = short_name or item.name
-        elif isinstance(item, Model):
-            self.sub_models.append(item)
-            self._sub_models_short[item.label_full] = short_name or item.label_full
-        else:
-            raise ValueError(
-                f'Item must be a linopy.Variable, linopy.Constraint or flixopt.structure.Model, got {type(item)}'
-            )
-        return item
+    def get_coords(
+        self,
+        dims: Collection[str] | None = None,
+        extra_timestep: bool = False,
+    ) -> xr.Coordinates | None:
+        return self._model.get_coords(dims=dims, extra_timestep=extra_timestep)
 
     def filter_variables(
         self,
-        filter_by: Optional[Literal['binary', 'continuous', 'integer']] = None,
-        length: Literal['scalar', 'time'] = None,
+        filter_by: Literal['binary', 'continuous', 'integer'] | None = None,
+        length: Literal['scalar', 'time'] | None = None,
     ):
         if filter_by is None:
             all_variables = self.variables
@@ -429,256 +1013,158 @@ class Model:
             return all_variables[[name for name in all_variables if 'time' in all_variables[name].dims]]
         raise ValueError(f'Invalid length "{length}", must be one of "scalar", "time" or None')
 
-    @property
-    def label(self) -> str:
-        return self._label if self._label else self.label_of_element
-
     @property
     def label_full(self) -> str:
-        """Used to construct the names of variables and constraints"""
-        if self._label_full:
-            return self._label_full
-        elif self._label:
-            return f'{self.label_of_element}|{self.label}'
-        return self.label_of_element
+        return self.label_of_model
 
     @property
     def variables_direct(self) -> linopy.Variables:
-        return self._model.variables[self._variables_direct]
+        """Variables of the model, excluding those of sub-models"""
+        return self._model.variables[[var.name for var in self._variables.values()]]
 
     @property
     def constraints_direct(self) -> linopy.Constraints:
-        return self._model.constraints[self._constraints_direct]
+        """Constraints of the model, excluding those of sub-models"""
+        return self._model.constraints[[con.name for con in self._constraints.values()]]
 
     @property
-    def _variables(self) -> List[str]:
-        all_variables = self._variables_direct.copy()
-        for sub_model in self.sub_models:
-            for variable in sub_model._variables:
-                if variable in all_variables:
-                    raise KeyError(
-                        f"Duplicate key found: '{variable}' in both {self.label_full} and {sub_model.label_full}!"
-                    )
-                all_variables.append(variable)
-        return all_variables
+    def constraints(self) -> linopy.Constraints:
+        """All constraints of the model, including those of all sub-models"""
+        names = list(self.constraints_direct) + [
+            constraint_name for submodel in self.submodels.values() for constraint_name in submodel.constraints
+        ]
 
-    @property
-    def _constraints(self) -> List[str]:
-        all_constraints = self._constraints_direct.copy()
-        for sub_model in self.sub_models:
-            for constraint in sub_model._constraints:
-                if constraint in all_constraints:
-                    raise KeyError(f"Duplicate key found: '{constraint}' in both main model and submodel!")
-                all_constraints.append(constraint)
-        return all_constraints
+        return self._model.constraints[names]
 
     @property
     def variables(self) -> linopy.Variables:
-        return self._model.variables[self._variables]
+        """All variables of the model, including those of all sub-models"""
+        names = list(self.variables_direct) + [
+            variable_name for submodel in self.submodels.values() for variable_name in submodel.variables
+        ]
 
-    @property
-    def constraints(self) -> linopy.Constraints:
-        return self._model.constraints[self._constraints]
+        return self._model.variables[names]
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of the linopy model.
+        """
+        # Extract content from existing representations
+        sections = {
+            f'Variables: [{len(self.variables)}/{len(self._model.variables)}]': self.variables.__repr__().split(
+                '\n', 2
+            )[2],
+            f'Constraints: [{len(self.constraints)}/{len(self._model.constraints)}]': self.constraints.__repr__().split(
+                '\n', 2
+            )[2],
+            f'Submodels: [{len(self.submodels)}]': self.submodels.__repr__().split('\n', 2)[2],
+        }
+
+        # Format sections with headers and underlines
+        formatted_sections = []
+        for section_header, section_content in sections.items():
+            formatted_sections.append(f'{section_header}\n{"-" * len(section_header)}\n{section_content}')
+
+        model_string = f'Submodel "{self.label_of_model}":'
+        all_sections = '\n'.join(formatted_sections)
+
+        return f'{model_string}\n{"=" * len(model_string)}\n\n{all_sections}'
 
     @property
-    def all_sub_models(self) -> List['Model']:
-        return [model for sub_model in self.sub_models for model in [sub_model] + sub_model.all_sub_models]
+    def hours_per_step(self):
+        return self._model.hours_per_step
 
+    def _do_modeling(self):
+        """Called at the end of initialization. Override in subclasses to create variables and constraints."""
+        pass
 
-class ElementModel(Model):
-    """Stores the mathematical Variables and Constraints for Elements"""
 
-    def __init__(self, model: SystemModel, element: Element):
-        """
-        Args:
-            model: The SystemModel that is used to create the model.
-            element: The element this model is created for.
-        """
-        super().__init__(model, label_of_element=element.label_full, label=element.label, label_full=element.label_full)
-        self.element = element
+@dataclass(repr=False)
+class Submodels:
+    """A simple collection for storing submodels with easy access and representation."""
 
-    def results_structure(self):
-        return {
-            'label': self.label_full,
-            'variables': list(self.variables),
-            'constraints': list(self.constraints),
-        }
+    data: dict[str, Submodel]
 
+    def __getitem__(self, name: str) -> Submodel:
+        """Get a submodel by its name."""
+        return self.data[name]
 
-def copy_and_convert_datatypes(data: Any, use_numpy: bool = True, use_element_label: bool = False) -> Any:
-    """
-    Converts values in a nested data structure into JSON-compatible types while preserving or transforming numpy arrays
-    and custom `Element` objects based on the specified options.
+    def __getattr__(self, name: str) -> Submodel:
+        """Get a submodel by attribute access."""
+        if name in self.data:
+            return self.data[name]
+        raise AttributeError(f"Submodels has no attribute '{name}'")
 
-    The function handles various data types and transforms them into a consistent, readable format:
-    - Primitive types (`int`, `float`, `str`, `bool`, `None`) are returned as-is.
-    - Numpy scalars are converted to their corresponding Python scalar types.
-    - Collections (`list`, `tuple`, `set`, `dict`) are recursively processed to ensure all elements are compatible.
-    - Numpy arrays are preserved or converted to lists, depending on `use_numpy`.
-    - Custom `Element` objects can be represented either by their `label` or their initialization parameters as a dictionary.
-    - Timestamps (`datetime`) are converted to ISO 8601 strings.
+    def __len__(self) -> int:
+        return len(self.data)
 
-    Args:
-        data: The input data to process, which may be deeply nested and contain a mix of types.
-        use_numpy: If `True`, numeric numpy arrays (`np.ndarray`) are preserved as-is. If `False`, they are converted to lists.
-            Default is `True`.
-        use_element_label: If `True`, `Element` objects are represented by their `label`. If `False`, they are converted into a dictionary
-            based on their initialization parameters. Default is `False`.
-
-    Returns:
-        A transformed version of the input data, containing only JSON-compatible types:
-        - `int`, `float`, `str`, `bool`, `None`
-        - `list`, `dict`
-        - `np.ndarray` (if `use_numpy=True`. This is NOT JSON-compatible)
-
-    Raises:
-        TypeError: If the data cannot be converted to the specified types.
-
-    Examples:
-        >>> copy_and_convert_datatypes({'a': np.array([1, 2, 3]), 'b': Element(label='example')})
-        {'a': array([1, 2, 3]), 'b': {'class': 'Element', 'label': 'example'}}
-
-        >>> copy_and_convert_datatypes({'a': np.array([1, 2, 3]), 'b': Element(label='example')}, use_numpy=False)
-        {'a': [1, 2, 3], 'b': {'class': 'Element', 'label': 'example'}}
-
-    Notes:
-        - The function gracefully handles unexpected types by issuing a warning and returning a deep copy of the data.
-        - Empty collections (lists, dictionaries) and default parameter values in `Element` objects are omitted from the output.
-        - Numpy arrays with non-numeric data types are automatically converted to lists.
-    """
-    if isinstance(data, np.integer):  # This must be checked before checking for regular int and float!
-        return int(data)
-    elif isinstance(data, np.floating):
-        return float(data)
-
-    elif isinstance(data, (int, float, str, bool, type(None))):
-        return data
-    elif isinstance(data, datetime):
-        return data.isoformat()
-
-    elif isinstance(data, (tuple, set)):
-        return copy_and_convert_datatypes([item for item in data], use_numpy, use_element_label)
-    elif isinstance(data, dict):
-        return {
-            copy_and_convert_datatypes(key, use_numpy, use_element_label=True): copy_and_convert_datatypes(
-                value, use_numpy, use_element_label
-            )
-            for key, value in data.items()
-        }
-    elif isinstance(data, list):  # Shorten arrays/lists to be readable
-        if use_numpy and all([isinstance(value, (int, float)) for value in data]):
-            return np.array([item for item in data])
-        else:
-            return [copy_and_convert_datatypes(item, use_numpy, use_element_label) for item in data]
+    def __iter__(self) -> Iterator[str]:
+        return iter(self.data)
 
-    elif isinstance(data, np.ndarray):
-        if not use_numpy:
-            return copy_and_convert_datatypes(data.tolist(), use_numpy, use_element_label)
-        elif use_numpy and np.issubdtype(data.dtype, np.number):
-            return data
-        else:
-            logger.critical(
-                f'An np.array with non-numeric content was found: {data=}.It will be converted to a list instead'
-            )
-            return copy_and_convert_datatypes(data.tolist(), use_numpy, use_element_label)
-
-    elif isinstance(data, TimeSeries):
-        return copy_and_convert_datatypes(data.selected_data, use_numpy, use_element_label)
-    elif isinstance(data, TimeSeriesData):
-        return copy_and_convert_datatypes(data.data, use_numpy, use_element_label)
-    elif isinstance(data, (pd.Series, pd.DataFrame)):
-        #TODO: This can be improved
-        return copy_and_convert_datatypes(data.values, use_numpy, use_element_label)
-
-    elif isinstance(data, Interface):
-        if use_element_label and isinstance(data, Element):
-            return data.label
-        return data.infos(use_numpy, use_element_label)
-    elif isinstance(data, xr.DataArray):
-        # TODO: This is a temporary basic work around
-        return copy_and_convert_datatypes(data.values, use_numpy, use_element_label)
-    else:
-        raise TypeError(f'copy_and_convert_datatypes() did get unexpected data of type "{type(data)}": {data=}')
-
-
-def get_compact_representation(data: Any, array_threshold: int = 50, decimals: int = 2) -> Dict:
-    """
-    Generate a compact json serializable representation of deeply nested data.
-    Numpy arrays are statistically described if they exceed a threshold and converted to lists.
+    def __contains__(self, name: str) -> bool:
+        return name in self.data
 
-    Args:
-        data (Any): The data to format and represent.
-        array_threshold (int): Maximum length of NumPy arrays to display. Longer arrays are statistically described.
-        decimals (int): Number of decimal places in which to describe the arrays.
+    def __repr__(self) -> str:
+        """Simple representation of the submodels collection."""
+        if not self.data:
+            return 'flixopt.structure.Submodels:\n----------------------------\n <empty>\n'
 
-    Returns:
-        Dict: A dictionary representation of the data
-    """
+        total_vars = sum(len(submodel.variables) for submodel in self.data.values())
+        total_cons = sum(len(submodel.constraints) for submodel in self.data.values())
 
-    def format_np_array_if_found(value: Any) -> Any:
-        """Recursively processes the data, formatting NumPy arrays."""
-        if isinstance(value, (int, float, str, bool, type(None))):
-            return value
-        elif isinstance(value, np.ndarray):
-            return describe_numpy_arrays(value)
-        elif isinstance(value, dict):
-            return {format_np_array_if_found(k): format_np_array_if_found(v) for k, v in value.items()}
-        elif isinstance(value, (list, tuple, set)):
-            return [format_np_array_if_found(v) for v in value]
-        else:
-            logger.warning(
-                f'Unexpected value found when trying to format numpy array numpy array: {type(value)=}; {value=}'
-            )
-            return value
-
-    def describe_numpy_arrays(arr: np.ndarray) -> Union[str, List]:
-        """Shortens NumPy arrays if they exceed the specified length."""
-
-        def normalized_center_of_mass(array: Any) -> float:
-            # position in array (0 bis 1 normiert)
-            if array.ndim >= 2:  # No good way to calculate center of mass for 2D arrays
-                return np.nan
-            positions = np.linspace(0, 1, len(array))  # weights w_i
-            # mass center
-            if np.sum(array) == 0:
-                return np.nan
-            else:
-                return np.sum(positions * array) / np.sum(array)
-
-        if arr.size > array_threshold:  # Calculate basic statistics
-            fmt = f'.{decimals}f'
-            return (
-                f'Array (min={np.min(arr):{fmt}}, max={np.max(arr):{fmt}}, mean={np.mean(arr):{fmt}}, '
-                f'median={np.median(arr):{fmt}}, std={np.std(arr):{fmt}}, len={len(arr)}, '
-                f'center={normalized_center_of_mass(arr):{fmt}})'
-            )
-        else:
-            return np.around(arr, decimals=decimals).tolist()
+        title = (
+            f'flixopt.structure.Submodels ({total_vars} vars, {total_cons} constraints, {len(self.data)} submodels):'
+        )
+        underline = '-' * len(title)
 
-    # Process the data to handle NumPy arrays
-    formatted_data = format_np_array_if_found(copy_and_convert_datatypes(data, use_numpy=True))
+        if not self.data:
+            return f'{title}\n{underline}\n <empty>\n'
+        sub_models_string = ''
+        for name, submodel in self.data.items():
+            type_name = submodel.__class__.__name__
+            var_count = len(submodel.variables)
+            con_count = len(submodel.constraints)
+            sub_models_string += f'\n * {name} [{type_name}] ({var_count}v/{con_count}c)'
 
-    return formatted_data
+        return f'{title}\n{underline}{sub_models_string}\n'
 
+    def items(self) -> ItemsView[str, Submodel]:
+        return self.data.items()
 
-def get_str_representation(data: Any, array_threshold: int = 50, decimals: int = 2) -> str:
-    """
-    Generate a string representation of deeply nested data using `rich.print`.
-    NumPy arrays are shortened to the specified length and converted to strings.
+    def keys(self):
+        return self.data.keys()
+
+    def values(self):
+        return self.data.values()
+
+    def add(self, submodel: Submodel, name: str) -> None:
+        """Add a submodel to the collection."""
+        self.data[name] = submodel
+
+    def get(self, name: str, default=None):
+        """Get submodel by name, returning default if not found."""
+        return self.data.get(name, default)
 
-    Args:
-        data (Any): The data to format and represent.
-        array_threshold (int): Maximum length of NumPy arrays to display. Longer arrays are statistically described.
-        decimals (int): Number of decimal places in which to describe the arrays.
 
-    Returns:
-        str: The formatted string representation of the data.
+class ElementModel(Submodel):
+    """
+    Stores the mathematical Variables and Constraints for Elements.
+    ElementModels are directly registered in the main FlowSystemModel
     """
 
-    formatted_data = get_compact_representation(data, array_threshold, decimals)
+    def __init__(self, model: FlowSystemModel, element: Element):
+        """
+        Args:
+            model: The FlowSystemModel that is used to create the model.
+            element: The element this model is created for.
+        """
+        self.element = element
+        super().__init__(model, label_of_element=element.label_full, label_of_model=element.label_full)
+        self._model.add_submodels(self, short_name=self.label_of_model)
 
-    # Use Rich to format and print the data
-    with StringIO() as output_buffer:
-        console = Console(file=output_buffer, width=1000)  # Adjust width as needed
-        console.print(Pretty(formatted_data, expand_all=True, indent_guides=True))
-        return output_buffer.getvalue()
+    def results_structure(self):
+        return {
+            'label': self.label_full,
+            'variables': list(self.variables),
+            'constraints': list(self.constraints),
+        }