openstef 3.4.63__py3-none-any.whl → 3.4.65__py3-none-any.whl

openstef/data_classes/prediction_job.py

@@ -96,6 +96,10 @@ class PredictionJobDataClass(BaseModel):
         1440,
         description="Number of minutes that the load has to be constant to detect a flatliner.",
     )
+    detect_non_zero_flatliner: bool = Field(
+        False,
+        description="If True, flatliners are also detected on non-zero values (median of the load).",
+    )
     data_balancing_ratio: Optional[float] = Field(
         None,
         description="If data balancing is enabled, the data will be balanced with data from 1 year ago in the future.",

openstef/exceptions.py

@@ -44,8 +44,8 @@ class InputDataWrongColumnOrderError(InputDataInvalidError):
     """Wrong column order input data."""
 
 
-class InputDataOngoingZeroFlatlinerError(InputDataInvalidError):
-    """All recent load measurements are zero."""
+class InputDataOngoingFlatlinerError(InputDataInvalidError):
+    """All recent load measurements are constant."""
 
 
 class OldModelHigherScoreError(Exception):

openstef/pipeline/create_basecase_forecast.py

@@ -8,7 +8,7 @@ import pandas as pd
 import structlog
 
 from openstef.data_classes.prediction_job import PredictionJobDataClass
-from openstef.exceptions import InputDataOngoingZeroFlatlinerError, NoRealisedLoadError
+from openstef.exceptions import NoRealisedLoadError
 from openstef.feature_engineering.feature_applicator import (
     OperationalPredictFeatureApplicator,
 )
@@ -58,12 +58,12 @@ def create_basecase_forecast_pipeline(
     if not isinstance(input_data.index, pd.DatetimeIndex):
         raise ValueError("Input dataframe does not have a datetime index.")
 
-    zero_flatliner_ongoing = validation.detect_ongoing_zero_flatliner(
+    flatliner_ongoing = validation.detect_ongoing_flatliner(
         load=input_data.iloc[:, 0],
         duration_threshold_minutes=pj.flatliner_threshold_minutes,
     )
 
-    if zero_flatliner_ongoing:
+    if flatliner_ongoing:
         # Set historic load to zero to force the basecase forecasts to be zero.
         input_data.loc[input_data.index < forecast_start, "load"] = 0
 

openstef/pipeline/create_forecast.py

@@ -45,7 +45,7 @@ def create_forecast_pipeline(
         DataFrame with the forecast
 
     Raises:
-        InputDataOngoingZeroFlatlinerError: When all recent load measurements are zero.
+        InputDataOngoingFlatlinerError: When all recent load measurements are constant.
         LookupError: When no model is found for the given prediction job in MLflow.
 
     """
@@ -85,7 +85,7 @@ def create_forecast_pipeline_core(
         Forecast
 
     Raises:
-        InputDataOngoingZeroFlatlinerError: When all recent load measurements are zero.
+        InputDataOngoingFlatlinerError: When all recent load measurements are constant.
 
     """
     structlog.configure(
@@ -103,6 +103,7 @@ def create_forecast_pipeline_core(
         input_data,
         pj["flatliner_threshold_minutes"],
         pj["resolution_minutes"],
+        detect_non_zero_flatliner=pj["detect_non_zero_flatliner"],
     )
 
     # Custom data prep or legacy behavior

openstef/pipeline/optimize_hyperparameters.py

@@ -132,7 +132,7 @@ def optimize_hyperparameters_pipeline_core(
         InputDataInsufficientError: If the input dataframe is empty.
         InputDataWrongColumnOrderError: If the load column is missing in the input dataframe.
         OldModelHigherScoreError: When old model is better than new model.
-        InputDataOngoingZeroFlatlinerError: When all recent load measurements are zero.
+        InputDataOngoingFlatlinerError: If all recent load measurements are constant.
 
     Returns:
         - Best model,
@@ -157,6 +157,7 @@ def optimize_hyperparameters_pipeline_core(
             input_data,
             pj["flatliner_threshold_minutes"],
             pj["resolution_minutes"],
+            detect_non_zero_flatliner=pj["detect_non_zero_flatliner"],
         )
     )
 

openstef/pipeline/train_create_forecast_backtest.py

@@ -60,7 +60,7 @@ def train_model_and_forecast_back_test(
         InputDataInsufficientError: when input data is insufficient.
         InputDataWrongColumnOrderError: when input data has a invalid column order.
         ValueError: when the horizon is a string and the corresponding column in not in the input data
-        InputDataOngoingZeroFlatlinerError: when all recent load measurements are zero.
+        InputDataOngoingFlatlinerError: If all recent load measurements are constant.
 
     """
     if pj.backtest_split_func is None:

openstef/pipeline/train_model.py

@@ -177,7 +177,7 @@ def train_model_pipeline_core(
         InputDataInsufficientError: when input data is insufficient.
         InputDataWrongColumnOrderError: when input data has a invalid column order.
         OldModelHigherScoreError: When old model is better than new model.
-        InputDataOngoingZeroFlatlinerError: when all recent load measurements are zero.
+        InputDataOngoingFlatlinerError: If all recent load measurements are constant.
 
     Returns:
         - Fitted_model (OpenstfRegressor)
@@ -272,7 +272,7 @@ def train_pipeline_common(
         InputDataInsufficientError: when input data is insufficient.
         InputDataWrongColumnOrderError: when input data has a invalid column order.
             'load' column should be first and 'horizon' column last.
-        InputDataOngoingZeroFlatlinerError: when all recent load measurements are zero.
+        InputDataOngoingFlatlinerError: If all recent load measurements are constant.
 
     """
     data_with_features = train_pipeline_step_compute_features(
@@ -363,7 +363,7 @@ def train_pipeline_step_compute_features(
         InputDataInsufficientError: when input data is insufficient.
         InputDataWrongColumnOrderError: when input data has a invalid column order.
         ValueError: when the horizon is a string and the corresponding column in not in the input data
-        InputDataOngoingZeroFlatlinerError: when all recent load measurements are zero.
+        InputDataOngoingFlatlinerError: If all recent load measurements are constant.
 
     """
     if input_data.empty:
@@ -389,6 +389,7 @@ def train_pipeline_step_compute_features(
             input_data,
             pj["flatliner_threshold_minutes"],
             pj["resolution_minutes"],
+            detect_non_zero_flatliner=pj["detect_non_zero_flatliner"],
         )
     )
     # Check if sufficient data is left after cleaning

openstef/plotting/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: 2017-2025 Contributors to the OpenSTEF project <korte.termijn.prognoses@alliander.com> # noqa E501>
+#
+# SPDX-License-Identifier: MPL-2.0

openstef/plotting/load_forecast_plotter.py

@@ -0,0 +1,216 @@
+# SPDX-FileCopyrightText: 2017-2025 Contributors to the OpenSTEF project <korte.termijn.prognoses@alliander.com> # noqa E501>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+from typing import Tuple, Optional
+
+import numpy as np
+from pydantic import BaseModel
+import pandas as pd
+import plotly.graph_objects as go
+import plotly.express as px
+
+
+class LoadForecastPlotter(BaseModel):
+    colormap: str = "Blues"
+    colormap_range: Tuple[float, float] = (0.2, 0.8)
+
+    fill_opacity: float = 0.5
+    stroke_opacity: float = 0.8
+    stroke_width: float = 1.5
+
+    def _get_color_by_value(self, value: float) -> str:
+        """Maps a normalized value to a color using the specified colormap.
+
+        Args:
+            value (float): A value between 0 and 1 to be mapped to a color.
+
+        Returns:
+            str: A color in the rgba format.
+        """
+        rescaled = self.colormap_range[0] + value * (
+            self.colormap_range[1] - self.colormap_range[0]
+        )
+        rescaled = min(1.0, max(0.0, rescaled))
+
+        return px.colors.sample_colorscale(
+            colorscale=self.colormap, samplepoints=[rescaled]
+        )[0]
+
+    def _get_quantile_colors(self, quantile: float) -> Tuple[str, str]:
+        """Generate fill and stroke colors for a given quantile using a colorscale.
+
+        Colors are determined based on the distance from the median (50th percentile).
+
+        Args:
+           quantile (float): The quantile value (0-100) to generate colors for.
+
+        Returns:
+           Tuple[str, str]: A tuple containing (fill_color, stroke_color).
+        """
+        fill_value = 1 - abs(quantile - 50.0) / 50.0
+        stroke_value = 1 - abs(quantile + 5.0 - 50.0) / 50.0
+        return (
+            self._get_color_by_value(fill_value),
+            self._get_color_by_value(stroke_value),
+        )
+
+    def _add_quantile_band(
+        self,
+        figure: go.Figure,
+        lower_quantile_data: pd.Series,
+        lower_quantile: float,
+        upper_quantile_data: pd.Series,
+        upper_quantile: float,
+    ):
+        """Add a quantile band to the plotly figure.
+
+        Creates a filled polygon representing the area between lower and upper quantiles,
+        and adds it to the provided figure along with hover information.
+
+        Args:
+            figure (go.Figure): The plotly figure to add the quantile band to.
+            lower_quantile_data (pd.Series): Series with data for the lower quantile.
+            lower_quantile (float): The percentile value of the lower quantile.
+            upper_quantile_data (pd.Series): Series with data for the upper quantile.
+            upper_quantile (float): The percentile value of the upper quantile.
+
+        Returns:
+            None: The figure is modified in place.
+        """
+        # Create polygon shape for the quantile band in counterclockwise order
+        x = list(lower_quantile_data.index) + list(upper_quantile_data.index[::-1])
+        y = list(lower_quantile_data) + list(upper_quantile_data[::-1])
+
+        # Get colors for the band
+        fill_color, stroke_color = self._get_quantile_colors(lower_quantile)
+
+        # Group traces by quantile range
+        legendgroup = f"quantile_{lower_quantile}_{upper_quantile}"
+
+        # Add a single trace that forms a filled polygon
+        figure.add_trace(
+            go.Scatter(
+                x=x,
+                y=y,
+                fill="toself",
+                fillcolor=f"rgba{fill_color[3:-1]}, {self.fill_opacity})",
+                line=dict(
+                    color=f"rgba{stroke_color[3:-1]}, {self.stroke_opacity})",
+                    width=self.stroke_width,
+                ),
+                name=f"{lower_quantile}%-{upper_quantile}%",
+                showlegend=True,
+                hoverinfo="skip",
+                legendgroup=legendgroup,
+            )
+        )
+
+        # Add an (invisible) line around the filled area to make quantile
+        # values selectable/hover-able.
+        # Hovering on filled area values is not supported by plotly.
+        figure.add_trace(
+            go.Scatter(
+                x=lower_quantile_data.index,
+                y=lower_quantile_data.values,
+                mode="lines",
+                line=dict(
+                    width=self.stroke_width,
+                    color=f"rgba{stroke_color[3:-1]}, {self.stroke_opacity})",
+                ),
+                customdata=np.column_stack(
+                    (lower_quantile_data.values, upper_quantile_data.values)
+                ),
+                hovertemplate=(
+                    f"{lower_quantile}%: %{{customdata[0]:,.4s}}<br>"
+                    f"{upper_quantile}%: %{{customdata[1]:,.4s}}"
+                    "<extra></extra>"
+                ),
+                name=f"{lower_quantile}%-{upper_quantile}% Hover Info",
+                showlegend=False,
+                legendgroup=legendgroup,
+            )
+        )
+
+    def plot(
+        self,
+        realized: Optional[pd.Series] = None,
+        forecast: Optional[pd.Series] = None,
+        quantiles: Optional[pd.DataFrame] = None,
+    ):
+        """Create a plot showing forecast quantiles and realized values.
+
+        Generates an interactive plotly figure displaying the forecast distribution
+        through quantile bands, the median forecast, and the actual realized values.
+
+        Args:
+            realized (pd.Series): Time series of realized (actual) values.
+            forecast (pd.Series): Time series of forecast values (typically the median).
+            quantiles (pd.DataFrame): DataFrame containing quantile predictions.
+                Column names should follow the format 'quantile_P{percentile:02d}',
+                e.g., 'quantile_P10', 'quantile_P90'.
+
+        Returns:
+            go.Figure: A plotly figure object with the configured visualization.
+        """
+        figure = go.Figure()
+
+        if quantiles is not None:
+            # Extract and sort quantile percentages
+            quantile_cols = [
+                col for col in quantiles.columns if col.startswith("quantile_P")
+            ]
+            percentiles = sorted([int(col.split("P")[1]) for col in quantile_cols])
+
+            # Add quantile bands from widest to narrowest
+            for i in range(len(percentiles) // 2):
+                lower_quantile, upper_quantile = percentiles[i], percentiles[-(i + 1)]
+                if float(lower_quantile) == 50.0:
+                    continue
+
+                self._add_quantile_band(
+                    figure=figure,
+                    lower_quantile_data=quantiles[f"quantile_P{lower_quantile:02d}"],
+                    lower_quantile=lower_quantile,
+                    upper_quantile_data=quantiles[f"quantile_P{upper_quantile:02d}"],
+                    upper_quantile=upper_quantile,
+                )
+
+        if forecast is not None:
+            # Add forecast line (50th percentile)
+            figure.add_trace(
+                go.Scatter(
+                    x=forecast.index,
+                    y=forecast,
+                    mode="lines",
+                    line=dict(color="blue", width=self.stroke_width),
+                    name="Forecast (50th)",
+                    customdata=forecast.values,
+                    hovertemplate="Forecast (50th): %{customdata:,.4s}<extra></extra>",
+                )
+            )
+
+        if realized is not None:
+            # Add realized values on top
+            figure.add_trace(
+                go.Scatter(
+                    x=realized.index,
+                    y=realized,
+                    mode="lines",
+                    line=dict(color="red", width=self.stroke_width),
+                    customdata=realized.values,
+                    hovertemplate="Realized: %{customdata:,.4s}<extra></extra>",
+                    name="Realized",
+                )
+            )
+
+        # Styling configuration
+        figure.update_layout(
+            title=f"Load Forecast vs Actual",
+            xaxis_title="Datetime [UTC]",
+            yaxis_title="Load [W]",
+            template="plotly_white",
+            hovermode="x unified",
+        )
+
+        return figure

openstef/tasks/create_forecast.py

@@ -25,11 +25,11 @@ from pathlib import Path
 
 from openstef.data_classes.prediction_job import PredictionJobDataClass
 from openstef.enums import BiddingZone, ModelType, PipelineType
-from openstef.exceptions import InputDataOngoingZeroFlatlinerError
+from openstef.exceptions import InputDataOngoingFlatlinerError
 from openstef.pipeline.create_forecast import create_forecast_pipeline
 from openstef.tasks.utils.predictionjobloop import PredictionJobLoop
 from openstef.tasks.utils.taskcontext import TaskContext
-from openstef.validation.validation import detect_ongoing_zero_flatliner
+from openstef.validation.validation import detect_ongoing_flatliner
 
 T_BEHIND_DAYS: int = 14
 
@@ -94,7 +94,7 @@ def create_forecast_task(
         forecast = create_forecast_pipeline(
             pj, input_data, mlflow_tracking_uri=mlflow_tracking_uri
         )
-    except (InputDataOngoingZeroFlatlinerError, LookupError) as e:
+    except (InputDataOngoingFlatlinerError, LookupError) as e:
         if (
             context.config.known_zero_flatliners
             and pj.id in context.config.known_zero_flatliners
@@ -103,18 +103,18 @@ def create_forecast_task(
                 "No forecasts were made for this known zero flatliner prediction job. No forecasts need to be made either, since the fallback forecasts are sufficient."
             )
             return
-        elif isinstance(e, InputDataOngoingZeroFlatlinerError):
-            raise InputDataOngoingZeroFlatlinerError(
-                'All recent load measurements are zero. Check the load profile of this pid as well as related/neighbouring prediction jobs. Afterwards, consider adding this pid to the "known_zero_flatliners" app_setting and possibly removing other pids from the same app_setting.'
+        elif isinstance(e, InputDataOngoingFlatlinerError):
+            raise InputDataOngoingFlatlinerError(
+                'All recent load measurements are constant. Check the load profile of this pid as well as related/neighbouring prediction jobs. Afterwards, consider adding this pid to the "known_zero_flatliners" app_setting and possibly removing other pids from the same app_setting.'
             ) from e
         elif isinstance(e, LookupError):
-            zero_flatliner_ongoing = detect_ongoing_zero_flatliner(
+            zero_flatliner_ongoing = detect_ongoing_flatliner(
                 load=input_data.iloc[:, 0],
                 duration_threshold_minutes=pj.flatliner_threshold_minutes,
             )
             if zero_flatliner_ongoing:
                 raise LookupError(
-                    'Model not found. Consider checking for a zero flatliner and adding this pid to the "known_zero_flatliners" app_setting. For zero flatliners, no model can be trained.'
+                    'Model not found. Consider checking for a flatliner and adding this pid to the "known_zero_flatliners" app_setting. For flatliners, no model can be trained.'
                 ) from e
             else:
                 raise e

openstef/tasks/train_model.py

@@ -27,7 +27,7 @@ import pandas as pd
 from openstef.data_classes.prediction_job import PredictionJobDataClass
 from openstef.enums import ModelType, PipelineType
 from openstef.exceptions import (
-    InputDataOngoingZeroFlatlinerError,
+    InputDataOngoingFlatlinerError,
     SkipSaveTrainingForecasts,
 )
 from openstef.model.serializer import MLflowSerializer
@@ -67,7 +67,7 @@ def train_model_task(
 
     Raises:
         SkipSaveTrainingForecasts: If old model is better or too young, you don't need to save the traing forcast.
-        InputDataOngoingZeroFlatlinerError: If all recent load measurements are zero.
+        InputDataOngoingFlatlinerError: If all recent load measurements are constant.
 
     """
     # Check pipeline types
@@ -187,18 +187,18 @@ def train_model_task(
             context.logger.debug("Saved Forecasts from trained model on datasets")
     except SkipSaveTrainingForecasts:
         context.logger.debug("Skip saving forecasts")
-    except InputDataOngoingZeroFlatlinerError:
+    except InputDataOngoingFlatlinerError:
         if (
             context.config.known_zero_flatliners
             and pj.id in context.config.known_zero_flatliners
         ):
             context.logger.info(
-                "No model was trained for this known zero flatliner. No model needs to be trained either, since the fallback forecasts are sufficient."
+                "No model was trained for this known flatliner. No model needs to be trained either, since the fallback forecasts are sufficient."
             )
             return
         else:
-            raise InputDataOngoingZeroFlatlinerError(
-                'All recent load measurements are zero. Check the load profile of this pid as well as related/neighbouring prediction jobs. Afterwards, consider adding this pid to the "known_zero_flatliners" app_setting and possibly removing other pids from the same app_setting.'
+            raise InputDataOngoingFlatlinerError(
+                'All recent load measurements are constant. Check the load profile of this pid as well as related/neighbouring prediction jobs. Afterwards, consider adding this pid to the "known_zero_flatliners" app_setting and possibly removing other pids from the same app_setting.'
             )
 
 

openstef/validation/validation.py

@@ -10,7 +10,8 @@ import numpy as np
 import pandas as pd
 import structlog
 
-from openstef.exceptions import InputDataOngoingZeroFlatlinerError
+from openstef.data_classes.prediction_job import PredictionJobDataClass
+from openstef.exceptions import InputDataOngoingFlatlinerError
 from openstef.model.regressors.regressor import OpenstfRegressor
 from openstef.preprocessing.preprocessing import replace_repeated_values_with_nan
 from openstef.settings import Settings
@@ -21,12 +22,15 @@ def validate(
     data: pd.DataFrame,
     flatliner_threshold_minutes: Union[int, None],
     resolution_minutes: int,
+    *,
+    detect_non_zero_flatliner: bool = False,
 ) -> pd.DataFrame:
     """Validate prediction job and timeseries data.
 
     Steps:
     1. Check if input dataframe has a datetime index.
-    1. Check if a zero flatliner pattern is ongoing (i.e. all recent measurements are zero).
+    1. Check if a flatliner pattern is ongoing (i.e. all recent measurements are constant,
+        0 in case detect_non_zero_flatliner = True).
     2. Replace repeated values for longer than flatliner_threshold_minutes with NaN.
 
     Args:
@@ -35,12 +39,14 @@ def validate(
         flatliner_threshold_minutes: int indicating the number of minutes after which constant load is considered a flatline.
             if None, the validation is effectively skipped
         resolution_minutes: The forecasting resolution in minutes.
+        detect_non_zero_flatliner: If True, a flatliner is detected for non-zero values. If False,
+            a flatliner is detected for zero values only.
 
     Returns:
         Dataframe where repeated values are set to None
 
     Raises:
-        InputDataOngoingZeroFlatlinerError: If all recent load measurements are zero.
+        InputDataOngoingFlatlinerError: If all recent load measurements are constant.
 
     """
     structlog.configure(
@@ -57,13 +63,15 @@ def validate(
         logger.info("Skipping validation of input data", pj_id=pj_id)
         return data
 
-    zero_flatliner_ongoing = detect_ongoing_zero_flatliner(
-        load=data.iloc[:, 0], duration_threshold_minutes=flatliner_threshold_minutes
+    flatliner_ongoing = detect_ongoing_flatliner(
+        load=data.iloc[:, 0],
+        duration_threshold_minutes=flatliner_threshold_minutes,
+        detect_non_zero_flatliner=detect_non_zero_flatliner,
     )
 
-    if zero_flatliner_ongoing:
-        raise InputDataOngoingZeroFlatlinerError(
-            "All recent load measurements are zero."
+    if flatliner_ongoing:
+        raise InputDataOngoingFlatlinerError(
+            "All recent load measurements are constant."
         )
 
     flatliner_threshold_repetitions = math.ceil(
@@ -228,18 +236,22 @@ def calc_completeness_features(
     return completeness
 
 
-def detect_ongoing_zero_flatliner(
+def detect_ongoing_flatliner(
     load: pd.Series,
     duration_threshold_minutes: int,
+    *,
+    detect_non_zero_flatliner: bool = False,
 ) -> bool:
-    """Detects if the latest measurements follow a zero flatliner pattern.
+    """Detects if the latest measurements follow a flatliner pattern.
 
     Args:
         load (pd.Series): A timeseries of measured load with a datetime index.
-        duration_threshold_minutes (int): A zero flatliner is only detected if it exceeds the threshold duration.
+        duration_threshold_minutes (int): A flatliner is only detected if it exceeds the threshold duration.
+        detect_non_zero_flatliner (bool): If True, a flatliner is detected for non-zero values. If False,
+            a flatliner is detected for zero values only.
 
     Returns:
-        bool: Indicating whether or not there is a zero flatliner ongoing for the given load.
+        bool: Indicating whether or not there is a flatliner ongoing for the given load.
 
     """
     # remove all timestamps in the future
@@ -249,7 +261,18 @@ def detect_ongoing_zero_flatliner(
         latest_measurement_time - timedelta(minutes=duration_threshold_minutes) :
     ].dropna()
 
-    return (latest_measurements == 0).all() & (not latest_measurements.empty)
+    flatliner_value = latest_measurements.median() if detect_non_zero_flatliner else 0
+
+    # check if all values are within a relative tolerance of each other
+    flatline_condition = np.isclose(
+        latest_measurements,
+        flatliner_value,
+        atol=0,
+        rtol=1e-5,
+    ).all()
+    non_empty_condition = not latest_measurements.empty
+
+    return flatline_condition & non_empty_condition
 
 
 def calc_completeness_dataframe(

{openstef-3.4.63.dist-info → openstef-3.4.65.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: openstef
-Version: 3.4.63
+Version: 3.4.65
 Summary: Open short term energy forecaster
 Home-page: https://github.com/OpenSTEF/openstef
 Author: Alliander N.V
@@ -33,7 +33,11 @@ Requires-Dist: scikit-learn<1.6,>=1.3
 Requires-Dist: scipy~=1.10
 Requires-Dist: statsmodels<1.0.0,>=0.13.5
 Requires-Dist: structlog<25,>=23.1
-Requires-Dist: xgboost~=2.0
+Requires-Dist: xgboost~=2.0; extra == "gpu"
+Provides-Extra: cpu
+Requires-Dist: xgboost-cpu~=2.0; extra == "cpu"
+Provides-Extra: gpu
+Requires-Dist: xgboost; extra == "gpu"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -42,6 +46,7 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
+Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
@@ -53,11 +58,15 @@ SPDX-License-Identifier: MPL-2.0
 -->
 
 # OpenSTEF
+
 <!-- Badges -->
+
 [![Downloads](https://static.pepy.tech/badge/openstef)](https://pepy.tech/project/openstef)
 [![Downloads](https://static.pepy.tech/badge/openstef/month)](https://pepy.tech/project/openstef)
 [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/5585/badge)](https://bestpractices.coreinfrastructure.org/projects/5585)
+
 <!-- SonarCloud badges -->
+
 [![Bugs](https://sonarcloud.io/api/project_badges/measure?project=OpenSTEF_openstef&metric=bugs)](https://sonarcloud.io/dashboard?id=OpenSTEF_openstef)
 [![Code Smells](https://sonarcloud.io/api/project_badges/measure?project=OpenSTEF_openstef&metric=code_smells)](https://sonarcloud.io/dashboard?id=OpenSTEF_openstef)
 [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=OpenSTEF_openstef&metric=coverage)](https://sonarcloud.io/dashboard?id=OpenSTEF_openstef)
@@ -71,19 +80,21 @@ SPDX-License-Identifier: MPL-2.0
 OpenSTEF is a Python package designed for generating short-term forecasts in the energy sector. The repository includes all the essential components required for machine learning pipelines that facilitate the forecasting process. To utilize the package, users are required to furnish their own data storage and retrieval interface.
 
 # Table of contents
+
 - [OpenSTEF](#openstef)
 - [Table of contents](#table-of-contents)
 - [External information sources](#external-information-sources)
 - [Installation](#installation)
 - [Usage](#usage)
-    - [Example notebooks](#example-notebooks)
-    - [Reference Implementation](#reference-implementation)
-    - [Database connector for OpenSTEF](#database-connector-for-openstef)
+  - [Example notebooks](#example-notebooks)
+  - [Reference Implementation](#reference-implementation)
+  - [Database connector for OpenSTEF](#database-connector-for-openstef)
 - [License](license)
 - [Contributing](#contributing)
 - [Contact](#contact)
 
 # External information sources
+
 - [Documentation website](https://openstef.github.io/openstef/index.html);
 - [Python package](https://pypi.org/project/openstef/);
 - [Linux Foundation project page](https://www.lfenergy.org/projects/openstef/);
@@ -101,9 +112,11 @@ pip install openstef
 ### Remark regarding installation within a **conda environment on Windows**
 
 A version of the pywin32 package will be installed as a secondary dependency along with the installation of the openstef package. Since conda relies on an old version of pywin32, the new installation can break conda's functionality. The following command can solve this issue:
+
 ```shell
 pip install pywin32==300
 ```
+
 For more information on this issue see the [readme of pywin32](https://github.com/mhammond/pywin32#installing-via-pip) or [this Github issue](https://github.com/mhammond/pywin32/issues/1865#issue-1212752696).
 
 ## Remark regarding installation on Apple Silicon
@@ -112,19 +125,31 @@ If you want to install the `openstef` package on Apple Silicon (Mac with M1-chip
 
 1. Run `brew install libomp` (if you haven’t installed Homebrew: [follow instructions here](https://brew.sh/))
 2. If your interpreter can not find the `libomp` installation in `/usr/local/bin`, it is probably in `/opt/brew/Cellar`. Run:
+
 ```sh
 mkdir -p /usr/local/opt/libomp/
 ln -s /opt/brew/Cellar/libomp/{your_version}/lib /usr/local/opt/libomp/lib
 ```
+
 3. Uninstall `xgboost` with `pip` (`pip uninstall xgboost`) and install with `conda-forge` (`conda install -c conda-forge xgboost`)
 4. If you encounter similar issues with `lightgbm`: uninstall `lightgbm` with `pip` (`pip uninstall lightgbm`) and install later version with `conda-forge` (`conda install -c conda-forge 'lightgbm>=4.2.0'`)
 
+### Remark regarding installation with minimal XGBoost dependency
+
+It is possible to install openSTEF with a minimal XGBoost (CPU-only) package. This only works on x86_64 (amd64) Linux and Windows platforms. Advantage is that significantly smaller dependencies are installed. In that case run:
+
+```shell
+pip install openstef[cpu]
+```
+
 # Usage
 
 ## Example notebooks
+
 To help you get started, a set of fundamental example notebooks has been created. You can access these offline examples [here](https://github.com/OpenSTEF/openstef-offline-example).
 
 ## Reference Implementation
+
 A complete implementation including databases, user interface, example data, etc. is available at: https://github.com/OpenSTEF/openstef-reference
 
 ![screenshot](https://user-images.githubusercontent.com/60883372/146760483-29af3ac7-62af-4f13-98c7-982a79c517d1.jpg)
@@ -138,17 +163,21 @@ python -m openstef task <task_name>
 ```
 
 ## Database connector for openstef
+
 This repository provides an interface to OpenSTEF (reference) databases. The repository can be found [here](https://github.com/OpenSTEF/openstef-dbc).
 
 # License
+
 This project is licensed under the Mozilla Public License, version 2.0 - see LICENSE for details.
 
 ## Licenses third-party libraries
+
 This project includes third-party libraries, which are licensed under their own respective Open-Source licenses. SPDX-License-Identifier headers are used to show which license is applicable. The concerning license files can be found in the LICENSES directory.
 
 # Contributing
+
 Please read [CODE_OF_CONDUCT.md](https://github.com/OpenSTEF/.github/blob/main/CODE_OF_CONDUCT.md), [CONTRIBUTING.md](https://github.com/OpenSTEF/.github/blob/main/CONTRIBUTING.md) and [PROJECT_GOVERNANCE.md](https://github.com/OpenSTEF/.github/blob/main/PROJECT_GOVERNANCE.md) for details on the process for submitting pull requests to us.
 
 # Contact
+
 Please read [SUPPORT.md](https://github.com/OpenSTEF/.github/blob/main/SUPPORT.md) for how to connect and get into contact with the OpenSTEF project
- 

{openstef-3.4.63.dist-info → openstef-3.4.65.dist-info}/RECORD

@@ -2,7 +2,7 @@ openstef/__init__.py,sha256=93UM6m0LLQhO69-mSqLuUy73jgs4W7Iuxfo3Lm8c98g,419
 openstef/__main__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
 openstef/app_settings.py,sha256=EJTDtimctFQQ-3f7ZcOQaRYohpZk3JD6aZBWPFYM2_A,582
 openstef/enums.py,sha256=FrP0m_Tk0kV7gSZ2hTY_8iD45KIKnexHrjNufhpKXpE,2829
-openstef/exceptions.py,sha256=U4u2LTcdT6cmzpipT2Jh7kq9nCjT_-6gntn8yjuhGU0,1993
+openstef/exceptions.py,sha256=dgnvZe5WWuJWCZm_GES6suEATbusPlwbiEUfNQKeExY,1993
 openstef/settings.py,sha256=nSgkBqFxuqB3w7Rwo60i8j37c5ngDbt6vpjHS6QtJXQ,354
 openstef/data/NL_terrestrial_radiation.csv,sha256=A4kbW56GDzWi4tWUwY2C-4PiOvcKJCwkWQQtdg4ekPE,820246
 openstef/data/NL_terrestrial_radiation.csv.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
@@ -17,7 +17,7 @@ openstef/data/dazls_model_3.4.24/dazls_stored_3.4.24_model_card.md.license,sha25
 openstef/data_classes/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
 openstef/data_classes/data_prep.py,sha256=sANgFjfwmSWhLCfmLjfqXQnczuvVZfk2765jZd7LwuE,3691
 openstef/data_classes/model_specifications.py,sha256=PZeBLfH_MrP9-QorL1r0Hklp0befE8Nw05vNhTX9Y20,1338
-openstef/data_classes/prediction_job.py,sha256=pbvffqje7X7UGx2AC1LX2bvChiEd4n9brbxtS6-4_iE,6553
+openstef/data_classes/prediction_job.py,sha256=e6_PFAovNd31tjzoTQJvqRNQyVM-M0XHffclAG9Ez8A,6721
 openstef/data_classes/split_function.py,sha256=K8y1dsQC5exeIDh37f7UwJ11tV71_uVSNbnKmwXpnOM,3435
 openstef/feature_engineering/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
 openstef/feature_engineering/apply_features.py,sha256=9Yzg61Whd4n0osQBfrcW8cI0gaUiv7u8KnQIQPR40fY,5327
@@ -68,13 +68,15 @@ openstef/monitoring/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4
 openstef/monitoring/performance_meter.py,sha256=6aCGjJFXFq-7qwaJyBkF3MLqjgVK6FMFVcO-bcLLUb4,2803
 openstef/monitoring/teams.py,sha256=A-tlZeuAgolxFHjgT3gGjraxzW2dmuB-UAOz4xgYNIQ,6668
 openstef/pipeline/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
-openstef/pipeline/create_basecase_forecast.py,sha256=8pyUHauJEFXMFxAg-lMy8B6oaZbsXMpdHXuNS6o_3QM,4630
+openstef/pipeline/create_basecase_forecast.py,sha256=ChIh8iQSRL9n2pc7l3Cw3RWRONkp2e7MOoUnpY9VT_s,4579
 openstef/pipeline/create_component_forecast.py,sha256=U2v_R-FSOXWVbWeknsJbkulN1YK56fL7-bB1h2B1yzw,6021
-openstef/pipeline/create_forecast.py,sha256=_WKoi-FRdODUmJh-6X82CbbFiHrbGwvoTPfLf60thco,5696
-openstef/pipeline/optimize_hyperparameters.py,sha256=3SLkcLR7XC4IeN48C-XT_lxlfCqW_D0NoMpZcrB9UUM,11045
-openstef/pipeline/train_create_forecast_backtest.py,sha256=-kZqCWal5zYLL0k0Sapks1zTmU5unNAooVPaPos1_7E,6050
-openstef/pipeline/train_model.py,sha256=ThZwPo5otikVqVe6NdXkYcxkVFh-kegRVxMsQg1lbFc,19743
+openstef/pipeline/create_forecast.py,sha256=uvp5mQqGSOx-ANY-9o5reiBYNNby0npm-0lt4w9EQ18,5763
+openstef/pipeline/optimize_hyperparameters.py,sha256=uwXkzRA_fTSFt0yBuvvEoY5-4dMv42FPdS4hZocL-N8,11114
+openstef/pipeline/train_create_forecast_backtest.py,sha256=hBJPxfDkbrmFSSGZrRH1vTiIVqJP-SWe0ibVpHT_8Qg,6048
+openstef/pipeline/train_model.py,sha256=zFQS_XSqN4VQWEpvC1dvGN1rcI2tGOuFOTaN_dnKZSA,19808
 openstef/pipeline/utils.py,sha256=23mB31p19FoGWelLJzxNmqlzGwEr3fCDBEA37V2kpYY,2167
+openstef/plotting/__init__.py,sha256=KQjXzyafCt1bE7XDrSeV4TDUIO7MkwN_Br4ASOcNI2g,163
+openstef/plotting/load_forecast_plotter.py,sha256=n-dB2dQnqjWCvV3kBjnOZYQ03J-9jSIHVovJy3nGSnQ,8129
 openstef/postprocessing/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
 openstef/postprocessing/postprocessing.py,sha256=6x_2ZcZaHEKMg_kxBAuKUlA_dDEs-KaO5SgGqGWHK14,8997
 openstef/preprocessing/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
@@ -83,20 +85,20 @@ openstef/tasks/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,16
 openstef/tasks/calculate_kpi.py,sha256=tcW_G0JRMA2tBcb8JN5eUbFFV9UcTsqHXQ1x3f-8Biw,11881
 openstef/tasks/create_basecase_forecast.py,sha256=_4Ry7AQmXNAKq19J1qmVyG-94atygXePLxVCejCfGPw,4227
 openstef/tasks/create_components_forecast.py,sha256=8LINqAHt7SnVsQAQMOuve5K-3bLJW-tK_dXTqzlh5Mw,6140
-openstef/tasks/create_forecast.py,sha256=xASSfHehdcxS64--alYoA6oElx_1Sy4S0tfxvWucVRw,6107
+openstef/tasks/create_forecast.py,sha256=CVUZDG-obMb78ytJ79Hf6LYhMCbqaDvX_vc7fkt9VXI,6075
 openstef/tasks/create_solar_forecast.py,sha256=HDrJrvTPCM8GS7EQwNr9uJNamf-nH2pu0o4d_xo4w4E,15062
 openstef/tasks/create_wind_forecast.py,sha256=RhshkmNSyFWx4Y6yQn02GzHjWTREbN5A5GAeWv0JpcE,2907
 openstef/tasks/optimize_hyperparameters.py,sha256=3NT0KFgim8wAzWPJ0S-GULM3zoshyj63Ivp-g1_oPDw,4765
 openstef/tasks/split_forecast.py,sha256=X1D3MnnMdAb9wzDWubAJwfMkWpNGdRUPDvPAbJApNhg,9277
-openstef/tasks/train_model.py,sha256=gbKRB3F5qFNfTt0HQnxOjwGS721MEmF110_-FMVlYh4,8527
+openstef/tasks/train_model.py,sha256=ioEOMpKMveEdY63aRXSh4IsioVFTqj-EDggFmJ7nfiw,8514
 openstef/tasks/utils/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
 openstef/tasks/utils/dependencies.py,sha256=Jy9dtV_G7lTEa5Cdy--wvMxJuAb0adb3R0X4QDjVteM,3077
 openstef/tasks/utils/predictionjobloop.py,sha256=Ysy3zF5lzPMz_asYDKeF5m0qgVT3tCtwSPihqMjnI5Q,9580
 openstef/tasks/utils/taskcontext.py,sha256=L9K14ycwgVxbIVUjH2DIn_QWbnu-OfxcGtQ1K9T6sus,5630
 openstef/validation/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
-openstef/validation/validation.py,sha256=DfnT7f29n9AbduJy9I6mXYQSnjt241Pn36Fp9SGehR0,11225
-openstef-3.4.63.dist-info/LICENSE,sha256=7Pm2fWFFHHUG5lDHed1vl5CjzxObIXQglnYsEdtjo_k,14907
-openstef-3.4.63.dist-info/METADATA,sha256=9kJWSv45Y-61ZmpZfIJWRzZYIogkP1lZrxGawsvDsEQ,8305
-openstef-3.4.63.dist-info/WHEEL,sha256=nn6H5-ilmfVryoAQl3ZQ2l8SH5imPWFpm1A5FgEuFV4,91
-openstef-3.4.63.dist-info/top_level.txt,sha256=kD0H4PqrQoncZ957FvqwfBxa89kTrun4Z_RAPs_HhLs,9
-openstef-3.4.63.dist-info/RECORD,,
+openstef/validation/validation.py,sha256=24GEzLyjVqaE2a-MppbFS-YQT5n739BxD7fH3LK5LEE,12133
+openstef-3.4.65.dist-info/LICENSE,sha256=7Pm2fWFFHHUG5lDHed1vl5CjzxObIXQglnYsEdtjo_k,14907
+openstef-3.4.65.dist-info/METADATA,sha256=YRXl2VGYnkq3BNtZ90rovW5__cBKVf5XuV8KrV7mhLI,8816
+openstef-3.4.65.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+openstef-3.4.65.dist-info/top_level.txt,sha256=kD0H4PqrQoncZ957FvqwfBxa89kTrun4Z_RAPs_HhLs,9
+openstef-3.4.65.dist-info/RECORD,,

{openstef-3.4.63.dist-info → openstef-3.4.65.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.1)
+Generator: setuptools (76.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any