Feature/402 feature silent framework (#407)

* Supress solver output in SegmentedCalculation in favor of a progress bar, add method to suppress_output() and add tqdm to dependencies

* Add logging.info() about solving

* Merge main intop feature/402-feature-silent-framework

* Merge main intop feature/402-feature-silent-framework

* Add extra log_to_console option to solvers.py

* Add extra log_to_console option to solvers.py

* Add extra log_to_console option config.py

* Add to tests

* Use default from console to say if logging to console (gurobipy still has some issues...)

* Add rounding duration of solve

* Use contextmanager to entirely supress output in SegmentedCalculation

* Improve suppress_output()

* More options in config.py

* Update CHANGELOG.md

* Use new Config options in examples

* Sett plotting backend in CI directly, overwriting all configs

* Fixed tqdm progress bar to respect CONFIG.silent()

* Replaced print() with framework logger (examples/05_Two-stage-optimization/two_stage_optimization.py

* Added comprehensive tests for suppress_output()

* Remove unused import

* Ensure progress bar cleanup on exceptions.

* Add test

* Split method in SegmentedCalculation for better distinction if show or not show solver output

* USe config show in exmaples

* USe config show in results.plot_network()

* Improve readabailty of code

* Typo

Author: FBumann

.github/workflows/python-app.yaml

@@ -24,6 +24,8 @@ concurrency:
 
 env:
   PYTHON_VERSION: "3.11"
+  MPLBACKEND: Agg  # Non-interactive matplotlib backend for CI/testing
+  PLOTLY_RENDERER: json  # Headless plotly renderer for CI/testing
 
 jobs:
   lint:

CHANGELOG.md

@@ -51,13 +51,23 @@ If upgrading from v2.x, see the [v3.0.0 release notes](https://github.com/flixOp
 
 ## [Unreleased] - ????-??-??
 
-**Summary**:
+**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
+
 ### 💥 Breaking Changes
+- Individual solver output is now hidden in **SegmentedCalculation**. To return to the prior behaviour, set `show_individual_solves=True` in `do_modeling_and_solve()`.
 
 ### ♻️ Changed
 

examples/00_Minmal/minimal_example.py

@@ -9,8 +9,7 @@
 import flixopt as fx
 
 if __name__ == '__main__':
-    fx.CONFIG.Logging.console = True
-    fx.CONFIG.apply()
+    fx.CONFIG.silent()
     flow_system = fx.FlowSystem(pd.date_range('2020-01-01', periods=3, freq='h'))
 
     flow_system.add_elements(

examples/01_Simple/simple_example.py

@@ -8,9 +8,8 @@
 import flixopt as fx
 
 if __name__ == '__main__':
-    # Enable console logging
-    fx.CONFIG.Logging.console = True
-    fx.CONFIG.apply()
+    fx.CONFIG.exploring()
+
     # --- Create Time Series Data ---
     # Heat demand profile (e.g., kW) over time and corresponding power prices
     heat_demand_per_h = np.array([30, 0, 90, 110, 110, 20, 20, 20, 20])
@@ -101,7 +100,7 @@
     flow_system.add_elements(costs, CO2, boiler, storage, chp, heat_sink, gas_source, power_sink)
 
     # Visualize the flow system for validation purposes
-    flow_system.plot_network(show=True)
+    flow_system.plot_network()
 
     # --- Define and Run Calculation ---
     # Create a calculation object to model the Flow System

examples/02_Complex/complex_example.py

@@ -9,9 +9,8 @@
 import flixopt as fx
 
 if __name__ == '__main__':
-    # Enable console logging
-    fx.CONFIG.Logging.console = True
-    fx.CONFIG.apply()
+    fx.CONFIG.exploring()
+
     # --- Experiment Options ---
     # Configure options for testing various parameters and behaviors
     check_penalty = False

examples/02_Complex/complex_example_results.py

@@ -5,9 +5,8 @@
 import flixopt as fx
 
 if __name__ == '__main__':
-    # Enable console logging
-    fx.CONFIG.Logging.console = True
-    fx.CONFIG.apply()
+    fx.CONFIG.exploring()
+
     # --- Load Results ---
     try:
         results = fx.results.CalculationResults.from_file('results', 'complex example')
@@ -19,7 +18,7 @@
         ) from e
 
     # --- Basic overview ---
-    results.plot_network(show=True)
+    results.plot_network()
     results['Fernwärme'].plot_node_balance()
 
     # --- Detailed Plots ---

examples/03_Calculation_types/example_calculation_types.py

@@ -11,9 +11,8 @@
 import flixopt as fx
 
 if __name__ == '__main__':
-    # Enable console logging
-    fx.CONFIG.Logging.console = True
-    fx.CONFIG.apply()
+    fx.CONFIG.exploring()
+
     # Calculation Types
     full, segmented, aggregated = True, True, True
 
@@ -165,7 +164,7 @@
         a_kwk,
         a_speicher,
     )
-    flow_system.plot_network(controls=False, show=True)
+    flow_system.plot_network()
 
     # Calculations
     calculations: list[fx.FullCalculation | fx.AggregatedCalculation | fx.SegmentedCalculation] = []

examples/04_Scenarios/scenario_example.py

@@ -8,6 +8,8 @@
 import flixopt as fx
 
 if __name__ == '__main__':
+    fx.CONFIG.exploring()
+
     # Create datetime array starting from '2020-01-01' for one week
     timesteps = pd.date_range('2020-01-01', periods=24 * 7, freq='h')
     scenarios = pd.Index(['Base Case', 'High Demand'])
@@ -186,7 +188,7 @@
     flow_system.add_elements(costs, CO2, boiler, storage, chp, heat_sink, gas_source, power_sink)
 
     # Visualize the flow system for validation purposes
-    flow_system.plot_network(show=True)
+    flow_system.plot_network()
 
     # --- Define and Run Calculation ---
     # Create a calculation object to model the Flow System
@@ -215,7 +217,6 @@
 
     # Convert the results for the storage component to a dataframe and display
     df = calculation.results['Storage'].node_balance_with_charge_state()
-    print(df)
 
     # Save results to file for later usage
     calculation.results.to_file()

examples/05_Two-stage-optimization/two_stage_optimization.py

@@ -19,6 +19,8 @@
 logger = logging.getLogger('flixopt')
 
 if __name__ == '__main__':
+    fx.CONFIG.exploring()
+
     # Data Import
     data_import = pd.read_csv(
         pathlib.Path(__file__).parent.parent / 'resources' / 'Zeitreihen2020.csv', index_col=0

flixopt/calculation.py

@@ -13,13 +13,15 @@
 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
@@ -227,7 +229,7 @@ def fix_sizes(self, ds: xr.Dataset, decimal_rounding: int | None = 5) -> FullCal
         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()
 
@@ -237,6 +239,8 @@ def solve(
             **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
@@ -250,7 +254,8 @@ def solve(
             )
 
         # 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(
@@ -368,7 +373,7 @@ def _perform_aggregation(self):
         )
 
         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():
@@ -569,48 +574,111 @@ def _create_sub_calculations(self):
                 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