openstef 3.4.60__tar.gz → 3.4.61__tar.gz

{openstef-3.4.60 → openstef-3.4.61}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: openstef
-Version: 3.4.60
+Version: 3.4.61
 Summary: Open short term energy forecaster
 Home-page: https://github.com/OpenSTEF/openstef
 Author: Alliander N.V

{openstef-3.4.60 → openstef-3.4.61}/openstef/data_classes/data_prep.py

@@ -2,12 +2,13 @@
 #
 # 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
+from pydantic import BaseModel, Field
 
 DataPrepClass = TypeVar("DataPrepClass")
 
@@ -15,10 +16,14 @@ 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
+    klass: Union[str, type[DataPrepClass]] = Field(
+        ...,
+        description="The class that should be used to prepare the data. Can be a string with the path to the class or the class itself.",
+    )
+    arguments: Union[str, dict[str, Any]] = Field(
+        default=None,
+        description="The arguments that should be passed to the class. Can be a 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."""

{openstef-3.4.60 → openstef-3.4.61}/openstef/data_classes/model_specifications.py

@@ -2,27 +2,31 @@
 #
 # SPDX-License-Identifier: MPL-2.0
 """Specifies the dataclass for model specifications."""
-from typing import Optional, Union
 
-from pydantic.v1 import BaseModel
+from typing import Any, Optional, Union
+
+from pydantic import BaseModel, Field
 
 
 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."""
+    id: Union[int, str] = Field(description="The model id.")
+    hyper_params: Optional[dict] = Field(
+        default={}, description="Hyperparameters that should be used during training."
+    )
+    feature_names: Optional[list] = Field(
+        default=None, description="Features that should be used during training."
+    )
+    feature_modules: Optional[list] = Field(
+        default=[], description="Modules that should be used during training."
+    )
 
-    def __getitem__(self, item: str) -> any:
+    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:
+    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

openstef-3.4.61/openstef/data_classes/prediction_job.py

@@ -0,0 +1,151 @@
+# 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 Any, Optional, Union
+
+from pydantic import BaseModel, Field
+
+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 AggregateFunction, BiddingZone, PipelineType
+
+
+class PredictionJobDataClass(BaseModel):
+    """Holds all information about the specific forecast that has to be made."""
+
+    id: Union[int, str] = Field(
+        ..., description="The predictions job id (often abreviated as pid)."
+    )
+    model: str = Field(
+        ...,
+        description="The model type that should be used. Options are: 'xgb', 'xgb_quantile', 'lgb', 'linear', 'linear_quantile', 'gblinear_quantile', 'xgb_multioutput_quantile', 'flatliner'.",
+    )
+
+    model_kwargs: Optional[dict] = Field(
+        default=None, description="The model parameters that should be used."
+    )
+
+    forecast_type: str = Field(
+        ...,
+        description="The type of forecasts that should be made. Options are: 'demand', 'wind', 'basecase'. If unsure what to pick, choose 'demand'.",
+    )
+    horizon_minutes: Optional[int] = Field(
+        2880,
+        description="The horizon of the desired forecast in minutes used in tasks. Defaults to 2880 minutes (i.e. 2 days).",
+    )
+
+    resolution_minutes: int = Field(
+        60, description="The resolution of the desired forecast in minutes."
+    )
+    lat: Optional[float] = Field(
+        52.132633,
+        description="Latitude of the forecasted location in degrees. Used for fetching weather data in tasks, calculating derrived features and component splitting.",
+    )
+    lon: Optional[float] = Field(
+        5.291266,
+        description="Longitude of the forecasted location in degrees. Used for fetching weather data in tasks, calculating derrived features and component splitting.",
+    )
+    name: str = Field(..., description="Name of the forecast, e.g. the location name.")
+
+    electricity_bidding_zone: Optional[BiddingZone] = Field(
+        BiddingZone.NL,
+        description="The bidding zone of the forecasted location. Used for fetching electricity prices in tasks. It is also used to determine the holidays that should be used. Currently only ENTSO-E bidding zones are supported.",
+    )
+    train_components: Optional[bool] = Field(
+        None,
+        description="Whether splitting the forecasts in wind, solar, rest is desired.",
+    )
+    description: Optional[str] = Field(
+        None,
+        description="Optional description of the prediction job for human reference.",
+    )
+
+    quantiles: Optional[list[float]] = Field(
+        None,
+        description="Quantiles that have to be forecasted. Only used for quantile models.",
+    )
+    train_split_func: Optional[SplitFuncDataClass] = Field(
+        None, description="Optional custom splitting function for operational procces."
+    )
+    backtest_split_func: Optional[SplitFuncDataClass] = Field(
+        None, description="Optional custom splitting function for backtesting."
+    )
+    train_horizons_minutes: Optional[list[int]] = Field(
+        None,
+        description="List of horizons that should be taken into account during training.",
+    )
+    default_modelspecs: Optional[ModelSpecificationDataClass] = Field(
+        None, description="Default model specifications"
+    )
+    save_train_forecasts: bool = Field(
+        False,
+        description="Indicate wether the forecasts produced during the training process should be saved.",
+    )
+    completeness_threshold: float = Field(
+        0.5,
+        description="Minimum fraction of data that should be available for making a regular forecast.",
+    )
+    minimal_table_length: int = Field(
+        100,
+        description="Minimum length (in rows) of the forecast input for making a regular forecast.",
+    )
+    flatliner_threshold_minutes: int = Field(
+        1440,
+        description="Number of minutes that the load has to be constant to detect a flatliner.",
+    )
+    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.",
+    )
+    rolling_aggregate_features: Optional[list[AggregateFunction]] = Field(
+        [],
+        description="If not None, rolling aggregate(s) of load will be used as features in the model.",
+    )
+    depends_on: Optional[list[Union[int, str]]] = Field(
+        [],
+        description="Link to another prediction job on which this prediction job might depend.",
+    )
+    sid: Optional[str] = Field(
+        None, description="Only required for create_solar_forecast task"
+    )
+    turbine_type: Optional[str] = Field(
+        None, description="Only required for create_wind_forecast task"
+    )
+    n_turbines: Optional[float] = Field(
+        None, description="Only required for create_wind_forecast task"
+    )
+    hub_height: Optional[float] = Field(
+        None, description="Only required for create_wind_forecast task"
+    )
+    pipelines_to_run: list[PipelineType] = Field(
+        [PipelineType.TRAIN, PipelineType.HYPER_PARMATERS, PipelineType.FORECAST],
+        description="The pipelines to run for this pj",
+    )
+    alternative_forecast_model_pid: Optional[Union[int, str]] = Field(
+        None,
+        description="The pid that references another prediction job from which the model should be used for making forecasts.",
+    )
+    data_prep_class: Optional[DataPrepDataClass] = Field(
+        None, description="The import string for the custom data prep class"
+    )
+
+    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-3.4.60 → openstef-3.4.61}/openstef/data_classes/split_function.py

@@ -2,27 +2,28 @@
 #
 # 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
+from pydantic import BaseModel, Field
 
 
 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
+    function: Union[str, Callable] = Field(..., description="The split function")
+    arguments: Union[str, dict[str, Any]] = Field(
+        ..., description="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):
+    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

{openstef-3.4.60 → openstef-3.4.61}/openstef.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: openstef
-Version: 3.4.60
+Version: 3.4.61
 Summary: Open short term energy forecaster
 Home-page: https://github.com/OpenSTEF/openstef
 Author: Alliander N.V

{openstef-3.4.60 → openstef-3.4.61}/setup.py

@@ -29,7 +29,7 @@ def read_long_description_from_readme():
 
 setup(
     name="openstef",
-    version="3.4.60",
+    version="3.4.61",
     packages=find_packages(include=["openstef", "openstef.*"]),
     description="Open short term energy forecaster",
     long_description=read_long_description_from_readme(),

openstef-3.4.60/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