openstef 3.4.56__py3-none-any.whl → 4.0.0a3__py3-none-any.whl

openstef/data_classes/data_prep.py

@@ -1,99 +0,0 @@
-# SPDX-FileCopyrightText: 2017-2023 Contributors to the OpenSTEF project <korte.termijn.prognoses@alliander.com> # noqa E501>
-#
-# SPDX-License-Identifier: MPL-2.0
-"""Specifies the split function dataclass."""
-import inspect
-import json
-from importlib import import_module
-from typing import Any, Sequence, TypeVar, Union
-
-from pydantic.v1 import BaseModel
-
-DataPrepClass = TypeVar("DataPrepClass")
-
-
-class DataPrepDataClass(BaseModel):
-    """Class that allows to specify a custom class to prepare the data (feature engineering , etc ...)."""
-
-    klass: Union[str, type[DataPrepClass]]
-    arguments: Union[
-        str, dict[str, Any]
-    ]  # JSON string holding the function parameters or dict
-
-    def __getitem__(self, key: str):
-        """Allows us to use subscription to get the items from the object."""
-        return getattr(self, key)
-
-    def __setitem__(self, key: str, value: any):
-        """Allows us to use subscription to set the items in the object."""
-        if hasattr(self, key):
-            self.__dict__[key] = value
-        else:
-            raise AttributeError(f"{key} not an attribute of prediction job.")
-
-    def _load_klass(
-        self, required_arguments: Sequence[str] = None
-    ) -> type[DataPrepClass]:
-        """Load data prep class from path.
-
-        Args:
-            klass_path (str): The path to the data prep class
-
-        Returns:
-            klass (type[AbstractDataPreparation]): The loaded data prep class
-
-        """
-        if isinstance(self.klass, str):
-            path_elements = self.klass.split(".")
-            module_path = ".".join(path_elements[:-1])
-            module = import_module(module_path)
-            klass_name = path_elements[-1]
-            klass = getattr(module, klass_name)
-        else:
-            klass = self.klass
-
-        # Check that the klass accepts mandatory arguments
-        if not inspect.isclass(klass):
-            raise ValueError("The loaded object is not a class: {klass!r}")
-
-        if required_arguments is not None:
-            klass_params = set(inspect.signature(klass).parameters)
-
-            if len(set(required_arguments) - klass_params) > 0:
-                raise ValueError(
-                    "The loaded data prep class does not have the required arguments"
-                )
-
-        return klass
-
-    def _load_arguments(self) -> dict[str, Any]:
-        """Load the arguments.
-
-        Convert the arguments from JSON if they are given as strings or simply return them otherwise.
-
-        Returns:
-            arguments (dict[str, Any]): The additional arguments to be passed to the class
-
-        """
-        if isinstance(self.arguments, str):
-            return json.loads(self.arguments)
-        else:
-            return self.arguments
-
-    def load(
-        self, required_arguments: Sequence[str] = None
-    ) -> tuple[type[DataPrepClass], dict[str, Any]]:
-        """Load the function and its arguments.
-
-        If the function and the arguments are given as strings in the instane attributes, load them as Python objects
-        otherwise just return them from the instance attributes.
-
-        Args:
-            required_arguments (list[str]): list of arguments the loaded class must have
-
-        Returns:
-            - class (type[AbstractDataPreparation])
-            - arguments (dict[str, Any])
-
-        """
-        return self._load_klass(required_arguments), self._load_arguments()

openstef/data_classes/model_specifications.py

@@ -1,30 +0,0 @@
-# SPDX-FileCopyrightText: 2017-2023 Contributors to the OpenSTEF project <korte.termijn.prognoses@alliander.com>
-#
-# SPDX-License-Identifier: MPL-2.0
-"""Specifies the dataclass for model specifications."""
-from typing import Optional, Union
-
-from pydantic.v1 import BaseModel
-
-
-class ModelSpecificationDataClass(BaseModel):
-    """Holds all information regarding the training procces of a specific model."""
-
-    id: Union[int, str]
-    hyper_params: Optional[dict] = {}
-    """Hyperparameters that should be used during training."""
-    feature_names: Optional[list] = None
-    """Features that should be used during training."""
-    feature_modules: Optional[list] = []
-    """Feature modules that should be used during training."""
-
-    def __getitem__(self, item: str) -> any:
-        """Allows us to use subscription to get the items from the object."""
-        return getattr(self, item)
-
-    def __setitem__(self, key: str, value: any) -> None:
-        """Allows us to use subscription to set the items in the object."""
-        if hasattr(self, key):
-            self.__dict__[key] = value
-        else:
-            raise AttributeError(f"{key} not an attribute of model specifications.")

openstef/data_classes/prediction_job.py

@@ -1,135 +0,0 @@
-# SPDX-FileCopyrightText: 2017-2023 Contributors to the OpenSTEF project <korte.termijn.prognoses@alliander.com> # noqa E501>
-#
-# SPDX-License-Identifier: MPL-2.0
-"""Specifies the prediction job dataclass."""
-from typing import Optional, Union
-
-from pydantic.v1 import BaseModel
-
-from openstef.data_classes.data_prep import DataPrepDataClass
-from openstef.data_classes.model_specifications import ModelSpecificationDataClass
-from openstef.data_classes.split_function import SplitFuncDataClass
-from openstef.enums import PipelineType, BiddingZone, AggregateFunction
-
-
-class PredictionJobDataClass(BaseModel):
-    """Holds all information about the specific forecast that has to be made."""
-
-    id: Union[int, str]
-    """The predictions job id (often abreviated as pid)."""
-    model: str
-    """The model type that should be used.
-
-    Options are:
-        - ``"xgb"``
-        - ``"xgb_quantile"``
-        - ``"lgb"``
-        - ``"linear"``
-        - ``"linear_quantile"``
-        - ``"gblinear_quantile"``
-        - ``"xgb_multioutput_quantile"``
-        - ``"flatliner"``
-
-    If unsure what to pick, choose ``"xgb"``.
-
-    """
-    model_kwargs: Optional[dict]
-    """The model parameters that should be used."""
-    forecast_type: str
-    """The type of forecasts that should be made.
-
-    Options are:
-        - ``"demand"``
-        - ``"wind"``
-        - ``"basecase"``
-
-    If unsure what to pick, choose ``"demand"``.
-
-    """
-    horizon_minutes: Optional[int] = 2880
-    """The horizon of the desired forecast in minutes used in tasks. Defaults to 2880 minutes (i.e. 2 days)."""
-    resolution_minutes: int
-    """The resolution of the desired forecast in minutes."""
-    lat: Optional[float] = 52.132633
-    """Latitude of the forecasted location in degrees. Used for fetching weather data in tasks, calculating derrived features and component splitting."""
-    lon: Optional[float] = 5.291266
-    """Longitude of the forecasted location in degrees. Used for fetching weather data in tasks, calculating derrived features and component splitting."""
-    name: str
-    """Bidding zone is used to determine the electricity price. It is also used to determine the holidays that should be used. Currently only ENTSO-E bidding zones are supported."""
-    electricity_bidding_zone: Optional[BiddingZone] = BiddingZone.NL
-    """Name of the forecast, e.g. the location name."""
-    train_components: Optional[bool]
-    """Whether splitting the forecasts in wind, solar, rest is desired."""
-    description: Optional[str]
-    """Optional description of the prediction job for human reference."""
-    quantiles: Optional[list[float]]
-    """Quantiles that have to be forecasted."""
-    train_split_func: Optional[SplitFuncDataClass]
-    """Optional custom splitting function for operational procces."""
-    backtest_split_func: Optional[SplitFuncDataClass]
-    """Optional custom splitting function for backtesting."""
-    train_horizons_minutes: Optional[list[int]]
-    """List of horizons that should be taken into account during training."""
-    default_modelspecs: Optional[ModelSpecificationDataClass]
-    """Default model specifications"""
-    save_train_forecasts: bool = False
-    """Indicate wether the forecasts produced during the training process should be saved."""
-    completeness_threshold: float = 0.5
-    """Minimum fraction of data that should be available for making a regular forecast."""
-    minimal_table_length: int = 100
-    """Minimum length (in rows) of the forecast input for making a regular forecast."""
-    flatliner_threshold_minutes: int = 1440
-    """Number of minutes that the load has to be constant to detect a flatliner. """
-    data_balancing_ratio: Optional[float] = None
-    """If data balancing is enabled, the data will be balanced with data from 1 year 
-    ago in the future."""
-    rolling_aggregate_features: Optional[list[AggregateFunction]] = None
-    """If not None, rolling aggregate(s) of load will be used as features in the model."""
-    depends_on: Optional[list[Union[int, str]]]
-    """Link to another prediction job on which this prediction job might depend."""
-    sid: Optional[str]
-    """Only required for create_solar_forecast task"""
-    turbine_type: Optional[str]
-    """Only required for create_wind_forecast task"""
-    n_turbines: Optional[float]
-    """Only required for create_wind_forecast task"""
-    hub_height: Optional[float]
-    """Only required for create_wind_forecast task"""
-    pipelines_to_run: list[PipelineType] = [
-        PipelineType.TRAIN,
-        PipelineType.HYPER_PARMATERS,
-        PipelineType.FORECAST,
-    ]
-    """The pipelines to run for this pj"""
-    alternative_forecast_model_pid: Optional[Union[int, str]]
-    """The pid that references another prediction job from which the model should be used for making forecasts."""
-    data_prep_class: Optional[DataPrepDataClass]
-    """The import string for the custom data prep class"""
-
-    class Config:
-        """Pydantic model configuration.
-
-        This following configuration is needed to prevent ids in "depends_on" to be converted from int to str when we
-        use integer ids.
-
-        """
-
-        smart_union = True
-
-    def __getitem__(self, item: str) -> any:
-        """Allows us to use subscription to get the items from the object."""
-        return getattr(self, item)
-
-    def __setitem__(self, key: str, value: any) -> None:
-        """Allows us to use subscription to set the items in the object."""
-        if hasattr(self, key):
-            self.__dict__[key] = value
-        else:
-            raise AttributeError(f"{key} not an attribute of prediction job.")
-
-    def get(self, key: str, default: any = None) -> any:
-        """Allows to use the get functions similar to a python dict."""
-        if hasattr(self, key):
-            return getattr(self, key)
-        else:
-            return default

openstef/data_classes/split_function.py

@@ -1,97 +0,0 @@
-# SPDX-FileCopyrightText: 2017-2023 Contributors to the OpenSTEF project <korte.termijn.prognoses@alliander.com> # noqa E501>
-#
-# SPDX-License-Identifier: MPL-2.0
-"""Specifies the split function dataclass."""
-import inspect
-import json
-from importlib import import_module
-from typing import Any, Callable, Sequence, Union
-
-from pydantic.v1 import BaseModel
-
-
-class SplitFuncDataClass(BaseModel):
-    """Class that allows to specify a custom function to generate a train, test and validation set."""
-
-    function: Union[str, Callable]
-    arguments: Union[
-        str, dict[str, Any]
-    ]  # JSON string holding the function parameters or dict
-
-    def __getitem__(self, key: str):
-        """Allows us to use subscription to get the items from the object."""
-        return getattr(self, key)
-
-    def __setitem__(self, key: str, value: any):
-        """Allows us to use subscription to set the items in the object."""
-        if hasattr(self, key):
-            self.__dict__[key] = value
-        else:
-            raise AttributeError(f"{key} not an attribute of prediction job.")
-
-    def _load_split_function(
-        self, required_arguments: Sequence[str] = None
-    ) -> Callable:
-        """Load split function from path.
-
-        Args:
-            func_path (str): The path to the split function
-
-        Returns:
-            split_func (Callable): The loaded split function
-
-        """
-        if isinstance(self.function, str):
-            path_elements = self.function.split(".")
-            module_path = ".".join(path_elements[:-1])
-            module = import_module(module_path)
-            func_name = path_elements[-1]
-            split_func = getattr(module, func_name)
-        else:
-            split_func = self.function
-
-        # Check that the function accepts mandatory arguments
-        if not callable(split_func):
-            raise ValueError("The loaded object is not callable: {func_path!r}")
-
-        if required_arguments is not None:
-            func_params = set(inspect.signature(split_func).parameters)
-
-            if len(set(required_arguments) - func_params) > 0:
-                raise ValueError(
-                    "The loaded split function does not have the required arguments"
-                )
-
-        return split_func
-
-    def _load_arguments(self) -> dict[str, Any]:
-        """Load the arguments.
-
-        Convert the arguments from JSON if they are given as strings or simply return them otherwise.
-
-        Returns:
-            arguments (dict[str, Any]): The additional arguments to be passed to he function
-
-        """
-        if isinstance(self.arguments, str):
-            return json.loads(self.arguments)
-        else:
-            return self.arguments
-
-    def load(
-        self, required_arguments: Sequence[str] = None
-    ) -> tuple[Callable, dict[str, Any]]:
-        """Load the function and its arguments.
-
-        If the function and the arguments are given as strings in the instane attributes, load them as Python objects
-        otherwise just return them from the instance attributes.
-
-        Args:
-            required_arguments (list[str]): list of arguments the loaded function must have
-
-        Returns:
-            - function (Callable)
-            - arguments (dict[str, Any])
-
-        """
-        return self._load_split_function(required_arguments), self._load_arguments()

openstef/enums.py

@@ -1,140 +0,0 @@
-# SPDX-FileCopyrightText: 2017-2023 Contributors to the OpenSTEF project <korte.termijn.prognoses@alliander.com> # noqa E501>
-#
-# SPDX-License-Identifier: MPL-2.0
-from enum import Enum
-
-
-class BiddingZone(Enum):
-    DE_50HZ = "DE_50HZ"
-    AL = "AL"
-    DE_AMPRION = "DE_AMPRION"
-    AT = "AT"
-    BY = "BY"
-    BE = "BE"
-    BA = "BA"
-    BG = "BG"
-    CZ_DE_SK = "CZ_DE_SK"
-    HR = "HR"
-    CWE = "CWE"
-    CY = "CY"
-    CZ = "CZ"
-    DE_AT_LU = "DE_AT_LU"
-    DE_LU = "DE_LU"
-    DK = "DK"
-    DK_1 = "DK_1"
-    DK_1_NO_1 = "DK_1_NO_1"
-    DK_2 = "DK_2"
-    DK_CA = "DK_CA"
-    EE = "EE"
-    FI = "FI"
-    MK = "MK"
-    FR = "FR"
-    DE = "DE"
-    GR = "GR"
-    HU = "HU"
-    IS = "IS"
-    IE_SEM = "IE_SEM"
-    IE = "IE"
-    IT = "IT"
-    IT_SACO_AC = "IT_SACO_AC"
-    IT_CALA = "IT_CALA"
-    IT_SACO_DC = "IT_SACO_DC"
-    IT_BRNN = "IT_BRNN"
-    IT_CNOR = "IT_CNOR"
-    IT_CSUD = "IT_CSUD"
-    IT_FOGN = "IT_FOGN"
-    IT_GR = "IT_GR"
-    IT_MACRO_NORTH = "IT_MACRO_NORTH"
-    IT_MACRO_SOUTH = "IT_MACRO_SOUTH"
-    IT_MALTA = "IT_MALTA"
-    IT_NORD = "IT_NORD"
-    IT_NORD_AT = "IT_NORD_AT"
-    IT_NORD_CH = "IT_NORD_CH"
-    IT_NORD_FR = "IT_NORD_FR"
-    IT_NORD_SI = "IT_NORD_SI"
-    IT_PRGP = "IT_PRGP"
-    IT_ROSN = "IT_ROSN"
-    IT_SARD = "IT_SARD"
-    IT_SICI = "IT_SICI"
-    IT_SUD = "IT_SUD"
-    RU_KGD = "RU_KGD"
-    LV = "LV"
-    LT = "LT"
-    LU = "LU"
-    LU_BZN = "LU_BZN"
-    MT = "MT"
-    ME = "ME"
-    GB = "GB"
-    GE = "GE"
-    GB_IFA = "GB_IFA"
-    GB_IFA2 = "GB_IFA2"
-    GB_ELECLINK = "GB_ELECLINK"
-    UK = "UK"
-    NL = "NL"
-    NO_1 = "NO_1"
-    NO_1A = "NO_1A"
-    NO_2 = "NO_2"
-    NO_2_NSL = "NO_2_NSL"
-    NO_2A = "NO_2A"
-    NO_3 = "NO_3"
-    NO_4 = "NO_4"
-    NO_5 = "NO_5"
-    NO = "NO"
-    PL_CZ = "PL_CZ"
-    PL = "PL"
-    PT = "PT"
-    MD = "MD"
-    RO = "RO"
-    RU = "RU"
-    SE_1 = "SE_1"
-    SE_2 = "SE_2"
-    SE_3 = "SE_3"
-    SE_4 = "SE_4"
-    RS = "RS"
-    SK = "SK"
-    SI = "SI"
-    GB_NIR = "GB_NIR"
-    ES = "ES"
-    SE = "SE"
-    CH = "CH"
-    DE_TENNET = "DE_TENNET"
-    DE_TRANSNET = "DE_TRANSNET"
-    TR = "TR"
-    UA = "UA"
-    UA_DOBTPP = "UA_DOBTPP"
-    UA_BEI = "UA_BEI"
-    UA_IPS = "UA_IPS"
-    XK = "XK"
-    DE_AMP_LU = "DE_AMP_LU"
-
-
-class AggregateFunction(Enum):
-    MEAN = "mean"
-    MEDIAN = "median"
-    MAX = "max"
-    MIN = "min"
-
-
-class ModelType(Enum):
-    XGB = "xgb"
-    XGB_QUANTILE = "xgb_quantile"
-    XGB_MULTIOUTPUT_QUANTILE = "xgb_multioutput_quantile"
-    LGB = "lgb"
-    LINEAR = "linear"
-    LINEAR_QUANTILE = "linear_quantile"
-    GBLINEAR_QUANTILE = "gblinear_quantile"
-    ARIMA = "arima"
-    FLATLINER = "flatliner"
-
-
-class ForecastType(Enum):
-    DEMAND = "demand"
-    WIND = "wind"
-    SOLAR = "solar"
-    BASECASE = "basecase"
-
-
-class PipelineType(Enum):
-    FORECAST = "forecast"
-    TRAIN = "train"
-    HYPER_PARMATERS = "hyper_parameters"

openstef/exceptions.py

@@ -1,74 +0,0 @@
-# SPDX-FileCopyrightText: 2017-2023 Contributors to the OpenSTEF project <korte.termijn.prognoses@alliander.com> # noqa E501>
-#
-# SPDX-License-Identifier: MPL-2.0
-
-"""Openstef custom exceptions."""
-
-
-# Define custom exceptions
-class NoPredictedLoadError(Exception):
-    """No predicted load for given datatime range."""
-
-    def __init__(
-        self,
-        pid: int,
-        message: str = "No predicted load found",
-    ):
-        self.pid = pid
-        self.message = message
-        super().__init__(self.message)
-
-
-class NoRealisedLoadError(Exception):
-    """No realised load for given datetime range."""
-
-    def __init__(
-        self,
-        pid: int,
-        message: str = "No realised load found",
-    ):
-        self.pid = pid
-        self.message = message
-        super().__init__(self.message)
-
-
-class InputDataInvalidError(Exception):
-    """Invalid input data."""
-
-
-class InputDataInsufficientError(InputDataInvalidError):
-    """Insufficient input data."""
-
-
-class InputDataWrongColumnOrderError(InputDataInvalidError):
-    """Wrong column order input data."""
-
-
-class InputDataOngoingZeroFlatlinerError(InputDataInvalidError):
-    """All recent load measurements are zero."""
-
-
-class OldModelHigherScoreError(Exception):
-    """Old model has a higher score then new model."""
-
-
-class ModelWithoutStDev(Exception):
-    """A machine learning model should have a valid standard deviation."""
-
-
-class ComponentForecastTooShortHorizonError(Exception):
-    """Component forecasts should be available for at least 30 hours in advance."""
-
-
-class PredictionJobException(Exception):
-    """One or more prediction jobs raised an exception."""
-
-    def __init__(self, metrics=None):
-        super().__init__("One or more prediction jobs raised an exception.")
-        if metrics is None:
-            metrics = {}
-        self.metrics = metrics
-
-
-class SkipSaveTrainingForecasts(Exception):
-    """If old model is better or too young, you don't need to save the traing forcast."""

openstef/feature_engineering/__init__.py

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