autogluon.timeseries 1.4.1b20250821__py3-none-any.whl → 1.4.1b20250823__py3-none-any.whl

autogluon/timeseries/trainer.py

@@ -5,7 +5,7 @@ import time
 import traceback
 from collections import defaultdict
 from pathlib import Path
-from typing import Any, Dict, List, Literal, Optional, Tuple, Type, Union
+from typing import Any, Literal, Optional, Type, Union
 
 import networkx as nx
 import numpy as np
@@ -81,7 +81,7 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
 
         self.verbosity = verbosity
 
-        #: Dict of normal model -> FULL model. FULL models are produced by
+        #: dict of normal model -> FULL model. FULL models are produced by
         #: self.refit_single_full() and self.refit_full().
         self.model_refit_map = {}
 
@@ -121,7 +121,7 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         else:
             return None
 
-    def load_data(self) -> Tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
+    def load_data(self) -> tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
         train_data = self.load_train_data()
         val_data = self.load_val_data()
         return train_data, val_data
@@ -136,7 +136,7 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
 
         self.models = models
 
-    def _get_model_oof_predictions(self, model_name: str) -> List[TimeSeriesDataFrame]:
+    def _get_model_oof_predictions(self, model_name: str) -> list[TimeSeriesDataFrame]:
         model_path = os.path.join(self.path, self.get_model_attribute(model=model_name, attribute="path"))
         model_type = self.get_model_attribute(model=model_name, attribute="type")
         return model_type.load_oof_predictions(path=model_path)
@@ -144,16 +144,16 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
     def _add_model(
         self,
         model: TimeSeriesModelBase,
-        base_models: Optional[List[str]] = None,
+        base_models: Optional[list[str]] = None,
     ):
         """Add a model to the model graph of the trainer. If the model is an ensemble, also add
         information about dependencies to the model graph (list of models specified via ``base_models``).
 
         Parameters
         ----------
-        model : TimeSeriesModelBase
+        model
             The model to be added to the model graph.
-        base_models : List[str], optional, default None
+        base_models
             If the model is an ensemble, the list of base model names that are included in the ensemble.
             Expected only when ``model`` is a ``AbstractTimeSeriesEnsembleModel``.
 
@@ -176,7 +176,7 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
             for base_model in base_models:
                 self.model_graph.add_edge(base_model, model.name)
 
-    def _get_model_levels(self) -> Dict[str, int]:
+    def _get_model_levels(self) -> dict[str, int]:
         """Get a dictionary mapping each model to their level in the model graph"""
 
         # get nodes without a parent
@@ -197,7 +197,7 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
 
         return levels
 
-    def get_models_attribute_dict(self, attribute: str, models: Optional[List[str]] = None) -> Dict[str, Any]:
+    def get_models_attribute_dict(self, attribute: str, models: Optional[list[str]] = None) -> dict[str, Any]:
         """Get an attribute from the `model_graph` for each of the model names
         specified. If `models` is none, the attribute will be returned for all models"""
         results = {}
@@ -230,13 +230,13 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
             key=lambda mns: (mns[1], -mns[2]),  # (score, -level)
         )[0]
 
-    def get_model_names(self, level: Optional[int] = None) -> List[str]:
+    def get_model_names(self, level: Optional[int] = None) -> list[str]:
         """Get model names that are registered in the model graph"""
         if level is not None:
             return list(node for node, l in self._get_model_levels().items() if l == level)  # noqa: E741
         return list(self.model_graph.nodes)
 
-    def get_info(self, include_model_info: bool = False) -> Dict[str, Any]:
+    def get_info(self, include_model_info: bool = False) -> dict[str, Any]:
         num_models_trained = len(self.get_model_names())
         if self.model_best is not None:
             best_model = self.model_best
@@ -339,12 +339,13 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         model: AbstractTimeSeriesModel,
         val_data: Optional[TimeSeriesDataFrame] = None,
         time_limit: Optional[float] = None,
-    ) -> List[str]:
+    ) -> list[str]:
         """Fit and save the given model on given training and validation data and save the trained model.
 
         Returns
         -------
-        model_names_trained: the list of model names that were successfully trained
+        model_names_trained
+            the list of model names that were successfully trained
         """
         fit_start_time = time.time()
         model_names_trained = []
@@ -397,13 +398,13 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
     def _train_multi(
         self,
         train_data: TimeSeriesDataFrame,
-        hyperparameters: Union[str, Dict],
+        hyperparameters: Union[str, dict],
         val_data: Optional[TimeSeriesDataFrame] = None,
         hyperparameter_tune_kwargs: Optional[Union[str, dict]] = None,
-        excluded_model_types: Optional[List[str]] = None,
+        excluded_model_types: Optional[list[str]] = None,
         time_limit: Optional[float] = None,
         random_seed: Optional[int] = None,
-    ) -> List[str]:
+    ) -> list[str]:
         logger.info(f"\nStarting training. Start time is {time.strftime('%Y-%m-%d %H:%M:%S')}")
 
         time_start = time.time()
@@ -541,7 +542,7 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
 
     def _get_ensemble_oof_data(
         self, train_data: TimeSeriesDataFrame, val_data: Optional[TimeSeriesDataFrame]
-    ) -> List[TimeSeriesDataFrame]:
+    ) -> list[TimeSeriesDataFrame]:
         if val_data is None:
             return [val_fold for _, val_fold in self.val_splitter.split(train_data)]
         else:
@@ -558,13 +559,13 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
 
     def fit_ensemble(
         self,
-        data_per_window: List[TimeSeriesDataFrame],
-        model_names: List[str],
+        data_per_window: list[TimeSeriesDataFrame],
+        model_names: list[str],
         time_limit: Optional[float] = None,
     ) -> str:
         logger.info("Fitting simple weighted ensemble.")
 
-        predictions_per_window: Dict[str, List[TimeSeriesDataFrame]] = {}
+        predictions_per_window: dict[str, list[TimeSeriesDataFrame]] = {}
         base_model_scores = self.get_models_attribute_dict(attribute="val_score", models=self.get_model_names(0))
 
         for model_name in model_names:
@@ -614,7 +615,7 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         self,
         data: Optional[TimeSeriesDataFrame] = None,
         extra_info: bool = False,
-        extra_metrics: Optional[List[Union[str, TimeSeriesScorer]]] = None,
+        extra_metrics: Optional[list[Union[str, TimeSeriesScorer]]] = None,
         use_cache: bool = True,
     ) -> pd.DataFrame:
         logger.debug("Generating leaderboard for all models trained")
@@ -704,8 +705,8 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         return df[explicit_column_order]
 
     def persist(
-        self, model_names: Union[Literal["all", "best"], List[str]] = "all", with_ancestors: bool = False
-    ) -> List[str]:
+        self, model_names: Union[Literal["all", "best"], list[str]] = "all", with_ancestors: bool = False
+    ) -> list[str]:
         if model_names == "all":
             model_names = self.get_model_names()
         elif model_names == "best":
@@ -729,7 +730,7 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
 
         return model_names
 
-    def unpersist(self, model_names: Union[Literal["all"], List[str]] = "all") -> List[str]:
+    def unpersist(self, model_names: Union[Literal["all"], list[str]] = "all") -> list[str]:
         if model_names == "all":
             model_names = list(self.models.keys())
         if not isinstance(model_names, list):
@@ -826,9 +827,9 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         self,
         data: TimeSeriesDataFrame,
         model: Optional[Union[str, TimeSeriesModelBase]] = None,
-        metrics: Optional[Union[str, TimeSeriesScorer, List[Union[str, TimeSeriesScorer]]]] = None,
+        metrics: Optional[Union[str, TimeSeriesScorer, list[Union[str, TimeSeriesScorer]]]] = None,
         use_cache: bool = True,
-    ) -> Dict[str, float]:
+    ) -> dict[str, float]:
         past_data, known_covariates = data.get_model_inputs_for_scoring(
             prediction_length=self.prediction_length, known_covariates_names=self.covariate_metadata.known_covariates
         )
@@ -846,7 +847,7 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
     def get_feature_importance(
         self,
         data: TimeSeriesDataFrame,
-        features: List[str],
+        features: list[str],
         model: Optional[Union[str, TimeSeriesModelBase]] = None,
         metric: Optional[Union[str, TimeSeriesScorer]] = None,
         time_limit: Optional[float] = None,
@@ -996,7 +997,7 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         self,
         model: Union[str, TimeSeriesModelBase],
         data: TimeSeriesDataFrame,
-        model_pred_dict: Dict[str, Optional[TimeSeriesDataFrame]],
+        model_pred_dict: dict[str, Optional[TimeSeriesDataFrame]],
         known_covariates: Optional[TimeSeriesDataFrame] = None,
     ) -> TimeSeriesDataFrame:
         """Generate predictions using the given model.
@@ -1012,8 +1013,8 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         self,
         model: Union[str, TimeSeriesModelBase],
         data: TimeSeriesDataFrame,
-        model_pred_dict: Dict[str, Optional[TimeSeriesDataFrame]],
-    ) -> Union[TimeSeriesDataFrame, Dict[str, Optional[TimeSeriesDataFrame]]]:
+        model_pred_dict: dict[str, Optional[TimeSeriesDataFrame]],
+    ) -> Union[TimeSeriesDataFrame, dict[str, Optional[TimeSeriesDataFrame]]]:
         """Get the first argument that should be passed to model.predict.
 
         This method assumes that model_pred_dict contains the predictions of all base models, if model is an ensemble.
@@ -1029,13 +1030,13 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
 
     def get_model_pred_dict(
         self,
-        model_names: List[str],
+        model_names: list[str],
         data: TimeSeriesDataFrame,
         known_covariates: Optional[TimeSeriesDataFrame] = None,
         raise_exception_if_failed: bool = True,
         use_cache: bool = True,
         random_seed: Optional[int] = None,
-    ) -> Tuple[Dict[str, Optional[TimeSeriesDataFrame]], Dict[str, float]]:
+    ) -> tuple[dict[str, Optional[TimeSeriesDataFrame]], dict[str, float]]:
         """Return a dictionary with predictions of all models for the given dataset.
 
         Parameters
@@ -1060,7 +1061,7 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
             model_pred_dict, pred_time_dict_marginal = self._get_cached_pred_dicts(dataset_hash)
         else:
             model_pred_dict = {}
-            pred_time_dict_marginal: Dict[str, Any] = {}
+            pred_time_dict_marginal: dict[str, Any] = {}
 
         model_set = set()
         for model_name in model_names:
@@ -1106,7 +1107,7 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
 
         return final_model_pred_dict, final_pred_time_dict_total
 
-    def _get_total_pred_time_from_marginal(self, pred_time_dict_marginal: Dict[str, float]) -> Dict[str, float]:
+    def _get_total_pred_time_from_marginal(self, pred_time_dict_marginal: dict[str, float]) -> dict[str, float]:
         pred_time_dict_total = defaultdict(float)
         for model_name in pred_time_dict_marginal.keys():
             for base_model in self.get_minimum_model_set(model_name):
@@ -1139,7 +1140,7 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
 
     def _get_cached_pred_dicts(
         self, dataset_hash: str
-    ) -> Tuple[Dict[str, Optional[TimeSeriesDataFrame]], Dict[str, float]]:
+    ) -> tuple[dict[str, Optional[TimeSeriesDataFrame]], dict[str, float]]:
         """Load cached predictions for given dataset_hash from disk, if possible.
 
         If loading fails for any reason, empty dicts are returned.
@@ -1158,8 +1159,8 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
     def _save_cached_pred_dicts(
         self,
         dataset_hash: str,
-        model_pred_dict: Dict[str, Optional[TimeSeriesDataFrame]],
-        pred_time_dict: Dict[str, float],
+        model_pred_dict: dict[str, Optional[TimeSeriesDataFrame]],
+        pred_time_dict: dict[str, float],
     ) -> None:
         cached_predictions = self._load_cached_predictions()
         # Do not save results for models that failed
@@ -1183,8 +1184,8 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         self,
         train_data: Optional[TimeSeriesDataFrame] = None,
         val_data: Optional[TimeSeriesDataFrame] = None,
-        models: Optional[List[str]] = None,
-    ) -> List[str]:
+        models: Optional[list[str]] = None,
+    ) -> list[str]:
         train_data = train_data or self.load_train_data()
         val_data = val_data or self.load_val_data()
         refit_full_data = self._merge_refit_full_data(train_data, val_data)
@@ -1228,7 +1229,7 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         self.save()
         return models_trained_full
 
-    def refit_full(self, model: str = "all") -> Dict[str, str]:
+    def refit_full(self, model: str = "all") -> dict[str, str]:
         time_start = time.time()
         existing_models = self.get_model_names()
         if model == "all":
@@ -1262,13 +1263,13 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
 
     def construct_model_templates(
         self,
-        hyperparameters: Union[str, Dict[str, Any]],
+        hyperparameters: Union[str, dict[str, Any]],
         *,
         multi_window: bool = False,
         freq: Optional[str] = None,
-        excluded_model_types: Optional[List[str]] = None,
+        excluded_model_types: Optional[list[str]] = None,
         hyperparameter_tune: bool = False,
-    ) -> List[TimeSeriesModelBase]:
+    ) -> list[TimeSeriesModelBase]:
         return get_preset_models(
             path=self.path,
             eval_metric=self.eval_metric,
@@ -1288,10 +1289,10 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
     def fit(
         self,
         train_data: TimeSeriesDataFrame,
-        hyperparameters: Union[str, Dict[Any, Dict]],
+        hyperparameters: Union[str, dict[Any, dict]],
         val_data: Optional[TimeSeriesDataFrame] = None,
-        hyperparameter_tune_kwargs: Optional[Union[str, Dict]] = None,
-        excluded_model_types: Optional[List[str]] = None,
+        hyperparameter_tune_kwargs: Optional[Union[str, dict]] = None,
+        excluded_model_types: Optional[list[str]] = None,
         time_limit: Optional[float] = None,
         random_seed: Optional[int] = None,
     ):
@@ -1301,13 +1302,13 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
 
         Parameters
         ----------
-        train_data: TimeSeriesDataFrame
+        train_data
             Training data for fitting time series timeseries models.
-        hyperparameters: str or Dict
+        hyperparameters
             A dictionary mapping selected model names, model classes or model factory to hyperparameter
             settings. Model names should be present in `trainer.presets.DEFAULT_MODEL_NAMES`. Optionally,
             the user may provide one of "default", "light" and "very_light" to specify presets.
-        val_data: TimeSeriesDataFrame
+        val_data
             Optional validation data set to report validation scores on.
         hyperparameter_tune_kwargs
             Args for hyperparameter tuning

autogluon/timeseries/transforms/covariate_scaler.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Dict, List, Literal, Optional, Protocol, overload, runtime_checkable
+from typing import Literal, Optional, Protocol, overload, runtime_checkable
 
 import numpy as np
 import pandas as pd
@@ -53,7 +53,7 @@ class GlobalCovariateScaler(CovariateScaler):
         self.use_past_covariates = use_past_covariates
         self.use_static_features = use_static_features
         self.skew_threshold = skew_threshold
-        self._column_transformers: Optional[Dict[Literal["known", "past", "static"], ColumnTransformer]] = None
+        self._column_transformers: Optional[dict[Literal["known", "past", "static"], ColumnTransformer]] = None
 
     def is_fit(self) -> bool:
         return self._column_transformers is not None
@@ -117,7 +117,7 @@ class GlobalCovariateScaler(CovariateScaler):
             known_covariates[columns] = self._column_transformers["known"].transform(known_covariates[columns])
         return known_covariates
 
-    def _get_transformer_for_columns(self, df: pd.DataFrame, columns: List[str]) -> ColumnTransformer:
+    def _get_transformer_for_columns(self, df: pd.DataFrame, columns: list[str]) -> ColumnTransformer:
         """Passthrough bool features, use QuantileTransform for skewed features, and use StandardScaler for the rest.
 
         The preprocessing logic is similar to the TORCH_NN model from Tabular.

autogluon/timeseries/transforms/target_scaler.py

@@ -1,4 +1,4 @@
-from typing import Literal, Optional, Protocol, Tuple, Union, overload
+from typing import Literal, Optional, Protocol, Union, overload
 
 import numpy as np
 import pandas as pd
@@ -30,7 +30,7 @@ class LocalTargetScaler(TargetScaler):
         self.loc: Optional[pd.Series] = None
         self.scale: Optional[pd.Series] = None
 
-    def _compute_loc_scale(self, target_series: pd.Series) -> Tuple[Optional[pd.Series], Optional[pd.Series]]:
+    def _compute_loc_scale(self, target_series: pd.Series) -> tuple[Optional[pd.Series], Optional[pd.Series]]:
         raise NotImplementedError
 
     def fit_transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame:
@@ -45,7 +45,7 @@ class LocalTargetScaler(TargetScaler):
             self.scale = self.scale.clip(lower=self.min_scale).replace([np.inf, -np.inf], np.nan).fillna(1.0)
         return self
 
-    def _reindex_loc_scale(self, item_index: pd.Index) -> Tuple[Union[np.ndarray, float], Union[np.ndarray, float]]:
+    def _reindex_loc_scale(self, item_index: pd.Index) -> tuple[Union[np.ndarray, float], Union[np.ndarray, float]]:
         """Reindex loc and scale parameters for the given item_ids and convert them to an array-like."""
         if self.loc is not None:
             loc = self.loc.reindex(item_index).to_numpy()
@@ -74,7 +74,7 @@ class LocalStandardScaler(LocalTargetScaler):
     The resulting affine transformation is (x - loc) / scale, where scale = std(x), loc = mean(x).
     """
 
-    def _compute_loc_scale(self, target_series: pd.Series) -> Tuple[pd.Series, pd.Series]:
+    def _compute_loc_scale(self, target_series: pd.Series) -> tuple[pd.Series, pd.Series]:
         stats = target_series.groupby(level=ITEMID, sort=False).agg(["mean", "std"])
         return stats["mean"], stats["std"]
 
@@ -82,7 +82,7 @@ class LocalStandardScaler(LocalTargetScaler):
 class LocalMeanAbsScaler(LocalTargetScaler):
     """Applies mean absolute scaling to each time series in the dataset."""
 
-    def _compute_loc_scale(self, target_series: pd.Series) -> Tuple[Optional[pd.Series], pd.Series]:
+    def _compute_loc_scale(self, target_series: pd.Series) -> tuple[Optional[pd.Series], pd.Series]:
         scale = target_series.abs().groupby(level=ITEMID, sort=False).agg("mean")
         return None, scale
 
@@ -93,7 +93,7 @@ class LocalMinMaxScaler(LocalTargetScaler):
     The resulting affine transformation is (x - loc) / scale, where scale = max(x) - min(x), loc = min(x) / scale.
     """
 
-    def _compute_loc_scale(self, target_series: pd.Series) -> Tuple[pd.Series, pd.Series]:
+    def _compute_loc_scale(self, target_series: pd.Series) -> tuple[pd.Series, pd.Series]:
         stats = target_series.abs().groupby(level=ITEMID, sort=False).agg(["min", "max"])
         scale = (stats["max"] - stats["min"]).clip(lower=self.min_scale)
         loc = stats["min"]
@@ -117,7 +117,7 @@ class LocalRobustScaler(LocalTargetScaler):
         self.q_max = 0.75
         assert 0 < self.q_min < self.q_max < 1
 
-    def _compute_loc_scale(self, target_series: pd.Series) -> Tuple[pd.Series, pd.Series]:
+    def _compute_loc_scale(self, target_series: pd.Series) -> tuple[pd.Series, pd.Series]:
         grouped = target_series.groupby(level=ITEMID, sort=False)
         loc = grouped.median()
         lower = grouped.quantile(self.q_min)

autogluon/timeseries/utils/datetime/lags.py

@@ -2,7 +2,7 @@
 Generate lag indices based on frequency string. Adapted from gluonts.time_feature.lag.
 """
 
-from typing import List, Optional
+from typing import Optional
 
 import numpy as np
 import pandas as pd
@@ -72,7 +72,7 @@ def get_lags_for_frequency(
     lag_ub: int = 1200,
     num_lags: Optional[int] = None,
     num_default_lags: int = 7,
-) -> List[int]:
+) -> list[int]:
     """
     Generates a list of lags that that are appropriate for the given frequency
     string.

autogluon/timeseries/utils/datetime/time_features.py

@@ -2,7 +2,7 @@
 Generate time features based on frequency string. Adapted from gluonts.time_feature.time_feature.
 """
 
-from typing import Callable, List
+from typing import Callable
 
 import numpy as np
 import pandas as pd
@@ -56,7 +56,7 @@ def second_of_minute(index: pd.DatetimeIndex) -> np.ndarray:
     return _normalize(index.second, num=60)
 
 
-def get_time_features_for_frequency(freq) -> List[Callable]:
+def get_time_features_for_frequency(freq) -> list[Callable]:
     features_by_offset_name = {
         "YE": [],
         "QE": [quarter_of_year],

autogluon/timeseries/utils/features.py

@@ -2,7 +2,7 @@ import logging
 import reprlib
 import time
 from dataclasses import asdict, dataclass, field
-from typing import Any, Dict, List, Literal, Optional, Tuple
+from typing import Any, Literal, Optional
 
 import numpy as np
 import pandas as pd
@@ -24,50 +24,50 @@ logger = logging.getLogger(__name__)
 class CovariateMetadata:
     """Provides mapping from different covariate types to columns in the dataset."""
 
-    static_features_cat: List[str] = field(default_factory=list)
-    static_features_real: List[str] = field(default_factory=list)
-    known_covariates_real: List[str] = field(default_factory=list)
-    known_covariates_cat: List[str] = field(default_factory=list)
-    past_covariates_real: List[str] = field(default_factory=list)
-    past_covariates_cat: List[str] = field(default_factory=list)
+    static_features_cat: list[str] = field(default_factory=list)
+    static_features_real: list[str] = field(default_factory=list)
+    known_covariates_real: list[str] = field(default_factory=list)
+    known_covariates_cat: list[str] = field(default_factory=list)
+    past_covariates_real: list[str] = field(default_factory=list)
+    past_covariates_cat: list[str] = field(default_factory=list)
 
     @property
-    def static_features(self) -> List[str]:
+    def static_features(self) -> list[str]:
         return self.static_features_cat + self.static_features_real
 
     @property
-    def known_covariates(self) -> List[str]:
+    def known_covariates(self) -> list[str]:
         return self.known_covariates_cat + self.known_covariates_real
 
     @property
-    def past_covariates(self) -> List[str]:
+    def past_covariates(self) -> list[str]:
         return self.past_covariates_cat + self.past_covariates_real
 
     @property
-    def covariates(self) -> List[str]:
+    def covariates(self) -> list[str]:
         return self.known_covariates + self.past_covariates
 
     @property
-    def covariates_real(self) -> List[str]:
+    def covariates_real(self) -> list[str]:
         return self.known_covariates_real + self.past_covariates_real
 
     @property
-    def covariates_cat(self) -> List[str]:
+    def covariates_cat(self) -> list[str]:
         return self.known_covariates_cat + self.past_covariates_cat
 
     @property
-    def real_features(self) -> List[str]:
+    def real_features(self) -> list[str]:
         return self.static_features_real + self.covariates_real
 
     @property
-    def cat_features(self) -> List[str]:
+    def cat_features(self) -> list[str]:
         return self.static_features_cat + self.covariates_cat
 
     @property
-    def all_features(self) -> List[str]:
+    def all_features(self) -> list[str]:
         return self.static_features + self.covariates
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         return asdict(self)
 
 
@@ -120,13 +120,13 @@ class TimeSeriesFeatureGenerator:
 
     Parameters
     ----------
-    target : str
+    target
         Name of the target column.
-    known_covariates_names : List[str]
+    known_covariates_names
         Columns that contain covariates that are known into the future.
-    float_dtype : str, default = "float32"
+    float_dtype
         Numpy float dtype to which all numeric columns (float, int, bool) will be converted both in static & dynamic dfs.
-    num_samples : int or None, default = 20_000
+    num_samples
         Number of rows sampled from the training dataset to speed up computation of the median (used later for imputation).
         If set to `None`, median will be computed using all rows.
     """
@@ -134,7 +134,7 @@ class TimeSeriesFeatureGenerator:
     def __init__(
         self,
         target: str,
-        known_covariates_names: List[str],
+        known_covariates_names: list[str],
         float_dtype: str = "float32",
         num_samples: Optional[int] = 20_000,
     ):
@@ -143,8 +143,8 @@ class TimeSeriesFeatureGenerator:
         self.num_samples = num_samples
 
         self._is_fit = False
-        self.known_covariates_names: List[str] = list(known_covariates_names)
-        self.past_covariates_names: List[str] = []
+        self.known_covariates_names: list[str] = list(known_covariates_names)
+        self.past_covariates_names: list[str] = []
         self.known_covariates_pipeline = ContinuousAndCategoricalFeatureGenerator()
         self.past_covariates_pipeline = ContinuousAndCategoricalFeatureGenerator()
         # Cat features with cat_count=1 are fine in static_features since they are repeated for all time steps in a TS
@@ -154,7 +154,7 @@ class TimeSeriesFeatureGenerator:
         self._train_static_real_median: Optional[pd.Series] = None
 
     @property
-    def required_column_names(self) -> List[str]:
+    def required_column_names(self) -> list[str]:
         return [self.target] + list(self.known_covariates_names) + list(self.past_covariates_names)
 
     @property
@@ -262,13 +262,13 @@ class TimeSeriesFeatureGenerator:
         return self._impute_covariates(ts_df, column_names=self.covariate_metadata.covariates_real)
 
     @staticmethod
-    def _concat_dfs(dfs_to_concat: List[pd.DataFrame]) -> pd.DataFrame:
+    def _concat_dfs(dfs_to_concat: list[pd.DataFrame]) -> pd.DataFrame:
         if len(dfs_to_concat) == 1:
             return dfs_to_concat[0]
         else:
             return pd.concat(dfs_to_concat, axis=1, copy=False)
 
-    def _impute_covariates(self, ts_df: TimeSeriesDataFrame, column_names: List[str]) -> TimeSeriesDataFrame:
+    def _impute_covariates(self, ts_df: TimeSeriesDataFrame, column_names: list[str]) -> TimeSeriesDataFrame:
         """Impute missing values in selected columns with ffill, bfill, and median imputation."""
         if len(column_names) > 0:
             # ffill + bfill covariates that have at least some observed values
@@ -346,10 +346,10 @@ class TimeSeriesFeatureGenerator:
             return None
 
     @staticmethod
-    def _detect_and_log_column_types(transformed_df: pd.DataFrame) -> Tuple[List[str], List[str]]:
+    def _detect_and_log_column_types(transformed_df: pd.DataFrame) -> tuple[list[str], list[str]]:
         """Log & return names of categorical and real-valued columns in the DataFrame."""
-        cat_column_names: List[str] = []
-        real_column_names: List[str] = []
+        cat_column_names: list[str] = []
+        real_column_names: list[str] = []
         for column_name, column_dtype in transformed_df.dtypes.items():
             if isinstance(column_dtype, pd.CategoricalDtype):
                 cat_column_names.append(str(column_name))
@@ -362,7 +362,7 @@ class TimeSeriesFeatureGenerator:
 
     @staticmethod
     def _check_required_columns_are_present(
-        data: TimeSeriesDataFrame, required_column_names: List[str], data_frame_name: str
+        data: TimeSeriesDataFrame, required_column_names: list[str], data_frame_name: str
     ) -> None:
         missing_columns = pd.Index(required_column_names).difference(data.columns)
         if len(missing_columns) > 0:

autogluon/timeseries/version.py

@@ -1,4 +1,4 @@
 """This is the autogluon version file."""
 
-__version__ = "1.4.1b20250821"
+__version__ = "1.4.1b20250823"
 __lite__ = False

{autogluon.timeseries-1.4.1b20250821.dist-info → autogluon.timeseries-1.4.1b20250823.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.4.1b20250821
+Version: 1.4.1b20250823
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community
@@ -55,10 +55,10 @@ Requires-Dist: fugue>=0.9.0
 Requires-Dist: tqdm<5,>=4.38
 Requires-Dist: orjson~=3.9
 Requires-Dist: tensorboard<3,>=2.9
-Requires-Dist: autogluon.core[raytune]==1.4.1b20250821
-Requires-Dist: autogluon.common==1.4.1b20250821
-Requires-Dist: autogluon.features==1.4.1b20250821
-Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.4.1b20250821
+Requires-Dist: autogluon.core[raytune]==1.4.1b20250823
+Requires-Dist: autogluon.common==1.4.1b20250823
+Requires-Dist: autogluon.features==1.4.1b20250823
+Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.4.1b20250823
 Provides-Extra: all
 Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"