autogluon.timeseries 1.4.1b20250818__tar.gz → 1.4.1b20250820__tar.gz

{autogluon.timeseries-1.4.1b20250818 → autogluon.timeseries-1.4.1b20250820}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.4.1b20250818
+Version: 1.4.1b20250820
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community

{autogluon.timeseries-1.4.1b20250818 → autogluon.timeseries-1.4.1b20250820}/src/autogluon/timeseries/dataset/ts_dataframe.py

@@ -1124,6 +1124,19 @@ class TimeSeriesDataFrame(pd.DataFrame):
 
         @overload
         def __new__(cls, data: pd.DataFrame, static_features: Optional[pd.DataFrame] = 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,
+            num_cpus: int = -1,
+            *args,
+            **kwargs,
+        ) -> Self:
+            """This overload is needed since in pandas, during type checking, the default constructor resolves to __new__"""
+            ...
 
         @overload
         def __getitem__(self, items: List[str]) -> Self: ...  # type: ignore

{autogluon.timeseries-1.4.1b20250818 → autogluon.timeseries-1.4.1b20250820}/src/autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -21,6 +21,7 @@ from autogluon.core.models import ModelBase
 from autogluon.core.utils.exceptions import TimeLimitExceeded
 from autogluon.timeseries.dataset import TimeSeriesDataFrame
 from autogluon.timeseries.metrics import TimeSeriesScorer, check_get_evaluation_metric
+from autogluon.timeseries.models.registry import ModelRegistry
 from autogluon.timeseries.regressor import CovariateRegressor, get_covariate_regressor
 from autogluon.timeseries.transforms import CovariateScaler, TargetScaler, get_covariate_scaler, get_target_scaler
 from autogluon.timeseries.utils.features import CovariateMetadata
@@ -376,11 +377,13 @@ class TimeSeriesModelBase(ModelBase, ABC):
         return template
 
 
-class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
+class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, metaclass=ModelRegistry):
     """Abstract base class for all time series models that take historical data as input and
     make predictions for the forecast horizon.
     """
 
+    ag_priority: int = 0
+
     def __init__(
         self,
         path: Optional[str] = None,
@@ -427,7 +430,7 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
     @property
     def allowed_hyperparameters(self) -> List[str]:
         """List of hyperparameters allowed by the model."""
-        return ["target_scaler", "covariate_regressor"]
+        return ["target_scaler", "covariate_regressor", "covariate_scaler"]
 
     def fit(
         self,
@@ -608,11 +611,13 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
         predictions = self._predict(data=data, known_covariates=known_covariates, **kwargs)
         self.covariate_regressor = covariate_regressor
 
-        column_order = pd.Index(["mean"] + [str(q) for q in self.quantile_levels])
+        # Ensure that 'mean' is the leading column. Trailing columns might not match quantile_levels if self is
+        # a MultiWindowBacktestingModel and base_model.must_drop_median=True
+        column_order = pd.Index(["mean"] + [col for col in predictions.columns if col != "mean"])
         if not predictions.columns.equals(column_order):
             predictions = predictions.reindex(columns=column_order)
 
-        # "0.5" might be missing from the quantiles if self is a wrapper (MultiWindowBacktestingModel or ensemble)
+        # "0.5" might be missing from the quantiles if self is a MultiWindowBacktestingModel
         if "0.5" in predictions.columns:
             if self.eval_metric.optimized_by_median:
                 predictions["mean"] = predictions["0.5"]

{autogluon.timeseries-1.4.1b20250818 → autogluon.timeseries-1.4.1b20250820}/src/autogluon/timeseries/models/autogluon_tabular/mlforecast.py

@@ -517,6 +517,8 @@ class DirectTabularModel(AbstractMLForecastModel):
         (starting from the end of each time series).
     """
 
+    ag_priority = 85
+
     @property
     def is_quantile_model(self) -> bool:
         return self.eval_metric.needs_quantile
@@ -698,6 +700,8 @@ class RecursiveTabularModel(AbstractMLForecastModel):
         (starting from the end of each time series).
     """
 
+    ag_priority = 90
+
     def get_hyperparameters(self) -> Dict[str, Any]:
         model_params = super().get_hyperparameters()
         # We don't set 'target_scaler' if user already provided 'scaler' to avoid overriding the user-provided value

{autogluon.timeseries-1.4.1b20250818 → autogluon.timeseries-1.4.1b20250820}/src/autogluon/timeseries/models/autogluon_tabular/per_step.py

@@ -81,6 +81,7 @@ class PerStepTabularModel(AbstractTimeSeriesModel):
         If None, automatically determined based on available memory to prevent OOM errors.
     """
 
+    ag_priority = 70
     _dummy_freq = "D"
 
     def __init__(self, *args, **kwargs):

{autogluon.timeseries-1.4.1b20250818 → autogluon.timeseries-1.4.1b20250820}/src/autogluon/timeseries/models/chronos/model.py

@@ -166,6 +166,7 @@ class ChronosModel(AbstractTimeSeriesModel):
         If True, the logs generated by transformers will NOT be removed after fine-tuning
     """
 
+    ag_priority = 55
     # default number of samples for prediction
     default_num_samples: int = 20
     default_model_path = "autogluon/chronos-bolt-small"

{autogluon.timeseries-1.4.1b20250818 → autogluon.timeseries-1.4.1b20250820}/src/autogluon/timeseries/models/gluonts/models.py

@@ -81,6 +81,8 @@ class DeepARModel(AbstractGluonTSModel):
 
     # TODO: Replace "scaling: bool" with "window_scaler": {"mean_abs", None} for consistency?
 
+    ag_priority = 40
+
     _supports_known_covariates = True
     _supports_static_features = True
 
@@ -138,6 +140,8 @@ class SimpleFeedForwardModel(AbstractGluonTSModel):
         If True, ``lightning_logs`` directory will NOT be removed after the model finished training.
     """
 
+    ag_priority = 10
+
     def _get_estimator_class(self) -> Type[GluonTSEstimator]:
         from gluonts.torch.model.simple_feedforward import SimpleFeedForwardEstimator
 
@@ -199,6 +203,9 @@ class TemporalFusionTransformerModel(AbstractGluonTSModel):
         If True, ``lightning_logs`` directory will NOT be removed after the model finished training.
     """
 
+    ag_priority = 45
+    ag_model_aliases = ["TFT"]
+
     _supports_known_covariates = True
     _supports_past_covariates = True
     _supports_cat_covariates = True
@@ -282,6 +289,8 @@ class DLinearModel(AbstractGluonTSModel):
         If True, ``lightning_logs`` directory will NOT be removed after the model finished training.
     """
 
+    ag_priority = 10
+
     def _get_default_hyperparameters(self):
         return super()._get_default_hyperparameters() | {
             "context_length": 96,
@@ -340,6 +349,8 @@ class PatchTSTModel(AbstractGluonTSModel):
         If True, ``lightning_logs`` directory will NOT be removed after the model finished training.
     """
 
+    ag_priority = 30
+
     _supports_known_covariates = True
 
     def _get_estimator_class(self) -> Type[GluonTSEstimator]:
@@ -416,6 +427,8 @@ class WaveNetModel(AbstractGluonTSModel):
         If True, ``lightning_logs`` directory will NOT be removed after the model finished training.
     """
 
+    ag_priority = 25
+
     _supports_known_covariates = True
     _supports_static_features = True
     default_num_samples: int = 100
@@ -508,6 +521,8 @@ class TiDEModel(AbstractGluonTSModel):
         If True, ``lightning_logs`` directory will NOT be removed after the model finished training.
     """
 
+    ag_priority = 30
+
     _supports_known_covariates = True
     _supports_static_features = True
 

{autogluon.timeseries-1.4.1b20250818 → autogluon.timeseries-1.4.1b20250820}/src/autogluon/timeseries/models/local/naive.py

@@ -24,6 +24,7 @@ class NaiveModel(AbstractLocalModel):
         When set to -1, all CPU cores are used.
     """
 
+    ag_priority = 100
     allowed_local_model_args = ["seasonal_period"]
 
     def _predict_with_local_model(
@@ -66,6 +67,7 @@ class SeasonalNaiveModel(AbstractLocalModel):
         When set to -1, all CPU cores are used.
     """
 
+    ag_priority = 100
     allowed_local_model_args = ["seasonal_period"]
 
     def _predict_with_local_model(
@@ -99,6 +101,7 @@ class AverageModel(AbstractLocalModel):
         This significantly speeds up fitting and usually leads to no change in accuracy.
     """
 
+    ag_priority = 100
     allowed_local_model_args = ["seasonal_period"]
     default_max_ts_length = None
 
@@ -138,6 +141,7 @@ class SeasonalAverageModel(AbstractLocalModel):
         This significantly speeds up fitting and usually leads to no change in accuracy.
     """
 
+    ag_priority = 100
     allowed_local_model_args = ["seasonal_period"]
     default_max_ts_length = None
 

{autogluon.timeseries-1.4.1b20250818 → autogluon.timeseries-1.4.1b20250820}/src/autogluon/timeseries/models/local/npts.py

@@ -36,6 +36,7 @@ class NPTSModel(AbstractLocalModel):
         This significantly speeds up fitting and usually leads to no change in accuracy.
     """
 
+    ag_priority = 80
     allowed_local_model_args = [
         "kernel_type",
         "exp_kernel_weights",

{autogluon.timeseries-1.4.1b20250818 → autogluon.timeseries-1.4.1b20250820}/src/autogluon/timeseries/models/local/statsforecast.py

@@ -133,6 +133,7 @@ class AutoARIMAModel(AbstractProbabilisticStatsForecastModel):
         This significantly speeds up fitting and usually leads to no change in accuracy.
     """
 
+    ag_priority = 60
     init_time_in_seconds = 0  # C++ models require no compilation
     allowed_local_model_args = [
         "d",
@@ -211,6 +212,7 @@ class ARIMAModel(AbstractProbabilisticStatsForecastModel):
         This significantly speeds up fitting and usually leads to no change in accuracy.
     """
 
+    ag_priority = 10
     init_time_in_seconds = 0  # C++ models require no compilation
     allowed_local_model_args = [
         "order",
@@ -267,6 +269,7 @@ class AutoETSModel(AbstractProbabilisticStatsForecastModel):
         This significantly speeds up fitting and usually leads to no change in accuracy.
     """
 
+    ag_priority = 70
     init_time_in_seconds = 0  # C++ models require no compilation
     allowed_local_model_args = [
         "damped",
@@ -330,6 +333,8 @@ class ETSModel(AutoETSModel):
         This significantly speeds up fitting and usually leads to no change in accuracy.
     """
 
+    ag_priority = 80
+
     def _update_local_model_args(self, local_model_args: dict) -> dict:
         local_model_args = super()._update_local_model_args(local_model_args)
         local_model_args.setdefault("model", "AAA")
@@ -369,6 +374,7 @@ class DynamicOptimizedThetaModel(AbstractProbabilisticStatsForecastModel):
         This significantly speeds up fitting and usually leads to no change in accuracy.
     """
 
+    ag_priority = 75
     allowed_local_model_args = [
         "decomposition_type",
         "seasonal_period",
@@ -413,6 +419,7 @@ class ThetaModel(AbstractProbabilisticStatsForecastModel):
         This significantly speeds up fitting and usually leads to no change in accuracy.
     """
 
+    ag_priority = 75
     allowed_local_model_args = [
         "decomposition_type",
         "seasonal_period",
@@ -533,6 +540,7 @@ class AutoCESModel(AbstractProbabilisticStatsForecastModel):
         This significantly speeds up fitting and usually leads to no change in accuracy.
     """
 
+    ag_priority = 10
     allowed_local_model_args = [
         "model",
         "seasonal_period",
@@ -600,6 +608,8 @@ class ADIDAModel(AbstractStatsForecastIntermittentDemandModel):
         This significantly speeds up fitting and usually leads to no change in accuracy.
     """
 
+    ag_priority = 10
+
     def _get_model_type(self, variant: Optional[str] = None):
         from statsforecast.models import ADIDA
 
@@ -636,6 +646,8 @@ class CrostonModel(AbstractStatsForecastIntermittentDemandModel):
         This significantly speeds up fitting and usually leads to no change in accuracy.
     """
 
+    ag_model_aliases = ["CrostonSBA"]
+    ag_priority = 80
     allowed_local_model_args = [
         "variant",
     ]
@@ -688,6 +700,8 @@ class IMAPAModel(AbstractStatsForecastIntermittentDemandModel):
         This significantly speeds up fitting and usually leads to no change in accuracy.
     """
 
+    ag_priority = 10
+
     def _get_model_type(self, variant: Optional[str] = None):
         from statsforecast.models import IMAPA
 
@@ -710,6 +724,8 @@ class ZeroModel(AbstractStatsForecastIntermittentDemandModel):
         This significantly speeds up fitting and usually leads to no change in accuracy.
     """
 
+    ag_priority = 100
+
     def _get_model_type(self, variant: Optional[str] = None):
         # ZeroModel does not depend on a StatsForecast implementation
         raise NotImplementedError

{autogluon.timeseries-1.4.1b20250818 → autogluon.timeseries-1.4.1b20250820}/src/autogluon/timeseries/models/presets.py

@@ -2,115 +2,21 @@ import copy
 import logging
 import re
 from collections import defaultdict
-from typing import Any, Dict, List, Optional, Type, Union
+from typing import Any, Dict, List, Optional, Set, Type, Union
 
 from autogluon.common import space
 from autogluon.core import constants
 from autogluon.timeseries.metrics import TimeSeriesScorer
 from autogluon.timeseries.utils.features import CovariateMetadata
 
-from . import (
-    ADIDAModel,
-    ARIMAModel,
-    AutoARIMAModel,
-    AutoCESModel,
-    AutoETSModel,
-    AverageModel,
-    ChronosModel,
-    CrostonModel,
-    DeepARModel,
-    DirectTabularModel,
-    DLinearModel,
-    DynamicOptimizedThetaModel,
-    ETSModel,
-    IMAPAModel,
-    NaiveModel,
-    NPTSModel,
-    PatchTSTModel,
-    PerStepTabularModel,
-    RecursiveTabularModel,
-    SeasonalAverageModel,
-    SeasonalNaiveModel,
-    SimpleFeedForwardModel,
-    TemporalFusionTransformerModel,
-    ThetaModel,
-    TiDEModel,
-    WaveNetModel,
-    ZeroModel,
-)
 from .abstract import AbstractTimeSeriesModel
 from .multi_window.multi_window_model import MultiWindowBacktestingModel
+from .registry import ModelRegistry
 
 logger = logging.getLogger(__name__)
 
 ModelHyperparameters = Dict[str, Any]
 
-# define the model zoo with their aliases
-MODEL_TYPES = dict(
-    SimpleFeedForward=SimpleFeedForwardModel,
-    DeepAR=DeepARModel,
-    DLinear=DLinearModel,
-    PatchTST=PatchTSTModel,
-    TemporalFusionTransformer=TemporalFusionTransformerModel,
-    TiDE=TiDEModel,
-    WaveNet=WaveNetModel,
-    RecursiveTabular=RecursiveTabularModel,
-    DirectTabular=DirectTabularModel,
-    PerStepTabular=PerStepTabularModel,
-    Average=AverageModel,
-    SeasonalAverage=SeasonalAverageModel,
-    Naive=NaiveModel,
-    SeasonalNaive=SeasonalNaiveModel,
-    Zero=ZeroModel,
-    AutoETS=AutoETSModel,
-    AutoCES=AutoCESModel,
-    AutoARIMA=AutoARIMAModel,
-    DynamicOptimizedTheta=DynamicOptimizedThetaModel,
-    NPTS=NPTSModel,
-    Theta=ThetaModel,
-    ETS=ETSModel,
-    ARIMA=ARIMAModel,
-    ADIDA=ADIDAModel,
-    Croston=CrostonModel,
-    CrostonSBA=CrostonModel,  # Alias for backward compatibility
-    IMAPA=IMAPAModel,
-    Chronos=ChronosModel,
-)
-
-DEFAULT_MODEL_NAMES = {v: k for k, v in MODEL_TYPES.items()}
-DEFAULT_MODEL_PRIORITY = dict(
-    Naive=100,
-    SeasonalNaive=100,
-    Average=100,
-    SeasonalAverage=100,
-    Zero=100,
-    RecursiveTabular=90,
-    DirectTabular=85,
-    PerStepTabular=70,  # TODO: Update priority
-    # All local models are grouped together to make sure that joblib parallel pool is reused
-    NPTS=80,
-    ETS=80,
-    CrostonSBA=80,  # Alias for backward compatibility
-    Croston=80,
-    Theta=75,
-    DynamicOptimizedTheta=75,
-    AutoETS=70,
-    AutoARIMA=60,
-    Chronos=55,
-    # Models that can early stop are trained at the end
-    TemporalFusionTransformer=45,
-    DeepAR=40,
-    TiDE=30,
-    PatchTST=30,
-    # Models below are not included in any presets
-    WaveNet=25,
-    AutoCES=10,
-    ARIMA=10,
-    ADIDA=10,
-    IMAPA=10,
-    SimpleFeedForward=10,
-)
-DEFAULT_CUSTOM_MODEL_PRIORITY = 0
 
 VALID_AG_ARGS_KEYS = {
     "name",
@@ -199,45 +105,23 @@ def get_preset_models(
     will create models according to presets.
     """
     models = []
-    if hyperparameters is None:
-        hp_string = "default"
-        hyperparameters = copy.deepcopy(get_default_hps(hp_string))
-    elif isinstance(hyperparameters, str):
-        hyperparameters = copy.deepcopy(get_default_hps(hyperparameters))
-    elif isinstance(hyperparameters, dict):
-        hyperparameters = copy.deepcopy(hyperparameters)
-    else:
-        raise ValueError(
-            f"hyperparameters must be a dict, a string or None (received {type(hyperparameters)}). "
-            f"Please see the documentation for TimeSeriesPredictor.fit"
-        )
-    hyperparameters = check_and_clean_hyperparameters(hyperparameters, must_contain_searchspace=hyperparameter_tune)
+    hyperparameter_dict = get_hyperparameter_dict(hyperparameters, hyperparameter_tune)
 
-    excluded_models = set()
-    if excluded_model_types is not None and len(excluded_model_types) > 0:
-        if not isinstance(excluded_model_types, list):
-            raise ValueError(f"`excluded_model_types` must be a list, received {type(excluded_model_types)}")
-        logger.info(f"Excluded model types: {excluded_model_types}")
-        for model in excluded_model_types:
-            if not isinstance(model, str):
-                raise ValueError(f"Each entry in `excluded_model_types` must be a string, received {type(model)}")
-            excluded_models.add(normalize_model_type_name(model))
-
-    all_assigned_names = set(all_assigned_names)
-
-    model_priority_list = sorted(hyperparameters.keys(), key=lambda x: DEFAULT_MODEL_PRIORITY.get(x, 0), reverse=True)
+    model_priority_list = sorted(
+        hyperparameter_dict.keys(), key=lambda x: ModelRegistry.get_model_priority(x), reverse=True
+    )
+    excluded_models = get_excluded_models(excluded_model_types)
+    all_assigned_names = all_assigned_names.copy()
 
     for model in model_priority_list:
         if isinstance(model, str):
-            if model not in MODEL_TYPES:
-                raise ValueError(f"Model {model} is not supported. Available models: {sorted(MODEL_TYPES)}")
             if model in excluded_models:
                 logger.info(
                     f"\tFound '{model}' model in `hyperparameters`, but '{model}' "
                     "is present in `excluded_model_types` and will be removed."
                 )
                 continue
-            model_type = MODEL_TYPES[model]
+            model_type: Type[AbstractTimeSeriesModel] = ModelRegistry.get_model_class(model)
         elif isinstance(model, type):
             if not issubclass(model, AbstractTimeSeriesModel):
                 raise ValueError(f"Custom model type {model} must inherit from `AbstractTimeSeriesModel`.")
@@ -247,7 +131,7 @@ def get_preset_models(
                 f"Keys of the `hyperparameters` dictionary must be strings or types, received {type(model)}."
             )
 
-        for model_hps in hyperparameters[model]:
+        for model_hps in hyperparameter_dict[model]:
             ag_args = model_hps.pop(constants.AG_ARGS, {})
             for key in ag_args:
                 if key not in VALID_AG_ARGS_KEYS:
@@ -256,7 +140,7 @@ def get_preset_models(
                     )
             model_name_base = get_model_name(ag_args, model_type)
 
-            model_type_kwargs = dict(
+            model_type_kwargs: Dict[str, Any] = dict(
                 name=model_name_base,
                 path=path,
                 freq=freq,
@@ -269,22 +153,60 @@ def get_preset_models(
 
             # add models while preventing name collisions
             model = model_type(**model_type_kwargs)
-
             model_type_kwargs.pop("name", None)
+
             increment = 1
             while model.name in all_assigned_names:
                 increment += 1
                 model = model_type(name=f"{model_name_base}_{increment}", **model_type_kwargs)
 
             if multi_window:
-                model = MultiWindowBacktestingModel(model_base=model, name=model.name, **model_type_kwargs)
+                model = MultiWindowBacktestingModel(model_base=model, name=model.name, **model_type_kwargs)  # type: ignore
 
-            all_assigned_names.add(model.name)
+            all_assigned_names.append(model.name)
             models.append(model)
 
     return models
 
 
+def get_excluded_models(excluded_model_types: Optional[List[str]]) -> Set[str]:
+    excluded_models = set()
+    if excluded_model_types is not None and len(excluded_model_types) > 0:
+        if not isinstance(excluded_model_types, list):
+            raise ValueError(f"`excluded_model_types` must be a list, received {type(excluded_model_types)}")
+        logger.info(f"Excluded model types: {excluded_model_types}")
+        for model in excluded_model_types:
+            if not isinstance(model, str):
+                raise ValueError(f"Each entry in `excluded_model_types` must be a string, received {type(model)}")
+            excluded_models.add(normalize_model_type_name(model))
+    return excluded_models
+
+
+def get_hyperparameter_dict(
+    hyperparameters: Union[str, Dict[str, Union[ModelHyperparameters, List[ModelHyperparameters]]], None],
+    hyperparameter_tune: bool,
+) -> Dict[str, List[ModelHyperparameters]]:
+    hyperparameter_dict = {}
+
+    if hyperparameters is None:
+        hyperparameter_dict = copy.deepcopy(get_default_hps("default"))
+    elif isinstance(hyperparameters, str):
+        hyperparameter_dict = copy.deepcopy(get_default_hps(hyperparameters))
+    elif isinstance(hyperparameters, dict):
+        hyperparameter_dict = copy.deepcopy(hyperparameters)
+    else:
+        raise ValueError(
+            f"hyperparameters must be a dict, a string or None (received {type(hyperparameters)}). "
+            f"Please see the documentation for TimeSeriesPredictor.fit"
+        )
+
+    hyperparameter_dict = check_and_clean_hyperparameters(
+        hyperparameter_dict, must_contain_searchspace=hyperparameter_tune
+    )
+
+    return hyperparameter_dict
+
+
 def normalize_model_type_name(model_name: str) -> str:
     """Remove 'Model' suffix from the end of the string, if it's present."""
     if model_name.endswith("Model"):

autogluon.timeseries-1.4.1b20250820/src/autogluon/timeseries/models/registry.py

@@ -0,0 +1,65 @@
+from abc import ABCMeta
+from dataclasses import dataclass
+from inspect import isabstract
+from typing import Dict, List, Union
+
+
+@dataclass
+class ModelRecord:
+    model_class: type
+    ag_priority: int
+
+
+class ModelRegistry(ABCMeta):
+    """Registry metaclass for time series models. Ensures that TimeSeriesModel classes
+    which implement this metaclass are automatically registered, in order to centralize
+    access to model types.
+
+    See, https://github.com/faif/python-patterns.
+    """
+
+    REGISTRY: Dict[str, ModelRecord] = {}
+
+    def __new__(cls, name, bases, attrs):
+        new_cls = super().__new__(cls, name, bases, attrs)
+
+        if name is not None and not isabstract(new_cls):
+            record = ModelRecord(
+                model_class=new_cls,
+                ag_priority=getattr(new_cls, "ag_priority", 0),
+            )
+            cls._add(name.removesuffix("Model"), record)
+
+            # if the class provides additional aliases, register them too
+            if aliases := attrs.get("ag_model_aliases"):
+                for alias in aliases:
+                    cls._add(alias, record)
+
+        return new_cls
+
+    @classmethod
+    def _add(cls, alias: str, record: ModelRecord) -> None:
+        if alias in cls.REGISTRY:
+            raise ValueError(f"You are trying to define a new model with {alias}, but this model already exists.")
+        cls.REGISTRY[alias] = record
+
+    @classmethod
+    def _get_model_record(cls, alias: Union[str, type]) -> ModelRecord:
+        if isinstance(alias, type):
+            alias = alias.__name__
+        alias = alias.removesuffix("Model")
+        if alias not in cls.REGISTRY:
+            raise ValueError(f"Unknown model: {alias}, available models are: {cls.available_aliases()}")
+        return cls.REGISTRY[alias]
+
+    @classmethod
+    def get_model_class(cls, alias: Union[str, type]) -> type:
+        return cls._get_model_record(alias).model_class
+
+    @classmethod
+    def get_model_priority(cls, alias: Union[str, type]) -> int:
+        return cls._get_model_record(alias).ag_priority
+
+    @classmethod
+    def available_aliases(cls) -> List[str]:
+        return sorted(cls.REGISTRY.keys())

{autogluon.timeseries-1.4.1b20250818 → autogluon.timeseries-1.4.1b20250820}/src/autogluon/timeseries/predictor.py

@@ -296,7 +296,10 @@ class TimeSeriesPredictor:
         df: TimeSeriesDataFrame = self._to_data_frame(data, name=name)
         if not pd.api.types.is_numeric_dtype(df[self.target]):
             raise ValueError(f"Target column {name}['{self.target}'] has a non-numeric dtype {df[self.target].dtype}")
+        # Assign makes a copy, so future operations can be performed in-place
         df = df.assign(**{self.target: df[self.target].astype("float64")})
+        df.replace(to_replace=[float("-inf"), float("inf")], value=float("nan"), inplace=True)
+
         # MultiIndex.is_monotonic_increasing checks if index is sorted by ["item_id", "timestamp"]
         if not df.index.is_monotonic_increasing:
             df = df.sort_index()

{autogluon.timeseries-1.4.1b20250818 → autogluon.timeseries-1.4.1b20250820}/src/autogluon/timeseries/utils/features.py

@@ -485,4 +485,4 @@ class ConstantReplacementFeatureImportanceTransform(AbstractFeatureImportanceTra
         if is_categorical:
             return feature_data.groupby(level=ITEMID, sort=False).transform(lambda x: x.mode()[0])
         else:
-            return feature_data.groupby(level=ITEMID, sort=False).transform(self.real_value_aggregation)
+            return feature_data.groupby(level=ITEMID, sort=False).transform(self.real_value_aggregation)  # type: ignore

{autogluon.timeseries-1.4.1b20250818 → autogluon.timeseries-1.4.1b20250820}/src/autogluon/timeseries/version.py

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

{autogluon.timeseries-1.4.1b20250818 → autogluon.timeseries-1.4.1b20250820}/src/autogluon.timeseries.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.4.1b20250818
+Version: 1.4.1b20250820
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community

{autogluon.timeseries-1.4.1b20250818 → autogluon.timeseries-1.4.1b20250820}/src/autogluon.timeseries.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ src/autogluon/timeseries/metrics/quantile.py
 src/autogluon/timeseries/metrics/utils.py
 src/autogluon/timeseries/models/__init__.py
 src/autogluon/timeseries/models/presets.py
+src/autogluon/timeseries/models/registry.py
 src/autogluon/timeseries/models/abstract/__init__.py
 src/autogluon/timeseries/models/abstract/abstract_timeseries_model.py
 src/autogluon/timeseries/models/abstract/model_trial.py

{autogluon.timeseries-1.4.1b20250818 → autogluon.timeseries-1.4.1b20250820}/src/autogluon.timeseries.egg-info/requires.txt

@@ -17,10 +17,10 @@ fugue>=0.9.0
 tqdm<5,>=4.38
 orjson~=3.9
 tensorboard<3,>=2.9
-autogluon.core[raytune]==1.4.1b20250818
-autogluon.common==1.4.1b20250818
-autogluon.features==1.4.1b20250818
-autogluon.tabular[catboost,lightgbm,xgboost]==1.4.1b20250818
+autogluon.core[raytune]==1.4.1b20250820
+autogluon.common==1.4.1b20250820
+autogluon.features==1.4.1b20250820
+autogluon.tabular[catboost,lightgbm,xgboost]==1.4.1b20250820
 
 [all]