openstef 3.4.10__py3-none-any.whl → 3.4.44__py3-none-any.whl

openstef/data/dutch_holidays_2020-2022.csv.license

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

openstef/feature_engineering/historic_features.py

@@ -1,40 +0,0 @@
-# SPDX-FileCopyrightText: 2017-2023 Alliander N.V. <korte.termijn.prognoses@alliander.com> # noqa E501>
-#
-# SPDX-License-Identifier: MPL-2.0
-
-"""This module contains historic load related functions used for feature engineering."""
-
-import pandas as pd
-import structlog
-
-from openstef.data_classes.prediction_job import PredictionJobDataClass
-
-
-def add_historic_load_as_a_feature(
-    data: pd.DataFrame,
-    pj: PredictionJobDataClass = None,
-) -> pd.DataFrame:
-    """Adds additional proloaf features to the input data, historic_load (equal to the load).
-
-    Args:
-        data: Dataframe to which the wind features have to be added
-        pj: Prediction job.
-
-    Returns:
-        DataFrame that is the same as input dataframe with extra columns for the added proloaf features
-
-    """
-    logger = structlog.get_logger(__name__)
-
-    if pj is None:
-        pj = {}
-
-    if pj.get("model") == "proloaf":
-        data["historic_load"] = data["load"]
-        logger.warning(
-            "The historic_load is added to the data, this is a copy of the load. Adding"
-            " this feature is in most of the cases not a good idea, it is designed for"
-            " the proloaf model."
-        )
-
-    return data

openstef/model/regressors/proloaf.py

@@ -1,281 +0,0 @@
-# SPDX-FileCopyrightText: 2017-2023 Alliander N.V. <korte.termijn.prognoses@alliander.com> # noqa E501>
-#
-# SPDX-License-Identifier: MPL-2.0
-from typing import Any, Union
-
-import numpy as np
-import pandas as pd
-
-# These imports will require the proloaf optional dependencies to be installed
-import proloaf.datahandler as dh
-import torch
-from proloaf.modelhandler import ModelWrapper
-
-from openstef.model.regressors.regressor import OpenstfRegressor
-
-# TODO: implement the hyperparameter optimalisation via optuna
-# TODO: set the default for hyperparameters in the init of OpenstfProloafRegressor
-# TODO: implement function for defining encoder and decoder features
-
-
-def divide_scaling_groups(x: pd.DataFrame) -> tuple[list[str], list[str], list[str]]:
-    """Divides the column names over different type of scaling groups.
-
-    Args:
-        x: Dataframe from which columns have to be divided
-
-    Returns:
-        List of all the grouped features for scaling (three groups)
-
-    """
-    minmax_scale_features = []
-    oh_scale_features = []
-    no_scale_features = []
-
-    for column in x.columns:
-        if (x[column].min() <= -1) or (x[column].max() >= 1):
-            minmax_scale_features.append(column)
-        elif x[column].dtype == "bool":
-            oh_scale_features.append(column)
-        else:
-            no_scale_features.append(column)
-
-    return minmax_scale_features, oh_scale_features, no_scale_features
-
-
-def apply_scaling(
-    scaler_features: tuple[list[str], list[str], list[str]],
-    data: pd.DataFrame,
-    scalers=None,
-):
-    """Applies different scaling methods to a certain dataframe (minmax, one hot, or no scaling).
-
-    Args:
-        scaler_features: Three different lists with features for each scaling
-        x: Dataframe from which columns have to be divided
-        scalers: scalers resulting from the previous scaling
-
-    Returns:
-        Dataframe with all the scaled features
-
-    """
-    selected_features, scalers = dh.scale_all(
-        data,
-        scalers=scalers,
-        feature_groups=[
-            {
-                "name": "main",
-                "scaler": ["minmax", -1.0, 1.0],
-                "features": scaler_features[0],
-            },
-            {"name": "aux", "scaler": None, "features": scaler_features[2]},
-        ],
-    )
-
-    # One hot encoding certain features
-    onehot_feature_groups = [
-        {
-            "name": "main",
-            "scaler": [
-                "onehot",
-            ],
-            "features": scaler_features[1],
-        }
-    ]
-    for group in onehot_feature_groups:
-        df_onehot = data.filter(group["features"])
-        result_oh_scale = np.transpose(np.array(df_onehot.iloc[:, :], dtype=np.int))
-        df_onehot.iloc[:, :] = result_oh_scale.T
-
-    if not df_onehot.columns.empty:
-        selected_features = pd.concat([selected_features, df_onehot], axis=1)
-    data = selected_features.iloc[:, :].replace(np.nan, 0)
-
-    return data, scalers
-
-
-class OpenstfProloafRegressor(OpenstfRegressor, ModelWrapper):
-    def __init__(
-        self,
-        name: str = "model",
-        core_net: str = "torch.nn.LSTM",
-        relu_leak: float = 0.1,
-        encoder_features: list[str] = [
-            "historic_load",
-        ],  # make sure historic load is present, TODO: implement so you can use None
-        decoder_features: list[str] = [
-            "air_density"
-        ],  # TODO: implement so you can use None
-        core_layers: int = 1,
-        rel_linear_hidden_size: float = 1.0,
-        rel_core_hidden_size: float = 1.0,
-        dropout_fc: float = 0.4,
-        dropout_core: float = 0.3,
-        training_metric: str = "nllgauss",
-        metric_options: dict[str, Any] = {},
-        optimizer_name: str = "adam",
-        early_stopping_patience: int = 7,
-        early_stopping_margin: float = 0,
-        learning_rate: float = 1e-3,
-        max_epochs: int = 100,
-        device: Union[str, int] = "cpu",  # "cuda" or "cpu"
-        batch_size: int = 6,
-        history_horizon: int = 24,
-        horizon_minutes: int = 2880,  # 2 days in minutes,
-    ):
-        self.device = device
-        self.batch_size = batch_size
-        self.history_horizon = history_horizon
-        self.forecast_horizon = int(horizon_minutes / 60)
-        ModelWrapper.__init__(
-            self,
-            name=name,
-            core_net=core_net,
-            relu_leak=relu_leak,
-            encoder_features=encoder_features,
-            decoder_features=decoder_features,
-            core_layers=core_layers,
-            rel_linear_hidden_size=rel_linear_hidden_size,
-            rel_core_hidden_size=rel_core_hidden_size,
-            dropout_fc=dropout_fc,
-            dropout_core=dropout_core,
-            training_metric=training_metric,
-            metric_options=metric_options,
-            optimizer_name=optimizer_name,
-            early_stopping_patience=early_stopping_patience,
-            early_stopping_margin=early_stopping_margin,
-            learning_rate=learning_rate,
-            max_epochs=max_epochs,
-        )
-        self.to(device)
-
-    @property
-    def feature_names(self):
-        return (
-            ["load"] + self.encoder_features + self.decoder_features
-        )  # TODO: gehele range, of een enkele feature
-
-    @property
-    def can_predict_quantiles(self):
-        return False
-
-    def predict(self, x: pd.DataFrame) -> np.ndarray:
-        x = x[list(self.feature_names)[1:]]
-        # Apply scaling and interpolation for NaN values
-        x = dh.fill_if_missing(x, periodicity=24)
-        x, _ = apply_scaling(
-            [
-                self.minmax_scale_features,
-                self.oh_scale_features,
-                self.no_scale_features,
-            ],
-            x,
-            self.scalers,
-        )
-
-        inputs_enc = torch.tensor(
-            x[self.encoder_features].to_numpy(), dtype=torch.float
-        ).unsqueeze(dim=0)
-        inputs_dec = torch.tensor(
-            x[self.decoder_features].to_numpy(), dtype=torch.float
-        ).unsqueeze(dim=0)
-        prediction = (
-            ModelWrapper.predict(self, inputs_enc, inputs_dec)[:, :, 0]
-            .squeeze()
-            .detach()
-            .numpy()
-        )
-
-        return prediction
-
-    def fit(
-        self,
-        x: pd.DataFrame,
-        y: pd.DataFrame,
-        eval_set: tuple = None,
-        early_stopping_rounds: int = None,
-        verbose: bool = False,
-        **kwargs,
-    ) -> ModelWrapper:
-        x = x[list(self.feature_names)[1:]]
-        # Apply scaling and interpolation for NaN values
-        x = dh.fill_if_missing(x, periodicity=24)
-        (
-            self.minmax_scale_features,
-            self.oh_scale_features,
-            self.no_scale_features,
-        ) = divide_scaling_groups(x)
-        x, self.scalers = apply_scaling(
-            [
-                self.minmax_scale_features,
-                self.oh_scale_features,
-                self.no_scale_features,
-            ],
-            x,
-            self.scalers,
-        )
-        y = y.to_frame()
-        self.target_id = [y.columns[0]]
-
-        df_train = pd.concat([x, y], axis="columns", verify_integrity=True)
-
-        print(f"{self.encoder_features = }")
-        print(f"{self.decoder_features = }")
-
-        train_dl, _, _ = dh.transform(
-            df=df_train,
-            encoder_features=self.encoder_features,
-            decoder_features=self.decoder_features,
-            batch_size=self.batch_size,
-            history_horizon=self.history_horizon,
-            forecast_horizon=self.forecast_horizon,
-            target_id=self.target_id,
-            train_split=1.0,
-            validation_split=1.0,
-            device=self.device,
-        )
-
-        val_x, val_y = eval_set[1][0], eval_set[1][1]
-        val_x = dh.fill_if_missing(val_x, periodicity=24)
-        val_x, _ = apply_scaling(
-            [
-                self.minmax_scale_features,
-                self.oh_scale_features,
-                self.no_scale_features,
-            ],
-            val_x,
-            self.scalers,
-        )
-
-        df_val = pd.concat([val_x, val_y], axis="columns", verify_integrity=True)
-        _, validation_dl, _ = dh.transform(
-            df=df_val,
-            encoder_features=self.encoder_features,
-            decoder_features=self.decoder_features,
-            batch_size=self.batch_size,
-            history_horizon=self.history_horizon,
-            forecast_horizon=self.forecast_horizon,
-            target_id=self.target_id,
-            train_split=0.0,
-            validation_split=1.0,
-            device=self.device,
-        )
-        self.to(self.device)
-        self.init_model()
-        self.is_fitted_ = True
-
-        return self.run_training(train_dl, validation_dl)
-
-    def get_params(self, deep=True):
-        model_params = self.get_model_config()
-        training_params = self.get_training_config()
-        return {**model_params, **training_params}
-
-    def set_params(self, **params):
-        self.update(**params)
-        return self
-
-
-if __name__ == "__main__":
-    test = OpenstfProloafRegressor()
-    print(test)

openstef/tasks/run_tracy.py

@@ -1,145 +0,0 @@
-# SPDX-FileCopyrightText: 2017-2023 Contributors to the OpenSTEF project <korte.termijn.prognoses@alliander.com> # noqa E501>
-#
-# SPDX-License-Identifier: MPL-2.0
-"""Tracy checks the mysql todolist and tries her best to execute the functions with desired inputs.
-
-This scripts works as follows:
-  1. Checks the mysql table 'todolist' for jobs (which are not already in progress and
-    which are not already failed)
-  2. Set all newly acquired jobs to 'in progress'
-For each job:
-  3. Convert input arguments to a dict with 'args' and 'kwargs'
-  4. Interpret the given function and arguments
-  5. Execute the job
-  6. Post result to Teams
-  7. Remove job from mysql table
-If job fails, set in progress to 2
-All functions that tracy is able to execute need to be imported and defined in the
-available_functions.
-
-Example:
-    This module is meant to be called directly from a CRON job.
-
-    Alternatively this code can be run directly by running::
-        $ python run_tracy.py
-
-"""
-# sql to create the Tracy jobs table (todolist)
-
-# CREATE TABLE IF NOT EXISTS `tst_icarus`.`todolist` (
-# `id` INT NOT NULL AUTO_INCREMENT ,
-# `created` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ,
-# `function` VARCHAR(200) NOT NULL ,
-# `args` VARCHAR(200) NOT NULL ,
-# `inprogress` BOOLEAN NULL DEFAULT NULL ,
-# PRIMARY KEY (`id`), UNIQUE `id` (`id`))
-# ENGINE = InnoDB;
-from pathlib import Path
-
-from openstef.data_classes.prediction_job import PredictionJobDataClass
-from openstef.enums import TracyJobResult
-from openstef.monitoring import teams
-from openstef.tasks.optimize_hyperparameters import optimize_hyperparameters_task
-from openstef.tasks.train_model import train_model_task
-from openstef.tasks.utils.taskcontext import TaskContext
-
-
-def run_tracy(context: TaskContext) -> None:
-    # Get all Tracy jobs
-    tracy_jobs = context.database.ktp_api.get_all_tracy_jobs(inprogress=0)
-    num_jobs = len(tracy_jobs)
-
-    if num_jobs == 0:
-        context.logger.warning(f"Number of tracy jobs is {num_jobs}, exit task")
-        return
-
-    context.logger.info("Start processing Tracy jobs", num_jobs=num_jobs)
-
-    for i, job in enumerate(tracy_jobs):
-        # get a new logger with bound job
-        logger = context.logger.bind(job=job)
-        logger.info("Process job", job_counter=i, total_jobs=num_jobs)
-
-        # Set all retrieved items of the todolist to inprogress
-        job["inprogress"] = 1
-        context.database.ktp_api.update_tracy_job(job)
-
-        pid = int(job["args"])
-        pj = context.database.get_prediction_job(pid)
-        result, exc = run_tracy_job(job, pj, context)
-        # job processing was succefull
-        if result is TracyJobResult.SUCCESS:
-            logger.info("Succesfully processed Tracy job")
-            # Delete job when succesfull
-            context.database.ktp_api.delete_tracy_job(job)
-            logger.info("Delete Tracy job")
-
-        # job was unknown
-        elif result is TracyJobResult.UNKNOWN:
-            logger.error(f"Unkown Tracy job {job['function']}")
-
-        # job processing failed / raised an exception
-        elif result is TracyJobResult.FAILED:
-            job["inprogress"] = 2
-            context.database.ktp_api.update_tracy_job(job)
-            msg = "Exception occured while processing Tracy job"
-            logger.error(msg, exc_info=exc)
-            teams.post_teams(teams.format_message(title=msg, params=job))
-
-    context.logger.info("Finished processing all Tracy jobs - Tracy out!")
-
-
-def run_tracy_job(
-    job: dict, pj: PredictionJobDataClass, context: TaskContext
-) -> TracyJobResult:
-    """Run tracy job.
-
-    Args:
-        job: Tracy jon
-        pj: Prediction job
-        context: Task context.
-
-    Returns:
-        Result of the Tracy job.
-
-    """
-    # Try to process Tracy job
-    try:
-        # If train model job (TODO remove old name when jobs are done)
-        if job["function"] in ["train_model", "train_specific_model"]:
-            train_model_task(pj, context, check_old_model_age=False)
-
-        # If optimize hyperparameters job (TODO remove old name when jobs are done)
-        elif job["function"] in [
-            "optimize_hyperparameters",
-            "optimize_hyperparameters_for_specific_pid",
-        ]:
-            optimize_hyperparameters_task(pj, context, check_hyper_param_age=False)
-
-        # Else unknown job
-        else:
-            return TracyJobResult.UNKNOWN, None
-
-        # job processing was succesfull
-        return TracyJobResult.SUCCESS, None
-
-    # Processing of Tracy job failed
-    except Exception as e:
-        return TracyJobResult.FAILED, e
-
-
-def main(config=None, database=None):
-    taskname = Path(__file__).name.replace(".py", "")
-
-    if database is None or config is None:
-        raise RuntimeError(
-            "Please specifiy a config object and/or database connection object. These"
-            " can be found in the openstef-dbc package."
-        )
-
-    with TaskContext(taskname, config, database) as context:
-        run_tracy(context)
-
-
-if __name__ == "__main__":
-    main()

openstef-3.4.10.dist-info/RECORD

@@ -1,104 +0,0 @@
-openstef/__init__.py,sha256=93UM6m0LLQhO69-mSqLuUy73jgs4W7Iuxfo3Lm8c98g,419
-openstef/__main__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
-openstef/enums.py,sha256=dFpGFySauUt-m_bsPNcmc5WVG33ZXcWsbJeQp_4iEBE,753
-openstef/exceptions.py,sha256=fVqjyrVMBiSGxcoZ3JfTcgZjIur1cPennZpfwqgc9qY,1992
-openstef/data/dutch_holidays_2020-2022.csv,sha256=pS-CjE0igYXd-2dG-MlqyvR2fgYgXkbNmgCKyTjmwxs,23704
-openstef/data/dutch_holidays_2020-2022.csv.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
-openstef/data/pv_single_coefs.csv,sha256=jadIEYdHvl1lnV_06X_FASkJZ6C3Hecs5xZnH1gPMvI,24779
-openstef/data/pv_single_coefs.csv.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
-openstef/data/dazls_model_3.4.0/dazls_stored_3.4.0_adaptation_model.z,sha256=M2S-3OBz-CA7iePcP0dt5dHQhlYOh6gW14jQQ3P_Fjw,29570256
-openstef/data/dazls_model_3.4.0/dazls_stored_3.4.0_adaptation_model.z.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
-openstef/data/dazls_model_3.4.0/dazls_stored_3.4.0_adaptation_model_features.z,sha256=J9mF1mqfVwrZoyzJ8VoWPehKIoGtRakfe1a1m5lZt5I,88
-openstef/data/dazls_model_3.4.0/dazls_stored_3.4.0_adaptation_model_features.z.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
-openstef/data/dazls_model_3.4.0/dazls_stored_3.4.0_adaptation_model_scaler.z,sha256=AJTlZ3M4fwB1XOkat4RuYX6sGJKYWO6mWuoSPGrqtLc,883
-openstef/data/dazls_model_3.4.0/dazls_stored_3.4.0_adaptation_model_scaler.z.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
-openstef/data/dazls_model_3.4.0/dazls_stored_3.4.0_domain_model.z,sha256=n-F4Iv1XsQ42-IXjNYDjy6bcQadWhtkmCxK360A2_wE,32794824
-openstef/data/dazls_model_3.4.0/dazls_stored_3.4.0_domain_model.z.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
-openstef/data/dazls_model_3.4.0/dazls_stored_3.4.0_domain_model_features.z,sha256=UUwyRZcUl4S884R86bL-8g9llaDHINmW5-WRoMJF0Do,123
-openstef/data/dazls_model_3.4.0/dazls_stored_3.4.0_domain_model_features.z.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
-openstef/data/dazls_model_3.4.0/dazls_stored_3.4.0_domain_model_scaler.z,sha256=yrXVWBgKXp5uQBh--n4db3aaB3SWrQcyZ_MJLsmCJV4,1077
-openstef/data/dazls_model_3.4.0/dazls_stored_3.4.0_domain_model_scaler.z.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
-openstef/data/dazls_model_3.4.0/dazls_stored_3.4.0_target.z,sha256=7GkwwyQPJosqmGa0LslpfYIf8qgLDMW9Krx8CM_YO10,40
-openstef/data/dazls_model_3.4.0/dazls_stored_3.4.0_target.z.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
-openstef/data/dazls_model_3.4.0/dazls_stored_3.4.0_target_scaler.z,sha256=Lh4EL1vuKr0rkvXq9xUr-4twVpow2vtjEUunXvh-XDM,683
-openstef/data/dazls_model_3.4.0/dazls_stored_3.4.0_target_scaler.z.license,sha256=AxxHusqwIXU5RHl5ZMU65LyXmgtbj6QlcnFaOEN4kEE,145
-openstef/data_classes/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
-openstef/data_classes/data_prep.py,sha256=3SLvHDXlL-fBw8IFGBP_pKXTfWjQsKjgVxDyYlgic1o,3417
-openstef/data_classes/model_specifications.py,sha256=Uod1W3QzhRqVLb6zvXwxh9wRL3EHCzSvX0oDNd28cFk,1197
-openstef/data_classes/prediction_job.py,sha256=YrPaUACW7u09yabmwXkXu3fRpu-M90FPgprd7vjSP0A,4856
-openstef/data_classes/split_function.py,sha256=ljQIQQu1t1Y_CVWGAy25jrM6wG9odIVVQVimrT1n-1s,3358
-openstef/feature_engineering/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
-openstef/feature_engineering/apply_features.py,sha256=pKvTl2c-L5OUuRPWy9mr_OcGExSNbwDRhTuLmNzGFqE,4114
-openstef/feature_engineering/data_preparation.py,sha256=vFdCdXrX7RWWa4uj1D8rVkHymacbfhvwoLiEnUk-v6g,5399
-openstef/feature_engineering/feature_adder.py,sha256=aSqDl_gUrB3H2TD3cNvU5JniY_KOb4u4a2A6J7zB2BQ,6835
-openstef/feature_engineering/feature_applicator.py,sha256=FpEEirbOTuOKZipoGHYliKvY0r_XE5f2z-r8NiAx4oU,7712
-openstef/feature_engineering/general.py,sha256=igAPyejYN5d09-a_c53C79a0A4cHjvMCa47KC4IfgCo,4072
-openstef/feature_engineering/historic_features.py,sha256=aDxoS42ndUmLmwqpII8rZ_-L86NFer-Gw_fGf0TAobU,1215
-openstef/feature_engineering/holiday_features.py,sha256=3Ff4Lkm26h8wJVoBplUewt4HfsvOUS9zj0x0MxewIm8,7842
-openstef/feature_engineering/lag_features.py,sha256=Dr6qS8UhdgEHPZZSe-w6ibtjl_lcbcQohhqdZN9fqEU,5652
-openstef/feature_engineering/weather_features.py,sha256=wy3KFXUIIwSydFJZpiejsJMwURtDpv9l0HBHu-uLAGQ,15561
-openstef/metrics/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
-openstef/metrics/figure.py,sha256=NPJGI4FygjSnOQuL8qCbB87-T31q6EkewkbVmpLwmnk,9657
-openstef/metrics/metrics.py,sha256=c6HGQubArT5G4YxF0KY9HCP19PRHaVfXQ8KEkSwrt0w,13164
-openstef/metrics/reporter.py,sha256=V6pa4IUOzVcZ8OY632g5KoF8hr2MT2ySexrjZCjnuwY,7668
-openstef/model/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
-openstef/model/basecase.py,sha256=caI6Q-8y0ymlxGK9Js_H3Vh0q6ruNHlGD5RG0_kE5M0,2878
-openstef/model/confidence_interval_applicator.py,sha256=7E1_JFLZ4-hyEhleacMvp5szdmYZS4tpKAjfhGvXXvg,8602
-openstef/model/fallback.py,sha256=VV9ehgnoMZtWzqKk9H1t8wnERFh5CyC4TvDIuRP_ZDI,2861
-openstef/model/model_creator.py,sha256=U1Lw4HFyajfxQ2o5lEnCxnmRC62DEu5PBHXrm_jnEJU,5582
-openstef/model/objective.py,sha256=qBZGij4P2uZXFt-1x4MxCkIRmpVY3TJoo4Mycxu9dO8,15433
-openstef/model/objective_creator.py,sha256=OiPPFSiSu7z9K_983ib5iqhhu6_9tt7iyTyKNZ2Iz68,2057
-openstef/model/serializer.py,sha256=Q7pKkA-K1bszER_tkOWhvwTQsj6-qZoX5zaXIemRKGs,16934
-openstef/model/standard_deviation_generator.py,sha256=Od9bzXi2TLb1v8Nz-VhBMZHSopWH6ssaDe8gYLlqO1I,2911
-openstef/model/metamodels/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
-openstef/model/metamodels/grouped_regressor.py,sha256=yMN_a6TnQSyFaqlB_6Nifq-ydpb5hs6w_b97IaBbHj4,8337
-openstef/model/metamodels/missing_values_handler.py,sha256=veyvYZHhKvlYZxaUpxRQ7XoE033_3Lcg9LrbuKchlOk,5241
-openstef/model/regressors/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
-openstef/model/regressors/arima.py,sha256=yATxKKz5kl-irr3CBNVHpkFY45aY3RILu0nUFfEFMgg,7587
-openstef/model/regressors/custom_regressor.py,sha256=Hsmxahc9nfSWD0aEZ6cm4pxW2noQ8B1SujS17_fmxcU,1768
-openstef/model/regressors/dazls.py,sha256=V8g88LhgsAZka_TFvUDI_sXlvuqSiGIbEUrO2hkAPVM,7216
-openstef/model/regressors/lgbm.py,sha256=zCdn1euEdSFxYJzH8XqQFFnb6R4JVUnmineKjX_Gy-g,800
-openstef/model/regressors/linear.py,sha256=uOvZMLGZH_9nXfmS5honCMfyVeyGXP1Cza9A_BdXlVw,3665
-openstef/model/regressors/proloaf.py,sha256=HjyfEQRiFMFzyfYSrFL3yPhduhL1igGr1FTO6d0ET7I,9081
-openstef/model/regressors/regressor.py,sha256=uJcx59AyCPE9f_yPcAQ59h2ZS7eNsDpIHJrladKvHIw,3461
-openstef/model/regressors/xgb.py,sha256=HggA1U10srzdysjV560BMMX66kfaxCKAnOZB3JyyT_Y,808
-openstef/model/regressors/xgb_quantile.py,sha256=Oenhe0cMLAEXlinHZF588zNTjwR-hB7NB0anQZPwPKU,7710
-openstef/model_selection/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
-openstef/model_selection/model_selection.py,sha256=oGloQBP_FPdNyCs9wzS3l8zFNJxMs1P5XPjVN9qUOsw,11081
-openstef/monitoring/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
-openstef/monitoring/performance_meter.py,sha256=mMQKpDNv_-RcNYdEvEFPvB76lkG8V9gJOKYQqnH5BX4,2851
-openstef/monitoring/teams.py,sha256=fnZScPD55z9yC0q3YavWj40GEZmL7tsSGhWzG_sMPws,6401
-openstef/pipeline/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
-openstef/pipeline/create_basecase_forecast.py,sha256=7jig8lt-e3xwIWDSk-bMwUC45y2mwKe9-zDZYHiiQMY,4324
-openstef/pipeline/create_component_forecast.py,sha256=ahtFKykD5Ff758fowil0StQa7zK8AjsqyMGCz5iRoEE,6255
-openstef/pipeline/create_forecast.py,sha256=El9xXKN8DeIADy_76-V22wBY8AMSa4KEfYuW00jw85k,5083
-openstef/pipeline/optimize_hyperparameters.py,sha256=BnahfVHlE1z9so0gxPyd75OKCXSZvtFvuqicH6skm5U,10892
-openstef/pipeline/train_create_forecast_backtest.py,sha256=upuoiE01vjjxUu_sY0tANPqdOtpGKrQQ3azhVDnBJdc,5512
-openstef/pipeline/train_model.py,sha256=cPTXDUjsQK5o5ygMNnmH-DfXins1khAnvt8gVF5eK4Q,18677
-openstef/pipeline/utils.py,sha256=fkc-oNirJ-JiyuOAL08RFrnPYPwudWal_N-BO6Cw980,2086
-openstef/postprocessing/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
-openstef/postprocessing/postprocessing.py,sha256=nehd0tDpkdIaWFJggQ-fDizIKdfmqJ3IOGfk0sDnrzk,8409
-openstef/preprocessing/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
-openstef/preprocessing/preprocessing.py,sha256=bM_cSSSb2vGTD79RGzUrI6KoELbzlCyJwc7jqQGNEsE,1454
-openstef/tasks/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
-openstef/tasks/calculate_kpi.py,sha256=pC8CJ0UqhySpVVewMN0GIe0ELEmYOf1Wc9xElUe0Q5M,11985
-openstef/tasks/create_basecase_forecast.py,sha256=Hk9fDljXvo5TfeS3nWHrerWi7y-lQzoJEaqWbqaxHOs,3852
-openstef/tasks/create_components_forecast.py,sha256=zLJQ-5w-L3sqxkGw6KaaXVkmzLqjLJoU5mT6QtvkME0,5520
-openstef/tasks/create_forecast.py,sha256=FPILsCqt2lT2QIjseXyKjViZG6SVRoGCxoj9tPiozIg,5575
-openstef/tasks/create_solar_forecast.py,sha256=bTr7NThTF6Yj405qAqRaJmlBUrL7HATqVVzsi9hMdMw,15049
-openstef/tasks/create_wind_forecast.py,sha256=RhshkmNSyFWx4Y6yQn02GzHjWTREbN5A5GAeWv0JpcE,2907
-openstef/tasks/optimize_hyperparameters.py,sha256=s-z8YQJF6Lf3DdYgKHEpAdlbFJ3a-0Gj0Ahsqj1DErc,4758
-openstef/tasks/run_tracy.py,sha256=mWRg5u74iSaUGHRQzIa-2Weyg6ChuW5w3JBL-7MrNBc,5036
-openstef/tasks/split_forecast.py,sha256=hBRoIlZ_DK4747EtMpY-HVh_tmTdGa65oYOtrjHRUxQ,9118
-openstef/tasks/train_model.py,sha256=-6JzNQIDdBC6j-nrp10KF_eFkTjkadcOGS5S5iG-JXM,7263
-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=yI6TntOkZcW8JiNVuw4uJIigEBL0_iIrkPklF4ZeCX4,5401
-openstef/validation/__init__.py,sha256=bIyGTSA4V5VoOLTwdaiJJAnozmpSzvQooVYlsf8H4eU,163
-openstef/validation/validation.py,sha256=SaI-Mff9UOHQPnQ2jodXzZAVZilc-2AXZsPpSjDRqAg,10346
-openstef-3.4.10.dist-info/LICENSE,sha256=7Pm2fWFFHHUG5lDHed1vl5CjzxObIXQglnYsEdtjo_k,14907
-openstef-3.4.10.dist-info/METADATA,sha256=s2gQqhwp9LXyxL0nt0jOhzguXJjHREZp5XHYJ_hj11o,7872
-openstef-3.4.10.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-openstef-3.4.10.dist-info/top_level.txt,sha256=kD0H4PqrQoncZ957FvqwfBxa89kTrun4Z_RAPs_HhLs,9
-openstef-3.4.10.dist-info/RECORD,,