autogluon.timeseries 1.2.1b20250224__py3-none-any.whl → 1.4.1b20251215__py3-none-any.whl

autogluon/timeseries/utils/features.py

@@ -1,8 +1,8 @@
 import logging
 import reprlib
 import time
-from dataclasses import dataclass, field
-from typing import Any, List, Literal, Optional, Tuple
+from dataclasses import asdict, dataclass, field
+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__)
@@ -24,49 +24,60 @@ logger = logging.getLogger(__name__)
 class CovariateMetadata:
     """Provides mapping from different covariate types to columns in the dataset."""
 
-    static_features_cat: List[str] = field(default_factory=list)
-    static_features_real: List[str] = field(default_factory=list)
-    known_covariates_real: List[str] = field(default_factory=list)
-    known_covariates_cat: List[str] = field(default_factory=list)
-    past_covariates_real: List[str] = field(default_factory=list)
-    past_covariates_cat: List[str] = field(default_factory=list)
+    static_features_cat: list[str] = field(default_factory=list)
+    static_features_real: list[str] = field(default_factory=list)
+    known_covariates_real: list[str] = field(default_factory=list)
+    known_covariates_cat: list[str] = field(default_factory=list)
+    past_covariates_real: list[str] = field(default_factory=list)
+    past_covariates_cat: list[str] = field(default_factory=list)
+    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]:
+    def static_features(self) -> list[str]:
         return self.static_features_cat + self.static_features_real
 
     @property
-    def known_covariates(self) -> List[str]:
+    def known_covariates(self) -> list[str]:
         return self.known_covariates_cat + self.known_covariates_real
 
     @property
-    def past_covariates(self) -> List[str]:
+    def past_covariates(self) -> list[str]:
         return self.past_covariates_cat + self.past_covariates_real
 
     @property
-    def covariates(self) -> List[str]:
+    def covariates(self) -> list[str]:
         return self.known_covariates + self.past_covariates
 
     @property
-    def covariates_real(self) -> List[str]:
+    def covariates_real(self) -> list[str]:
         return self.known_covariates_real + self.past_covariates_real
 
     @property
-    def covariates_cat(self) -> List[str]:
+    def covariates_cat(self) -> list[str]:
         return self.known_covariates_cat + self.past_covariates_cat
 
     @property
-    def real_features(self) -> List[str]:
+    def real_features(self) -> list[str]:
         return self.static_features_real + self.covariates_real
 
     @property
-    def cat_features(self) -> List[str]:
+    def cat_features(self) -> list[str]:
         return self.static_features_cat + self.covariates_cat
 
     @property
-    def all_features(self) -> List[str]:
+    def all_features(self) -> list[str]:
         return self.static_features + self.covariates
 
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
 
 class ContinuousAndCategoricalFeatureGenerator(PipelineFeatureGenerator):
     """Generates categorical and continuous features for time series models.
@@ -117,13 +128,13 @@ class TimeSeriesFeatureGenerator:
 
     Parameters
     ----------
-    target : str
+    target
         Name of the target column.
-    known_covariates_names : List[str]
+    known_covariates_names
         Columns that contain covariates that are known into the future.
-    float_dtype : str, default = "float32"
+    float_dtype
         Numpy float dtype to which all numeric columns (float, int, bool) will be converted both in static & dynamic dfs.
-    num_samples : int or None, default = 20_000
+    num_samples
         Number of rows sampled from the training dataset to speed up computation of the median (used later for imputation).
         If set to `None`, median will be computed using all rows.
     """
@@ -131,27 +142,27 @@ class TimeSeriesFeatureGenerator:
     def __init__(
         self,
         target: str,
-        known_covariates_names: List[str],
+        known_covariates_names: list[str],
         float_dtype: str = "float32",
-        num_samples: Optional[int] = 20_000,
+        num_samples: int | None = 20_000,
     ):
         self.target = target
         self.float_dtype = float_dtype
         self.num_samples = num_samples
 
         self._is_fit = False
-        self.known_covariates_names: List[str] = list(known_covariates_names)
-        self.past_covariates_names: List[str] = []
+        self.known_covariates_names: list[str] = list(known_covariates_names)
+        self.past_covariates_names: list[str] = []
         self.known_covariates_pipeline = ContinuousAndCategoricalFeatureGenerator()
         self.past_covariates_pipeline = ContinuousAndCategoricalFeatureGenerator()
         # Cat features with cat_count=1 are fine in static_features since they are repeated for all time steps in a TS
         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]:
+    def required_column_names(self) -> list[str]:
         return [self.target] + list(self.known_covariates_names) + list(self.past_covariates_names)
 
     @property
@@ -218,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:")
@@ -243,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
@@ -259,13 +275,13 @@ class TimeSeriesFeatureGenerator:
         return self._impute_covariates(ts_df, column_names=self.covariate_metadata.covariates_real)
 
     @staticmethod
-    def _concat_dfs(dfs_to_concat: List[pd.DataFrame]) -> pd.DataFrame:
+    def _concat_dfs(dfs_to_concat: list[pd.DataFrame]) -> pd.DataFrame:
         if len(dfs_to_concat) == 1:
             return dfs_to_concat[0]
         else:
             return pd.concat(dfs_to_concat, axis=1, copy=False)
 
-    def _impute_covariates(self, ts_df: TimeSeriesDataFrame, column_names: List[str]) -> TimeSeriesDataFrame:
+    def _impute_covariates(self, ts_df: TimeSeriesDataFrame, column_names: list[str]) -> TimeSeriesDataFrame:
         """Impute missing values in selected columns with ffill, bfill, and median imputation."""
         if len(column_names) > 0:
             # ffill + bfill covariates that have at least some observed values
@@ -276,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:
@@ -325,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"
@@ -343,10 +359,10 @@ class TimeSeriesFeatureGenerator:
             return None
 
     @staticmethod
-    def _detect_and_log_column_types(transformed_df: pd.DataFrame) -> Tuple[List[str], List[str]]:
+    def _detect_and_log_column_types(transformed_df: pd.DataFrame) -> tuple[list[str], list[str]]:
         """Log & return names of categorical and real-valued columns in the DataFrame."""
-        cat_column_names: List[str] = []
-        real_column_names: List[str] = []
+        cat_column_names: list[str] = []
+        real_column_names: list[str] = []
         for column_name, column_dtype in transformed_df.dtypes.items():
             if isinstance(column_dtype, pd.CategoricalDtype):
                 cat_column_names.append(str(column_name))
@@ -359,9 +375,9 @@ class TimeSeriesFeatureGenerator:
 
     @staticmethod
     def _check_required_columns_are_present(
-        data: TimeSeriesDataFrame, required_column_names: List[str], data_frame_name: str
+        data: TimeSeriesDataFrame, required_column_names: list[str], data_frame_name: str
     ) -> None:
-        missing_columns = pd.Index(required_column_names).difference(data.columns)
+        missing_columns = pd.Index(required_column_names).difference(data.columns)  # type: ignore
         if len(missing_columns) > 0:
             raise ValueError(
                 f"{len(missing_columns)} columns are missing from {data_frame_name}: {reprlib.repr(missing_columns.to_list())}"
@@ -395,7 +411,7 @@ class AbstractFeatureImportanceTransform:
         """Transforms a series with the same index as the pandas DataFrame"""
         raise NotImplementedError
 
-    def _transform_series(self, feature_data: pd.Series, is_categorical: bool) -> TimeSeriesDataFrame:
+    def _transform_series(self, feature_data: pd.Series, is_categorical: bool) -> pd.Series:
         """Transforms a series with the same index as the pandas DataFrame"""
         raise NotImplementedError
 
@@ -403,7 +419,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)
 
@@ -412,11 +428,14 @@ 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))
         elif feature_name in self.covariate_metadata.static_features:
+            assert data.static_features is not None
             feature_data = data.static_features[feature_name].copy()
             feature_data.reset_index(drop=True, inplace=True)
             data.static_features[feature_name] = self._transform_static_series(
@@ -435,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,
     ):
@@ -451,11 +470,13 @@ 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":
             return pd.Series(feature_data.sample(frac=1, random_state=rng).values, index=feature_data.index)
+        else:
+            raise ValueError(f"Unknown shuffle_type: {self.shuffle_type}")
 
 
 class ConstantReplacementFeatureImportanceTransform(AbstractFeatureImportanceTransform):
@@ -477,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)
+            return feature_data.groupby(level=TimeSeriesDataFrame.ITEMID, sort=False).transform(
+                self.real_value_aggregation
+            )  # type: ignore

autogluon/timeseries/utils/forecast.py

@@ -1,10 +1,10 @@
 import warnings
-from typing import Optional
 
 import numpy as np
 import pandas as pd
 
-from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TIMESTAMP, TimeSeriesDataFrame
+from autogluon.common.utils.deprecated_utils import Deprecated
+from autogluon.timeseries.dataset import TimeSeriesDataFrame
 
 
 def get_forecast_horizon_index_single_time_series(
@@ -15,30 +15,35 @@ 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)
 
 
-# TODO: Deprecate this method, add this functionality to `TimeSeriesPredictor`
-def get_forecast_horizon_index_ts_dataframe(
+@Deprecated(
+    min_version_to_warn="1.3", min_version_to_error="2.0", new="TimeSeriesPredictor.forecast_horizon_data_frame"
+)
+def get_forecast_horizon_index_ts_dataframe(*args, **kwargs) -> pd.MultiIndex:
+    return pd.MultiIndex.from_frame(make_future_data_frame(*args, **kwargs))
+
+
+def make_future_data_frame(
     ts_dataframe: TimeSeriesDataFrame,
     prediction_length: int,
-    freq: Optional[str] = None,
-) -> pd.MultiIndex:
+    freq: str | None = None,
+) -> pd.DataFrame:
     """For each item in the dataframe, get timestamps for the next `prediction_length` time steps into the future.
 
-    Returns a pandas.MultiIndex, where
-    - level 0 ("item_id") contains the same item_ids as the input ts_dataframe.
-    - level 1 ("timestamp") contains the next prediction_length time steps starting from the end of each time series.
+    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()
-    item_ids = np.repeat(last[ITEMID], prediction_length)
+    indptr = ts_dataframe.get_indptr()
+    last = ts_dataframe.index[indptr[1:] - 1].to_frame(index=False)
+    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.MultiIndex.from_arrays([item_ids, timestamps], names=[ITEMID, TIMESTAMP])
+    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/utils/warning_filters.py

@@ -8,12 +8,14 @@ import sys
 import warnings
 from collections import Counter
 
+import pandas as pd
+
 __all__ = ["warning_filter", "disable_root_logger", "disable_tqdm"]
 
 
 @contextlib.contextmanager
 def warning_filter(all_warnings: bool = False):
-    categories = [RuntimeWarning, UserWarning, FutureWarning]
+    categories = [RuntimeWarning, UserWarning, FutureWarning, pd.errors.PerformanceWarning]
     if all_warnings:
         categories.append(Warning)
     with warnings.catch_warnings():
@@ -57,7 +59,7 @@ def disable_tqdm():
         from tqdm import tqdm
 
         _init = tqdm.__init__
-        tqdm.__init__ = functools.partialmethod(tqdm.__init__, disable=True)
+        tqdm.__init__ = functools.partialmethod(tqdm.__init__, disable=True)  # type: ignore
         yield
     except ImportError:
         yield

autogluon/timeseries/version.py

@@ -1,4 +1,4 @@
 """This is the autogluon version file."""
 
-__version__ = "1.2.1b20250224"
+__version__ = "1.4.1b20251215"
 __lite__ = False

autogluon.timeseries-1.4.1b20251215-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)