autogluon.timeseries 1.4.1b20251128__tar.gz → 1.5.1b20260117__tar.gz

{autogluon_timeseries-1.4.1b20251128/src/autogluon.timeseries.egg-info → autogluon_timeseries-1.5.1b20260117}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autogluon.timeseries
-Version: 1.4.1b20251128
+Version: 1.5.1b20260117
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community
@@ -39,10 +39,9 @@ Requires-Dist: joblib<1.7,>=1.2
 Requires-Dist: numpy<2.4.0,>=1.25.0
 Requires-Dist: scipy<1.17,>=1.5.4
 Requires-Dist: pandas<2.4.0,>=2.0.0
-Requires-Dist: torch<2.8,>=2.6
-Requires-Dist: lightning<2.8,>=2.5.1
-Requires-Dist: pytorch_lightning
-Requires-Dist: transformers[sentencepiece]<4.50,>=4.38.0
+Requires-Dist: torch<2.10,>=2.6
+Requires-Dist: lightning<2.6,>=2.5.1
+Requires-Dist: transformers[sentencepiece]<4.58,>=4.51.0
 Requires-Dist: accelerate<2.0,>=0.34.0
 Requires-Dist: gluonts<0.17,>=0.15.0
 Requires-Dist: networkx<4,>=3.0
@@ -53,23 +52,23 @@ Requires-Dist: coreforecast<0.0.17,>=0.0.12
 Requires-Dist: fugue>=0.9.0
 Requires-Dist: tqdm<5,>=4.38
 Requires-Dist: orjson~=3.9
-Requires-Dist: chronos-forecasting<3,>=2.0.1
+Requires-Dist: einops<1,>=0.7
+Requires-Dist: chronos-forecasting<2.4,>=2.2.2
+Requires-Dist: peft<0.18,>=0.13.0
 Requires-Dist: tensorboard<3,>=2.9
-Requires-Dist: autogluon.core[raytune]==1.4.1b20251128
-Requires-Dist: autogluon.common==1.4.1b20251128
-Requires-Dist: autogluon.features==1.4.1b20251128
-Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.4.1b20251128
+Requires-Dist: autogluon.core==1.5.1b20260117
+Requires-Dist: autogluon.common==1.5.1b20260117
+Requires-Dist: autogluon.features==1.5.1b20260117
+Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.5.1b20260117
 Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: ruff>=0.0.285; extra == "tests"
 Requires-Dist: flaky<4,>=3.7; extra == "tests"
 Requires-Dist: pytest-timeout<3,>=2.1; extra == "tests"
-Provides-Extra: toto
-Requires-Dist: einops<1,>=0.7; extra == "toto"
-Requires-Dist: rotary-embedding-torch<1,>=0.8; extra == "toto"
+Provides-Extra: ray
+Requires-Dist: autogluon.core[raytune]==1.5.1b20260117; extra == "ray"
 Provides-Extra: all
-Requires-Dist: rotary-embedding-torch<1,>=0.8; extra == "all"
-Requires-Dist: einops<1,>=0.7; extra == "all"
+Requires-Dist: autogluon.core[raytune]==1.5.1b20260117; extra == "all"
 Dynamic: author
 Dynamic: classifier
 Dynamic: description

{autogluon_timeseries-1.4.1b20251128 → autogluon_timeseries-1.5.1b20260117}/setup.py

@@ -30,7 +30,6 @@ install_requires = [
     "pandas",  # version range defined in `core/_setup_utils.py`
     "torch",  # version range defined in `core/_setup_utils.py`
     "lightning",  # version range defined in `core/_setup_utils.py`
-    "pytorch_lightning",  # version range defined in `core/_setup_utils.py`
     "transformers[sentencepiece]",  # version range defined in `core/_setup_utils.py`
     "accelerate",  # version range defined in `core/_setup_utils.py`
     "gluonts>=0.15.0,<0.17",
@@ -42,10 +41,11 @@ install_requires = [
     "fugue>=0.9.0",  # prevent dependency clash with omegaconf
     "tqdm",  # version range defined in `core/_setup_utils.py`
     "orjson~=3.9",  # use faster JSON implementation in GluonTS
-    "chronos-forecasting>=2.0.1,<3",
-    # TODO v1.1: use lightning[pytorch-extra] instead of explicitly installing tensorboard
+    "einops>=0.7,<1",  # required by Chronos-2 and Toto
+    "chronos-forecasting>=2.2.2,<2.4",
+    "peft>=0.13.0,<0.18",  # version range same as in chronos-forecasting[extras]
     "tensorboard>=2.9,<3",  # fixes https://github.com/autogluon/autogluon/issues/3612
-    f"autogluon.core[raytune]=={version}",
+    f"autogluon.core=={version}",
     f"autogluon.common=={version}",
     f"autogluon.features=={version}",
     f"autogluon.tabular[catboost,lightgbm,xgboost]=={version}",
@@ -58,13 +58,12 @@ extras_require = {
         "flaky>=3.7,<4",
         "pytest-timeout>=2.1,<3",
     ],
-    "toto": [
-        "einops>=0.7,<1",
-        "rotary-embedding-torch>=0.8,<1",
+    "ray": [
+        f"autogluon.core[raytune]=={version}",
     ],
 }
 
-extras_require["all"] = list(set.union(*(set(extras_require[extra]) for extra in ["toto"])))
+extras_require["all"] = list(set.union(*(set(extras_require[extra]) for extra in ["ray"])))
 install_requires = ag.get_dependency_version_ranges(install_requires)
 
 if __name__ == "__main__":

autogluon_timeseries-1.5.1b20260117/src/autogluon/timeseries/configs/hyperparameter_presets.py

@@ -0,0 +1,47 @@
+from typing import Any
+
+
+def get_hyperparameter_presets() -> dict[str, dict[str, dict[str, Any] | list[dict[str, Any]]]]:
+    return {
+        "very_light": {
+            "Naive": {},
+            "SeasonalNaive": {},
+            "ETS": {},
+            "Theta": {},
+            "RecursiveTabular": {"max_num_samples": 100_000},
+            "DirectTabular": {"max_num_samples": 100_000},
+        },
+        "light": {
+            "SeasonalNaive": {},
+            "ETS": {},
+            "Theta": {},
+            "RecursiveTabular": {},
+            "DirectTabular": {},
+            "TemporalFusionTransformer": {},
+            "Chronos2": {"model_path": "autogluon/chronos-2-small"},
+        },
+        "default": {
+            "SeasonalNaive": {},
+            "AutoETS": {},
+            "DynamicOptimizedTheta": {},
+            "RecursiveTabular": {},
+            "DirectTabular": {},
+            "TemporalFusionTransformer": {},
+            "DeepAR": {},
+            "Chronos2": [
+                {},
+                {
+                    "ag_args": {"name_suffix": "SmallFineTuned"},
+                    "model_path": "autogluon/chronos-2-small",
+                    "fine_tune": True,
+                    "eval_during_fine_tune": True,
+                },
+            ],
+            "Chronos": {
+                "ag_args": {"name_suffix": "WithRegressor"},
+                "model_path": "bolt_small",
+                "target_scaler": "standard",
+                "covariate_regressor": {"model_name": "CAT", "model_hyperparameters": {"iterations": 1000}},
+            },
+        },
+    }

{autogluon_timeseries-1.4.1b20251128 → autogluon_timeseries-1.5.1b20260117}/src/autogluon/timeseries/configs/predictor_presets.py

@@ -2,10 +2,7 @@
 
 from typing import Any
 
-from . import get_hyperparameter_presets
-
 TIMESERIES_PRESETS_ALIASES = dict(
-    chronos="chronos_small",
     best="best_quality",
     high="high_quality",
     medium="medium_quality",
@@ -16,13 +13,33 @@ TIMESERIES_PRESETS_ALIASES = dict(
 
 
 def get_predictor_presets() -> dict[str, Any]:
-    hp_presets = get_hyperparameter_presets()
-
     predictor_presets = dict(
-        best_quality={"hyperparameters": "default", "num_val_windows": 2},
+        best_quality={"hyperparameters": "default", "num_val_windows": "auto", "refit_every_n_windows": "auto"},
         high_quality={"hyperparameters": "default"},
         medium_quality={"hyperparameters": "light"},
         fast_training={"hyperparameters": "very_light"},
+        # Chronos-2 models
+        chronos2={
+            "hyperparameters": {"Chronos2": {"model_path": "autogluon/chronos-2"}},
+            "skip_model_selection": True,
+        },
+        chronos2_small={
+            "hyperparameters": {"Chronos2": {"model_path": "autogluon/chronos-2-small"}},
+            "skip_model_selection": True,
+        },
+        chronos2_ensemble={
+            "hyperparameters": {
+                "Chronos2": [
+                    {"model_path": "autogluon/chronos-2", "ag_args": {"name_suffix": "ZeroShot"}},
+                    {
+                        "model_path": "autogluon/chronos-2-small",
+                        "fine_tune": True,
+                        "eval_during_fine_tune": True,
+                        "ag_args": {"name_suffix": "SmallFineTuned"},
+                    },
+                ]
+            },
+        },
         # Chronos-Bolt models
         bolt_tiny={
             "hyperparameters": {"Chronos": {"model_path": "bolt_tiny"}},
@@ -40,39 +57,6 @@ def get_predictor_presets() -> dict[str, Any]:
             "hyperparameters": {"Chronos": {"model_path": "bolt_base"}},
             "skip_model_selection": True,
         },
-        # Original Chronos models
-        chronos_tiny={
-            "hyperparameters": {"Chronos": {"model_path": "tiny"}},
-            "skip_model_selection": True,
-        },
-        chronos_mini={
-            "hyperparameters": {"Chronos": {"model_path": "mini"}},
-            "skip_model_selection": True,
-        },
-        chronos_small={
-            "hyperparameters": {"Chronos": {"model_path": "small"}},
-            "skip_model_selection": True,
-        },
-        chronos_base={
-            "hyperparameters": {"Chronos": {"model_path": "base"}},
-            "skip_model_selection": True,
-        },
-        chronos_large={
-            "hyperparameters": {"Chronos": {"model_path": "large", "batch_size": 8}},
-            "skip_model_selection": True,
-        },
-        chronos_ensemble={
-            "hyperparameters": {
-                "Chronos": {"model_path": "small"},
-                **hp_presets["light_inference"],
-            }
-        },
-        chronos_large_ensemble={
-            "hyperparameters": {
-                "Chronos": {"model_path": "large", "batch_size": 8},
-                **hp_presets["light_inference"],
-            }
-        },
     )
 
     # update with aliases

{autogluon_timeseries-1.4.1b20251128 → autogluon_timeseries-1.5.1b20260117}/src/autogluon/timeseries/dataset/ts_dataframe.py

@@ -7,7 +7,7 @@ import reprlib
 from collections.abc import Iterable
 from itertools import islice
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Final, Optional, Type, Union, overload
+from typing import TYPE_CHECKING, Any, Final, Type, overload
 
 import numpy as np
 import pandas as pd
@@ -122,10 +122,10 @@ class TimeSeriesDataFrame(pd.DataFrame):
 
     def __init__(
         self,
-        data: Union[pd.DataFrame, str, Path, Iterable],
-        static_features: Optional[Union[pd.DataFrame, str, Path]] = None,
-        id_column: Optional[str] = None,
-        timestamp_column: Optional[str] = None,
+        data: pd.DataFrame | str | Path | Iterable,
+        static_features: pd.DataFrame | str | Path | None = None,
+        id_column: str | None = None,
+        timestamp_column: str | None = None,
         num_cpus: int = -1,
         *args,
         **kwargs,
@@ -149,7 +149,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
         else:
             raise ValueError(f"data must be a pd.DataFrame, Iterable, string or Path (received {type(data)}).")
         super().__init__(data=data, *args, **kwargs)  # type: ignore
-        self._static_features: Optional[pd.DataFrame] = None
+        self._static_features: pd.DataFrame | None = None
         if static_features is not None:
             self.static_features = self._construct_static_features(static_features, id_column=id_column)
 
@@ -168,8 +168,8 @@ class TimeSeriesDataFrame(pd.DataFrame):
     def _construct_tsdf_from_data_frame(
         cls,
         df: pd.DataFrame,
-        id_column: Optional[str] = None,
-        timestamp_column: Optional[str] = None,
+        id_column: str | None = None,
+        timestamp_column: str | None = None,
     ) -> pd.DataFrame:
         df = df.copy()
         if id_column is not None:
@@ -272,9 +272,9 @@ class TimeSeriesDataFrame(pd.DataFrame):
     def from_data_frame(
         cls,
         df: pd.DataFrame,
-        id_column: Optional[str] = None,
-        timestamp_column: Optional[str] = None,
-        static_features_df: Optional[pd.DataFrame] = None,
+        id_column: str | None = None,
+        timestamp_column: str | None = None,
+        static_features_df: pd.DataFrame | None = None,
     ) -> TimeSeriesDataFrame:
         """Construct a ``TimeSeriesDataFrame`` from a pandas DataFrame.
 
@@ -315,10 +315,10 @@ class TimeSeriesDataFrame(pd.DataFrame):
     @classmethod
     def from_path(
         cls,
-        path: Union[str, Path],
-        id_column: Optional[str] = None,
-        timestamp_column: Optional[str] = None,
-        static_features_path: Optional[Union[str, Path]] = None,
+        path: str | Path,
+        id_column: str | None = None,
+        timestamp_column: str | None = None,
+        static_features_path: str | Path | None = None,
     ) -> TimeSeriesDataFrame:
         """Construct a ``TimeSeriesDataFrame`` from a CSV or Parquet file.
 
@@ -396,8 +396,8 @@ class TimeSeriesDataFrame(pd.DataFrame):
     @classmethod
     def _construct_static_features(
         cls,
-        static_features: Union[pd.DataFrame, str, Path],
-        id_column: Optional[str] = None,
+        static_features: pd.DataFrame | str | Path,
+        id_column: str | None = None,
     ) -> pd.DataFrame:
         if isinstance(static_features, (str, Path)):
             static_features = load_pd.load(str(static_features))
@@ -421,7 +421,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
         return self._static_features
 
     @static_features.setter
-    def static_features(self, value: Optional[pd.DataFrame]):
+    def static_features(self, value: pd.DataFrame | None):
         # if the current item index is not a multiindex, then we are dealing with a single
         # item slice. this should only happen when the user explicitly requests only a
         # single item or during `slice_by_timestep`. In this case we do not set static features
@@ -454,7 +454,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
 
         self._static_features = value
 
-    def infer_frequency(self, num_items: Optional[int] = None, raise_if_irregular: bool = False) -> str:
+    def infer_frequency(self, num_items: int | None = None, raise_if_irregular: bool = False) -> str:
         """Infer the time series frequency based on the timestamps of the observations.
 
         Parameters
@@ -570,7 +570,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
         return obj
 
     def __finalize__(  # noqa
-        self: TimeSeriesDataFrame, other, method: Optional[str] = None, **kwargs
+        self: TimeSeriesDataFrame, other, method: str | None = None, **kwargs
     ) -> TimeSeriesDataFrame:
         super().__finalize__(other=other, method=method, **kwargs)
         # when finalizing the copy/slice operation, we use the property setter to stay consistent
@@ -602,9 +602,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
         after = TimeSeriesDataFrame(data_after, static_features=self.static_features)
         return before, after
 
-    def slice_by_timestep(
-        self, start_index: Optional[int] = None, end_index: Optional[int] = None
-    ) -> TimeSeriesDataFrame:
+    def slice_by_timestep(self, start_index: int | None = None, end_index: int | None = None) -> TimeSeriesDataFrame:
         """Select a subsequence from each time series between start (inclusive) and end (exclusive) indices.
 
         This operation is equivalent to selecting a slice ``[start_index : end_index]`` from each time series, and then
@@ -907,8 +905,8 @@ class TimeSeriesDataFrame(pd.DataFrame):
         return super().sort_index(*args, **kwargs)  # type: ignore
 
     def get_model_inputs_for_scoring(
-        self, prediction_length: int, known_covariates_names: Optional[list[str]] = None
-    ) -> tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
+        self, prediction_length: int, known_covariates_names: list[str] | None = None
+    ) -> tuple[TimeSeriesDataFrame, TimeSeriesDataFrame | None]:
         """Prepare model inputs necessary to predict the last ``prediction_length`` time steps of each time series in the dataset.
 
         Parameters
@@ -938,8 +936,8 @@ class TimeSeriesDataFrame(pd.DataFrame):
     def train_test_split(
         self,
         prediction_length: int,
-        end_index: Optional[int] = None,
-        suffix: Optional[str] = None,
+        end_index: int | None = None,
+        suffix: str | None = None,
     ) -> tuple[TimeSeriesDataFrame, TimeSeriesDataFrame]:
         """Generate a train/test split from the given dataset.
 
@@ -984,7 +982,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
 
     def convert_frequency(
         self,
-        freq: Union[str, pd.DateOffset],
+        freq: str | pd.DateOffset,
         agg_numeric: str = "mean",
         agg_categorical: str = "first",
         num_cpus: int = -1,
@@ -1003,7 +1001,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
 
         Parameters
         ----------
-        freq : Union[str, pd.DateOffset]
+        freq : str | pd.DateOffset
             Frequency to which the data should be converted. See `pandas frequency aliases <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`_
             for supported values.
         agg_numeric : {"max", "min", "sum", "mean", "median", "first", "last"}, default = "mean"
@@ -1130,14 +1128,14 @@ class TimeSeriesDataFrame(pd.DataFrame):
         def reindex(*args, **kwargs) -> Self: ...  # type: ignore
 
         @overload
-        def __new__(cls, data: pd.DataFrame, static_features: Optional[pd.DataFrame] = None) -> Self: ...  # type: ignore
+        def __new__(cls, data: pd.DataFrame, static_features: pd.DataFrame | None = None) -> Self: ...  # type: ignore
         @overload
         def __new__(
             cls,
-            data: Union[pd.DataFrame, str, Path, Iterable],
-            static_features: Optional[Union[pd.DataFrame, str, Path]] = None,
-            id_column: Optional[str] = None,
-            timestamp_column: Optional[str] = None,
+            data: pd.DataFrame | str | Path | Iterable,
+            static_features: pd.DataFrame | str | Path | None = None,
+            id_column: str | None = None,
+            timestamp_column: str | None = None,
             num_cpus: int = -1,
             *args,
             **kwargs,

{autogluon_timeseries-1.4.1b20251128 → autogluon_timeseries-1.5.1b20260117}/src/autogluon/timeseries/learner.py

@@ -1,7 +1,7 @@
 import logging
 import reprlib
 import time
-from typing import Any, Literal, Optional, Type, Union
+from typing import Any, Literal, Type
 
 import pandas as pd
 
@@ -25,12 +25,12 @@ class TimeSeriesLearner(AbstractLearner):
         self,
         path_context: str,
         target: str = "target",
-        known_covariates_names: Optional[list[str]] = None,
+        known_covariates_names: list[str] | None = None,
         trainer_type: Type[TimeSeriesTrainer] = TimeSeriesTrainer,
-        eval_metric: Union[str, TimeSeriesScorer, None] = None,
+        eval_metric: str | TimeSeriesScorer | None = None,
         prediction_length: int = 1,
         cache_predictions: bool = True,
-        ensemble_model_type: Optional[Type] = None,
+        ensemble_model_type: Type | None = None,
         **kwargs,
     ):
         super().__init__(path_context=path_context)
@@ -41,7 +41,7 @@ class TimeSeriesLearner(AbstractLearner):
         self.prediction_length = prediction_length
         self.quantile_levels = kwargs.get("quantile_levels", [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])
         self.cache_predictions = cache_predictions
-        self.freq: Optional[str] = None
+        self.freq: str | None = None
         self.ensemble_model_type = ensemble_model_type
 
         self.feature_generator = TimeSeriesFeatureGenerator(
@@ -55,14 +55,15 @@ class TimeSeriesLearner(AbstractLearner):
     def fit(
         self,
         train_data: TimeSeriesDataFrame,
-        hyperparameters: Union[str, dict],
-        val_data: Optional[TimeSeriesDataFrame] = None,
-        hyperparameter_tune_kwargs: Optional[Union[str, dict]] = None,
-        time_limit: Optional[float] = None,
-        num_val_windows: Optional[int] = None,
-        val_step_size: Optional[int] = None,
-        refit_every_n_windows: Optional[int] = 1,
-        random_seed: Optional[int] = None,
+        hyperparameters: str | dict,
+        val_data: TimeSeriesDataFrame | None = None,
+        hyperparameter_tune_kwargs: str | dict | None = None,
+        ensemble_hyperparameters: dict[str, Any] | list[dict[str, Any]] | None = None,
+        time_limit: float | None = None,
+        num_val_windows: tuple[int, ...] = (1,),
+        val_step_size: int | None = None,
+        refit_every_n_windows: int | None = 1,
+        random_seed: int | None = None,
         **kwargs,
     ) -> None:
         self._time_limit = time_limit
@@ -95,7 +96,7 @@ class TimeSeriesLearner(AbstractLearner):
         )
 
         assert issubclass(self.trainer_type, TimeSeriesTrainer)
-        self.trainer: Optional[TimeSeriesTrainer] = self.trainer_type(**trainer_init_kwargs)
+        self.trainer: TimeSeriesTrainer | None = self.trainer_type(**trainer_init_kwargs)
         self.trainer_path = self.trainer.path
         self.save()
 
@@ -112,6 +113,7 @@ class TimeSeriesLearner(AbstractLearner):
             val_data=val_data,
             hyperparameters=hyperparameters,
             hyperparameter_tune_kwargs=hyperparameter_tune_kwargs,
+            ensemble_hyperparameters=ensemble_hyperparameters,
             excluded_model_types=kwargs.get("excluded_model_types"),
             time_limit=time_limit,
             random_seed=random_seed,
@@ -122,9 +124,9 @@ class TimeSeriesLearner(AbstractLearner):
 
     def _align_covariates_with_forecast_index(
         self,
-        known_covariates: Optional[TimeSeriesDataFrame],
+        known_covariates: TimeSeriesDataFrame | None,
         data: TimeSeriesDataFrame,
-    ) -> Optional[TimeSeriesDataFrame]:
+    ) -> TimeSeriesDataFrame | None:
         """Select the relevant item_ids and timestamps from the known_covariates dataframe.
 
         If some of the item_ids or timestamps are missing, an exception is raised.
@@ -163,10 +165,10 @@ class TimeSeriesLearner(AbstractLearner):
     def predict(
         self,
         data: TimeSeriesDataFrame,
-        known_covariates: Optional[TimeSeriesDataFrame] = None,
-        model: Optional[Union[str, AbstractTimeSeriesModel]] = None,
+        known_covariates: TimeSeriesDataFrame | None = None,
+        model: str | AbstractTimeSeriesModel | None = None,
         use_cache: bool = True,
-        random_seed: Optional[int] = None,
+        random_seed: int | None = None,
         **kwargs,
     ) -> TimeSeriesDataFrame:
         data = self.feature_generator.transform(data)
@@ -184,8 +186,8 @@ class TimeSeriesLearner(AbstractLearner):
     def score(
         self,
         data: TimeSeriesDataFrame,
-        model: Optional[Union[str, AbstractTimeSeriesModel]] = None,
-        metric: Union[str, TimeSeriesScorer, None] = None,
+        model: str | AbstractTimeSeriesModel | None = None,
+        metric: str | TimeSeriesScorer | None = None,
         use_cache: bool = True,
     ) -> float:
         data = self.feature_generator.transform(data)
@@ -194,8 +196,8 @@ class TimeSeriesLearner(AbstractLearner):
     def evaluate(
         self,
         data: TimeSeriesDataFrame,
-        model: Optional[str] = None,
-        metrics: Optional[Union[str, TimeSeriesScorer, list[Union[str, TimeSeriesScorer]]]] = None,
+        model: str | None = None,
+        metrics: str | TimeSeriesScorer | list[str | TimeSeriesScorer] | None = None,
         use_cache: bool = True,
     ) -> dict[str, float]:
         data = self.feature_generator.transform(data)
@@ -203,15 +205,15 @@ class TimeSeriesLearner(AbstractLearner):
 
     def get_feature_importance(
         self,
-        data: Optional[TimeSeriesDataFrame] = None,
-        model: Optional[str] = None,
-        metric: Optional[Union[str, TimeSeriesScorer]] = None,
-        features: Optional[list[str]] = None,
-        time_limit: Optional[float] = None,
+        data: TimeSeriesDataFrame | None = None,
+        model: str | None = None,
+        metric: str | TimeSeriesScorer | None = None,
+        features: list[str] | None = None,
+        time_limit: float | None = None,
         method: Literal["naive", "permutation"] = "permutation",
         subsample_size: int = 50,
-        num_iterations: Optional[int] = None,
-        random_seed: Optional[int] = None,
+        num_iterations: int | None = None,
+        random_seed: int | None = None,
         relative_scores: bool = False,
         include_confidence_band: bool = True,
         confidence_level: float = 0.99,
@@ -272,9 +274,9 @@ class TimeSeriesLearner(AbstractLearner):
 
     def leaderboard(
         self,
-        data: Optional[TimeSeriesDataFrame] = None,
+        data: TimeSeriesDataFrame | None = None,
         extra_info: bool = False,
-        extra_metrics: Optional[list[Union[str, TimeSeriesScorer]]] = None,
+        extra_metrics: list[str | TimeSeriesScorer] | None = None,
         use_cache: bool = True,
     ) -> pd.DataFrame:
         if data is not None:
@@ -301,7 +303,7 @@ class TimeSeriesLearner(AbstractLearner):
         return learner_info
 
     def persist_trainer(
-        self, models: Union[Literal["all", "best"], list[str]] = "all", with_ancestors: bool = False
+        self, models: Literal["all", "best"] | list[str] = "all", with_ancestors: bool = False
     ) -> list[str]:
         """Loads models and trainer in memory so that they don't have to be
         loaded during predictions
@@ -332,10 +334,10 @@ class TimeSeriesLearner(AbstractLearner):
 
     def backtest_predictions(
         self,
-        data: Optional[TimeSeriesDataFrame],
+        data: TimeSeriesDataFrame | None,
         model_names: list[str],
-        num_val_windows: Optional[int] = None,
-        val_step_size: Optional[int] = None,
+        num_val_windows: int | None = None,
+        val_step_size: int | None = None,
         use_cache: bool = True,
     ) -> dict[str, list[TimeSeriesDataFrame]]:
         if data is not None:
@@ -350,9 +352,9 @@ class TimeSeriesLearner(AbstractLearner):
 
     def backtest_targets(
         self,
-        data: Optional[TimeSeriesDataFrame],
-        num_val_windows: Optional[int] = None,
-        val_step_size: Optional[int] = None,
+        data: TimeSeriesDataFrame | None,
+        num_val_windows: int | None = None,
+        val_step_size: int | None = None,
     ) -> list[TimeSeriesDataFrame]:
         if data is not None:
             data = self.feature_generator.transform(data)

{autogluon_timeseries-1.4.1b20251128 → autogluon_timeseries-1.5.1b20260117}/src/autogluon/timeseries/metrics/__init__.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from pprint import pformat
-from typing import Any, Optional, Sequence, Type, Union
+from typing import Any, Sequence, Type
 
 import numpy as np
 
@@ -54,10 +54,10 @@ EXPERIMENTAL_METRICS: dict[str, Type[TimeSeriesScorer]] = {
 
 
 def check_get_evaluation_metric(
-    eval_metric: Union[str, TimeSeriesScorer, Type[TimeSeriesScorer], None],
+    eval_metric: str | TimeSeriesScorer | Type[TimeSeriesScorer] | None,
     prediction_length: int,
-    seasonal_period: Optional[int] = None,
-    horizon_weight: Optional[Sequence[float] | np.ndarray] = None,
+    seasonal_period: int | None = None,
+    horizon_weight: Sequence[float] | np.ndarray | None = None,
 ) -> TimeSeriesScorer:
     """Factory method for TimeSeriesScorer objects.