autogluon.timeseries 1.4.1b20250907__py3-none-any.whl → 1.5.1b20260122__py3-none-any.whl

autogluon/timeseries/trainer/utils.py

@@ -0,0 +1,17 @@
+import logging
+
+logger = logging.getLogger("autogluon.timeseries.trainer")
+
+
+def log_scores_and_times(
+    val_score: float | None,
+    fit_time: float | None,
+    predict_time: float | None,
+    eval_metric_name: str,
+):
+    if val_score is not None:
+        logger.info(f"\t{val_score:<7.4f}".ljust(15) + f"= Validation score ({eval_metric_name})")
+    if fit_time is not None:
+        logger.info(f"\t{fit_time:<7.2f} s".ljust(15) + "= Training runtime")
+    if predict_time is not None:
+        logger.info(f"\t{predict_time:<7.2f} s".ljust(15) + "= Validation (prediction) runtime")

autogluon/timeseries/transforms/covariate_scaler.py

@@ -1,12 +1,12 @@
 import logging
-from typing import Literal, Optional, Protocol, overload, runtime_checkable
+from typing import Literal, Protocol, overload, runtime_checkable
 
 import numpy as np
 import pandas as pd
 from sklearn.compose import ColumnTransformer
 from sklearn.preprocessing import QuantileTransformer, StandardScaler
 
-from autogluon.timeseries.dataset.ts_dataframe import TimeSeriesDataFrame
+from autogluon.timeseries.dataset import TimeSeriesDataFrame
 from autogluon.timeseries.utils.features import CovariateMetadata
 from autogluon.timeseries.utils.warning_filters import warning_filter
 
@@ -25,8 +25,8 @@ class CovariateScaler(Protocol):
     def transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame: ...
 
     def transform_known_covariates(
-        self, known_covariates: Optional[TimeSeriesDataFrame] = None
-    ) -> Optional[TimeSeriesDataFrame]: ...
+        self, known_covariates: TimeSeriesDataFrame | None = None
+    ) -> TimeSeriesDataFrame | None: ...
 
 
 class GlobalCovariateScaler(CovariateScaler):
@@ -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: dict[Literal["known", "past", "static"], ColumnTransformer] | None = None
 
     def is_fit(self) -> bool:
         return self._column_transformers is not None
@@ -105,8 +105,8 @@ class GlobalCovariateScaler(CovariateScaler):
         return data
 
     def transform_known_covariates(
-        self, known_covariates: Optional[TimeSeriesDataFrame] = None
-    ) -> Optional[TimeSeriesDataFrame]:
+        self, known_covariates: TimeSeriesDataFrame | None = None
+    ) -> TimeSeriesDataFrame | None:
         assert self._column_transformers is not None, "CovariateScaler must be fit before transform can be called"
 
         if "known" in self._column_transformers:
@@ -154,7 +154,7 @@ AVAILABLE_COVARIATE_SCALERS = {
 def get_covariate_scaler(name: None, **scaler_kwargs) -> None: ...
 @overload
 def get_covariate_scaler(name: Literal["global"], **scaler_kwargs) -> GlobalCovariateScaler: ...
-def get_covariate_scaler(name: Optional[Literal["global"]] = None, **scaler_kwargs) -> Optional[CovariateScaler]:
+def get_covariate_scaler(name: Literal["global"] | None = None, **scaler_kwargs) -> CovariateScaler | None:
     if name is None:
         return None
     if name not in AVAILABLE_COVARIATE_SCALERS:

autogluon/timeseries/transforms/target_scaler.py

@@ -1,10 +1,10 @@
-from typing import Literal, Optional, Protocol, Union, overload
+from typing import Literal, Protocol, overload
 
 import numpy as np
 import pandas as pd
 from typing_extensions import Self
 
-from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TimeSeriesDataFrame
+from autogluon.timeseries.dataset import TimeSeriesDataFrame
 
 
 class TargetScaler(Protocol):
@@ -27,10 +27,10 @@ class LocalTargetScaler(TargetScaler):
     ):
         self.target = target
         self.min_scale = min_scale
-        self.loc: Optional[pd.Series] = None
-        self.scale: Optional[pd.Series] = None
+        self.loc: pd.Series | None = None
+        self.scale: pd.Series | None = 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[pd.Series | None, pd.Series | None]:
         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[np.ndarray | float, 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()
@@ -59,12 +59,12 @@ class LocalTargetScaler(TargetScaler):
 
     def transform(self, data: TimeSeriesDataFrame) -> TimeSeriesDataFrame:
         """Apply scaling to the target column in the dataframe."""
-        loc, scale = self._reindex_loc_scale(item_index=data.index.get_level_values(ITEMID))
+        loc, scale = self._reindex_loc_scale(item_index=data.index.get_level_values(TimeSeriesDataFrame.ITEMID))
         return data.assign(**{self.target: (data[self.target] - loc) / scale})
 
     def inverse_transform(self, predictions: TimeSeriesDataFrame) -> TimeSeriesDataFrame:
         """Apply inverse scaling to all columns in the predictions dataframe."""
-        loc, scale = self._reindex_loc_scale(item_index=predictions.index.get_level_values(ITEMID))
+        loc, scale = self._reindex_loc_scale(item_index=predictions.index.get_level_values(TimeSeriesDataFrame.ITEMID))
         return predictions.assign(**{col: predictions[col] * scale + loc for col in predictions.columns})
 
 
@@ -75,15 +75,15 @@ class LocalStandardScaler(LocalTargetScaler):
     """
 
     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"])
+        stats = target_series.groupby(level=TimeSeriesDataFrame.ITEMID, sort=False).agg(["mean", "std"])
         return stats["mean"], stats["std"]
 
 
 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]:
-        scale = target_series.abs().groupby(level=ITEMID, sort=False).agg("mean")
+    def _compute_loc_scale(self, target_series: pd.Series) -> tuple[pd.Series | None, pd.Series]:
+        scale = target_series.abs().groupby(level=TimeSeriesDataFrame.ITEMID, sort=False).agg("mean")
         return None, scale
 
 
@@ -94,7 +94,7 @@ class LocalMinMaxScaler(LocalTargetScaler):
     """
 
     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"])
+        stats = target_series.abs().groupby(level=TimeSeriesDataFrame.ITEMID, sort=False).agg(["min", "max"])
         scale = (stats["max"] - stats["min"]).clip(lower=self.min_scale)
         loc = stats["min"]
         return loc, scale
@@ -118,7 +118,7 @@ class LocalRobustScaler(LocalTargetScaler):
         assert 0 < self.q_min < self.q_max < 1
 
     def _compute_loc_scale(self, target_series: pd.Series) -> tuple[pd.Series, pd.Series]:
-        grouped = target_series.groupby(level=ITEMID, sort=False)
+        grouped = target_series.groupby(level=TimeSeriesDataFrame.ITEMID, sort=False)
         loc = grouped.median()
         lower = grouped.quantile(self.q_min)
         upper = grouped.quantile(self.q_max)
@@ -139,8 +139,8 @@ def get_target_scaler(name: None, **scaler_kwargs) -> None: ...
 @overload
 def get_target_scaler(name: Literal["standard", "mean_abs", "min_max", "robust"], **scaler_kwargs) -> TargetScaler: ...
 def get_target_scaler(
-    name: Optional[Literal["standard", "mean_abs", "min_max", "robust"]], **scaler_kwargs
-) -> Optional[TargetScaler]:
+    name: Literal["standard", "mean_abs", "min_max", "robust"] | None, **scaler_kwargs
+) -> TargetScaler | None:
     """Get LocalTargetScaler object from a string."""
     if name is None:
         return None

autogluon/timeseries/utils/constants.py

@@ -0,0 +1,10 @@
+import joblib.externals.loky
+from joblib import cpu_count
+
+# By default, joblib w/ loky backend kills processes that take >300MB of RAM assuming that this is caused by a memory
+# leak. This leads to problems for some memory-hungry models like AutoARIMA/Theta.
+# This monkey patch removes this undesired behavior
+joblib.externals.loky.process_executor._MAX_MEMORY_LEAK_SIZE = int(3e10)
+
+# We use the same default n_jobs across AG-TS to ensure that Joblib reuses the process pool
+AG_DEFAULT_N_JOBS = max(cpu_count(only_physical_cores=True), 1)

autogluon/timeseries/utils/datetime/lags.py

@@ -2,8 +2,6 @@
 Generate lag indices based on frequency string. Adapted from gluonts.time_feature.lag.
 """
 
-from typing import Optional
-
 import numpy as np
 import pandas as pd
 
@@ -70,7 +68,7 @@ def _make_lags_for_semi_month(multiple, num_cycles=3):
 def get_lags_for_frequency(
     freq: str,
     lag_ub: int = 1200,
-    num_lags: Optional[int] = None,
+    num_lags: int | None = None,
     num_default_lags: int = 7,
 ) -> list[int]:
     """

autogluon/timeseries/utils/datetime/seasonality.py

@@ -1,5 +1,3 @@
-from typing import Union
-
 import pandas as pd
 
 from .base import norm_freq_str
@@ -22,7 +20,7 @@ DEFAULT_SEASONALITIES = {
 }
 
 
-def get_seasonality(freq: Union[str, None]) -> int:
+def get_seasonality(freq: str | None) -> int:
     """Return the seasonality of a given frequency. Adapted from ``gluonts.time_feature.seasonality``."""
     if freq is None:
         return 1

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, Literal, Optional
+from typing import Any, Literal
 
 import numpy as np
 import pandas as pd
@@ -14,7 +14,7 @@ from autogluon.features.generators import (
     IdentityFeatureGenerator,
     PipelineFeatureGenerator,
 )
-from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TimeSeriesDataFrame
+from autogluon.timeseries.dataset import TimeSeriesDataFrame
 from autogluon.timeseries.utils.warning_filters import warning_filter
 
 logger = logging.getLogger(__name__)
@@ -30,6 +30,14 @@ class CovariateMetadata:
     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_cat_cardinality: dict[str, int] = field(default_factory=dict)
+    known_cat_cardinality: dict[str, int] = field(default_factory=dict)
+    past_cat_cardinality: dict[str, int] = field(default_factory=dict)
+
+    def __post_init__(self):
+        assert list(self.static_cat_cardinality.keys()) == self.static_features_cat
+        assert list(self.known_cat_cardinality.keys()) == self.known_covariates_cat
+        assert list(self.past_cat_cardinality.keys()) == self.past_covariates_cat
 
     @property
     def static_features(self) -> list[str]:
@@ -136,7 +144,7 @@ class TimeSeriesFeatureGenerator:
         target: str,
         known_covariates_names: list[str],
         float_dtype: str = "float32",
-        num_samples: Optional[int] = 20_000,
+        num_samples: int | None = 20_000,
     ):
         self.target = target
         self.float_dtype = float_dtype
@@ -149,9 +157,9 @@ class TimeSeriesFeatureGenerator:
         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
         self.static_feature_pipeline = ContinuousAndCategoricalFeatureGenerator(minimum_cat_count=1)
-        self._covariate_metadata: Optional[CovariateMetadata] = None  # type ignore
-        self._train_covariates_real_median: Optional[pd.Series] = None
-        self._train_static_real_median: Optional[pd.Series] = None
+        self._covariate_metadata: CovariateMetadata | None = None  # type ignore
+        self._train_covariates_real_median: pd.Series | None = None
+        self._train_static_real_median: pd.Series | None = None
 
     @property
     def required_column_names(self) -> list[str]:
@@ -221,11 +229,13 @@ class TimeSeriesFeatureGenerator:
             static_features_cat, static_features_real = self._detect_and_log_column_types(static_features_df)
             ignored_static_features = data.static_features.columns.difference(self.static_feature_pipeline.features_in)
             self._train_static_real_median = data.static_features[static_features_real].median()
+            static_cat_cardinality = static_features_df[static_features_cat].nunique().to_dict()
         else:
             static_features_cat = []
             static_features_real = []
             ignored_static_features = []
             static_features_df = None
+            static_cat_cardinality = {}
 
         if len(ignored_covariates) > 0 or len(ignored_static_features) > 0:
             logger.info("\nAutoGluon will ignore following non-numeric/non-informative columns:")
@@ -246,6 +256,9 @@ class TimeSeriesFeatureGenerator:
             past_covariates_real=past_covariates_real,
             static_features_cat=static_features_cat,
             static_features_real=static_features_real,
+            static_cat_cardinality=static_cat_cardinality,
+            known_cat_cardinality=df[known_covariates_cat].nunique().to_dict(),
+            past_cat_cardinality=df[past_covariates_cat].nunique().to_dict(),
         )
 
         # Median of real-valued covariates will be used for missing value imputation
@@ -279,7 +292,7 @@ class TimeSeriesFeatureGenerator:
             ts_df[column_names] = covariates_real
         return ts_df
 
-    def _impute_static_features(self, static_df: Optional[pd.DataFrame]) -> Optional[pd.DataFrame]:
+    def _impute_static_features(self, static_df: pd.DataFrame | None) -> pd.DataFrame | None:
         """Impute missing values in static features using the median."""
         static_real_names = self.covariate_metadata.static_features_real
         if static_df is not None and static_real_names:
@@ -328,8 +341,8 @@ class TimeSeriesFeatureGenerator:
         return self._impute_covariates(ts_df, column_names=self.covariate_metadata.covariates_real)
 
     def transform_future_known_covariates(
-        self, known_covariates: Optional[TimeSeriesDataFrame]
-    ) -> Optional[TimeSeriesDataFrame]:
+        self, known_covariates: TimeSeriesDataFrame | None
+    ) -> TimeSeriesDataFrame | None:
         assert self._is_fit, f"{self.__class__.__name__} has not been fit yet"
         if len(self.known_covariates_names) > 0:
             assert known_covariates is not None, "known_covariates must be provided at prediction time"
@@ -415,7 +428,9 @@ class AbstractFeatureImportanceTransform:
         if feature_name in self.covariate_metadata.past_covariates:
             # we'll have to work on the history of the data alone
             data[feature_name] = data[feature_name].copy()
-            feature_data = data[feature_name].groupby(level=ITEMID, sort=False).head(-self.prediction_length)
+            feature_data = (
+                data[feature_name].groupby(level=TimeSeriesDataFrame.ITEMID, sort=False).head(-self.prediction_length)
+            )
             # Silence spurious FutureWarning raised by DataFrame.update https://github.com/pandas-dev/pandas/issues/57124
             with warning_filter():
                 data[feature_name].update(self._transform_series(feature_data, is_categorical=is_categorical))
@@ -439,7 +454,7 @@ class PermutationFeatureImportanceTransform(AbstractFeatureImportanceTransform):
         self,
         covariate_metadata: CovariateMetadata,
         prediction_length: int,
-        random_seed: Optional[int] = None,
+        random_seed: int | None = None,
         shuffle_type: Literal["itemwise", "naive"] = "itemwise",
         **kwargs,
     ):
@@ -455,7 +470,7 @@ class PermutationFeatureImportanceTransform(AbstractFeatureImportanceTransform):
         rng = np.random.RandomState(self.random_seed)
 
         if self.shuffle_type == "itemwise":
-            return feature_data.groupby(level=ITEMID, sort=False).transform(
+            return feature_data.groupby(level=TimeSeriesDataFrame.ITEMID, sort=False).transform(
                 lambda x: x.sample(frac=1, random_state=rng).values
             )
         elif self.shuffle_type == "naive":
@@ -483,6 +498,8 @@ class ConstantReplacementFeatureImportanceTransform(AbstractFeatureImportanceTra
 
     def _transform_series(self, feature_data: pd.Series, is_categorical: bool) -> pd.Series:
         if is_categorical:
-            return feature_data.groupby(level=ITEMID, sort=False).transform(lambda x: x.mode()[0])
+            return feature_data.groupby(level=TimeSeriesDataFrame.ITEMID, sort=False).transform(lambda x: x.mode()[0])
         else:
-            return feature_data.groupby(level=ITEMID, sort=False).transform(self.real_value_aggregation)  # type: ignore
+            return feature_data.groupby(level=TimeSeriesDataFrame.ITEMID, sort=False).transform(
+                self.real_value_aggregation
+            )  # type: ignore

autogluon/timeseries/utils/forecast.py

@@ -1,11 +1,10 @@
 import warnings
-from typing import Optional
 
 import numpy as np
 import pandas as pd
 
 from autogluon.common.utils.deprecated_utils import Deprecated
-from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TIMESTAMP, TimeSeriesDataFrame
+from autogluon.timeseries.dataset import TimeSeriesDataFrame
 
 
 def get_forecast_horizon_index_single_time_series(
@@ -16,7 +15,7 @@ def get_forecast_horizon_index_single_time_series(
     if offset is None:
         raise ValueError(f"Invalid frequency: {freq}")
     start_ts = past_timestamps.max() + 1 * offset
-    return pd.date_range(start=start_ts, periods=prediction_length, freq=freq, name=TIMESTAMP)
+    return pd.date_range(start=start_ts, periods=prediction_length, freq=freq, name=TimeSeriesDataFrame.TIMESTAMP)
 
 
 @Deprecated(
@@ -29,7 +28,7 @@ def get_forecast_horizon_index_ts_dataframe(*args, **kwargs) -> pd.MultiIndex:
 def make_future_data_frame(
     ts_dataframe: TimeSeriesDataFrame,
     prediction_length: int,
-    freq: Optional[str] = None,
+    freq: str | None = None,
 ) -> pd.DataFrame:
     """For each item in the dataframe, get timestamps for the next `prediction_length` time steps into the future.
 
@@ -37,14 +36,14 @@ def make_future_data_frame(
     """
     indptr = ts_dataframe.get_indptr()
     last = ts_dataframe.index[indptr[1:] - 1].to_frame(index=False)
-    item_ids = np.repeat(last[ITEMID].to_numpy(), prediction_length)
+    item_ids = np.repeat(last[TimeSeriesDataFrame.ITEMID].to_numpy(), prediction_length)
 
     if freq is None:
         freq = ts_dataframe.freq
     offset = pd.tseries.frequencies.to_offset(freq)
-    last_ts = pd.DatetimeIndex(last[TIMESTAMP])
+    last_ts = pd.DatetimeIndex(last[TimeSeriesDataFrame.TIMESTAMP])
     # Non-vectorized offsets like BusinessDay may produce a PerformanceWarning - we filter them
     with warnings.catch_warnings():
         warnings.simplefilter("ignore", category=pd.errors.PerformanceWarning)
         timestamps = np.dstack([last_ts + step * offset for step in range(1, prediction_length + 1)]).ravel()  # type: ignore[operator]
-    return pd.DataFrame({ITEMID: item_ids, TIMESTAMP: timestamps})
+    return pd.DataFrame({TimeSeriesDataFrame.ITEMID: item_ids, TimeSeriesDataFrame.TIMESTAMP: timestamps})

autogluon/timeseries/utils/timer.py

@@ -0,0 +1,173 @@
+import time
+
+from typing_extensions import Self
+
+
+class Timer:
+    """A timer class that tracks a start time, and computes the time elapsed and
+    time remaining, used for handling ``time_limit`` parameters in AutoGluon.
+
+    Parameters
+    ----------
+    time_limit
+        The time limit to set. If None, then ``time_remaining`` will return None, and
+        ``timed_out`` will return False.
+
+    Examples
+    --------
+    Basic usage with time limit:
+
+    >>> timer = Timer(time_limit=10.0).start()
+    >>> # Do some work...
+    >>> if timer.timed_out():
+    ...     print("Time limit exceeded!")
+    >>> print(f"Time remaining: {timer.time_remaining():.2f}s")
+
+    Using as a stopwatch (no time limit):
+
+    >>> timer = Timer(time_limit=None).start()
+    >>> # Do some work...
+    >>> print(f"Elapsed time: {timer.time_elapsed():.2f}s")
+
+    Checking time in a loop:
+
+    >>> timer = Timer(time_limit=5.0).start()
+    >>> for i in range(100):
+    ...     if timer.timed_out():
+    ...         break
+    ...     # Do work for iteration i
+    """
+
+    def __init__(
+        self,
+        time_limit: float | None,
+    ):
+        self.time_limit = time_limit
+
+        self.start_time = None
+
+    def start(self) -> Self:
+        """Start or reset the timer."""
+        self.start_time = time.monotonic()
+        return self
+
+    def time_elapsed(self) -> float:
+        """Total time elapsed since the timer was started. This method can also be used
+        when ``time_limit`` is set to None to count time forward (i.e., as opposed to
+        a countdown timer which other methods imply).
+        """
+        if self.start_time is None:
+            raise RuntimeError("Timer has not been started")
+        return time.monotonic() - self.start_time
+
+    def time_remaining(self) -> float | None:
+        """Total time remaining on the timer. If ``time_limit`` is None,
+        this method also returns None.
+        """
+        if self.start_time is None:
+            raise RuntimeError("Timer has not been started")
+        if self.time_limit is None:
+            return None
+        return self.time_limit - (time.monotonic() - self.start_time)
+
+    def timed_out(self) -> bool:
+        """Whether the timer has timed out. If ``time_limit`` is None, this method
+        always returns False.
+        """
+        if self.start_time is None:
+            raise RuntimeError("Timer has not been started")
+        if self.time_limit is None:
+            return False
+        return self.time_elapsed() >= self.time_limit
+
+
+class SplitTimer(Timer):
+    """A timer that splits remaining time across multiple rounds.
+
+    Extends Timer to divide the total time limit across a specified number of rounds,
+    useful for allocating time budgets to sequential operations. At each call of
+    ``next_round``, the timer re-distributes the remaining time evenly among
+    the remaining rounds.
+
+    Parameters
+    ----------
+    time_limit
+        Total time limit to split across all rounds. If None, ``round_time_remaining``
+        returns None.
+    rounds
+        Number of rounds to split the time across. Default is 1.
+
+    Examples
+    --------
+    Split time across 3 rounds:
+
+    >>> timer = SplitTimer(time_limit=10.0, rounds=3).start()
+    >>> time_round_1 = timer.round_time_remaining()  # Returns ~3.33
+    >>> # Do work for round 1
+    >>> timer.next_round()
+    >>> time_round_2 = timer.round_time_remaining()  # Returns remaining time divided by 2
+    >>> # Do work for round 2
+    >>> timer.next_round()
+    >>> time_round_3 = timer.round_time_remaining()  # Returns all remaining time
+    """
+
+    def __init__(
+        self,
+        time_limit: float | None,
+        rounds: int = 1,
+    ):
+        super().__init__(time_limit)
+        self.rounds = rounds
+
+        self.round_index: int
+        self.round_start_time: float
+
+    def start(self) -> Self:
+        """Reset and start the timer."""
+        super().start()
+        self.round_index = 0
+        self.round_start_time = time.monotonic()
+        return self
+
+    def round_time_remaining(self) -> float | None:
+        """Get the time budget for the current round.
+
+        Calculates the time allocation by dividing the remaining time equally among
+        the remaining rounds. This means if a previous round used less time than
+        allocated, subsequent rounds get more time, and vice versa.
+
+        Returns time budget for the current round in seconds. Returns None if
+        ``time_limit`` is None. Returns 0.0 if all rounds have been exhausted.
+        """
+        if self.time_limit is None:
+            return None
+        if self.start_time is None:
+            raise RuntimeError("Timer has not been started")
+
+        remaining_rounds = self.rounds - self.round_index
+        if remaining_rounds <= 0:
+            return 0.0
+
+        elapsed_time_at_round_start = self.round_start_time - self.start_time
+        remaining_time_at_round_start = self.time_limit - elapsed_time_at_round_start
+        round_time_budget = remaining_time_at_round_start / remaining_rounds
+
+        return round_time_budget - self.round_time_elapsed()
+
+    def round_time_elapsed(self) -> float:
+        """Total time elapsed since the start of this round."""
+        if self.start_time is None:
+            raise RuntimeError("Timer has not been started")
+        return time.monotonic() - self.round_start_time
+
+    def next_round(self) -> Self:
+        """Advance timer to the next round.
+
+        Increments the round counter, which affects the time allocation returned
+        by subsequent ``round_time_remaining`` calls.
+        """
+        if self.start_time is None:
+            raise RuntimeError("Timer has not been started")
+        self.round_index += 1
+        self.round_start_time = time.monotonic()
+        return self

autogluon/timeseries/version.py

@@ -1,4 +1,4 @@
 """This is the autogluon version file."""
 
-__version__ = "1.4.1b20250907"
+__version__ = "1.5.1b20260122"
 __lite__ = False

autogluon.timeseries-1.5.1b20260122-py3.11-nspkg.pth

@@ -0,0 +1 @@
+import sys, types, os;p = os.path.join(sys._getframe(1).f_locals['sitedir'], *('autogluon',));importlib = __import__('importlib.util');__import__('importlib.machinery');m = sys.modules.setdefault('autogluon', importlib.util.module_from_spec(importlib.machinery.PathFinder.find_spec('autogluon', [os.path.dirname(p)])));m = m or sys.modules.setdefault('autogluon', types.ModuleType('autogluon'));mp = (m or []) and m.__dict__.setdefault('__path__',[]);(p not in mp) and mp.append(p)