autogluon.timeseries 1.0.1b20240301__py3-none-any.whl → 1.0.1b20240302__py3-none-any.whl

autogluon/timeseries/models/autogluon_tabular/mlforecast.py

@@ -231,9 +231,6 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         if static_features is not None:
             df = pd.merge(df, static_features, how="left", on=ITEMID, suffixes=(None, "_static_feat"))
 
-        # Convert float64 to float32 to reduce memory usage
-        float64_cols = list(df.select_dtypes(include="float64"))
-        df[float64_cols] = df[float64_cols].astype("float32")
         # We assume that df is sorted by 'unique_id' inside `TimeSeriesPredictor._check_and_prepare_data_frame`
         return df.rename(columns=column_name_mapping)
 

autogluon/timeseries/predictor.py

@@ -293,7 +293,7 @@ class TimeSeriesPredictor(TimeSeriesPredictorDeprecatedMixin):
             Preprocessed data in TimeSeriesDataFrame format.
         """
         df = self._to_data_frame(data, name=name)
-        df = df.astype({self.target: float})
+        df = df.astype({self.target: "float32"})
         # MultiIndex.is_monotonic_increasing checks if index is sorted by ["item_id", "timestamp"]
         if not df.index.is_monotonic_increasing:
             df = df.sort_index()

autogluon/timeseries/utils/features.py

@@ -1,9 +1,8 @@
 import logging
 import reprlib
 from dataclasses import dataclass, field
-from typing import List, Optional
+from typing import List, Optional, Tuple
 
-import numpy as np
 import pandas as pd
 
 from autogluon.common.features.types import R_FLOAT, R_INT
@@ -33,9 +32,9 @@ class CovariateMetadata:
 class ContinuousAndCategoricalFeatureGenerator(PipelineFeatureGenerator):
     """Generates categorical and continuous features for time series models."""
 
-    def __init__(self, verbosity: int = 0, **kwargs):
+    def __init__(self, verbosity: int = 0, minimum_cat_count=2, float_dtype: str = "float32", **kwargs):
         generators = [
-            CategoryFeatureGenerator(minimum_cat_count=1, fillna="mode"),
+            CategoryFeatureGenerator(minimum_cat_count=minimum_cat_count, fillna="mode"),
             IdentityFeatureGenerator(infer_features_in_args={"valid_raw_types": [R_INT, R_FLOAT]}),
         ]
         super().__init__(
@@ -47,34 +46,47 @@ class ContinuousAndCategoricalFeatureGenerator(PipelineFeatureGenerator):
             verbosity=verbosity,
             **kwargs,
         )
+        self.float_dtype = float_dtype
+
+    def _convert_numerical_columns_to_float(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Convert the dtype of all numerical (float or int) columns to the given float dtype."""
+        numeric_columns = [col for col in df.columns if pd.api.types.is_numeric_dtype(df[col])]
+        return df.astype({col: self.float_dtype for col in numeric_columns})
+
+    def transform(self, X: pd.DataFrame, *args, **kwargs) -> pd.DataFrame:
+        if isinstance(X, TimeSeriesDataFrame):
+            X = pd.DataFrame(X)
+        return self._convert_numerical_columns_to_float(super().transform(X, *args, **kwargs))
+
+    def fit_transform(self, X: pd.DataFrame, *args, **kwargs) -> pd.DataFrame:
+        # PipelineFeatureGenerator does not use transform() inside fit_transform(), so we need to override both methods
+        if isinstance(X, TimeSeriesDataFrame):
+            X = pd.DataFrame(X)
+        return self._convert_numerical_columns_to_float(super().fit_transform(X, *args, **kwargs))
 
 
 class TimeSeriesFeatureGenerator:
     """Takes care of preprocessing for static_features and past/known covariates.
 
-    Covariates are all converted to float dtype. Static features, if present, are all converted to categorical & float
-    dtypes.
+    All covariates & static features are converted into either float32 or categorical dtype.
     """
 
-    def __init__(self, target: str, known_covariates_names: List[str]):
+    def __init__(self, target: str, known_covariates_names: List[str], float_dtype: str = "float32"):
         self.target = target
+        self.float_dtype = float_dtype
         self._is_fit = False
         self.known_covariates_names = list(known_covariates_names)
         self.past_covariates_names = []
-        self.static_feature_pipeline = ContinuousAndCategoricalFeatureGenerator()
+        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: CovariateMetadata = None
 
     @property
     def required_column_names(self) -> List[str]:
         return [self.target] + list(self.known_covariates_names) + list(self.past_covariates_names)
 
-    @staticmethod
-    def _convert_numerical_features_to_float(df: pd.DataFrame, float_dtype=np.float64) -> pd.DataFrame:
-        """In-place convert the dtype of all numerical (float or int) columns to the given float dtype."""
-        numeric_columns = [col for col in df.columns if pd.api.types.is_numeric_dtype(df[col])]
-        df[numeric_columns] = df[numeric_columns].astype(float_dtype)
-        return df
-
     def fit(self, data: TimeSeriesDataFrame) -> None:
         assert not self._is_fit, f"{self.__class__.__name__} has already been fit"
 
@@ -83,70 +95,67 @@ class TimeSeriesFeatureGenerator:
             if column != self.target and column not in self.known_covariates_names:
                 self.past_covariates_names.append(column)
 
-        logger.info("\nProvided dataset contains following columns:")
-        logger.info(f"\ttarget:           '{self.target}'")
+        self._check_required_columns_are_present(
+            data, required_column_names=self.required_column_names, data_frame_name="train_data"
+        )
+
+        logger.info("\nProvided data contains following columns:")
+        logger.info(f"\ttarget: '{self.target}'")
+
         if len(self.known_covariates_names) > 0:
-            logger.info(f"\tknown covariates: {self.known_covariates_names}")
+            known_covariates_df = self.known_covariates_pipeline.fit_transform(data[self.known_covariates_names])
+            logger.info("\tknown_covariates:")
+            known_covariates_cat, known_covariates_real = self._detect_and_log_column_types(known_covariates_df)
+            self.known_covariates_names = self.known_covariates_pipeline.features_in
+        else:
+            known_covariates_cat = []
+            known_covariates_real = []
+
         if len(self.past_covariates_names) > 0:
-            logger.info(f"\tpast covariates:  {self.past_covariates_names}")
+            past_covariates_df = self.past_covariates_pipeline.fit_transform(data[self.past_covariates_names])
+            logger.info("\tpast_covariates:")
+            past_covariates_cat, past_covariates_real = self._detect_and_log_column_types(past_covariates_df)
+            self.past_covariates_names = self.past_covariates_pipeline.features_in
+        else:
+            past_covariates_cat = []
+            past_covariates_real = []
+
+        ignored_covariates = data.columns.difference(
+            [self.target] + self.known_covariates_names + self.past_covariates_names
+        )
 
-        static_features_cat = []
-        static_features_real = []
         if data.static_features is not None:
-            static = self.static_feature_pipeline.fit_transform(data.static_features)
-            static = self._convert_numerical_features_to_float(static)
-
-            unused = []
-            for col_name in data.static_features.columns:
-                if col_name in static.columns and static[col_name].dtype == "category":
-                    static_features_cat.append(col_name)
-                elif col_name in static.columns and static[col_name].dtype == np.float64:
-                    static_features_real.append(col_name)
-                else:
-                    unused.append(col_name)
-
-            logger.info("Following types of static features have been inferred:")
-            logger.info(f"\tcategorical:        {static_features_cat}")
-            logger.info(f"\tcontinuous (float): {static_features_real}")
-            if len(unused) > 0:
-                logger.info(f"\tremoved (uninformative columns): {unused}")
+            static_features_df = self.static_feature_pipeline.fit_transform(data.static_features)
+            logger.info("\tstatic_features:")
+            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)
+        else:
+            static_features_cat = []
+            static_features_real = []
+            ignored_static_features = []
+
+        if len(ignored_covariates) > 0 or len(ignored_static_features) > 0:
+            logger.info("\nAutoGluon will ignore following non-numeric/non-informative columns:")
+            if len(ignored_covariates) > 0:
+                logger.info(f"\tignored covariates:      {list(ignored_covariates)}")
+            if len(ignored_static_features) > 0:
+                logger.info(f"\tignored static_features: {list(ignored_static_features)}")
+
+        if len(data.columns) > 1 or data.static_features is not None:
             logger.info(
-                "To learn how to fix incorrectly inferred types, please see documentation for TimeSeriesPredictor.fit "
+                "\nTo learn how to fix incorrectly inferred types, please see documentation for TimeSeriesPredictor.fit"
             )
 
         self.covariate_metadata = CovariateMetadata(
+            known_covariates_cat=known_covariates_cat,
+            known_covariates_real=known_covariates_real,
+            past_covariates_cat=past_covariates_cat,
+            past_covariates_real=past_covariates_real,
             static_features_cat=static_features_cat,
             static_features_real=static_features_real,
-            known_covariates_real=self.known_covariates_names,
-            past_covariates_real=self.past_covariates_names,
-            # TODO: Categorical time-varying covariates are not yet supported
-            known_covariates_cat=[],
-            past_covariates_cat=[],
         )
         self._is_fit = True
 
-    @staticmethod
-    def _check_and_prepare_covariates(
-        data: TimeSeriesDataFrame,
-        required_column_names: List[str],
-        data_frame_name: str,
-    ) -> TimeSeriesDataFrame:
-        """Select the required dataframe columns and convert them to float64 dtype."""
-        missing_columns = pd.Index(required_column_names).difference(data.columns)
-        if len(missing_columns) > 0:
-            raise ValueError(
-                f"{len(missing_columns)} columns are missing from {data_frame_name}: {reprlib.repr(missing_columns.to_list())}"
-            )
-        data = data[required_column_names]
-        try:
-            data = data.astype(np.float64)
-        except ValueError:
-            raise ValueError(
-                f"Columns in {data_frame_name} must all have numeric (float or int) dtypes, "
-                f"but in provided data they have dtypes {data.dtypes}"
-            )
-        return data
-
     def transform(self, data: TimeSeriesDataFrame, data_frame_name: str = "data") -> TimeSeriesDataFrame:
         """Transform static features and past/known covariates.
 
@@ -156,24 +165,25 @@ class TimeSeriesFeatureGenerator:
         If some columns are missing or are incompatible, an exception will be raised.
         """
         assert self._is_fit, f"{self.__class__.__name__} has not been fit yet"
-        # Avoid modifying inplace
-        data = data.copy(deep=False)
-
-        data = self._check_and_prepare_covariates(
-            data=data,
-            required_column_names=self.required_column_names,
-            data_frame_name=data_frame_name,
+        self._check_required_columns_are_present(
+            data, required_column_names=self.required_column_names, data_frame_name=data_frame_name
         )
+        dfs = [data[[self.target]]]
+
+        if len(self.known_covariates_names) > 0:
+            dfs.append(self.known_covariates_pipeline.transform(data[self.known_covariates_names]))
+
+        if len(self.past_covariates_names) > 0:
+            dfs.append(self.past_covariates_pipeline.transform(data[self.past_covariates_names]))
 
         if self.static_feature_pipeline.is_fit():
             if data.static_features is None:
                 raise ValueError(f"Provided {data_frame_name} must contain static_features")
             static_features = self.static_feature_pipeline.transform(data.static_features)
-            data.static_features = self._convert_numerical_features_to_float(static_features)
         else:
-            data.static_features = None
+            static_features = None
 
-        return data
+        return TimeSeriesDataFrame(pd.concat(dfs, axis=1), static_features=static_features)
 
     def transform_future_known_covariates(
         self, known_covariates: Optional[TimeSeriesDataFrame]
@@ -181,14 +191,38 @@ class TimeSeriesFeatureGenerator:
         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"
-            return self._check_and_prepare_covariates(
-                known_covariates,
-                required_column_names=self.known_covariates_names,
-                data_frame_name="known_covariates",
+            self._check_required_columns_are_present(
+                known_covariates, required_column_names=self.known_covariates_names, data_frame_name="known_covariates"
             )
+            return TimeSeriesDataFrame(self.known_covariates_pipeline.transform(known_covariates))
         else:
             return None
 
     def fit_transform(self, data: TimeSeriesDataFrame, data_frame_name: str = "data") -> TimeSeriesDataFrame:
         self.fit(data)
         return self.transform(data, data_frame_name=data_frame_name)
+
+    @staticmethod
+    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 = []
+        real_column_names = []
+        for column_name, column_dtype in transformed_df.dtypes.items():
+            if isinstance(column_dtype, pd.CategoricalDtype):
+                cat_column_names.append(column_name)
+            elif pd.api.types.is_numeric_dtype(column_dtype):
+                real_column_names.append(column_name)
+
+        logger.info(f"\t\tcategorical:        {reprlib.repr(cat_column_names)}")
+        logger.info(f"\t\tcontinuous (float): {reprlib.repr(real_column_names)}")
+        return cat_column_names, real_column_names
+
+    @staticmethod
+    def _check_required_columns_are_present(
+        data: TimeSeriesDataFrame, required_column_names: List[str], data_frame_name: str
+    ) -> None:
+        missing_columns = pd.Index(required_column_names).difference(data.columns)
+        if len(missing_columns) > 0:
+            raise ValueError(
+                f"{len(missing_columns)} columns are missing from {data_frame_name}: {reprlib.repr(missing_columns.to_list())}"
+            )

autogluon/timeseries/version.py

@@ -1,3 +1,3 @@
 """This is the autogluon version file."""
-__version__ = '1.0.1b20240301'
+__version__ = '1.0.1b20240302'
 __lite__ = False

{autogluon.timeseries-1.0.1b20240301.dist-info → autogluon.timeseries-1.0.1b20240302.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.0.1b20240301
+Version: 1.0.1b20240302
 Summary: AutoML for Image, Text, and Tabular Data
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community
@@ -50,9 +50,9 @@ Requires-Dist: utilsforecast <0.0.11,>=0.0.10
 Requires-Dist: tqdm <5,>=4.38
 Requires-Dist: orjson ~=3.9
 Requires-Dist: tensorboard <3,>=2.9
-Requires-Dist: autogluon.core[raytune] ==1.0.1b20240301
-Requires-Dist: autogluon.common ==1.0.1b20240301
-Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost] ==1.0.1b20240301
+Requires-Dist: autogluon.core[raytune] ==1.0.1b20240302
+Requires-Dist: autogluon.common ==1.0.1b20240302
+Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost] ==1.0.1b20240302
 Provides-Extra: all
 Provides-Extra: tests
 Requires-Dist: pytest ; extra == 'tests'

{autogluon.timeseries-1.0.1b20240301.dist-info → autogluon.timeseries-1.0.1b20240302.dist-info}/RECORD

@@ -1,10 +1,10 @@
-autogluon.timeseries-1.0.1b20240301-py3.8-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
+autogluon.timeseries-1.0.1b20240302-py3.8-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=VGBFTuNebD5xF2RfimornX86DOw5dxqpPtXlrUpNSHo,9814
-autogluon/timeseries/predictor.py,sha256=mTbuIJDuPOq64iLs-c6zFAWQHuWYZhuNrmLYExgeodU,67766
+autogluon/timeseries/predictor.py,sha256=FkjPpEdboQHBsEh7GxCQZn-mmkICtnNL3ZV3MoWwJbs,67770
 autogluon/timeseries/splitter.py,sha256=eghGwAAN2_cxGk5aJBILgjGWtLzjxJcytMy49gg_q18,3061
-autogluon/timeseries/version.py,sha256=T6sjO4V0hWRcSC7zTvU--rHZTaCF62JTV9ZYby7tezM,90
+autogluon/timeseries/version.py,sha256=h8nntaJLbUW6cfAKCiHy5GiEzFjrk259_uFIYznVD7Q,90
 autogluon/timeseries/configs/__init__.py,sha256=BTtHIPCYeGjqgOcvqb8qPD4VNX-ICKOg6wnkew1cPOE,98
 autogluon/timeseries/configs/presets_configs.py,sha256=1u6tbOKJdIRULYDu41dlJwXRNswWsjBDF0aR2YhyMQs,479
 autogluon/timeseries/dataset/__init__.py,sha256=UvnhAN5tjgxXTHoZMQDy64YMDj4Xxa68yY7NP4vAw0o,81
@@ -20,7 +20,7 @@ autogluon/timeseries/models/abstract/__init__.py,sha256=wvDsQAZIV0N3AwBeMaGItoQ8
 autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=LSIc6rIwFs870MHpKUC24naMIcczFGY_--Ov-wyAq2w,21431
 autogluon/timeseries/models/abstract/model_trial.py,sha256=_5Nrk4CrG3u35tTd3elekfdnQI2Pn3P9AGS5CE6nuyg,3749
 autogluon/timeseries/models/autogluon_tabular/__init__.py,sha256=r9i6jWcyeLHYClkcMSKRVsfrkBUMxpDrTATNTBc_qgQ,136
-autogluon/timeseries/models/autogluon_tabular/mlforecast.py,sha256=Juig6ZiKATqyHfOJ48zU_eWv7CjnlgMMPZCpmhwDFb0,29785
+autogluon/timeseries/models/autogluon_tabular/mlforecast.py,sha256=uydOXTIy74Exy3jQ90YoCF1L4rP7A0jtUcOreAqdn5Q,29598
 autogluon/timeseries/models/autogluon_tabular/utils.py,sha256=4-gTrBtizxeMVQlsuscugPqw9unaXWXhS1TVVssfzYY,2125
 autogluon/timeseries/models/ensemble/__init__.py,sha256=kFr11Gmt7lQJu9Rr8HuIPphQN5l1TsoorfbJm_O3a_s,128
 autogluon/timeseries/models/ensemble/abstract_timeseries_ensemble.py,sha256=tifETwmiEGt-YtQ9eNK7ojJ3fBvtFMUJvisbfkIJ7gw,3393
@@ -40,7 +40,7 @@ autogluon/timeseries/trainer/__init__.py,sha256=lxiOT-Gc6BEnr_yWQqra85kEngeM_wtH
 autogluon/timeseries/trainer/abstract_trainer.py,sha256=d8Qt3euZyKUGt_R-_f0sPlGZhZgLkG8tV8qsq48zZj0,49335
 autogluon/timeseries/trainer/auto_trainer.py,sha256=ftjGd27V6dsfw3t7GY1YcoyKfj9Pl_UrU77T9u-kCQ0,3244
 autogluon/timeseries/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autogluon/timeseries/utils/features.py,sha256=72RC_oLNh87VWIRv65M1v62vuz83zeaDhNlWBc0foSY,8354
+autogluon/timeseries/utils/features.py,sha256=Liq_Vn_BH43AqwjfuHGbiaEzCjRcWMQUy24taL5Upc0,10937
 autogluon/timeseries/utils/forecast.py,sha256=Thjt6yTPSe3V4s5cQ9UbW3ysTJb1lkqxtZiCqgBSt3w,1776
 autogluon/timeseries/utils/warning_filters.py,sha256=VoyTzHovxDFFbeSQXttjzmifZxKJShpKIAfCHGQGoUU,1426
 autogluon/timeseries/utils/datetime/__init__.py,sha256=bTMR8jLh1LW55vHjbOr1zvWRMF_PqbvxpS-cUcNIDWI,173
@@ -48,11 +48,11 @@ autogluon/timeseries/utils/datetime/base.py,sha256=MsqIHY14m3QMjSwwtE7Uo1oNwepWU
 autogluon/timeseries/utils/datetime/lags.py,sha256=kcU4liKbHj7KP2ajNU-KLZ8OYSU35EgT4kJjZNSw0Zg,5875
 autogluon/timeseries/utils/datetime/seasonality.py,sha256=kgK_ukw2wCviEB7CZXRVC5HZpBJZu9IsRrvCJ9E_rOE,755
 autogluon/timeseries/utils/datetime/time_features.py,sha256=pROkYyxETQ8rHKfPGhf2paB73C7rWJ2Ui0cCswLqbBg,2562
-autogluon.timeseries-1.0.1b20240301.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-autogluon.timeseries-1.0.1b20240301.dist-info/METADATA,sha256=iJrEt8t-ErNVreSnkS7LaZZ7rFLmdJCQLAyUAY0Yxtc,12081
-autogluon.timeseries-1.0.1b20240301.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
-autogluon.timeseries-1.0.1b20240301.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-autogluon.timeseries-1.0.1b20240301.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.0.1b20240301.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.0.1b20240301.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon.timeseries-1.0.1b20240301.dist-info/RECORD,,
+autogluon.timeseries-1.0.1b20240302.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+autogluon.timeseries-1.0.1b20240302.dist-info/METADATA,sha256=5s8UXslOw3JPbV_cwFnw4RfEgNvt4h4vLs7BprE60o8,12081
+autogluon.timeseries-1.0.1b20240302.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
+autogluon.timeseries-1.0.1b20240302.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+autogluon.timeseries-1.0.1b20240302.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.0.1b20240302.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.0.1b20240302.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+autogluon.timeseries-1.0.1b20240302.dist-info/RECORD,,