autogluon.timeseries 1.3.2b20250624__py3-none-any.whl → 1.3.2b20250626__py3-none-any.whl

autogluon/timeseries/dataset/ts_dataframe.py

@@ -7,9 +7,9 @@ import reprlib
 from collections.abc import Iterable
 from itertools import islice
 from pathlib import Path
-from pprint import pformat
 from typing import TYPE_CHECKING, Any, List, Optional, Tuple, Type, Union, overload
 
+import numpy as np
 import pandas as pd
 from joblib.parallel import Parallel, delayed
 from pandas.core.internals import ArrayManager, BlockManager  # type: ignore
@@ -28,7 +28,7 @@ IRREGULAR_TIME_INDEX_FREQSTR = "IRREG"
 class TimeSeriesDataFrame(pd.DataFrame):
     """A collection of univariate time series, where each row is identified by an (``item_id``, ``timestamp``) pair.
 
-    For example, a time series data frame could represent the daily sales of a collection of products, where each
+    For example, a time series dataframe could represent the daily sales of a collection of products, where each
     ``item_id`` corresponds to a product and ``timestamp`` corresponds to the day of the record.
 
     Parameters
@@ -78,7 +78,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
         You can also use :meth:`~autogluon.timeseries.TimeSeriesDataFrame.from_iterable_dataset` for loading data in such format.
 
     static_features : pd.DataFrame, str or pathlib.Path, optional
-        An optional data frame describing the metadata of each individual time series that does not change with time.
+        An optional dataframe describing the metadata of each individual time series that does not change with time.
         Can take real-valued or categorical values. For example, if ``TimeSeriesDataFrame`` contains sales of various
         products, static features may refer to time-independent features like color or brand.
 
@@ -223,7 +223,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
             raise ValueError(f"for {TIMESTAMP}, the only pandas dtype allowed is `datetime64`.")
         if not data.index.names == (f"{ITEMID}", f"{TIMESTAMP}"):
             raise ValueError(f"data must have index names as ('{ITEMID}', '{TIMESTAMP}'), got {data.index.names}")
-        item_id_index = data.index.get_level_values(level=ITEMID)
+        item_id_index = data.index.levels[0]
         if not (pd.api.types.is_integer_dtype(item_id_index) or pd.api.types.is_string_dtype(item_id_index)):
             raise ValueError(f"all entries in index `{ITEMID}` must be of integer or string dtype")
 
@@ -303,7 +303,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
         Returns
         -------
         ts_df: TimeSeriesDataFrame
-            A data frame in TimeSeriesDataFrame format.
+            A dataframe in TimeSeriesDataFrame format.
         """
         return cls(df, static_features=static_features_df, id_column=id_column, timestamp_column=timestamp_column)
 
@@ -350,7 +350,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
         Returns
         -------
         ts_df: TimeSeriesDataFrame
-            A data frame in TimeSeriesDataFrame format.
+            A dataframe in TimeSeriesDataFrame format.
         """
         return cls(path, static_features=static_features_path, id_column=id_column, timestamp_column=timestamp_column)
 
@@ -379,7 +379,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
         Returns
         -------
         ts_df: TimeSeriesDataFrame
-            A data frame in TimeSeriesDataFrame format.
+            A dataframe in TimeSeriesDataFrame format.
         """
         return cls(iterable_dataset, num_cpus=num_cpus)
 
@@ -469,53 +469,58 @@ class TimeSeriesDataFrame(pd.DataFrame):
             If some items have an irregular frequency or if different items have different frequencies, returns string
             `IRREG`.
         """
+        ts_df = self
+        if num_items is not None and ts_df.num_items > num_items:
+            items_subset = ts_df.item_ids.to_series().sample(n=num_items, random_state=123)
+            ts_df = ts_df.loc[items_subset]
+
+        if not ts_df.index.is_monotonic_increasing:
+            ts_df = ts_df.sort_index()
+
+        indptr = ts_df.get_indptr()
+        item_ids = ts_df.item_ids
+        timestamps = ts_df.index.get_level_values(level=1)
+        candidate_freq = ts_df.index.levels[1].freq
+
+        frequencies = []
+        irregular_items = []
+        for i in range(len(indptr) - 1):
+            start, end = indptr[i], indptr[i + 1]
+            item_timestamps = timestamps[start:end]
+            inferred_freq = item_timestamps.inferred_freq
 
-        df = pd.DataFrame(self)
-        if num_items is not None:
-            all_item_ids = self.item_ids
-            if len(all_item_ids) > num_items:
-                items_subset = all_item_ids.to_series().sample(n=num_items, random_state=123)
-                df = df.loc[items_subset]
-
-        candidate_freq = df.index.levels[1].freq
-        index_df = df.index.to_frame(index=False)
-
-        def get_freq(series: pd.Series) -> Optional[str]:
-            dt_index = pd.DatetimeIndex(series)
-            inferred_freq = dt_index.inferred_freq
             # Fallback option: maybe original index has a `freq` attribute that pandas fails to infer (e.g., 'SME')
             if inferred_freq is None and candidate_freq is not None:
                 try:
                     # If this line does not raise an exception, then candidate_freq is a compatible frequency
-                    dt_index.freq = candidate_freq
+                    item_timestamps.freq = candidate_freq
                 except ValueError:
                     inferred_freq = None
                 else:
                     inferred_freq = candidate_freq.freqstr
-            return inferred_freq
 
-        freq_for_each_item = index_df.groupby(ITEMID, sort=False).agg(get_freq)[TIMESTAMP]
-        freq = freq_for_each_item.iloc[0]
-        if len(set(freq_for_each_item)) > 1 or freq is None:
+            if inferred_freq is None:
+                irregular_items.append(item_ids[i])
+            else:
+                frequencies.append(inferred_freq)
+
+        unique_freqs = list(set(frequencies))
+        if len(unique_freqs) != 1 or len(irregular_items) > 0:
             if raise_if_irregular:
-                items_with_irregular_freq = freq_for_each_item[pd.isnull(freq_for_each_item)]
-                if len(items_with_irregular_freq) > 0:
+                if irregular_items:
                     raise ValueError(
-                        "Cannot infer frequency. Items with irregular frequency: "
-                        f"{pformat(items_with_irregular_freq.index.tolist())}"
+                        f"Cannot infer frequency. Items with irregular frequency: {reprlib.repr(irregular_items)}"
                     )
                 else:
-                    raise ValueError(
-                        "Cannot infer frequency. Multiple frequencies detected in the dataset: "
-                        f"{freq_for_each_item.unique().tolist()}"
-                    )
-            return IRREGULAR_TIME_INDEX_FREQSTR
+                    raise ValueError(f"Cannot infer frequency. Multiple frequencies detected: {unique_freqs}")
+            else:
+                return IRREGULAR_TIME_INDEX_FREQSTR
         else:
-            return pd.tseries.frequencies.to_offset(freq).freqstr
+            return pd.tseries.frequencies.to_offset(unique_freqs[0]).freqstr
 
     @property
     def freq(self):
-        """Inferred pandas-compatible frequency of the timestamps in the data frame.
+        """Inferred pandas-compatible frequency of the timestamps in the dataframe.
 
         Computed using a random subset of the time series for speed. This may sometimes result in incorrectly inferred
         values. For reliable results, use :meth:`~autogluon.timeseries.TimeSeriesDataFrame.infer_frequency`.
@@ -529,8 +534,13 @@ class TimeSeriesDataFrame(pd.DataFrame):
         return len(self.item_ids)
 
     def num_timesteps_per_item(self) -> pd.Series:
-        """Length of each time series in the dataframe."""
-        return self.groupby(level=ITEMID, sort=False).size()
+        """Number of observations in each time series in the dataframe.
+
+        Returns a `pandas.Series` with item_id as index and number of observations per item as values.
+        """
+        counts = pd.Series(self.index.codes[0]).value_counts(sort=False)
+        counts.index = self.index.levels[0][counts.index]
+        return counts
 
     def copy(self: TimeSeriesDataFrame, deep: bool = True) -> TimeSeriesDataFrame:
         """Make a copy of the TimeSeriesDataFrame.
@@ -568,7 +578,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
         Parameters
         ----------
         cutoff_time: pd.Timestamp
-            The time to split the current data frame into two data frames.
+            The time to split the current dataframe into two dataframes.
 
         Returns
         -------
@@ -593,7 +603,8 @@ class TimeSeriesDataFrame(pd.DataFrame):
         This operation is equivalent to selecting a slice ``[start_index : end_index]`` from each time series, and then
         combining these slices into a new ``TimeSeriesDataFrame``. See examples below.
 
-        Returns a copy of the original data. This is useful for constructing holdout sets for validation.
+        It is recommended to sort the index with `ts_df.sort_index()` before calling this method to take advantage of
+        a fast optimized algorithm.
 
         Parameters
         ----------
@@ -680,10 +691,53 @@ class TimeSeriesDataFrame(pd.DataFrame):
         if end_index is not None and not isinstance(end_index, int):
             raise ValueError(f"end_index must be of type int or None (got {type(end_index)})")
 
-        time_step_slice = slice(start_index, end_index)
-        result = self.groupby(level=ITEMID, sort=False, as_index=False).nth(time_step_slice)
-        result.static_features = self.static_features
-        return result
+        if start_index is None and end_index is None:
+            # Return a copy to avoid in-place modification.
+            # self.copy() is much faster than self.loc[ones(len(self), dtype=bool)]
+            return self.copy()
+
+        if self.index.is_monotonic_increasing:
+            # Use a fast optimized algorithm if the index is sorted
+            indptr = self.get_indptr()
+            lengths = np.diff(indptr)
+            starts = indptr[:-1]
+
+            slice_start = (
+                np.zeros_like(lengths)
+                if start_index is None
+                else np.clip(np.where(start_index >= 0, start_index, lengths + start_index), 0, lengths)
+            )
+            slice_end = (
+                lengths.copy()
+                if end_index is None
+                else np.clip(np.where(end_index >= 0, end_index, lengths + end_index), 0, lengths)
+            )
+
+            # Filter out invalid slices where start >= end
+            valid_slices = slice_start < slice_end
+            if not np.any(valid_slices):
+                # Return empty dataframe with same structure
+                return self.loc[np.zeros(len(self), dtype=bool)]
+
+            starts = starts[valid_slices]
+            slice_start = slice_start[valid_slices]
+            slice_end = slice_end[valid_slices]
+
+            # We put 1 at the slice_start index for each item and -1 at the slice_end index for each item.
+            # After we apply cumsum we get the indicator mask selecting values between slice_start and slice_end
+            # cumsum([0, 0, 1, 0, 0, -1, 0]) -> [0, 0, 1, 1, 1, 0, 0]
+            # We need array of size len(self) + 1 in case events[starts + slice_end] tries to access position len(self)
+            events = np.zeros(len(self) + 1, dtype=np.int8)
+            events[starts + slice_start] += 1
+            events[starts + slice_end] -= 1
+            mask = np.cumsum(events)[:-1].astype(bool)
+            # loc[mask] returns a view of the original data - modifying it will produce a SettingWithCopyWarning
+            return self.loc[mask]
+        else:
+            # Fall back to a slow groupby operation
+            result = self.groupby(level=ITEMID, sort=False, as_index=False).nth(slice(start_index, end_index))
+            result.static_features = self.static_features
+            return result
 
     def slice_by_time(self, start_time: pd.Timestamp, end_time: pd.Timestamp) -> TimeSeriesDataFrame:
         """Select a subsequence from each time series between start (inclusive) and end (exclusive) timestamps.
@@ -712,7 +766,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
 
     @classmethod
     def from_pickle(cls, filepath_or_buffer: Any) -> TimeSeriesDataFrame:
-        """Convenience method to read pickled time series data frames. If the read pickle
+        """Convenience method to read pickled time series dataframes. If the read pickle
         file refers to a plain pandas DataFrame, it will be cast to a TimeSeriesDataFrame.
 
         Parameters
@@ -723,7 +777,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
         Returns
         -------
         ts_df : TimeSeriesDataFrame
-            The pickled time series data frame.
+            The pickled time series dataframe.
         """
         try:
             data = pd.read_pickle(filepath_or_buffer)
@@ -734,6 +788,11 @@ class TimeSeriesDataFrame(pd.DataFrame):
     def fill_missing_values(self, method: str = "auto", value: float = 0.0) -> TimeSeriesDataFrame:
         """Fill missing values represented by NaN.
 
+        .. note::
+            This method assumes that the index of the TimeSeriesDataFrame is sorted by [item_id, timestamp].
+
+            If the index is not sorted, this method will log a warning and may produce an incorrect result.
+
         Parameters
         ----------
         method : str, default = "auto"
@@ -876,8 +935,12 @@ class TimeSeriesDataFrame(pd.DataFrame):
         suffix: Optional[str] = None,
     ) -> Tuple[TimeSeriesDataFrame, TimeSeriesDataFrame]:
         """Generate a train/test split from the given dataset.
+
         This method can be used to generate splits for multi-window backtesting.
 
+        .. note::
+            This method automatically sorts the TimeSeriesDataFrame by [item_id, timestamp].
+
         Parameters
         ----------
         prediction_length : int
@@ -921,7 +984,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
         chunk_size: int = 100,
         **kwargs,
     ) -> TimeSeriesDataFrame:
-        """Convert each time series in the data frame to the given frequency.
+        """Convert each time series in the dataframe to the given frequency.
 
         This method is useful for two purposes:
 
@@ -931,7 +994,6 @@ class TimeSeriesDataFrame(pd.DataFrame):
         Standard ``df.groupby(...).resample(...)`` can be extremely slow for large datasets, so we parallelize this
         operation across multiple CPU cores.
 
-
         Parameters
         ----------
         freq : Union[str, pd.DateOffset]
@@ -1044,6 +1106,13 @@ class TimeSeriesDataFrame(pd.DataFrame):
         """Convert `TimeSeriesDataFrame` to a `pandas.DataFrame`"""
         return pd.DataFrame(self)
 
+    def get_indptr(self) -> np.ndarray:
+        """[Advanced] Get a numpy array of shape [num_items + 1] that points to the start and end of each time series.
+
+        This method assumes that the TimeSeriesDataFrame is sorted by [item_id, timestamp].
+        """
+        return np.concatenate([[0], np.cumsum(self.num_timesteps_per_item().to_numpy())]).astype(np.int32)
+
     # inline typing stubs for various overridden methods
     if TYPE_CHECKING:
 

autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -570,7 +570,7 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
         Returns
         -------
         predictions: TimeSeriesDataFrame
-            pandas data frames with a timestamp index, where each input item from the input
+            pandas dataframes with a timestamp index, where each input item from the input
             data is given as a separate forecast item in the dictionary, keyed by the `item_id`s
             of input items.
         """

autogluon/timeseries/models/chronos/pipeline/utils.py

@@ -16,7 +16,7 @@ from transformers import TrainerCallback
 from autogluon.common.loaders.load_s3 import download, list_bucket_prefix_suffix_contains_s3
 from autogluon.core.utils.exceptions import TimeLimitExceeded
 from autogluon.timeseries.dataset.ts_dataframe import TimeSeriesDataFrame
-from autogluon.timeseries.models.gluonts.abstract_gluonts import SimpleGluonTSDataset
+from autogluon.timeseries.models.gluonts.dataset import SimpleGluonTSDataset
 
 if TYPE_CHECKING:
     # TODO: fix the underlying reason for this circular import, the pipeline should handle tokenization
@@ -255,8 +255,7 @@ class ChronosInferenceDataset:
         self.target_array = target_df[target_column].to_numpy(dtype=np.float32)
 
         # store pointer to start:end of each time series
-        cum_sizes = target_df.num_timesteps_per_item().values.cumsum()
-        self.indptr = np.append(0, cum_sizes).astype(np.int32)
+        self.indptr = target_df.get_indptr()
 
     def __len__(self):
         return len(self.indptr) - 1  # noqa

autogluon/timeseries/models/gluonts/__init__.py

@@ -1,4 +1,4 @@
-from .torch.models import (
+from .models import (
     DeepARModel,
     DLinearModel,
     PatchTSTModel,

autogluon/timeseries/models/gluonts/{abstract_gluonts.py → abstract.py}

@@ -3,7 +3,7 @@ import os
 import shutil
 from datetime import timedelta
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Dict, Iterator, List, Optional, Type, Union, cast, overload
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Type, Union, cast, overload
 
 import gluonts
 import gluonts.core.settings
@@ -11,7 +11,6 @@ import numpy as np
 import pandas as pd
 from gluonts.core.component import from_hyperparameters
 from gluonts.dataset.common import Dataset as GluonTSDataset
-from gluonts.dataset.field_names import FieldName
 from gluonts.env import env as gluonts_env
 from gluonts.model.estimator import Estimator as GluonTSEstimator
 from gluonts.model.forecast import Forecast, QuantileForecast, SampleForecast
@@ -22,14 +21,15 @@ from autogluon.core.hpo.constants import RAY_BACKEND
 from autogluon.tabular.models.tabular_nn.utils.categorical_encoders import (
     OneHotMergeRaresHandleUnknownEncoder as OneHotEncoder,
 )
-from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TIMESTAMP, TimeSeriesDataFrame
+from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TimeSeriesDataFrame
 from autogluon.timeseries.models.abstract import AbstractTimeSeriesModel
-from autogluon.timeseries.utils.datetime import norm_freq_str
 from autogluon.timeseries.utils.warning_filters import disable_root_logger, warning_filter
 
 if TYPE_CHECKING:
     from gluonts.torch.model.forecast import DistributionForecast
 
+from .dataset import SimpleGluonTSDataset
+
 # NOTE: We avoid imports for torch and lightning.pytorch at the top level and hide them inside class methods.
 # This is done to skip these imports during multiprocessing (which may cause bugs)
 
@@ -37,109 +37,6 @@ logger = logging.getLogger(__name__)
 gts_logger = logging.getLogger(gluonts.__name__)
 
 
-class SimpleGluonTSDataset(GluonTSDataset):
-    """Wrapper for TimeSeriesDataFrame that is compatible with the GluonTS Dataset API."""
-
-    def __init__(
-        self,
-        target_df: TimeSeriesDataFrame,
-        freq: str,
-        target_column: str = "target",
-        feat_static_cat: Optional[np.ndarray] = None,
-        feat_static_real: Optional[np.ndarray] = None,
-        feat_dynamic_cat: Optional[np.ndarray] = None,
-        feat_dynamic_real: Optional[np.ndarray] = None,
-        past_feat_dynamic_cat: Optional[np.ndarray] = None,
-        past_feat_dynamic_real: Optional[np.ndarray] = None,
-        includes_future: bool = False,
-        prediction_length: Optional[int] = None,
-    ):
-        assert target_df is not None
-        # Convert TimeSeriesDataFrame to pd.Series for faster processing
-        self.target_array = target_df[target_column].to_numpy(np.float32)
-        self.feat_static_cat = self._astype(feat_static_cat, dtype=np.int64)
-        self.feat_static_real = self._astype(feat_static_real, dtype=np.float32)
-        self.feat_dynamic_cat = self._astype(feat_dynamic_cat, dtype=np.int64)
-        self.feat_dynamic_real = self._astype(feat_dynamic_real, dtype=np.float32)
-        self.past_feat_dynamic_cat = self._astype(past_feat_dynamic_cat, dtype=np.int64)
-        self.past_feat_dynamic_real = self._astype(past_feat_dynamic_real, dtype=np.float32)
-        self.freq = self._get_freq_for_period(freq)
-
-        # Necessary to compute indptr for known_covariates at prediction time
-        self.includes_future = includes_future
-        self.prediction_length = prediction_length
-
-        # Replace inefficient groupby ITEMID with indptr that stores start:end of each time series
-        item_id_index = target_df.index.get_level_values(ITEMID)
-        indices_sizes = item_id_index.value_counts(sort=False)
-        self.item_ids = indices_sizes.index  # shape [num_items]
-        cum_sizes = indices_sizes.to_numpy().cumsum()
-        self.indptr = np.append(0, cum_sizes).astype(np.int32)
-        self.start_timestamps = target_df.reset_index(TIMESTAMP).groupby(level=ITEMID, sort=False).first()[TIMESTAMP]
-        assert len(self.item_ids) == len(self.start_timestamps)
-
-    @staticmethod
-    def _astype(array: Optional[np.ndarray], dtype: Type[np.generic]) -> Optional[np.ndarray]:
-        if array is None:
-            return None
-        else:
-            return array.astype(dtype)
-
-    @staticmethod
-    def _get_freq_for_period(freq: str) -> str:
-        """Convert freq to format compatible with pd.Period.
-
-        For example, ME freq must be converted to M when creating a pd.Period.
-        """
-        offset = pd.tseries.frequencies.to_offset(freq)
-        assert offset is not None
-        freq_name = norm_freq_str(offset)
-        if freq_name == "SME":
-            # Replace unsupported frequency "SME" with "2W"
-            return "2W"
-        elif freq_name == "bh":
-            # Replace unsupported frequency "bh" with dummy value "Y"
-            return "Y"
-        else:
-            freq_name_for_period = {"YE": "Y", "QE": "Q", "ME": "M"}.get(freq_name, freq_name)
-            return f"{offset.n}{freq_name_for_period}"
-
-    def __len__(self):
-        return len(self.indptr) - 1  # noqa
-
-    def __iter__(self) -> Iterator[Dict[str, Any]]:
-        for j in range(len(self.indptr) - 1):
-            start_idx = self.indptr[j]
-            end_idx = self.indptr[j + 1]
-            # GluonTS expects item_id to be a string
-            ts = {
-                FieldName.ITEM_ID: str(self.item_ids[j]),
-                FieldName.START: pd.Period(self.start_timestamps.iloc[j], freq=self.freq),
-                FieldName.TARGET: self.target_array[start_idx:end_idx],
-            }
-            if self.feat_static_cat is not None:
-                ts[FieldName.FEAT_STATIC_CAT] = self.feat_static_cat[j]
-            if self.feat_static_real is not None:
-                ts[FieldName.FEAT_STATIC_REAL] = self.feat_static_real[j]
-            if self.past_feat_dynamic_cat is not None:
-                ts[FieldName.PAST_FEAT_DYNAMIC_CAT] = self.past_feat_dynamic_cat[start_idx:end_idx].T
-            if self.past_feat_dynamic_real is not None:
-                ts[FieldName.PAST_FEAT_DYNAMIC_REAL] = self.past_feat_dynamic_real[start_idx:end_idx].T
-
-            # Dynamic features that may extend into the future
-            if self.includes_future:
-                assert self.prediction_length is not None, (
-                    "Prediction length must be provided if includes_future is True"
-                )
-                start_idx = start_idx + j * self.prediction_length
-                end_idx = end_idx + (j + 1) * self.prediction_length
-            if self.feat_dynamic_cat is not None:
-                ts[FieldName.FEAT_DYNAMIC_CAT] = self.feat_dynamic_cat[start_idx:end_idx].T
-            if self.feat_dynamic_real is not None:
-                ts[FieldName.FEAT_DYNAMIC_REAL] = self.feat_dynamic_real[start_idx:end_idx].T
-            yield ts
-
-
 class AbstractGluonTSModel(AbstractTimeSeriesModel):
     """Abstract class wrapping GluonTS estimators for use in autogluon.timeseries.
 

autogluon/timeseries/models/gluonts/dataset.py

@@ -0,0 +1,109 @@
+from typing import Any, Dict, Iterator, Optional, Type
+
+import numpy as np
+import pandas as pd
+from gluonts.dataset.common import Dataset as GluonTSDataset
+from gluonts.dataset.field_names import FieldName
+
+from autogluon.timeseries.dataset.ts_dataframe import TIMESTAMP, TimeSeriesDataFrame
+from autogluon.timeseries.utils.datetime import norm_freq_str
+
+
+class SimpleGluonTSDataset(GluonTSDataset):
+    """Wrapper for TimeSeriesDataFrame that is compatible with the GluonTS Dataset API."""
+
+    def __init__(
+        self,
+        target_df: TimeSeriesDataFrame,
+        freq: str,
+        target_column: str = "target",
+        feat_static_cat: Optional[np.ndarray] = None,
+        feat_static_real: Optional[np.ndarray] = None,
+        feat_dynamic_cat: Optional[np.ndarray] = None,
+        feat_dynamic_real: Optional[np.ndarray] = None,
+        past_feat_dynamic_cat: Optional[np.ndarray] = None,
+        past_feat_dynamic_real: Optional[np.ndarray] = None,
+        includes_future: bool = False,
+        prediction_length: Optional[int] = None,
+    ):
+        assert target_df is not None
+        # Convert TimeSeriesDataFrame to pd.Series for faster processing
+        self.target_array = target_df[target_column].to_numpy(np.float32)
+        self.feat_static_cat = self._astype(feat_static_cat, dtype=np.int64)
+        self.feat_static_real = self._astype(feat_static_real, dtype=np.float32)
+        self.feat_dynamic_cat = self._astype(feat_dynamic_cat, dtype=np.int64)
+        self.feat_dynamic_real = self._astype(feat_dynamic_real, dtype=np.float32)
+        self.past_feat_dynamic_cat = self._astype(past_feat_dynamic_cat, dtype=np.int64)
+        self.past_feat_dynamic_real = self._astype(past_feat_dynamic_real, dtype=np.float32)
+        self.freq = self._get_freq_for_period(freq)
+
+        # Necessary to compute indptr for known_covariates at prediction time
+        self.includes_future = includes_future
+        self.prediction_length = prediction_length
+
+        # Replace inefficient groupby ITEMID with indptr that stores start:end of each time series
+        self.item_ids = target_df.item_ids
+        self.indptr = target_df.get_indptr()
+        self.start_timestamps = target_df.index[self.indptr[:-1]].to_frame(index=False)[TIMESTAMP]
+        assert len(self.item_ids) == len(self.start_timestamps)
+
+    @staticmethod
+    def _astype(array: Optional[np.ndarray], dtype: Type[np.generic]) -> Optional[np.ndarray]:
+        if array is None:
+            return None
+        else:
+            return array.astype(dtype)
+
+    @staticmethod
+    def _get_freq_for_period(freq: str) -> str:
+        """Convert freq to format compatible with pd.Period.
+
+        For example, ME freq must be converted to M when creating a pd.Period.
+        """
+        offset = pd.tseries.frequencies.to_offset(freq)
+        assert offset is not None
+        freq_name = norm_freq_str(offset)
+        if freq_name == "SME":
+            # Replace unsupported frequency "SME" with "2W"
+            return "2W"
+        elif freq_name == "bh":
+            # Replace unsupported frequency "bh" with dummy value "Y"
+            return "Y"
+        else:
+            freq_name_for_period = {"YE": "Y", "QE": "Q", "ME": "M"}.get(freq_name, freq_name)
+            return f"{offset.n}{freq_name_for_period}"
+
+    def __len__(self):
+        return len(self.indptr) - 1  # noqa
+
+    def __iter__(self) -> Iterator[Dict[str, Any]]:
+        for j in range(len(self.indptr) - 1):
+            start_idx = self.indptr[j]
+            end_idx = self.indptr[j + 1]
+            # GluonTS expects item_id to be a string
+            ts = {
+                FieldName.ITEM_ID: str(self.item_ids[j]),
+                FieldName.START: pd.Period(self.start_timestamps.iloc[j], freq=self.freq),
+                FieldName.TARGET: self.target_array[start_idx:end_idx],
+            }
+            if self.feat_static_cat is not None:
+                ts[FieldName.FEAT_STATIC_CAT] = self.feat_static_cat[j]
+            if self.feat_static_real is not None:
+                ts[FieldName.FEAT_STATIC_REAL] = self.feat_static_real[j]
+            if self.past_feat_dynamic_cat is not None:
+                ts[FieldName.PAST_FEAT_DYNAMIC_CAT] = self.past_feat_dynamic_cat[start_idx:end_idx].T
+            if self.past_feat_dynamic_real is not None:
+                ts[FieldName.PAST_FEAT_DYNAMIC_REAL] = self.past_feat_dynamic_real[start_idx:end_idx].T
+
+            # Dynamic features that may extend into the future
+            if self.includes_future:
+                assert self.prediction_length is not None, (
+                    "Prediction length must be provided if includes_future is True"
+                )
+                start_idx = start_idx + j * self.prediction_length
+                end_idx = end_idx + (j + 1) * self.prediction_length
+            if self.feat_dynamic_cat is not None:
+                ts[FieldName.FEAT_DYNAMIC_CAT] = self.feat_dynamic_cat[start_idx:end_idx].T
+            if self.feat_dynamic_real is not None:
+                ts[FieldName.FEAT_DYNAMIC_REAL] = self.feat_dynamic_real[start_idx:end_idx].T
+            yield ts

autogluon/timeseries/models/gluonts/{torch/models.py → models.py}

@@ -7,13 +7,14 @@ from typing import Any, Dict, Type
 
 from gluonts.model.estimator import Estimator as GluonTSEstimator
 
-from autogluon.timeseries.models.gluonts.abstract_gluonts import AbstractGluonTSModel
 from autogluon.timeseries.utils.datetime import (
     get_lags_for_frequency,
     get_seasonality,
     get_time_features_for_frequency,
 )
 
+from .abstract import AbstractGluonTSModel
+
 # NOTE: We avoid imports for torch and lightning.pytorch at the top level and hide them inside class methods.
 # This is done to skip these imports during multiprocessing (which may cause bugs)
 

autogluon/timeseries/models/local/abstract_local_model.py

@@ -136,9 +136,12 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
         self._dummy_forecast = self._get_dummy_forecast(train_data)
         return self
 
-    def _get_dummy_forecast(self, train_data: TimeSeriesDataFrame) -> pd.DataFrame:
+    def _get_dummy_forecast(self, train_data: TimeSeriesDataFrame, max_num_rows: int = 20_000) -> pd.DataFrame:
         agg_functions = ["mean"] + [get_quantile_function(q) for q in self.quantile_levels]
-        stats_marginal = train_data[self.target].agg(agg_functions)
+        target_series = train_data[self.target]
+        if len(target_series) > max_num_rows:
+            target_series = target_series.sample(max_num_rows, replace=True)
+        stats_marginal = target_series.agg(agg_functions)
         stats_repeated = np.tile(stats_marginal.values, [self.prediction_length, 1])
         return pd.DataFrame(stats_repeated, columns=stats_marginal.index)
 
@@ -150,10 +153,11 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
         max_ts_length = model_params["max_ts_length"]
         if max_ts_length is not None:
             logger.debug(f"Shortening all time series to at most {max_ts_length}")
-            data = data.groupby(level=ITEMID, sort=False).tail(max_ts_length)
+            data = data.slice_by_timestep(-max_ts_length, None)
 
-        df = pd.DataFrame(data).reset_index(level=ITEMID)
-        all_series = (ts for _, ts in df.groupby(by=ITEMID, as_index=False, sort=False)[self.target])
+        indptr = data.get_indptr()
+        target_series = data[self.target].droplevel(level=ITEMID)
+        all_series = (target_series[indptr[i] : indptr[i + 1]] for i in range(len(indptr) - 1))
 
         # timeout ensures that no individual job takes longer than time_limit
         # TODO: a job started late may still exceed time_limit - how to prevent that?

autogluon/timeseries/models/local/naive.py

@@ -70,7 +70,7 @@ class SeasonalNaiveModel(AbstractLocalModel):
 
     def _predict_with_local_model(
         self,
-        time_series: np.ndarray,
+        time_series: pd.Series,
         local_model_args: dict,
     ) -> pd.DataFrame:
         return seasonal_naive_forecast(

autogluon/timeseries/predictor.py

@@ -108,7 +108,7 @@ class TimeSeriesPredictor:
 
         If ``known_covariates_names`` are provided, then:
 
-        - :meth:`~autogluon.timeseries.TimeSeriesPredictor.fit`, :meth:`~autogluon.timeseries.TimeSeriesPredictor.evaluate`, and :meth:`~autogluon.timeseries.TimeSeriesPredictor.leaderboard` will expect a data frame with columns listed in ``known_covariates_names`` (in addition to the ``target`` column).
+        - :meth:`~autogluon.timeseries.TimeSeriesPredictor.fit`, :meth:`~autogluon.timeseries.TimeSeriesPredictor.evaluate`, and :meth:`~autogluon.timeseries.TimeSeriesPredictor.leaderboard` will expect a dataframe with columns listed in ``known_covariates_names`` (in addition to the ``target`` column).
         - :meth:`~autogluon.timeseries.TimeSeriesPredictor.predict` will expect an additional keyword argument ``known_covariates`` containing the future values of the known covariates in ``TimeSeriesDataFrame`` format.
 
     quantile_levels : List[float], optional
@@ -284,7 +284,7 @@ class TimeSeriesPredictor:
         Parameters
         ----------
         data : Union[TimeSeriesDataFrame, pd.DataFrame, Path, str]
-            Data as a data frame or path to file storing the data.
+            Data as a dataframe or path to file storing the data.
         name : str
             Name of the data that will be used in log messages (e.g., 'train_data', 'tuning_data', or 'data').
 
@@ -809,7 +809,7 @@ class TimeSeriesPredictor:
             - Must include ``timestamp`` values for the full forecast horizon (i.e., ``prediction_length`` time steps) following the end of each series in the input ``data``.
 
             You can use :meth:`autogluon.timeseries.TimeSeriesPredictor.make_future_data_frame` to generate a template
-            containing the required ``item_id`` and ``timestamp`` combinations for the `known_covariates` data frame.
+            containing the required ``item_id`` and ``timestamp`` combinations for the `known_covariates` dataframe.
 
             See example below.
         model : str, optional
@@ -1230,7 +1230,7 @@ class TimeSeriesPredictor:
         **kwargs,
     ) -> pd.DataFrame:
         """Return a leaderboard showing the performance of every trained model, the output is a
-        pandas data frame with columns:
+        pandas dataframe with columns:
 
         * ``model``: The name of the model.
         * ``score_test``: The test score of the model on ``data``, if provided. Computed according to ``eval_metric``.
@@ -1315,7 +1315,7 @@ class TimeSeriesPredictor:
         return leaderboard
 
     def make_future_data_frame(self, data: Union[TimeSeriesDataFrame, pd.DataFrame, Path, str]) -> pd.DataFrame:
-        """Generate a data frame with the `item_id` and `timestamp` values corresponding to the forecast horizon.
+        """Generate a dataframe with the `item_id` and `timestamp` values corresponding to the forecast horizon.
 
         Parameters
         ----------

autogluon/timeseries/utils/features.py

@@ -406,7 +406,7 @@ class AbstractFeatureImportanceTransform:
         if feature_name not in self.covariate_metadata.all_features:
             raise ValueError(f"Target feature {feature_name} not found in covariate metadata")
 
-        # feature transform works on a shallow copy of the main time series data frame
+        # feature transform works on a shallow copy of the main time series dataframe
         # but a deep copy of the static features.
         data = data.copy(deep=False)
 

autogluon/timeseries/utils/forecast.py

@@ -35,7 +35,8 @@ def make_future_data_frame(
 
     Returns a pandas.DataFrame, with columns "item_id" and "timestamp" corresponding to the forecast horizon.
     """
-    last = ts_dataframe.reset_index()[[ITEMID, TIMESTAMP]].groupby(by=ITEMID, sort=False, as_index=False).last()
+    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)
 
     if freq is None:

autogluon/timeseries/version.py

@@ -1,4 +1,4 @@
 """This is the autogluon version file."""
 
-__version__ = "1.3.2b20250624"
+__version__ = "1.3.2b20250626"
 __lite__ = False

{autogluon.timeseries-1.3.2b20250624.dist-info → autogluon.timeseries-1.3.2b20250626.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.3.2b20250624
+Version: 1.3.2b20250626
 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.3.2b20250624
-Requires-Dist: autogluon.common==1.3.2b20250624
-Requires-Dist: autogluon.features==1.3.2b20250624
-Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.3.2b20250624
+Requires-Dist: autogluon.core[raytune]==1.3.2b20250626
+Requires-Dist: autogluon.common==1.3.2b20250626
+Requires-Dist: autogluon.features==1.3.2b20250626
+Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.3.2b20250626
 Provides-Extra: all
 Provides-Extra: chronos-onnx
 Requires-Dist: optimum[onnxruntime]<1.23,>=1.17; extra == "chronos-onnx"

{autogluon.timeseries-1.3.2b20250624.dist-info → autogluon.timeseries-1.3.2b20250626.dist-info}/RECORD

@@ -1,16 +1,16 @@
-autogluon.timeseries-1.3.2b20250624-py3.9-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
+autogluon.timeseries-1.3.2b20250626-py3.9-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
 autogluon/timeseries/__init__.py,sha256=_CrLLc1fkjen7UzWoO0Os8WZoHOgvZbHKy46I8v_4k4,304
 autogluon/timeseries/evaluator.py,sha256=l642tYfTHsl8WVIq_vV6qhgAFVFr9UuZD7gLra3A_Kc,250
 autogluon/timeseries/learner.py,sha256=pIn4YSOk0aqCWyBpIlwnAsFnG4h7PLXk8guFH3wFS-w,13923
-autogluon/timeseries/predictor.py,sha256=Dz-LJVU5sjlFCOqHTeYPt77DuGavdAXB0DkclpM55rY,88173
+autogluon/timeseries/predictor.py,sha256=u4d7-xMs669g5xxqIYuvEyGQ0P6Y8IoToiyg9zUZoy4,88168
 autogluon/timeseries/regressor.py,sha256=ozlhO-wce6YEtSMj0bfMgfNVeblfU3rI6ITuIk_WAFo,11868
 autogluon/timeseries/splitter.py,sha256=yzPca9p2bWV-_VJAptUyyzQsxu-uixAdpMoGQtDzMD4,3205
 autogluon/timeseries/trainer.py,sha256=4T7y58P3RImDbRZn-Og2qSQtOLpEocwdHi_tl1yt0Sc,58021
-autogluon/timeseries/version.py,sha256=UEJ7h9MzyXYPRR-OeEpNfrN3hoqD3VlyD4RcaxwT2k4,91
+autogluon/timeseries/version.py,sha256=5dMBYnKftwwZVY-S-rLR9v1qoLZO3N1-0AEIXvncohs,91
 autogluon/timeseries/configs/__init__.py,sha256=BTtHIPCYeGjqgOcvqb8qPD4VNX-ICKOg6wnkew1cPOE,98
 autogluon/timeseries/configs/presets_configs.py,sha256=cLat8ecLlWrI-SC5KLBDCX2SbVXaucemy2pjxJAtSY0,2543
 autogluon/timeseries/dataset/__init__.py,sha256=UvnhAN5tjgxXTHoZMQDy64YMDj4Xxa68yY7NP4vAw0o,81
-autogluon/timeseries/dataset/ts_dataframe.py,sha256=W3VE65lFyWmqMQ3XHN4Jhrqf_dO1EOLneNL2QDvVxeY,48120
+autogluon/timeseries/dataset/ts_dataframe.py,sha256=pvL85NCrwcIYr7lxFzY2NZ57yUL82nl6Ypdm1z3ho04,51193
 autogluon/timeseries/metrics/__init__.py,sha256=wfqEf2AiaqCcFGXVGhpNrbo1XBQFmJCS8gRa8Qk2L50,3602
 autogluon/timeseries/metrics/abstract.py,sha256=BpHVmzkzM6EN63NQrDRkApIeAyrpT6Y9LZiPEygaxvE,11829
 autogluon/timeseries/metrics/point.py,sha256=xllyGh11otbmUVHyIaceROPR3qyllWPQ9xlSmIGI3EI,18306
@@ -19,7 +19,7 @@ autogluon/timeseries/metrics/utils.py,sha256=HuDe1BNe8yJU4f_DKM913nNrUueoRaw6zhx
 autogluon/timeseries/models/__init__.py,sha256=MYD9JJ-wUDE5B6jW6E6LU2eXQ6vflfQBvqQJkdzJa3A,1189
 autogluon/timeseries/models/presets.py,sha256=HEACiRpnY6dcff7W44gnM0x1KRgr2bNf5D6zcaHgHxo,12201
 autogluon/timeseries/models/abstract/__init__.py,sha256=Htfkjjc3vo92RvyM8rIlQ0PLWt3jcrCKZES07UvCMV0,146
-autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=94TG7tsdfENP41QATr4IeMofaFt8ySjrrrH4MxZZ3Xc,32104
+autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=v4qgHYGmktNz-rY-qCgZjm1n1aOQ6F_OOZIpBsw46hc,32103
 autogluon/timeseries/models/abstract/model_trial.py,sha256=ENPg_7nsdxIvaNM0o0UShZ3x8jFlRmwRc5m0fGPC0TM,3720
 autogluon/timeseries/models/abstract/tunable.py,sha256=SFl4vjkb6BfFFaRPVdftnnLYlIyCThutLHxiiAlV6tY,7168
 autogluon/timeseries/models/autogluon_tabular/__init__.py,sha256=r9i6jWcyeLHYClkcMSKRVsfrkBUMxpDrTATNTBc_qgQ,136
@@ -32,18 +32,18 @@ autogluon/timeseries/models/chronos/pipeline/__init__.py,sha256=bkTR0LSKIxAaKFOr
 autogluon/timeseries/models/chronos/pipeline/base.py,sha256=14OAKHmio6LmO4mVom2mPGB0CvIrOjMGJzb-MVSAq-s,5596
 autogluon/timeseries/models/chronos/pipeline/chronos.py,sha256=uFJLsSb2WQiSrmDZ0g2mO-lhTFUlq7vplGRBXZ9_VBk,22591
 autogluon/timeseries/models/chronos/pipeline/chronos_bolt.py,sha256=kNIDesojKB3rbEK9jM8st4k7ZeaT6tz1znf4PsRDv2Q,20066
-autogluon/timeseries/models/chronos/pipeline/utils.py,sha256=dtDX5Pyu95bGv7qmqgfUc1iYowWPY84dnGN0uyqyHyQ,13131
+autogluon/timeseries/models/chronos/pipeline/utils.py,sha256=rWqT3DB9upZb7GFVMOxc-ww2EhH8bD7TmEZNi_xTAbE,13033
 autogluon/timeseries/models/ensemble/__init__.py,sha256=x2Y6dWk15XugTEWNUKq8U5z6nIjelo3UjpI-TfS13OE,159
 autogluon/timeseries/models/ensemble/abstract.py,sha256=ie-BKD4JIkQQoKqtf6sYI5Aix7dSgywFsSdeGPxoElk,5821
 autogluon/timeseries/models/ensemble/basic.py,sha256=BRPWg_Wgfb87iInFSoTRE75BRHaovRR5HFRvzxET_wU,3423
 autogluon/timeseries/models/ensemble/greedy.py,sha256=fKVLtnaJZ03zrfr9yqxvyA5IdiMtFL6TQidqw0BoqkU,7220
-autogluon/timeseries/models/gluonts/__init__.py,sha256=asC1PTj4j9xMbilvk1IT1julnpeoKbv5ZNuAR6-DFgA,361
-autogluon/timeseries/models/gluonts/abstract_gluonts.py,sha256=35T8rty6sPGiaSFNpiVNmeseo1_qpn664UcWo92W5eI,32906
-autogluon/timeseries/models/gluonts/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autogluon/timeseries/models/gluonts/torch/models.py,sha256=f7IicZzLAN2v_9y3Pxt9G6f48xIzmDjb1U5k44hS3O0,25760
+autogluon/timeseries/models/gluonts/__init__.py,sha256=YfyNYOkhhNsloA4MAavfmqKO29_q6o4lwPoV7L4_h7M,355
+autogluon/timeseries/models/gluonts/abstract.py,sha256=ae-VGN2KY6W8RtzZH3wxhjUP-aMjdWZrZbAPOIYh-1Y,27808
+autogluon/timeseries/models/gluonts/dataset.py,sha256=I_4Rq2CXiLiiSf99WYYaRfT7NXEUmlkW1JIZnWjAdLY,5121
+autogluon/timeseries/models/gluonts/models.py,sha256=Pi_zCRkslt2-LXkZpE56aRx9J4gRCOVabqYltPtI9tE,25718
 autogluon/timeseries/models/local/__init__.py,sha256=e2UImoJhmj70E148IIObv90C_bHxgyLNk6YsS4p7pfs,701
-autogluon/timeseries/models/local/abstract_local_model.py,sha256=VP-yP5Rx93Kb6ine1d5lBe6fRbeZcGG3hBn-AoL4OqQ,11841
-autogluon/timeseries/models/local/naive.py,sha256=BhXxL52-_i4Xynx-spfZMkRejofFPpknggS35_aQSwc,7253
+autogluon/timeseries/models/local/abstract_local_model.py,sha256=0apyzut7Vs3jElsR1YipMqRQrskgrZu6kJFs-k4DB0g,12053
+autogluon/timeseries/models/local/naive.py,sha256=SMdA2Tu-o7gfOLhOoh5m1oe85F3LXn9ulTzRXFhLH20,7252
 autogluon/timeseries/models/local/npts.py,sha256=Bp74doKnfpGE8ywP4FWOCI_RwRMsmgocYDfGtq764DA,4143
 autogluon/timeseries/models/local/statsforecast.py,sha256=s3Byp7WAUy0Rnfl1qYMSIm44MKD9t8E732xuNLk_aao,32615
 autogluon/timeseries/models/multi_window/__init__.py,sha256=Bq7AT2Jxdd4WNqmjTdzeqgNiwn1NCyWp4tBIWaM-zfI,60
@@ -52,19 +52,19 @@ autogluon/timeseries/transforms/__init__.py,sha256=fKlT4pkJ_8Gl7IUTc3uSDzt2Xow5i
 autogluon/timeseries/transforms/covariate_scaler.py,sha256=G56PTHKqCFKiXRKLkLun7mN3-T09jxN-5oI1ISADJdQ,7042
 autogluon/timeseries/transforms/target_scaler.py,sha256=BeT1aP51Wq9EidxC0dVg6dHvampKafpG1uKu4ZaaJPs,6050
 autogluon/timeseries/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autogluon/timeseries/utils/features.py,sha256=7gyRkuD2sMwJivF6O_bW7kADJBnCbBM055CnwkoU94I,22658
-autogluon/timeseries/utils/forecast.py,sha256=vd0Y5YsHU6awu4E7xyDXQGe21P1aB26gwFsA3m09mKw,2197
+autogluon/timeseries/utils/features.py,sha256=OeMvwVX4D2kwoFjuj0RZYZ7MgcbaeBjV97Ud1aUdvNc,22657
+autogluon/timeseries/utils/forecast.py,sha256=yK1_eNtRUPYGs0R-VWMO4c81LrTGF57ih3yzsXVHyGY,2191
 autogluon/timeseries/utils/warning_filters.py,sha256=tHvhj9y7c3MP6JrjAedc7UiFFw0_mKYziDQupw8NhiQ,2538
 autogluon/timeseries/utils/datetime/__init__.py,sha256=bTMR8jLh1LW55vHjbOr1zvWRMF_PqbvxpS-cUcNIDWI,173
 autogluon/timeseries/utils/datetime/base.py,sha256=3NdsH3NDq4cVAOSoy3XpaNixyNlbjy4DJ_YYOGuu9x4,1341
 autogluon/timeseries/utils/datetime/lags.py,sha256=gQDk5_zmsY5DUWDUpSaCKYkQ9nHKKY-LsywJQRAoYSk,5988
 autogluon/timeseries/utils/datetime/seasonality.py,sha256=YK_2k8hvYIMW-sJPnjGWRtCnvIOthwA2hATB3nwVoD4,834
 autogluon/timeseries/utils/datetime/time_features.py,sha256=MjLi3zQ00uWWJtXH9oGX2GJkTbvjdSiuabSa4kcVuxE,2672
-autogluon.timeseries-1.3.2b20250624.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-autogluon.timeseries-1.3.2b20250624.dist-info/METADATA,sha256=QLbYt4MsNYmLGSGUbIPfk2wetYO9dBAcYwRoGNGyRPA,12737
-autogluon.timeseries-1.3.2b20250624.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
-autogluon.timeseries-1.3.2b20250624.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-autogluon.timeseries-1.3.2b20250624.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.3.2b20250624.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.3.2b20250624.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon.timeseries-1.3.2b20250624.dist-info/RECORD,,
+autogluon.timeseries-1.3.2b20250626.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+autogluon.timeseries-1.3.2b20250626.dist-info/METADATA,sha256=6N5dVqfXWEyWkgMGkH3IJLrMj26LQ0nvFlKzwSg87u4,12737
+autogluon.timeseries-1.3.2b20250626.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
+autogluon.timeseries-1.3.2b20250626.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+autogluon.timeseries-1.3.2b20250626.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.3.2b20250626.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.3.2b20250626.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+autogluon.timeseries-1.3.2b20250626.dist-info/RECORD,,