tabpfn-time-series 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

tabpfn_time_series/__init__.py

@@ -1,11 +1,13 @@
 from .feature import DefaultFeatures, FeatureTransformer
 from .predictor import TabPFNTimeSeriesPredictor, TabPFNMode
+from .defaults import TABPFN_TS_DEFAULT_QUANTILE_CONFIG
 
 __version__ = "0.1.0"
 
 __all__ = [
     "DefaultFeatures",
-    "FeatureTransformer", 
+    "FeatureTransformer",
     "TabPFNTimeSeriesPredictor",
     "TabPFNMode",
+    "TABPFN_TS_DEFAULT_QUANTILE_CONFIG",
 ]

tabpfn_time_series/defaults.py

@@ -1,5 +1,7 @@
-TABPFN_DEFAULT_QUANTILE_CONFIG = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
-TABPFN_DEFAULT_CONFIG = {
-    "model": "2noar4o2",
-    "optimize_metric": "median",
+TABPFN_TS_DEFAULT_QUANTILE_CONFIG = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
+TABPFN_TS_DEFAULT_CONFIG = {
+    "tabpfn_internal": {
+        "model_path": "2noar4o2",
+    },
+    "tabpfn_output_selection": "median",  # mean or median
 }

tabpfn_time_series/predictor.py

@@ -3,8 +3,8 @@ from enum import Enum
 
 from autogluon.timeseries import TimeSeriesDataFrame
 
-from tabpfn_time_series.tabpfn_worker import TabPFNClient, LocalTabPFN
-from tabpfn_time_series.defaults import TABPFN_DEFAULT_QUANTILE_CONFIG, TABPFN_DEFAULT_CONFIG
+from tabpfn_time_series.tabpfn_worker import TabPFNClient, LocalTabPFN, MockTabPFN
+from tabpfn_time_series.defaults import TABPFN_TS_DEFAULT_CONFIG
 
 logger = logging.getLogger(__name__)
 
@@ -12,6 +12,7 @@ logger = logging.getLogger(__name__)
 class TabPFNMode(Enum):
     LOCAL = "tabpfn-local"
     CLIENT = "tabpfn-client"
+    MOCK = "tabpfn-mock"
 
 
 class TabPFNTimeSeriesPredictor:
@@ -22,11 +23,12 @@ class TabPFNTimeSeriesPredictor:
     def __init__(
         self,
         tabpfn_mode: TabPFNMode = TabPFNMode.CLIENT,
-        tabpfn_config: dict = TABPFN_DEFAULT_CONFIG,
+        config: dict = TABPFN_TS_DEFAULT_CONFIG,
     ) -> None:
         worker_mapping = {
-            TabPFNMode.CLIENT: lambda: TabPFNClient(tabpfn_config),
-            TabPFNMode.LOCAL: lambda: LocalTabPFN(tabpfn_config),
+            TabPFNMode.CLIENT: lambda: TabPFNClient(config),
+            TabPFNMode.LOCAL: lambda: LocalTabPFN(config),
+            TabPFNMode.MOCK: lambda: MockTabPFN(config),
         }
         self.tabpfn_worker = worker_mapping[tabpfn_mode]()
 
@@ -34,14 +36,13 @@ class TabPFNTimeSeriesPredictor:
         self,
         train_tsdf: TimeSeriesDataFrame,  # with features and target
         test_tsdf: TimeSeriesDataFrame,  # with features only
-        quantile_config: list[float] = TABPFN_DEFAULT_QUANTILE_CONFIG,
     ) -> TimeSeriesDataFrame:
         """
         Predict on each time series individually (local forecasting).
         """
 
         logger.info(
-            f"Predicting {len(train_tsdf.item_ids)} time series with config{self.tabpfn_worker.tabpfn_config}"
+            f"Predicting {len(train_tsdf.item_ids)} time series with config{self.tabpfn_worker.config}"
         )
 
-        return self.tabpfn_worker.predict(train_tsdf, test_tsdf, quantile_config)
+        return self.tabpfn_worker.predict(train_tsdf, test_tsdf)

tabpfn_time_series/tabpfn_worker.py

@@ -2,13 +2,15 @@ import logging
 from abc import ABC, abstractmethod
 from joblib import Parallel, delayed
 
+from tqdm import tqdm
 import pandas as pd
 import numpy as np
+import torch
 from scipy.stats import norm
 from autogluon.timeseries import TimeSeriesDataFrame
 
 from tabpfn_time_series.data_preparation import split_time_series_to_X_y
-from tabpfn_time_series.defaults import TABPFN_DEFAULT_QUANTILE_CONFIG
+from tabpfn_time_series.defaults import TABPFN_TS_DEFAULT_QUANTILE_CONFIG
 
 logger = logging.getLogger(__name__)
 
@@ -16,17 +18,16 @@ logger = logging.getLogger(__name__)
 class TabPFNWorker(ABC):
     def __init__(
         self,
-        tabpfn_config: dict = {},
+        config: dict = {},
         num_workers: int = 1,
     ):
-        self.tabpfn_config = tabpfn_config
+        self.config = config
         self.num_workers = num_workers
 
     def predict(
         self,
         train_tsdf: TimeSeriesDataFrame,
         test_tsdf: TimeSeriesDataFrame,
-        quantile_config: list[float],
     ):
         predictions = Parallel(
             n_jobs=self.num_workers,
@@ -36,9 +37,8 @@ class TabPFNWorker(ABC):
                 item_id,
                 train_tsdf.loc[item_id],
                 test_tsdf.loc[item_id],
-                quantile_config,
             )
-            for item_id in train_tsdf.item_ids
+            for item_id in tqdm(train_tsdf.item_ids, desc="Predicting time series")
         )
 
         predictions = pd.concat(predictions)
@@ -53,8 +53,9 @@ class TabPFNWorker(ABC):
         item_id: str,
         single_train_tsdf: TimeSeriesDataFrame,
         single_test_tsdf: TimeSeriesDataFrame,
-        quantile_config: list[float],
     ) -> pd.DataFrame:
+        # logger.debug(f"Predicting on item_id: {item_id}")
+
         test_index = single_test_tsdf.index
         train_X, train_y = split_time_series_to_X_y(single_train_tsdf.copy())
         test_X, _ = split_time_series_to_X_y(single_test_tsdf.copy())
@@ -64,15 +65,21 @@ class TabPFNWorker(ABC):
         if train_y_has_constant_value:
             logger.info("Found time-series with constant target")
             result = self._predict_on_constant_train_target(
-                single_train_tsdf, single_test_tsdf, quantile_config
+                single_train_tsdf, single_test_tsdf
             )
         else:
-            # Call worker-specific prediction routine
-            result = self._worker_specific_prediction_routine(
-                train_X,
-                train_y,
-                test_X,
-                quantile_config,
+            tabpfn = self._get_tabpfn_engine()
+            tabpfn.fit(train_X, train_y)
+            full_pred = tabpfn.predict(test_X, output_type="main")
+
+            result = {"target": full_pred[self.config["tabpfn_output_selection"]]}
+            result.update(
+                {
+                    q: q_pred
+                    for q, q_pred in zip(
+                        TABPFN_TS_DEFAULT_QUANTILE_CONFIG, full_pred["quantiles"]
+                    )
+                }
             )
 
         result = pd.DataFrame(result, index=test_index)
@@ -81,20 +88,13 @@ class TabPFNWorker(ABC):
         return result
 
     @abstractmethod
-    def _worker_specific_prediction_routine(
-        self,
-        train_X: pd.DataFrame,
-        train_y: pd.Series,
-        test_X: pd.DataFrame,
-        quantile_config: list[float],
-    ) -> pd.DataFrame:
+    def _get_tabpfn_engine(self):
         pass
 
     def _predict_on_constant_train_target(
         self,
         single_train_tsdf: TimeSeriesDataFrame,
         single_test_tsdf: TimeSeriesDataFrame,
-        quantile_config: list[float],
     ) -> pd.DataFrame:
         # If train_y is constant, we return the constant value from the training set
         mean_constant = single_train_tsdf.target.iloc[0]
@@ -102,12 +102,14 @@ class TabPFNWorker(ABC):
 
         # For quantile prediction, we assume that the uncertainty follows a standard normal distribution
         quantile_pred_with_uncertainty = norm.ppf(
-            quantile_config, loc=mean_constant, scale=1
+            TABPFN_TS_DEFAULT_QUANTILE_CONFIG, loc=mean_constant, scale=1
         )
         result.update(
             {
                 q: np.full(len(single_test_tsdf), v)
-                for q, v in zip(quantile_config, quantile_pred_with_uncertainty)
+                for q, v in zip(
+                    TABPFN_TS_DEFAULT_QUANTILE_CONFIG, quantile_pred_with_uncertainty
+                )
             }
         )
 
@@ -117,108 +119,141 @@ class TabPFNWorker(ABC):
 class TabPFNClient(TabPFNWorker):
     def __init__(
         self,
-        tabpfn_config: dict = {},
+        config: dict = {},
         num_workers: int = 2,
     ):
-        super().__init__(tabpfn_config, num_workers)
+        super().__init__(config, num_workers)
 
         # Initialize the TabPFN client (e.g. sign up, login, etc.)
         from tabpfn_client import init
 
         init()
 
+    def _get_tabpfn_engine(self):
+        from tabpfn_client import TabPFNRegressor
+
+        return TabPFNRegressor(**self.config["tabpfn_internal"])
+
+
+class LocalTabPFN(TabPFNWorker):
+    def __init__(
+        self,
+        config: dict = {},
+        num_workers_per_gpu: int = 4,  # per GPU
+    ):
+        self.num_workers_per_gpu = num_workers_per_gpu
+
+        # Only support GPU for now (inference on CPU takes too long)
+        if not torch.cuda.is_available():
+            raise ValueError("GPU is required for local TabPFN inference")
+
+        super().__init__(
+            config, num_workers=torch.cuda.device_count() * self.num_workers_per_gpu
+        )
+
     def predict(
         self,
         train_tsdf: TimeSeriesDataFrame,
         test_tsdf: TimeSeriesDataFrame,
-        quantile_config: list[float],
     ):
-        if not set(quantile_config).issubset(set(TABPFN_DEFAULT_QUANTILE_CONFIG)):
-            raise NotImplementedError(
-                f"TabPFNClient currently only supports {TABPFN_DEFAULT_QUANTILE_CONFIG} for quantile prediction,"
-                f" but got {quantile_config}."
+        total_num_workers = torch.cuda.device_count() * self.num_workers_per_gpu
+
+        # Split data into chunks for parallel inference on each GPU
+        #   since the time series are of different lengths, we shuffle
+        #   the item_ids s.t. the workload is distributed evenly across GPUs
+        # Also, using 'min' since num_workers could be larger than the number of time series
+        np.random.seed(0)
+        item_ids_chunks = np.array_split(
+            np.random.permutation(train_tsdf.item_ids),
+            min(total_num_workers, len(train_tsdf.item_ids)),
+        )
+
+        # Run predictions in parallel
+        predictions = Parallel(n_jobs=len(item_ids_chunks), backend="loky")(
+            delayed(self._prediction_routine_per_gpu)(
+                train_tsdf.loc[chunk],
+                test_tsdf.loc[chunk],
+                gpu_id=i
+                % torch.cuda.device_count(),  # Alternate between available GPUs
             )
+            for i, chunk in enumerate(item_ids_chunks)
+        )
 
-        return super().predict(train_tsdf, test_tsdf, quantile_config)
+        predictions = pd.concat(predictions)
 
-    def _worker_specific_prediction_routine(
-        self,
-        train_X: pd.DataFrame,
-        train_y: pd.Series,
-        test_X: pd.DataFrame,
-        quantile_config: list[float],
-    ) -> pd.DataFrame:
-        from tabpfn_client import TabPFNRegressor
+        # Sort predictions according to original item_ids order
+        predictions = predictions.loc[train_tsdf.item_ids]
 
-        tabpfn = TabPFNRegressor(**self.tabpfn_config)
-        tabpfn.fit(train_X, train_y)
-        full_pred = tabpfn.predict_full(test_X)
+        return TimeSeriesDataFrame(predictions)
 
-        result = {"target": full_pred[self._get_optimization_mode()]}
-        result.update({q: full_pred[f"quantile_{q:.2f}"] for q in quantile_config})
+    def _get_tabpfn_engine(self):
+        from tabpfn import TabPFNRegressor
 
-        return result
+        if "model_path" in self.config["tabpfn_internal"]:
+            config = self.config["tabpfn_internal"].copy()
+            config["model_path"] = self._parse_model_path(config["model_path"])
 
-    def _get_optimization_mode(self):
-        if (
-            "optimize_metric" not in self.tabpfn_config
-            or self.tabpfn_config["optimize_metric"] is None
-        ):
-            return "mean"
-        elif self.tabpfn_config["optimize_metric"] in ["rmse", "mse", "r2", "mean"]:
-            return "mean"
-        elif self.tabpfn_config["optimize_metric"] in ["mae", "median"]:
-            return "median"
-        elif self.tabpfn_config["optimize_metric"] in ["mode", "exact_match"]:
-            return "mode"
-        else:
-            raise ValueError(f"Unknown metric {self.tabpfn_config['optimize_metric']}")
+        return TabPFNRegressor(**config, random_state=0)
 
+    def _parse_model_path(self, model_name: str) -> str:
+        return f"tabpfn-v2-regressor-{model_name}.ckpt"
 
-class LocalTabPFN(TabPFNWorker):
-    def __init__(
+    def _prediction_routine_per_gpu(
         self,
-        tabpfn_config: dict = {},
+        train_tsdf: TimeSeriesDataFrame,
+        test_tsdf: TimeSeriesDataFrame,
+        gpu_id: int,
     ):
-        # Local TabPFN has a different interface for declaring the model
-        if "model" in tabpfn_config:
-            config = tabpfn_config.copy()
-            config["model_path"] = self._parse_model_path(config["model"])
-            del config["model"]
-            tabpfn_config = config
+        # Set GPU
+        torch.cuda.set_device(gpu_id)
+
+        all_pred = []
+        for item_id in tqdm(train_tsdf.item_ids, desc=f"GPU {gpu_id}:"):
+            predictions = self._prediction_routine(
+                item_id,
+                train_tsdf.loc[item_id],
+                test_tsdf.loc[item_id],
+            )
+            all_pred.append(predictions)
 
-        super().__init__(tabpfn_config, num_workers=1)
+        # Clear GPU cache
+        torch.cuda.empty_cache()
 
-    def _worker_specific_prediction_routine(
-        self,
-        train_X: pd.DataFrame,
-        train_y: pd.Series,
-        test_X: pd.DataFrame,
-        quantile_config: list[float],
-    ) -> pd.DataFrame:
-        from tabpfn import TabPFNRegressor
+        return pd.concat(all_pred)
 
-        tabpfn = TabPFNRegressor(**self.tabpfn_config)
-        tabpfn.fit(train_X, train_y)
-        full_pred = tabpfn.predict_full(test_X)
 
-        result = {"target": full_pred[tabpfn.get_optimization_mode()]}
-        if set(quantile_config).issubset(set(TABPFN_DEFAULT_QUANTILE_CONFIG)):
-            result.update({q: full_pred[f"quantile_{q:.2f}"] for q in quantile_config})
-        else:
-            import torch
+class MockTabPFN(TabPFNWorker):
+    """
+    Mock TabPFN worker that returns random values for predictions.
+    Can be used for testing or debugging.
+    """
 
-            criterion = full_pred["criterion"]
-            logits = torch.tensor(full_pred["logits"])
-            result.update({q: criterion.icdf(logits, q) for q in quantile_config})
+    class MockTabPFNRegressor:
+        TABPFN_QUANTILE = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
 
-        return result
+        def __init__(self, *args, **kwargs):
+            pass
 
-    def _parse_model_path(self, model_name: str) -> str:
-        from pathlib import Path
-        import importlib.util
+        def fit(self, *args, **kwargs):
+            pass
 
-        tabpfn_path = Path(importlib.util.find_spec("tabpfn").origin).parent
-        return str(
-            tabpfn_path / "model_cache" / f"model_hans_regression_{model_name}.ckpt"
-        )
+        def predict(self, test_X, output_type="main", **kwargs):
+            if output_type != "main":
+                raise NotImplementedError(
+                    "Only main output is supported for mock TabPFN"
+                )
+
+            return {
+                "mean": np.random.rand(len(test_X)),
+                "median": np.random.rand(len(test_X)),
+                "mode": np.random.rand(len(test_X)),
+                "quantiles": [
+                    np.random.rand(len(test_X)) for _ in self.TABPFN_QUANTILE
+                ],
+            }
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def _get_tabpfn_engine(self):
+        return self.MockTabPFNRegressor()

{tabpfn_time_series-0.1.1.dist-info → tabpfn_time_series-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tabpfn_time_series
-Version: 0.1.1
+Version: 0.1.3
 Summary: Zero-shot time series forecasting with TabPFN
 Project-URL: Homepage, https://github.com/liam-sbhoo/tabpfn-time-series
 Project-URL: Bug Tracker, https://github.com/liam-sbhoo/tabpfn-time-series/issues
@@ -10,26 +10,36 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
-Requires-Dist: autogluon-timeseries
-Requires-Dist: gluonts
-Requires-Dist: pandas
-Requires-Dist: tabpfn-client
+Requires-Dist: autogluon-timeseries>=1.2
+Requires-Dist: datasets>=3.3.2
+Requires-Dist: gluonts>=0.16.0
+Requires-Dist: pandas<2.2.0,>=2.1.2
+Requires-Dist: tabpfn-client>=0.1.1
+Requires-Dist: tabpfn>=2.0.0
 Requires-Dist: tqdm
 Provides-Extra: dev
 Requires-Dist: build; extra == 'dev'
+Requires-Dist: jupyter; extra == 'dev'
 Requires-Dist: pre-commit; extra == 'dev'
 Requires-Dist: ruff; extra == 'dev'
 Requires-Dist: twine; extra == 'dev'
 Description-Content-Type: text/markdown
 
-# Time Series Forecasting with TabPFN
+# Zero-Shot Time Series Forecasting with TabPFN
 
+[![PyPI version](https://badge.fury.io/py/tabpfn-time-series.svg)](https://badge.fury.io/py/tabpfn-time-series)
 [![colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/liam-sbhoo/tabpfn-time-series/blob/main/demo.ipynb)
 [![Discord](https://img.shields.io/discord/1285598202732482621?color=7289da&label=Discord&logo=discord&logoColor=ffffff)](https://discord.com/channels/1285598202732482621/)
-[![arXiv](https://img.shields.io/badge/arXiv-<INDEX>-<COLOR>.svg)](https://arxiv.org/abs/2501.02945)
+[![arXiv](https://img.shields.io/badge/arXiv-2501.02945-<COLOR>.svg)](https://arxiv.org/abs/2501.02945)
 
+## 📌 News
+- **27-01-2025**: 🚀 Ranked _**1st**_ on [GIFT-EVAL](https://huggingface.co/spaces/Salesforce/GIFT-Eval) benchmark<sup>[1]</sup>!
+- **10-10-2024**: 🚀 TabPFN-TS [paper](https://arxiv.org/abs/2501.02945) accepted to NeurIPS 2024 [TRL](https://table-representation-learning.github.io/NeurIPS2024/) and [TSALM](https://neurips-time-series-workshop.github.io/) workshops!
 
-We demonstrate that the tabular foundation model **TabPFN**, when paired with minimal featurization, can perform zero-shot time series forecasting. Its performance on point forecasting matches or even slightly outperforms state-of-the-art methods.
+_[1] Last checked on: 10/03/2025_
+
+## ✨ Introduction
+We demonstrate that the tabular foundation model **[TabPFN](https://github.com/PriorLabs/TabPFN)**, when paired with minimal featurization, can perform zero-shot time series forecasting. Its performance on point forecasting matches or even slightly outperforms state-of-the-art methods.
 
 ## 📖 How does it work?
 
@@ -50,10 +60,16 @@ For more details, please refer to our [paper](https://arxiv.org/abs/2501.02945)
 - **Point and probabilistic forecasting**: it provides accurate point forecasts as well as probabilistic forecasts.
 - **Support for exogenous variables**: if you have exogenous variables, this method can seemlessly incorporate them into the forecasting model.
 
-On top of that, thanks to [tabpfn-client](https://github.com/automl/tabpfn-client) from [Prior Labs](https://priorlabs.ai), you won’t even need your own GPU to run fast inference with TabPFN. 😉 We have included `tabpfn-client` as the default engine in our implementation.
+On top of that, thanks to **[tabpfn-client](https://github.com/automl/tabpfn-client)** from **[Prior Labs](https://priorlabs.ai)**, you won’t even need your own GPU to run fast inference with TabPFN. 😉 We have included `tabpfn-client` as the default engine in our implementation.
 
 ## How to use it?
 
 [![colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/liam-sbhoo/tabpfn-time-series/blob/main/demo.ipynb)
 
 The demo should explain it all. 😉
+
+## 📊 GIFT-EVAL Benchmark
+
+We have submitted our results to the [GIFT-EVAL](https://huggingface.co/spaces/Salesforce/GIFT-Eval) benchmark. Stay tuned for results!
+
+For more details regarding the evaluation setup, please refer to [README.md](gift_eval/README.md).

tabpfn_time_series-0.1.3.dist-info/RECORD

@@ -0,0 +1,11 @@
+tabpfn_time_series/__init__.py,sha256=brJLLVOis4tBGOmNk6PCjyk_RaOvFITZgaYChOTVqSo,353
+tabpfn_time_series/data_preparation.py,sha256=iNW7sAnRkTgmzzOEHBhkkTwm_lQ3p_Q9xgAQ5PbkOts,5416
+tabpfn_time_series/defaults.py,sha256=u2_JnwxiZ5NNibzyNpsE63KuP3TcmOL1iAP8llZ2rJk,238
+tabpfn_time_series/feature.py,sha256=_9FxfQfgPOOO1MiT8hB8523eZ3Nc5oKuoY7vcohKZZc,2531
+tabpfn_time_series/plot.py,sha256=bwSYcWBanzPrUxXKFsbqG8fyGsOJZfgU2v3NsxzTSXo,6571
+tabpfn_time_series/predictor.py,sha256=JzuV34zERf1XDLacGzSFJb-o077qd7GlKC6lvD62EPk,1457
+tabpfn_time_series/tabpfn_worker.py,sha256=zvFwg4Dc01_m5emqmVITBr6W_cNZ04tMyntmj40pyPE,8299
+tabpfn_time_series-0.1.3.dist-info/METADATA,sha256=KQZBVKZgMX4e3uxk2LTCuSwruATLowUmgrP6wbcLMB8,4158
+tabpfn_time_series-0.1.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+tabpfn_time_series-0.1.3.dist-info/licenses/LICENSE.txt,sha256=iwhPL7kIWQG6gyLZZwIMDItGrNgxMDIq9itxkUSMapY,11345
+tabpfn_time_series-0.1.3.dist-info/RECORD,,

tabpfn_time_series-0.1.1.dist-info/RECORD

@@ -1,11 +0,0 @@
-tabpfn_time_series/__init__.py,sha256=atVNap8tQLI0t5COkkCop-wbY3y1FdVxIMfvCf6VDsQ,257
-tabpfn_time_series/data_preparation.py,sha256=iNW7sAnRkTgmzzOEHBhkkTwm_lQ3p_Q9xgAQ5PbkOts,5416
-tabpfn_time_series/defaults.py,sha256=C9HiD7Zm0BzVfE9e2f8nhpiPQSYx79hWozvzb-93L40,165
-tabpfn_time_series/feature.py,sha256=_9FxfQfgPOOO1MiT8hB8523eZ3Nc5oKuoY7vcohKZZc,2531
-tabpfn_time_series/plot.py,sha256=bwSYcWBanzPrUxXKFsbqG8fyGsOJZfgU2v3NsxzTSXo,6571
-tabpfn_time_series/predictor.py,sha256=YfJIe8KsyzkwgX4EFAHR8dDp-mqSv9WK88_qO_EXlws,1505
-tabpfn_time_series/tabpfn_worker.py,sha256=3xInPzzQtmIBPjbc_5TaQsX3-Bl3WOlxttqj3KZlC9Q,7395
-tabpfn_time_series-0.1.1.dist-info/METADATA,sha256=EK_9xSO0-EiE-YzlGietFOwOdD7gt5zFI5gqkzo1IMk,3147
-tabpfn_time_series-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-tabpfn_time_series-0.1.1.dist-info/licenses/LICENSE.txt,sha256=iwhPL7kIWQG6gyLZZwIMDItGrNgxMDIq9itxkUSMapY,11345
-tabpfn_time_series-0.1.1.dist-info/RECORD,,