rtc-tools-interface 0.10.2a2__tar.gz → 0.10.2a3__tar.gz

rtc_tools_interface-0.10.2a3/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: rtc_tools_interface
+Version: 0.10.2a3
+Summary: Toolbox for user interfaces for RTC-Tools
+Author: Deltares
+Maintainer: Deltares
+Requires-Python: >=3.9
+License-File: COPYING.LESSER
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: plotly
+Requires-Dist: pydantic
+Requires-Dist: casadi!=3.6.6
+Requires-Dist: rtc-tools>=2.7.0a3
+Dynamic: author
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

{rtc_tools_interface-0.10.2a2 → rtc_tools_interface-0.10.2a3}/README.md

@@ -255,3 +255,11 @@ Note that this happens for:
 - Currently, only the initial values of the first time step in a given time range are set.
 - The closed_loop runner only works in combination with the CSVMixin or the PIMixin.
     The CDFMixin is not supported.
+
+### Matplotlib in Headless Environments
+
+For CI or servers without a display, set `MPLBACKEND=Agg` to ensure Matplotlib uses a non-interactive backend:
+
+```bash
+export MPLBACKEND=Agg
+```

rtc_tools_interface-0.10.2a3/rtc_tools_interface.egg-info/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: rtc_tools_interface
+Version: 0.10.2a3
+Summary: Toolbox for user interfaces for RTC-Tools
+Author: Deltares
+Maintainer: Deltares
+Requires-Python: >=3.9
+License-File: COPYING.LESSER
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: plotly
+Requires-Dist: pydantic
+Requires-Dist: casadi!=3.6.6
+Requires-Dist: rtc-tools>=2.7.0a3
+Dynamic: author
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

{rtc_tools_interface-0.10.2a2 → rtc_tools_interface-0.10.2a3}/rtctools_interface/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-10-30T09:45:54+0100",
+ "date": "2026-01-19T15:25:58+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "dcc43a518f9d2672d43280e14083500fb85225cb",
- "version": "0.10.2a2"
+ "full-revisionid": "b1cd2bed75dbdf57577a1474771953e8983e405d",
+ "version": "0.10.2a3"
 }
 '''  # END VERSION_JSON
 

{rtc_tools_interface-0.10.2a2 → rtc_tools_interface-0.10.2a3}/rtctools_interface/closed_loop/config.py

@@ -1,10 +1,10 @@
 """Module for configuring a closed-loop optimization problem."""
+
 from datetime import timedelta
 from pathlib import Path
-from typing import Optional
 
 
-class ClosedLoopConfig():
+class ClosedLoopConfig:
     """Configuration of a closed-loop optimization problem."""
 
     def __init__(
@@ -30,8 +30,8 @@ class ClosedLoopConfig():
         if file is not None:
             file = Path(file).resolve()
         self._file = file
-        self._forecast_timestep: Optional[timedelta] = None
-        self._optimization_period: Optional[timedelta] = None
+        self._forecast_timestep: timedelta | None = None
+        self._optimization_period: timedelta | None = None
         self.round_to_dates = round_to_dates
 
     @classmethod

{rtc_tools_interface-0.10.2a2 → rtc_tools_interface-0.10.2a3}/rtctools_interface/closed_loop/optimization_ranges.py

@@ -1,4 +1,5 @@
 """Module for calculating optimization periods."""
+
 import bisect
 import datetime
 from pathlib import Path
@@ -12,30 +13,40 @@ def get_optimization_ranges_from_file(
     """Read horizon config from a csv file"""
     if not file_path.exists():
         raise FileNotFoundError(
-            f"The closed_loop_dates csv does not exist. Please create a horizon config file in {file_path}."
+            "The closed_loop_dates csv does not exist. Please create a horizon "
+            f"config file in {file_path}."
         )
     try:
         closed_loop_dates = pd.read_csv(file_path)
     except pd.errors.EmptyDataError:
         raise ValueError(
-            "The closed_loop_dates csv is empty. Please provide a valid file with start_date and end_date column."
+            "The closed_loop_dates csv is empty. Please provide a valid file with "
+            "start_date and end_date column."
         )
     closed_loop_dates.columns = closed_loop_dates.columns.str.replace(" ", "")
-    if not all([col in closed_loop_dates.columns for col in ["start_date", "end_date"]]):
-        raise ValueError("The closed_loop_dates csv should have both 'start_date' and 'end_date' columns.")
+    if not all(col in closed_loop_dates.columns for col in ["start_date", "end_date"]):
+        raise ValueError(
+            "The closed_loop_dates csv should have both 'start_date' and 'end_date' columns."
+        )
     closed_loop_dates["start_date"] = pd.to_datetime(closed_loop_dates["start_date"])
     closed_loop_dates["end_date"] = pd.to_datetime(closed_loop_dates["end_date"])
     for i in range(1, len(closed_loop_dates)):
         if closed_loop_dates["start_date"].iloc[i] > closed_loop_dates["end_date"].iloc[i - 1]:
-            raise ValueError(f"Closed loop date table: Start date at row {i} is later than the previous end date. ")
+            raise ValueError(
+                f"Closed loop date table: Start date at row {i} is later than previous end date."
+            )
     if any(closed_loop_dates["start_date"] < closed_loop_dates["start_date"].shift(1)):
         raise ValueError("Closed loop date table: The start dates are not in ascending order.")
     if any(closed_loop_dates["end_date"] < closed_loop_dates["end_date"].shift(1)):
         raise ValueError("Closed loop date table: The end dates are not in ascending order.")
     if any(closed_loop_dates["end_date"] < closed_loop_dates["start_date"]):
-        raise ValueError("Closed loop date table: For one or more rows the end date is before the start date.")
+        raise ValueError(
+            "Closed loop date table: For one or more rows the end date is before the start date."
+        )
     if any(closed_loop_dates["start_date"] > closed_loop_dates["end_date"]):
-        raise ValueError("Closed loop date table: For one or more rows the start date is after the end date.")
+        raise ValueError(
+            "Closed loop date table: For one or more rows the start date is after the end date."
+        )
     if (
         any(closed_loop_dates["start_date"].dt.hour != 0)
         or any(closed_loop_dates["start_date"].dt.minute != 0)
@@ -43,17 +54,14 @@ def get_optimization_ranges_from_file(
         or any(closed_loop_dates["end_date"].dt.minute != 0)
     ):
         raise ValueError(
-            "Closed loop date table: Currently, the date ranges can only be specific up to the level of days."
+            "Closed loop date table: Currently, the date ranges can only be specific "
+            "up to the level of days."
         )
-    assert (
-        min(closed_loop_dates["start_date"]).date() == model_time_range[0].date()
-    ), (
+    assert min(closed_loop_dates["start_date"]).date() == model_time_range[0].date(), (
         "The start day of the first optimization run is not equal"
         " to the start day of the forecast date (or first timestep)."
     )
-    assert (
-        max(closed_loop_dates["end_date"]).date() <= model_time_range[1].date()
-    ), (
+    assert max(closed_loop_dates["end_date"]).date() <= model_time_range[1].date(), (
         "The end date of one or more optimization runs is later"
         " than the end date of the timeseries import."
     )
@@ -65,9 +73,7 @@ def get_optimization_ranges_from_file(
 
 
 def _get_next_time_index(
-    times: list[datetime.date],
-    i_current: int,
-    timestep_size: datetime.timedelta
+    times: list[datetime.date], i_current: int, timestep_size: datetime.timedelta
 ) -> int:
     """
     Get the next timestep index.
@@ -91,7 +97,7 @@ def get_optimization_ranges(
     model_times: list[datetime.date],
     start_time: datetime.datetime,
     forecast_timestep: datetime.timedelta,
-    optimization_period: datetime.timedelta
+    optimization_period: datetime.timedelta,
 ) -> list[tuple[datetime.datetime, datetime.datetime]]:
     """Calculate a list of optimization periods."""
     if forecast_timestep > optimization_period:
@@ -114,7 +120,7 @@ def get_optimization_ranges(
 
 
 def round_datetime_ranges_to_days(
-    datetime_ranges: list[tuple[datetime.datetime, datetime.datetime]]
+    datetime_ranges: list[tuple[datetime.datetime, datetime.datetime]],
 ) -> list[tuple[datetime.datetime, datetime.datetime]]:
     """Round datetimes to dats in datetime ranges.
 

{rtc_tools_interface-0.10.2a2 → rtc_tools_interface-0.10.2a3}/rtctools_interface/closed_loop/results_construction.py

@@ -2,10 +2,9 @@ import copy
 import logging
 import os
 from pathlib import Path
-from typing import List
+
 import pandas as pd
-from rtctools.data import rtc
-from rtctools.data import pi
+from rtctools.data import pi, rtc
 
 logger = logging.getLogger("rtctools")
 
@@ -22,7 +21,9 @@ def _get_variables_from_pi(data_config: rtc.DataConfig, timeseries: pi.Timeserie
     return variables
 
 
-def combine_xml_exports(output_base_path: Path, original_input_timeseries_path: Path, write_csv_out: bool = False):
+def combine_xml_exports(
+    output_base_path: Path, original_input_timeseries_path: Path, write_csv_out: bool = False
+):
     """Combine the xml exports of multiple periods into a single xml file."""
     logger.info("Combining XML exports.")
     dataconfig = rtc.DataConfig(folder=original_input_timeseries_path)
@@ -34,14 +35,22 @@ def combine_xml_exports(output_base_path: Path, original_input_timeseries_path:
         binary=False,
     )
     if ts_import_orig.forecast_datetime > ts_import_orig.start_datetime:
-        logger.info("Timeseries export will start at original forecast date, disregarding data before forecast date.")
+        logger.info(
+            "Timeseries export will start at original forecast date, "
+            "disregarding data before forecast date."
+        )
         ts_import_orig.resize(ts_import_orig.forecast_datetime, ts_import_orig.end_datetime)
-        ts_import_orig.times = ts_import_orig.times[ts_import_orig.times.index(ts_import_orig.forecast_datetime):]
+        ts_import_orig.times = ts_import_orig.times[
+            ts_import_orig.times.index(ts_import_orig.forecast_datetime) :
+        ]
     orig_start_datetime = ts_import_orig.start_datetime
     orig_end_datetime = ts_import_orig.end_datetime
 
     ts_export = pi.Timeseries(
-        data_config=dataconfig, folder=output_base_path / "period_0", basename="timeseries_export", binary=False
+        data_config=dataconfig,
+        folder=output_base_path / "period_0",
+        basename="timeseries_export",
+        binary=False,
     )  # Use the first timeseries export as a starting point for the combined timeseries export.
     ts_export.resize(orig_start_datetime, orig_end_datetime)
 
@@ -63,7 +72,7 @@ def combine_xml_exports(output_base_path: Path, original_input_timeseries_path:
                 current_values = ts_export.get(loc_par)
                 new_values = ts_export_step.get(loc_par)
             except KeyError:
-                logger.debug("Variable {} not found in output of model horizon: {}".format(loc_par, i))
+                logger.debug(f"Variable {loc_par} not found in output of model horizon: {i}")
                 continue
             new_times = ts_export_step.times
             try:
@@ -77,7 +86,9 @@ def combine_xml_exports(output_base_path: Path, original_input_timeseries_path:
                         + "with the end of the previous."
                     )
             combined_values = copy.deepcopy(current_values)
-            combined_values[start_new_data_index : start_new_data_index + len(new_values)] = new_values  # noqa
+            combined_values[start_new_data_index : start_new_data_index + len(new_values)] = (
+                new_values  # noqa
+            )
             ts_export.set(loc_par, combined_values)
         i += 1
     ts_export.write(output_folder=output_base_path.parent, output_filename="timeseries_export")
@@ -90,16 +101,16 @@ def combine_xml_exports(output_base_path: Path, original_input_timeseries_path:
                 values = ts_export.get(timeseries_id)
                 new_columns.append(pd.Series(values, name=timeseries_id))
             except KeyError:
-                logger.debug("Variable {} not found in output of model horizon: {}".format(timeseries_id, i))
+                logger.debug(f"Variable {timeseries_id} not found in output of model horizon: {i}")
                 continue
         data = pd.concat([data] + new_columns, axis=1)
         data.round(6).to_csv(output_base_path.parent / "timeseries_export.csv", index=False)
 
 
-def combine_dataframes(dfs: List[pd.DataFrame], index_col: str = "time"):
+def combine_dataframes(dfs: list[pd.DataFrame], index_col: str = "time"):
     """Combine multiple dataframes with the same index column.
-    The dataframes are combined in the order they are passed, with the last dataframe taking precedence
-    in case of overlapping indices."""
+    The dataframes are combined in the order they are passed,
+    with the last dataframe taking precedence in case of overlapping indices."""
     combined_df = pd.DataFrame()
     for df in dfs:
         df.set_index(index_col, inplace=True)
@@ -125,5 +136,7 @@ if __name__ == "__main__":
     output_base_path = closed_loop_test_folder / Path(
         r"test_models\goal_programming_xml\output\output_modelling_periods_reference"
     )
-    original_input_timeseries_path = closed_loop_test_folder / Path(r"test_models\goal_programming_xml\input")
+    original_input_timeseries_path = closed_loop_test_folder / Path(
+        r"test_models\goal_programming_xml\input"
+    )
     combine_xml_exports(output_base_path, original_input_timeseries_path, True)

{rtc_tools_interface-0.10.2a2 → rtc_tools_interface-0.10.2a3}/rtctools_interface/closed_loop/runner.py

@@ -6,28 +6,38 @@ import os
 import shutil
 import sys
 from pathlib import Path
-from typing import List, Optional
 
 from rtctools.data.pi import DiagHandler
-from rtctools.optimization.pi_mixin import PIMixin
 from rtctools.optimization.csv_mixin import CSVMixin
-from rtctools.util import run_optimization_problem, _resolve_folder
-from rtctools_interface.closed_loop.config import ClosedLoopConfig
+from rtctools.optimization.pi_mixin import PIMixin
+from rtctools.util import _resolve_folder, run_optimization_problem
+
 import rtctools_interface.closed_loop.optimization_ranges as opt_ranges
-from rtctools_interface.closed_loop.results_construction import combine_csv_exports, combine_xml_exports
-from rtctools_interface.closed_loop.time_series_handler import XMLTimeSeriesFile, CSVTimeSeriesFile, TimeSeriesHandler
+from rtctools_interface.closed_loop.config import ClosedLoopConfig
+from rtctools_interface.closed_loop.results_construction import (
+    combine_csv_exports,
+    combine_xml_exports,
+)
+from rtctools_interface.closed_loop.time_series_handler import (
+    CSVTimeSeriesFile,
+    TimeSeriesHandler,
+    XMLTimeSeriesFile,
+)
 
 logger = logging.getLogger("rtctools")
 
 
 def set_initial_values_from_previous_run(
-    results_previous_run: Optional[dict],
+    results_previous_run: dict | None,
     timeseries: TimeSeriesHandler,
-    previous_run_datetimes: List[datetime.datetime],
+    previous_run_datetimes: list[datetime.datetime],
 ) -> None:
-    """Modifies the initial values of `timeseries` based on the results of the previous run (if any)"""
+    """Modifies the initial values of `timeseries` based on the results of the previous run
+    (if any)"""
     if results_previous_run is not None:
-        variables_to_set = {key: value for key, value in results_previous_run.items() if not timeseries.is_set(key)}
+        variables_to_set = {
+            key: value for key, value in results_previous_run.items() if not timeseries.is_set(key)
+        }
         if timeseries.forecast_date:
             index_of_initial_value = previous_run_datetimes.index(timeseries.forecast_date)
         else:
@@ -63,7 +73,9 @@ def _get_optimization_ranges(
     """Return a list of optimization periods."""
     if config.file is not None:
         datetime_range = input_timeseries.get_datetime_range()
-        optimization_ranges = opt_ranges.get_optimization_ranges_from_file(config.file, datetime_range)
+        optimization_ranges = opt_ranges.get_optimization_ranges_from_file(
+            config.file, datetime_range
+        )
     elif config.optimization_period is not None:
         datetimes = input_timeseries.get_datetimes()
         optimization_ranges = opt_ranges.get_optimization_ranges(
@@ -73,7 +85,9 @@ def _get_optimization_ranges(
             optimization_period=config.optimization_period,
         )
     else:
-        raise ValueError("The closed-loop configuration should have either a file or optimization_period set.")
+        raise ValueError(
+            "The closed-loop configuration should have either a file or optimization_period set."
+        )
     if config.round_to_dates:
         optimization_ranges = opt_ranges.round_datetime_ranges_to_days(optimization_ranges)
     return optimization_ranges
@@ -84,8 +98,8 @@ def run_optimization_problem_closed_loop(
     base_folder="..",
     log_level=logging.INFO,
     profile=False,
-    config: Optional[ClosedLoopConfig] = None,
-    modelling_period_input_folder: Optional[str] = None,
+    config: ClosedLoopConfig | None = None,
+    modelling_period_input_folder: str | None = None,
     **kwargs,
 ) -> dict:
     """
@@ -111,7 +125,7 @@ def run_optimization_problem_closed_loop(
         handler.setFormatter(formatter)
         logger.addHandler(handler)
     if issubclass(optimization_problem_class, PIMixin):
-        if not any((isinstance(h, DiagHandler) for h in logger.handlers)):
+        if not any(isinstance(h, DiagHandler) for h in logger.handlers):
             diag_handler = DiagHandler(original_output_folder)
             logger.addHandler(diag_handler)
     logger.setLevel(log_level)
@@ -129,11 +143,14 @@ def run_optimization_problem_closed_loop(
     if not fixed_input_config_file.exists():
         raise FileNotFoundError(
             f"Could not find fixed inputs configuration file: {fixed_input_config_file}"
-            "Create a file with a list of strings that represent the fixed inputs (can be an empty list)."
+            "Create a file with a list of strings that represent the fixed inputs"
+            " (can be an empty list)."
         )
-    with open(fixed_input_config_file, "r") as file:
+    with open(fixed_input_config_file) as file:
         fixed_input_series = json.load(file)
-    if not isinstance(fixed_input_series, list) and all(isinstance(item, str) for item in fixed_input_series):
+    if not isinstance(fixed_input_series, list) and all(
+        isinstance(item, str) for item in fixed_input_series
+    ):
         raise ValueError("Fixed input config file should be a list of strings (or an empty list).")
 
     if modelling_period_input_folder is None:
@@ -157,13 +174,17 @@ def run_optimization_problem_closed_loop(
 
         timeseries_import.select_time_range(start_date=start_time, end_date=end_time)
 
-        set_initial_values_from_previous_run(results_previous_run, timeseries_import, previous_run_datetimes)
+        set_initial_values_from_previous_run(
+            results_previous_run, timeseries_import, previous_run_datetimes
+        )
 
         modelling_period_name = f"period_{i}"
         modelling_period_output_folder_i = modelling_periods_output_folder / modelling_period_name
         modelling_period_output_folder_i.mkdir(exist_ok=True)
         modelling_period_input_folder_i = modelling_period_input_folder / modelling_period_name
-        write_input_folder(modelling_period_input_folder_i, original_input_folder, timeseries_import)
+        write_input_folder(
+            modelling_period_input_folder_i, original_input_folder, timeseries_import
+        )
 
         logger.info(f"Running optimization for period {i}: {(str(start_time), str(end_time))}.")
         result = run_optimization_problem(
@@ -179,22 +200,30 @@ def run_optimization_problem_closed_loop(
         if result.solver_stats["success"]:
             logger.info(f"Successful optimization for {period}.")
         else:
-            message = f"Failed optimization for {period} with status '{result.solver_stats['return_status']}'."
+            message = (
+                f"Failed optimization for {period} with status"
+                + f"{result.solver_stats['return_status']}'."
+            )
             logger.error(message)
             raise Exception(message)
 
         results_previous_run = {
-            key: result.extract_results().get(key) for key in variables_in_import if key not in fixed_input_series
+            key: result.extract_results().get(key)
+            for key in variables_in_import
+            if key not in fixed_input_series
         }
         previous_run_datetimes = result.io.datetimes
 
     logger.info("Finished all optimization runs.")
     if issubclass(optimization_problem_class, PIMixin):
-        combine_xml_exports(modelling_periods_output_folder, original_input_folder, write_csv_out=True)
+        combine_xml_exports(
+            modelling_periods_output_folder, original_input_folder, write_csv_out=True
+        )
     elif issubclass(optimization_problem_class, CSVMixin):
         combine_csv_exports(modelling_periods_output_folder)
     else:
         logger.warning(
-            "Could not combine exports because the optimization problem class is not derived from PIMixin or CSVMixin."
+            "Could not combine exports because the optimization problem class is not "
+            "derived from PIMixin or CSVMixin."
         )
     return result.solver_stats

{rtc_tools_interface-0.10.2a2 → rtc_tools_interface-0.10.2a3}/rtctools_interface/closed_loop/time_series_handler.py

@@ -3,14 +3,10 @@ import datetime
 import logging
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import List, Optional, Tuple
 
-import pandas as pd
 import numpy as np
-
-from rtctools.data import pi
-from rtctools.data import rtc
-from rtctools.data import csv
+import pandas as pd
+from rtctools.data import csv, pi, rtc
 
 ns = {"fews": "http://www.wldelft.nl/fews", "pi": "http://www.wldelft.nl/fews/PI"}
 
@@ -21,7 +17,7 @@ class TimeSeriesHandler(ABC):
     """ABC for handling timeseries data."""
 
     # The forecast date determines at which date the optimization starts.
-    forecast_date: Optional[datetime.datetime] = None
+    forecast_date: datetime.datetime | None = None
 
     @abstractmethod
     def read(self, file_name: str) -> None:
@@ -41,15 +37,15 @@ class TimeSeriesHandler(ABC):
         """Get the timestep of the timeseries data."""
 
     @abstractmethod
-    def get_datetimes(self) -> List[datetime.datetime]:
+    def get_datetimes(self) -> list[datetime.datetime]:
         """Get the dates of the timeseries."""
 
     @abstractmethod
-    def get_datetime_range(self) -> Tuple[datetime.datetime, datetime.datetime]:
+    def get_datetime_range(self) -> tuple[datetime.datetime, datetime.datetime]:
         """Get the date range of the timeseries data (min, max)."""
 
     @abstractmethod
-    def get_all_internal_ids(self) -> List[str]:
+    def get_all_internal_ids(self) -> list[str]:
         """Get all internal id's of the timeseries data."""
 
     @abstractmethod
@@ -58,7 +54,8 @@ class TimeSeriesHandler(ABC):
 
     @abstractmethod
     def is_set(self, internal_id: str) -> bool:
-        """Check whether the variable exists in the timeseries data and whether it has a least one non-nan value"""
+        """Check whether the variable exists in the timeseries data
+        and whether it has a least one non-nan value"""
 
 
 class CSVTimeSeriesFile(TimeSeriesHandler):
@@ -98,7 +95,7 @@ class CSVTimeSeriesFile(TimeSeriesHandler):
                     delimiter=self.csv_delimiter,
                     with_time=False,
                 )
-                self.initial_state: Optional[dict] = {
+                self.initial_state: dict | None = {
                     field: float(initial_state[field]) for field in initial_state.dtype.names
                 }
         else:
@@ -123,7 +120,9 @@ class CSVTimeSeriesFile(TimeSeriesHandler):
     def write_initial_state(self, file_path: Path, file_name: str = "initial_state"):
         if self.initial_state is not None:
             initial_state = pd.DataFrame(self.initial_state, index=[0])
-            initial_state.to_csv((file_path / file_name).with_suffix(".csv"), header=True, index=False)
+            initial_state.to_csv(
+                (file_path / file_name).with_suffix(".csv"), header=True, index=False
+            )
 
     def get_timestep(self):
         return self.data[self.date_col].diff().min()
@@ -171,7 +170,9 @@ class XMLTimeSeriesFile(TimeSeriesHandler):
         self.read(timeseries_import_basename)
 
         if self.get_datetime_range()[0] < self.forecast_date:
-            logger.warning("Currently, the closed loop runner does support data before the forecast date.")
+            logger.warning(
+                "Currently, the closed loop runner does support data before the forecast date."
+            )
             logger.warning("Removing data before forecast date.")
             self.select_time_range(self.forecast_date, self.pi_timeseries.times[-1])
 
@@ -189,8 +190,9 @@ class XMLTimeSeriesFile(TimeSeriesHandler):
         self.forecast_date = self.pi_timeseries.forecast_datetime
 
     def is_set(self, internal_id):
-        """Check whether the variable exists in the timeseries data and whether it has a value at at least
-        one of time steps."""
+        """Check whether the variable exists in the timeseries data.
+
+        and whether it has a value at at least one of time steps."""
         try:
             var: np.ndarray = self.pi_timeseries.get(variable=internal_id)
             return not np.isnan(var).all()
@@ -206,7 +208,9 @@ class XMLTimeSeriesFile(TimeSeriesHandler):
             return False
 
     def get_all_internal_ids(self):
-        """Get all internal id's of the timeseries data. Only returns the id's that are also in the dataconfig."""
+        """Get all internal id's of the timeseries data.
+
+        Only returns the id's that are also in the dataconfig."""
         all_ids = [var for var, _ in self.pi_timeseries.items() if self._is_in_dataconfig(var)]
         return all_ids
 
@@ -215,12 +219,13 @@ class XMLTimeSeriesFile(TimeSeriesHandler):
         i_start = bisect.bisect_left(times, start_date)
         i_end = bisect.bisect_right(times, end_date) - 1
         self.pi_timeseries.resize(start_datetime=times[i_start], end_datetime=times[i_end])
-        self.pi_timeseries.times = times[i_start:i_end + 1]
+        self.pi_timeseries.times = times[i_start : i_end + 1]
         self.pi_timeseries.forecast_datetime = times[i_start]
         self.forecast_date = times[i_start]
 
     def write(self, file_path: Path, file_name: str = "timeseries_import"):
-        # By setting make_new_file headers will be recreated, neceesary for writing new forecast date
+        # By setting make_new_file headers will be recreated,
+        # neceesary for writing new forecast date
         self.pi_timeseries.make_new_file = True
         self.pi_timeseries.write(output_folder=file_path, output_filename=file_name)