flixopt 3.2.1__tar.gz → 3.4.0__tar.gz

{flixopt-3.2.1 → flixopt-3.4.0}/CHANGELOG.md

@@ -81,6 +81,77 @@ If upgrading from v2.x, see the [v3.0.0 release notes](https://github.com/flixOp
 
 Until here -->
 
+## [3.4.0] - 2025-11-01
+
+**Summary**: Enhanced solver configuration with new CONFIG.Solving section for centralized solver parameter management.
+
+If upgrading from v2.x, see the [v3.0.0 release notes](https://github.com/flixOpt/flixOpt/releases/tag/v3.0.0) and [Migration Guide](https://flixopt.github.io/flixopt/latest/user-guide/migration-guide-v3/).
+
+### ✨ Added
+
+**Solver configuration:**
+- **New `CONFIG.Solving` configuration section** for centralized solver parameter management:
+    - `mip_gap`: Default MIP gap tolerance for solver convergence (default: 0.01)
+    - `time_limit_seconds`: Default time limit in seconds for solver runs (default: 300)
+    - `log_to_console`: Whether solver should output to console (default: True)
+    - `log_main_results`: Whether to log main results after solving (default: True)
+- Solvers (`HighsSolver`, `GurobiSolver`) now use `CONFIG.Solving` defaults for parameters, allowing global configuration
+- Solver parameters can still be explicitly overridden when creating solver instances
+- New `log_to_console` parameter in all Solver classes
+
+### ♻️ Changed
+- Individual solver output is now hidden in **SegmentedCalculation**. To return to the prior behaviour, set `show_individual_solves=True` in `do_modeling_and_solve()`.
+
+### 🐛 Fixed
+-  New compacted list representation for periods and scenarios also in results log and console print
+
+### 📝 Docs
+- Unified contributing guides in docs and on github
+
+### 👷 Development
+- Added type hints for submodel in all Interface classes
+
+---
+
+## [3.3.1] - 2025-10-30
+
+**Summary**: Small Bugfix and improving readability
+
+If upgrading from v2.x, see the [v3.0.0 release notes](https://github.com/flixOpt/flixOpt/releases/tag/v3.0.0) and [Migration Guide](https://flixopt.github.io/flixopt/latest/user-guide/migration-guide-v3/).
+
+### ♻️ Changed
+- Improved `summary.yaml` to use a compacted list representation for periods and scenarios
+
+### 🐛 Fixed
+- Using `switch_on_total_max` with periods or scenarios failed
+
+### 📝 Docs
+- Add more comprehensive `CONTRIBUTE.md`
+- Improve logical structure in User Guide
+
+---
+
+## [3.3.0] - 2025-10-30
+
+**Summary**: Better access to Elements stored in the FLowSystem and better representations (repr)
+
+If upgrading from v2.x, see the [v3.0.0 release notes](https://github.com/flixOpt/flixOpt/releases/tag/v3.0.0) and [Migration Guide](https://flixopt.github.io/flixopt/latest/user-guide/migration-guide-v3/).
+
+### ♻️ Changed
+**Improved repr methods:**
+- **Results classes** (`ComponentResults`, `BusResults`, `FlowResults`, `EffectResults`) now show concise header with key metadata followed by xarray Dataset repr
+- **Element classes** (`Component`, `Bus`, `Flow`, `Effect`, `Storage`) now show one-line summaries with essential information (connections, sizes, capacities, constraints)
+
+**Container-based access:**
+- **FlowSystem** now provides dict-like access patterns for all elements
+- Use `flow_system['element_label']`, `flow_system.keys()`, `flow_system.values()`, and `flow_system.items()` for unified element access
+- Specialized containers (`components`, `buses`, `effects`, `flows`) offer type-specific access with helpful error messages
+
+### 🗑️ Deprecated
+- **`FlowSystem.all_elements`** property is deprecated in favor of dict-like interface (`flow_system['label']`, `.keys()`, `.values()`, `.items()`). Will be removed in v4.0.0.
+
+---
+
 ## [3.2.1] - 2025-10-29
 
 **Summary**:
@@ -105,21 +176,21 @@ If upgrading from v2.x, see the [v3.0.0 release notes](https://github.com/flixOp
 
 **Color management:**
 - **`setup_colors()` method** for `CalculationResults` and `SegmentedCalculationResults` to configure consistent colors across all plots
-  - Group components by colorscales: `results.setup_colors({'CHP': 'reds', 'Storage': 'blues', 'Greys': ['Grid', 'Demand']})`
-  - Automatically propagates to all segments in segmented calculations
-  - Colors persist across all plot calls unless explicitly overridden
+    - Group components by colorscales: `results.setup_colors({'CHP': 'reds', 'Storage': 'blues', 'Greys': ['Grid', 'Demand']})`
+    - Automatically propagates to all segments in segmented calculations
+    - Colors persist across all plot calls unless explicitly overridden
 - **Flexible color inputs**: Supports colorscale names (e.g., 'turbo', 'plasma'), color lists, or label-to-color dictionaries
 - **Cross-backend compatibility**: Seamless color handling for both Plotly and Matplotlib
 
 **Plotting customization:**
 - **Plotting kwargs support**: Pass additional arguments to plotting backends via `px_kwargs`, `plot_kwargs`, and `backend_kwargs` parameters
 - **New `CONFIG.Plotting` configuration section**:
-  - `default_show`: Control default plot visibility
-  - `default_engine`: Choose 'plotly' or 'matplotlib'
-  - `default_dpi`: Set resolution for saved plots
-  - `default_facet_cols`: Configure default faceting columns
-  - `default_sequential_colorscale`: Default for heatmaps (now 'turbo')
-  - `default_qualitative_colorscale`: Default for categorical plots (now 'plotly')
+    - `default_show`: Control default plot visibility
+    - `default_engine`: Choose 'plotly' or 'matplotlib'
+    - `default_dpi`: Set resolution for saved plots
+    - `default_facet_cols`: Configure default faceting columns
+    - `default_sequential_colorscale`: Default for heatmaps (now 'turbo')
+    - `default_qualitative_colorscale`: Default for categorical plots (now 'plotly')
 
 **I/O improvements:**
 - Centralized JSON/YAML I/O with auto-format detection
@@ -286,12 +357,12 @@ This replaces `specific_share_to_other_effects_*` parameters and inverts the dir
 **API and Behavior Changes:**
 
 - **Effect system redesigned** (no deprecation):
-  - **Terminology changes**: Effect domains renamed for clarity: `operation` → `temporal`, `invest`/`investment` → `periodic`
-  - **Sharing system**: The old `specific_share_to_other_effects_*` parameters were completely replaced with the new `share_from_temporal` and `share_from_periodic` syntax (see 🔥 Removed section)
+    - **Terminology changes**: Effect domains renamed for clarity: `operation` → `temporal`, `invest`/`investment` → `periodic`
+    - **Sharing system**: The old `specific_share_to_other_effects_*` parameters were completely replaced with the new `share_from_temporal` and `share_from_periodic` syntax (see 🔥 Removed section)
 - **FlowSystem independence**: FlowSystems cannot be shared across multiple Calculations anymore. A copy of the FlowSystem is created instead, making every Calculation independent. Each Subcalculation in `SegmentedCalculation` now has its own distinct `FlowSystem` object
 - **Bus and Effect object assignment**: Direct assignment of Bus/Effect objects is no longer supported. Use labels (strings) instead:
-  - `Flow.bus` must receive a string label, not a Bus object
-  - Effect shares must use effect labels (strings) in dictionaries, not Effect objects
+    - `Flow.bus` must receive a string label, not a Bus object
+    - Effect shares must use effect labels (strings) in dictionaries, not Effect objects
 - **Logging defaults** (from v2.2.0): Console and file logging are now disabled by default. Enable explicitly with `CONFIG.Logging.console = True` and `CONFIG.apply()`
 
 **Class and Method Renaming:**
@@ -305,14 +376,14 @@ This replaces `specific_share_to_other_effects_*` parameters and inverts the dir
 
 - Investment binary variable: `is_invested` → `invested` in `InvestmentModel`
 - Switch tracking variables in `OnOffModel`:
-  - `switch_on` → `switch|on`
-  - `switch_off` → `switch|off`
-  - `switch_on_nr` → `switch|count`
+    - `switch_on` → `switch|on`
+    - `switch_off` → `switch|off`
+    - `switch_on_nr` → `switch|count`
 - Effect submodel variables (following terminology changes):
-  - `Effect(invest)|total` → `Effect(periodic)`
-  - `Effect(operation)|total` → `Effect(temporal)`
-  - `Effect(operation)|total_per_timestep` → `Effect(temporal)|per_timestep`
-  - `Effect|total` → `Effect`
+    - `Effect(invest)|total` → `Effect(periodic)`
+    - `Effect(operation)|total` → `Effect(temporal)`
+    - `Effect(operation)|total_per_timestep` → `Effect(temporal)|per_timestep`
+    - `Effect|total` → `Effect`
 
 **Data Structure Changes:**
 
@@ -533,7 +604,7 @@ This replaces `specific_share_to_other_effects_*` parameters and inverts the dir
 
 ### ✨ Added
 - **Network Visualization**: Added `FlowSystem.start_network_app()` and `FlowSystem.stop_network_app()` to easily visualize the network structure of a flow system in an interactive Dash web app
-  - *Note: This is still experimental and might change in the future*
+    - *Note: This is still experimental and might change in the future*
 
 ### ♻️ Changed
 - **Multi-Flow Support**: `Sink`, `Source`, and `SourceAndSink` now accept multiple `flows` as `inputs` and `outputs` instead of just one. This enables modeling more use cases with these classes
@@ -575,8 +646,8 @@ This replaces `specific_share_to_other_effects_*` parameters and inverts the dir
 
 ### 🐛 Fixed
 - Storage losses per hour were not calculated correctly, as mentioned by @brokenwings01. This might have led to issues when modeling large losses and long timesteps.
-  - Old implementation:     $c(\text{t}_{i}) \cdot (1-\dot{\text{c}}_\text{rel,loss}(\text{t}_i)) \cdot \Delta \text{t}_{i}$
-  - Correct implementation: $c(\text{t}_{i}) \cdot (1-\dot{\text{c}}_\text{rel,loss}(\text{t}_i)) ^{\Delta \text{t}_{i}}$
+    - Old implementation:     $c(\text{t}_{i}) \cdot (1-\dot{\text{c}}_\text{rel,loss}(\text{t}_i)) \cdot \Delta \text{t}_{i}$
+    - Correct implementation: $c(\text{t}_{i}) \cdot (1-\dot{\text{c}}_\text{rel,loss}(\text{t}_i)) ^{\Delta \text{t}_{i}}$
 
 ### 🚧 Known Issues
 - Just to mention: Plotly >= 6 may raise errors if "nbformat" is not installed. We pinned plotly to <6, but this may be fixed in the future.
@@ -601,10 +672,10 @@ This replaces `specific_share_to_other_effects_*` parameters and inverts the dir
 
 ### 💥 Breaking Changes
 - Restructured the modeling of the On/Off state of Flows or Components
-  - Variable renaming: `...|consecutive_on_hours` → `...|ConsecutiveOn|hours`
-  - Variable renaming: `...|consecutive_off_hours` → `...|ConsecutiveOff|hours`
-  - Constraint renaming: `...|consecutive_on_hours_con1` → `...|ConsecutiveOn|con1`
-  - Similar pattern for all consecutive on/off constraints
+    - Variable renaming: `...|consecutive_on_hours` → `...|ConsecutiveOn|hours`
+    - Variable renaming: `...|consecutive_off_hours` → `...|ConsecutiveOff|hours`
+    - Constraint renaming: `...|consecutive_on_hours_con1` → `...|ConsecutiveOn|con1`
+    - Similar pattern for all consecutive on/off constraints
 
 ### 🐛 Fixed
 - Fixed the lower bound of `flow_rate` when using optional investments without OnOffParameters
@@ -650,10 +721,10 @@ This replaces `specific_share_to_other_effects_*` parameters and inverts the dir
 
 **Variable Structure:**
 - Restructured the modeling of the On/Off state of Flows or Components
-  - Variable renaming: `...|consecutive_on_hours` → `...|ConsecutiveOn|hours`
-  - Variable renaming: `...|consecutive_off_hours` → `...|ConsecutiveOff|hours`
-  - Constraint renaming: `...|consecutive_on_hours_con1` → `...|ConsecutiveOn|con1`
-  - Similar pattern for all consecutive on/off constraints
+    - Variable renaming: `...|consecutive_on_hours` → `...|ConsecutiveOn|hours`
+    - Variable renaming: `...|consecutive_off_hours` → `...|ConsecutiveOff|hours`
+    - Constraint renaming: `...|consecutive_on_hours_con1` → `...|ConsecutiveOn|con1`
+    - Similar pattern for all consecutive on/off constraints
 
 ### 🔥 Removed
 - **Pyomo dependency** (replaced by linopy)

{flixopt-3.2.1/flixopt.egg-info → flixopt-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flixopt
-Version: 3.2.1
+Version: 3.4.0
 Summary: Vector based energy and material flow optimization framework in Python.
 Author-email: "Chair of Building Energy Systems and Heat Supply, TU Dresden" <peter.stange@tu-dresden.de>, Felix Bumann <felixbumann387@gmail.com>, Felix Panitz <baumbude@googlemail.com>, Peter Stange <peter.stange@tu-dresden.de>
 Maintainer-email: Felix Bumann <felixbumann387@gmail.com>, Peter Stange <peter.stange@tu-dresden.de>
@@ -27,6 +27,7 @@ Requires-Dist: linopy<0.6,>=0.5.1
 Requires-Dist: netcdf4<2,>=1.6.1
 Requires-Dist: pyyaml<7,>=6.0.0
 Requires-Dist: rich<15,>=13.0.0
+Requires-Dist: tqdm<5,>=4.66.0
 Requires-Dist: tomli<3,>=2.0.1; python_version < "3.11"
 Requires-Dist: highspy<2,>=1.5.3
 Requires-Dist: matplotlib<4,>=3.5.2
@@ -60,7 +61,7 @@ Requires-Dist: pyvis==0.3.2; extra == "dev"
 Requires-Dist: tsam==2.3.9; extra == "dev"
 Requires-Dist: scipy==1.15.1; extra == "dev"
 Requires-Dist: gurobipy==12.0.3; extra == "dev"
-Requires-Dist: dash==3.0.0; extra == "dev"
+Requires-Dist: dash==3.2.0; extra == "dev"
 Requires-Dist: dash-cytoscape==1.0.2; extra == "dev"
 Requires-Dist: dash-daq==0.6.0; extra == "dev"
 Requires-Dist: networkx==3.0.0; extra == "dev"

{flixopt-3.2.1 → flixopt-3.4.0}/flixopt/calculation.py

@@ -13,13 +13,14 @@ from __future__ import annotations
 import logging
 import math
 import pathlib
+import sys
 import timeit
 import warnings
 from collections import Counter
 from typing import TYPE_CHECKING, Annotated, Any
 
 import numpy as np
-import yaml
+from tqdm import tqdm
 
 from . import io as fx_io
 from .aggregation import Aggregation, AggregationModel, AggregationParameters
@@ -53,6 +54,8 @@ class Calculation:
         active_timesteps: Deprecated. Use FlowSystem.sel(time=...) or FlowSystem.isel(time=...) instead.
     """
 
+    model: FlowSystemModel | None
+
     def __init__(
         self,
         name: str,
@@ -87,7 +90,7 @@ class Calculation:
         flow_system._used_in_calculation = True
 
         self.flow_system = flow_system
-        self.model: FlowSystemModel | None = None
+        self.model = None
 
         self.durations = {'modeling': 0.0, 'solving': 0.0, 'saving': 0.0}
         self.folder = pathlib.Path.cwd() / 'results' if folder is None else pathlib.Path(folder)
@@ -112,7 +115,7 @@ class Calculation:
                     'periodic': effect.submodel.periodic.total.solution.values,
                     'total': effect.submodel.total.solution.values,
                 }
-                for effect in self.flow_system.effects
+                for effect in sorted(self.flow_system.effects.values(), key=lambda e: e.label_full.upper())
             },
             'Invest-Decisions': {
                 'Invested': {
@@ -225,7 +228,7 @@ class FullCalculation(Calculation):
         return self
 
     def solve(
-        self, solver: _Solver, log_file: pathlib.Path | None = None, log_main_results: bool = True
+        self, solver: _Solver, log_file: pathlib.Path | None = None, log_main_results: bool | None = None
     ) -> FullCalculation:
         t_start = timeit.default_timer()
 
@@ -235,6 +238,8 @@ class FullCalculation(Calculation):
             **solver.options,
         )
         self.durations['solving'] = round(timeit.default_timer() - t_start, 2)
+        logger.info(f'Model solved with {solver.name} in {self.durations["solving"]:.2f} seconds.')
+        logger.info(f'Model status after solve: {self.model.status}')
 
         if self.model.status == 'warning':
             # Save the model and the flow_system to file in case of infeasibility
@@ -248,15 +253,13 @@ class FullCalculation(Calculation):
             )
 
         # Log the formatted output
-        if log_main_results:
+        should_log = log_main_results if log_main_results is not None else CONFIG.Solving.log_main_results
+        if should_log:
             logger.info(
                 f'{" Main Results ":#^80}\n'
-                + yaml.dump(
+                + fx_io.format_yaml_string(
                     self.main_results,
-                    default_flow_style=False,
-                    sort_keys=False,
-                    allow_unicode=True,
-                    indent=4,
+                    compact_numeric_lists=True,
                 )
             )
 
@@ -366,7 +369,7 @@ class AggregatedCalculation(FullCalculation):
         )
 
         self.aggregation.cluster()
-        self.aggregation.plot(show=True, save=self.folder / 'aggregation.html')
+        self.aggregation.plot(show=CONFIG.Plotting.default_show, save=self.folder / 'aggregation.html')
         if self.aggregation_parameters.aggregate_data_and_fix_non_binary_vars:
             ds = self.flow_system.to_dataset()
             for name, series in self.aggregation.aggregated_data.items():
@@ -567,48 +570,111 @@ class SegmentedCalculation(Calculation):
                 f'({timesteps_of_segment[0]} -> {timesteps_of_segment[-1]}):'
             )
 
+    def _solve_single_segment(
+        self,
+        i: int,
+        calculation: FullCalculation,
+        solver: _Solver,
+        log_file: pathlib.Path | None,
+        log_main_results: bool,
+        suppress_output: bool,
+    ) -> None:
+        """Solve a single segment calculation."""
+        if i > 0 and self.nr_of_previous_values > 0:
+            self._transfer_start_values(i)
+
+        calculation.do_modeling()
+
+        # Warn about Investments, but only in first run
+        if i == 0:
+            invest_elements = [
+                model.label_full
+                for component in calculation.flow_system.components.values()
+                for model in component.submodel.all_submodels
+                if isinstance(model, InvestmentModel)
+            ]
+            if invest_elements:
+                logger.critical(
+                    f'Investments are not supported in Segmented Calculation! '
+                    f'Following InvestmentModels were found: {invest_elements}'
+                )
+
+        log_path = pathlib.Path(log_file) if log_file is not None else self.folder / f'{self.name}.log'
+
+        if suppress_output:
+            with fx_io.suppress_output():
+                calculation.solve(solver, log_file=log_path, log_main_results=log_main_results)
+        else:
+            calculation.solve(solver, log_file=log_path, log_main_results=log_main_results)
+
     def do_modeling_and_solve(
-        self, solver: _Solver, log_file: pathlib.Path | None = None, log_main_results: bool = False
+        self,
+        solver: _Solver,
+        log_file: pathlib.Path | None = None,
+        log_main_results: bool = False,
+        show_individual_solves: bool = False,
     ) -> SegmentedCalculation:
+        """Model and solve all segments of the segmented calculation.
+
+        This method creates sub-calculations for each time segment, then iteratively
+        models and solves each segment. It supports two output modes: a progress bar
+        for compact output, or detailed individual solve information.
+
+        Args:
+            solver: The solver instance to use for optimization (e.g., Gurobi, HiGHS).
+            log_file: Optional path to the solver log file. If None, defaults to
+                folder/name.log.
+            log_main_results: Whether to log main results (objective, effects, etc.)
+                after each segment solve. Defaults to False.
+            show_individual_solves: If True, shows detailed output for each segment
+                solve with logger messages. If False (default), shows a compact progress
+                bar with suppressed solver output for cleaner display.
+
+        Returns:
+            Self, for method chaining.
+
+        Note:
+            The method automatically transfers all start values between segments to ensure
+            continuity of storage states and flow rates across segment boundaries.
+        """
         logger.info(f'{"":#^80}')
         logger.info(f'{" Segmented Solving ":#^80}')
         self._create_sub_calculations()
 
-        for i, calculation in enumerate(self.sub_calculations):
-            logger.info(
-                f'{self.segment_names[i]} [{i + 1:>2}/{len(self.segment_names):<2}] '
-                f'({calculation.flow_system.timesteps[0]} -> {calculation.flow_system.timesteps[-1]}):'
+        if show_individual_solves:
+            # Path 1: Show individual solves with detailed output
+            for i, calculation in enumerate(self.sub_calculations):
+                logger.info(
+                    f'Solving segment {i + 1}/{len(self.sub_calculations)}: '
+                    f'{calculation.flow_system.timesteps[0]} -> {calculation.flow_system.timesteps[-1]}'
+                )
+                self._solve_single_segment(i, calculation, solver, log_file, log_main_results, suppress_output=False)
+        else:
+            # Path 2: Show only progress bar with suppressed output
+            progress_bar = tqdm(
+                enumerate(self.sub_calculations),
+                total=len(self.sub_calculations),
+                desc='Solving segments',
+                unit='segment',
+                file=sys.stdout,
+                disable=not CONFIG.Solving.log_to_console,
             )
 
-            if i > 0 and self.nr_of_previous_values > 0:
-                self._transfer_start_values(i)
-
-            calculation.do_modeling()
-
-            # Warn about Investments, but only in fist run
-            if i == 0:
-                invest_elements = [
-                    model.label_full
-                    for component in calculation.flow_system.components.values()
-                    for model in component.submodel.all_submodels
-                    if isinstance(model, InvestmentModel)
-                ]
-                if invest_elements:
-                    logger.critical(
-                        f'Investments are not supported in Segmented Calculation! '
-                        f'Following InvestmentModels were found: {invest_elements}'
+            try:
+                for i, calculation in progress_bar:
+                    progress_bar.set_description(
+                        f'Solving ({calculation.flow_system.timesteps[0]} -> {calculation.flow_system.timesteps[-1]})'
                     )
-
-            calculation.solve(
-                solver,
-                log_file=pathlib.Path(log_file) if log_file is not None else self.folder / f'{self.name}.log',
-                log_main_results=log_main_results,
-            )
+                    self._solve_single_segment(i, calculation, solver, log_file, log_main_results, suppress_output=True)
+            finally:
+                progress_bar.close()
 
         for calc in self.sub_calculations:
             for key, value in calc.durations.items():
                 self.durations[key] += value
 
+        logger.info(f'Model solved with {solver.name} in {self.durations["solving"]:.2f} seconds.')
+
         self.results = SegmentedCalculationResults.from_calculation(self)
 
         return self

{flixopt-3.2.1 → flixopt-3.4.0}/flixopt/components.py

@@ -11,6 +11,7 @@ from typing import TYPE_CHECKING, Literal
 import numpy as np
 import xarray as xr
 
+from . import io as fx_io
 from .core import PeriodicDataUser, PlausibilityError, TemporalData, TemporalDataUser
 from .elements import Component, ComponentModel, Flow
 from .features import InvestmentModel, PiecewiseModel
@@ -160,6 +161,8 @@ class LinearConverter(Component):
 
     """
 
+    submodel: LinearConverterModel | None
+
     def __init__(
         self,
         label: str,
@@ -376,6 +379,8 @@ class Storage(Component):
         With flow rates in m3/h, the charge state is therefore in m3.
     """
 
+    submodel: StorageModel | None
+
     def __init__(
         self,
         label: str,
@@ -528,6 +533,15 @@ class Storage(Component):
                     f'{self.discharging.size.minimum_size=}, {self.discharging.size.maximum_size=}.'
                 )
 
+    def __repr__(self) -> str:
+        """Return string representation."""
+        # Use build_repr_from_init directly to exclude charging and discharging
+        return fx_io.build_repr_from_init(
+            self,
+            excluded_params={'self', 'label', 'charging', 'discharging', 'kwargs'},
+            skip_default_size=True,
+        ) + fx_io.format_flow_details(self)
+
 
 @register_class_for_io
 class Transmission(Component):
@@ -640,6 +654,8 @@ class Transmission(Component):
 
     """
 
+    submodel: TransmissionModel | None
+
     def __init__(
         self,
         label: str,

{flixopt-3.2.1 → flixopt-3.4.0}/flixopt/config.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+import os
 import sys
 import warnings
 from logging.handlers import RotatingFileHandler
@@ -63,6 +64,14 @@ _DEFAULTS = MappingProxyType(
                 'default_qualitative_colorscale': 'plotly',
             }
         ),
+        'solving': MappingProxyType(
+            {
+                'mip_gap': 0.01,
+                'time_limit_seconds': 300,
+                'log_to_console': True,
+                'log_main_results': True,
+            }
+        ),
     }
 )
 
@@ -75,6 +84,8 @@ class CONFIG:
     Attributes:
         Logging: Logging configuration.
         Modeling: Optimization modeling parameters.
+        Solving: Solver configuration and default parameters.
+        Plotting: Plotting configuration.
         config_name: Configuration name.
 
     Examples:
@@ -91,6 +102,9 @@ class CONFIG:
           level: DEBUG
           console: true
           file: app.log
+        solving:
+          mip_gap: 0.001
+          time_limit_seconds: 600
         ```
     """
 
@@ -194,6 +208,30 @@ class CONFIG:
         epsilon: float = _DEFAULTS['modeling']['epsilon']
         big_binary_bound: int = _DEFAULTS['modeling']['big_binary_bound']
 
+    class Solving:
+        """Solver configuration and default parameters.
+
+        Attributes:
+            mip_gap: Default MIP gap tolerance for solver convergence.
+            time_limit_seconds: Default time limit in seconds for solver runs.
+            log_to_console: Whether solver should output to console.
+            log_main_results: Whether to log main results after solving.
+
+        Examples:
+            ```python
+            # Set tighter convergence and longer timeout
+            CONFIG.Solving.mip_gap = 0.001
+            CONFIG.Solving.time_limit_seconds = 600
+            CONFIG.Solving.log_to_console = False
+            CONFIG.apply()
+            ```
+        """
+
+        mip_gap: float = _DEFAULTS['solving']['mip_gap']
+        time_limit_seconds: int = _DEFAULTS['solving']['time_limit_seconds']
+        log_to_console: bool = _DEFAULTS['solving']['log_to_console']
+        log_main_results: bool = _DEFAULTS['solving']['log_main_results']
+
     class Plotting:
         """Plotting configuration.
 
@@ -246,6 +284,12 @@ class CONFIG:
         for key, value in _DEFAULTS['modeling'].items():
             setattr(cls.Modeling, key, value)
 
+        for key, value in _DEFAULTS['solving'].items():
+            setattr(cls.Solving, key, value)
+
+        for key, value in _DEFAULTS['plotting'].items():
+            setattr(cls.Plotting, key, value)
+
         cls.config_name = _DEFAULTS['config_name']
         cls.apply()
 
@@ -329,6 +373,12 @@ class CONFIG:
             elif key == 'modeling' and isinstance(value, dict):
                 for nested_key, nested_value in value.items():
                     setattr(cls.Modeling, nested_key, nested_value)
+            elif key == 'solving' and isinstance(value, dict):
+                for nested_key, nested_value in value.items():
+                    setattr(cls.Solving, nested_key, nested_value)
+            elif key == 'plotting' and isinstance(value, dict):
+                for nested_key, nested_value in value.items():
+                    setattr(cls.Plotting, nested_key, nested_value)
             elif hasattr(cls, key):
                 setattr(cls, key, value)
 
@@ -366,6 +416,12 @@ class CONFIG:
                 'epsilon': cls.Modeling.epsilon,
                 'big_binary_bound': cls.Modeling.big_binary_bound,
             },
+            'solving': {
+                'mip_gap': cls.Solving.mip_gap,
+                'time_limit_seconds': cls.Solving.time_limit_seconds,
+                'log_to_console': cls.Solving.log_to_console,
+                'log_main_results': cls.Solving.log_main_results,
+            },
             'plotting': {
                 'default_show': cls.Plotting.default_show,
                 'default_engine': cls.Plotting.default_engine,
@@ -376,6 +432,70 @@ class CONFIG:
             },
         }
 
+    @classmethod
+    def silent(cls) -> type[CONFIG]:
+        """Configure for silent operation.
+
+        Disables console logging, solver output, and result logging
+        for clean production runs. Does not show plots. Automatically calls apply().
+        """
+        cls.Logging.console = False
+        cls.Plotting.default_show = False
+        cls.Logging.file = None
+        cls.Solving.log_to_console = False
+        cls.Solving.log_main_results = False
+        cls.apply()
+        return cls
+
+    @classmethod
+    def debug(cls) -> type[CONFIG]:
+        """Configure for debug mode with verbose output.
+
+        Enables console logging at DEBUG level and all solver output for
+        troubleshooting. Automatically calls apply().
+        """
+        cls.Logging.console = True
+        cls.Logging.level = 'DEBUG'
+        cls.Solving.log_to_console = True
+        cls.Solving.log_main_results = True
+        cls.apply()
+        return cls
+
+    @classmethod
+    def exploring(cls) -> type[CONFIG]:
+        """Configure for exploring flixopt
+
+        Enables console logging at INFO level and all solver output.
+        Also enables browser plotting for plotly with showing plots per default
+        """
+        cls.Logging.console = True
+        cls.Logging.level = 'INFO'
+        cls.Solving.log_to_console = True
+        cls.Solving.log_main_results = True
+        cls.browser_plotting()
+        cls.apply()
+        return cls
+
+    @classmethod
+    def browser_plotting(cls) -> type[CONFIG]:
+        """Configure for interactive usage with plotly to open plots in browser.
+
+        Sets plotly.io.renderers.default = 'browser'. Useful for running examples
+        and viewing interactive plots. Does NOT modify CONFIG.Plotting settings.
+
+        Respects FLIXOPT_CI environment variable if set.
+        """
+        cls.Plotting.default_show = True
+        cls.apply()
+
+        # Only set to True if environment variable hasn't overridden it
+        if 'FLIXOPT_CI' not in os.environ:
+            import plotly.io as pio
+
+            pio.renderers.default = 'browser'
+
+        return cls
+
 
 class MultilineFormatter(logging.Formatter):
     """Formatter that handles multi-line messages with consistent prefixes.