openstef 3.4.60__py3-none-any.whl → 3.4.61__py3-none-any.whl

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/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/data_classes/prediction_job.py

@@ -2,132 +2,148 @@
 #
 # SPDX-License-Identifier: MPL-2.0
 """Specifies the prediction job dataclass."""
-from typing import Optional, Union
 
-from pydantic.v1 import BaseModel
+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 PipelineType, BiddingZone, AggregateFunction
+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]
-    """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:
+    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:
+    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:
+    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)

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.dist-info → openstef-3.4.61.dist-info}/METADATA

@@ -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.dist-info → openstef-3.4.61.dist-info}/RECORD

@@ -15,10 +15,10 @@ openstef/data/dazls_model_3.4.24/dazls_stored_3.4.24_baseline_model.z.license,sh
 openstef/data/dazls_model_3.4.24/dazls_stored_3.4.24_model_card.md,sha256=KJ8S8jg2k_aL1pCK_b3wOLMZqGdDALa4in73c4Am8gY,539
 openstef/data/dazls_model_3.4.24/dazls_stored_3.4.24_model_card.md.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
 openstef/data_classes/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
-openstef/data_classes/data_prep.py,sha256=gRSL7UiHvZis8m8z7VoTCZc0Ccffhef5_hmSyApnqK0,3417
-openstef/data_classes/model_specifications.py,sha256=Uod1W3QzhRqVLb6zvXwxh9wRL3EHCzSvX0oDNd28cFk,1197
-openstef/data_classes/prediction_job.py,sha256=OFGg6h0XQZOIkJEYr1EoT3LE2oV6YULaCCxhkaES4wA,5874
-openstef/data_classes/split_function.py,sha256=ljQIQQu1t1Y_CVWGAy25jrM6wG9odIVVQVimrT1n-1s,3358
+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/split_function.py,sha256=K8y1dsQC5exeIDh37f7UwJ11tV71_uVSNbnKmwXpnOM,3435
 openstef/feature_engineering/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
 openstef/feature_engineering/apply_features.py,sha256=9Yzg61Whd4n0osQBfrcW8cI0gaUiv7u8KnQIQPR40fY,5327
 openstef/feature_engineering/bidding_zone_to_country_mapping.py,sha256=u9aabjFDImydkO6_cXiaQxBT4gb5zy0gGTg2EoIUO_Y,2106
@@ -95,8 +95,8 @@ openstef/tasks/utils/predictionjobloop.py,sha256=Ysy3zF5lzPMz_asYDKeF5m0qgVT3tCt
 openstef/tasks/utils/taskcontext.py,sha256=L9K14ycwgVxbIVUjH2DIn_QWbnu-OfxcGtQ1K9T6sus,5630
 openstef/validation/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
 openstef/validation/validation.py,sha256=6FY-mD7bWxM7NpM9y-RcGZJt-kyyOmPl8QSemYRY11w,11200
-openstef-3.4.60.dist-info/LICENSE,sha256=7Pm2fWFFHHUG5lDHed1vl5CjzxObIXQglnYsEdtjo_k,14907
-openstef-3.4.60.dist-info/METADATA,sha256=b9Mutfbm9_plLc8zVyV5rGI8PL285ILqpZgqsWlH42M,8305
-openstef-3.4.60.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-openstef-3.4.60.dist-info/top_level.txt,sha256=kD0H4PqrQoncZ957FvqwfBxa89kTrun4Z_RAPs_HhLs,9
-openstef-3.4.60.dist-info/RECORD,,
+openstef-3.4.61.dist-info/LICENSE,sha256=7Pm2fWFFHHUG5lDHed1vl5CjzxObIXQglnYsEdtjo_k,14907
+openstef-3.4.61.dist-info/METADATA,sha256=9_xC8_cXy1j3ZWt4a-xHIaT1JZ2OlW1RUU3BEBYMhAg,8305
+openstef-3.4.61.dist-info/WHEEL,sha256=nn6H5-ilmfVryoAQl3ZQ2l8SH5imPWFpm1A5FgEuFV4,91
+openstef-3.4.61.dist-info/top_level.txt,sha256=kD0H4PqrQoncZ957FvqwfBxa89kTrun4Z_RAPs_HhLs,9
+openstef-3.4.61.dist-info/RECORD,,

{openstef-3.4.60.dist-info → openstef-3.4.61.dist-info}/WHEEL

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