autogluon.timeseries 1.4.1b20250821__py3-none-any.whl → 1.4.1b20250825__py3-none-any.whl

autogluon/timeseries/dataset/ts_dataframe.py

@@ -7,7 +7,7 @@ import reprlib
 from collections.abc import Iterable
 from itertools import islice
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, List, Optional, Tuple, Type, Union, overload
+from typing import TYPE_CHECKING, Any, Optional, Type, Union, overload
 
 import numpy as np
 import pandas as pd
@@ -118,7 +118,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
 
     """
 
-    index: pd.MultiIndex
+    index: pd.MultiIndex  # type: ignore
     _metadata = ["_static_features"]
 
     def __init__(
@@ -572,7 +572,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
             self.static_features = other._static_features
         return self
 
-    def split_by_time(self, cutoff_time: pd.Timestamp) -> Tuple[TimeSeriesDataFrame, TimeSeriesDataFrame]:
+    def split_by_time(self, cutoff_time: pd.Timestamp) -> tuple[TimeSeriesDataFrame, TimeSeriesDataFrame]:
         """Split dataframe to two different ``TimeSeriesDataFrame`` s before and after a certain ``cutoff_time``.
 
         Parameters
@@ -900,15 +900,15 @@ class TimeSeriesDataFrame(pd.DataFrame):
         return super().sort_index(*args, **kwargs)  # type: ignore
 
     def get_model_inputs_for_scoring(
-        self, prediction_length: int, known_covariates_names: Optional[List[str]] = None
-    ) -> Tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
+        self, prediction_length: int, known_covariates_names: Optional[list[str]] = None
+    ) -> tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
         """Prepare model inputs necessary to predict the last ``prediction_length`` time steps of each time series in the dataset.
 
         Parameters
         ----------
         prediction_length : int
             The forecast horizon, i.e., How many time steps into the future must be predicted.
-        known_covariates_names : List[str], optional
+        known_covariates_names : list[str], optional
             Names of the dataframe columns that contain covariates known in the future.
             See ``known_covariates_names`` of :class:`~autogluon.timeseries.TimeSeriesPredictor` for more details.
 
@@ -933,7 +933,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
         prediction_length: int,
         end_index: Optional[int] = None,
         suffix: Optional[str] = None,
-    ) -> Tuple[TimeSeriesDataFrame, TimeSeriesDataFrame]:
+    ) -> tuple[TimeSeriesDataFrame, TimeSeriesDataFrame]:
         """Generate a train/test split from the given dataset.
 
         This method can be used to generate splits for multi-window backtesting.
@@ -1083,7 +1083,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
             iterable = iter(iterable)
             return iter(lambda: tuple(islice(iterable, size)), ())
 
-        def resample_chunk(chunk: Iterable[Tuple[str, pd.DataFrame]]) -> pd.DataFrame:
+        def resample_chunk(chunk: Iterable[tuple[str, pd.DataFrame]]) -> pd.DataFrame:
             resampled_dfs = []
             for item_id, df in chunk:
                 resampled_df = df.resample(offset, level=TIMESTAMP, **kwargs).agg(aggregation)
@@ -1139,6 +1139,6 @@ class TimeSeriesDataFrame(pd.DataFrame):
             ...
 
         @overload
-        def __getitem__(self, items: List[str]) -> Self: ...  # type: ignore
+        def __getitem__(self, items: list[str]) -> Self: ...  # type: ignore
         @overload
         def __getitem__(self, item: str) -> pd.Series: ...  # type: ignore

autogluon/timeseries/learner.py

@@ -1,7 +1,7 @@
 import logging
 import reprlib
 import time
-from typing import Any, Dict, List, Literal, Optional, Type, Union
+from typing import Any, Literal, Optional, Type, Union
 
 import pandas as pd
 
@@ -26,7 +26,7 @@ class TimeSeriesLearner(AbstractLearner):
         self,
         path_context: str,
         target: str = "target",
-        known_covariates_names: Optional[List[str]] = None,
+        known_covariates_names: Optional[list[str]] = None,
         trainer_type: Type[TimeSeriesTrainer] = TimeSeriesTrainer,
         eval_metric: Union[str, TimeSeriesScorer, None] = None,
         prediction_length: int = 1,
@@ -56,7 +56,7 @@ class TimeSeriesLearner(AbstractLearner):
     def fit(
         self,
         train_data: TimeSeriesDataFrame,
-        hyperparameters: Union[str, Dict],
+        hyperparameters: Union[str, dict],
         val_data: Optional[TimeSeriesDataFrame] = None,
         hyperparameter_tune_kwargs: Optional[Union[str, dict]] = None,
         time_limit: Optional[float] = None,
@@ -194,9 +194,9 @@ class TimeSeriesLearner(AbstractLearner):
         self,
         data: TimeSeriesDataFrame,
         model: Optional[str] = None,
-        metrics: Optional[Union[str, TimeSeriesScorer, List[Union[str, TimeSeriesScorer]]]] = None,
+        metrics: Optional[Union[str, TimeSeriesScorer, list[Union[str, TimeSeriesScorer]]]] = None,
         use_cache: bool = True,
-    ) -> Dict[str, float]:
+    ) -> dict[str, float]:
         data = self.feature_generator.transform(data)
         return self.load_trainer().evaluate(data=data, model=model, metrics=metrics, use_cache=use_cache)
 
@@ -205,7 +205,7 @@ class TimeSeriesLearner(AbstractLearner):
         data: Optional[TimeSeriesDataFrame] = None,
         model: Optional[str] = None,
         metric: Optional[Union[str, TimeSeriesScorer]] = None,
-        features: Optional[List[str]] = None,
+        features: Optional[list[str]] = None,
         time_limit: Optional[float] = None,
         method: Literal["naive", "permutation"] = "permutation",
         subsample_size: int = 50,
@@ -273,7 +273,7 @@ class TimeSeriesLearner(AbstractLearner):
         self,
         data: Optional[TimeSeriesDataFrame] = None,
         extra_info: bool = False,
-        extra_metrics: Optional[List[Union[str, TimeSeriesScorer]]] = None,
+        extra_metrics: Optional[list[Union[str, TimeSeriesScorer]]] = None,
         use_cache: bool = True,
     ) -> pd.DataFrame:
         if data is not None:
@@ -282,7 +282,7 @@ class TimeSeriesLearner(AbstractLearner):
             data, extra_info=extra_info, extra_metrics=extra_metrics, use_cache=use_cache
         )
 
-    def get_info(self, include_model_info: bool = False, **kwargs) -> Dict[str, Any]:
+    def get_info(self, include_model_info: bool = False, **kwargs) -> dict[str, Any]:
         learner_info = super().get_info(include_model_info=include_model_info)
         trainer = self.load_trainer()
         trainer_info = trainer.get_info(include_model_info=include_model_info)
@@ -300,31 +300,31 @@ class TimeSeriesLearner(AbstractLearner):
         return learner_info
 
     def persist_trainer(
-        self, models: Union[Literal["all", "best"], List[str]] = "all", with_ancestors: bool = False
-    ) -> List[str]:
+        self, models: Union[Literal["all", "best"], list[str]] = "all", with_ancestors: bool = False
+    ) -> list[str]:
         """Loads models and trainer in memory so that they don't have to be
         loaded during predictions
 
         Returns
         -------
-        list_of_models : List[str]
+        list_of_models
             List of models persisted in memory
         """
         self.trainer = self.load_trainer()
         return self.trainer.persist(models, with_ancestors=with_ancestors)
 
-    def unpersist_trainer(self) -> List[str]:
+    def unpersist_trainer(self) -> list[str]:
         """Unloads models and trainer from memory. Models will have to be reloaded from disk
         when predicting.
 
         Returns
         -------
-        list_of_models : List[str]
+        list_of_models
             List of models removed from memory
         """
         unpersisted_models = self.load_trainer().unpersist()
         self.trainer = None  # type: ignore
         return unpersisted_models
 
-    def refit_full(self, model: str = "all") -> Dict[str, str]:
+    def refit_full(self, model: str = "all") -> dict[str, str]:
         return self.load_trainer().refit_full(model=model)

autogluon/timeseries/metrics/__init__.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from pprint import pformat
-from typing import Any, Dict, Optional, Sequence, Type, Union
+from typing import Any, Optional, Sequence, Type, Union
 
 import numpy as np
 
@@ -28,7 +28,7 @@ __all__ = [
 
 DEFAULT_METRIC_NAME = "WQL"
 
-AVAILABLE_METRICS: Dict[str, Type[TimeSeriesScorer]] = {
+AVAILABLE_METRICS: dict[str, Type[TimeSeriesScorer]] = {
     "MASE": MASE,
     "MAPE": MAPE,
     "SMAPE": SMAPE,
@@ -48,7 +48,7 @@ DEPRECATED_METRICS = {
 }
 
 # Experimental metrics that are not yet user facing
-EXPERIMENTAL_METRICS: Dict[str, Type[TimeSeriesScorer]] = {
+EXPERIMENTAL_METRICS: dict[str, Type[TimeSeriesScorer]] = {
     "WCD": WCD,
 }
 
@@ -63,7 +63,7 @@ def check_get_evaluation_metric(
 
     Returns
     -------
-    scorer :
+    scorer
         A `TimeSeriesScorer` object based on the provided `eval_metric`.
 
         `scorer.prediction_length` is always set to the `prediction_length` provided to this method.
@@ -75,7 +75,7 @@ def check_get_evaluation_metric(
         value of `horizon_weight` is kept.
     """
     scorer: TimeSeriesScorer
-    metric_kwargs: Dict[str, Any] = dict(
+    metric_kwargs: dict[str, Any] = dict(
         prediction_length=prediction_length, seasonal_period=seasonal_period, horizon_weight=horizon_weight
     )
     if isinstance(eval_metric, TimeSeriesScorer):

autogluon/timeseries/metrics/abstract.py

@@ -1,5 +1,5 @@
 import warnings
-from typing import Optional, Sequence, Tuple, Union, overload
+from typing import Optional, Sequence, Union, overload
 
 import numpy as np
 import numpy.typing as npt
@@ -200,14 +200,14 @@ class TimeSeriesScorer:
     @staticmethod
     def _get_point_forecast_score_inputs(
         data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target"
-    ) -> Tuple[pd.Series, pd.Series]:
+    ) -> tuple[pd.Series, pd.Series]:
         """Get inputs necessary to compute point forecast metrics.
 
         Returns
         -------
-        y_true : pd.Series, shape [num_items * prediction_length]
+        y_true
             Target time series values during the forecast horizon.
-        y_pred : pd.Series, shape [num_items * prediction_length]
+        y_pred
             Predicted time series values during the forecast horizon.
         """
         y_true = data_future[target]
@@ -217,16 +217,16 @@ class TimeSeriesScorer:
     @staticmethod
     def _get_quantile_forecast_score_inputs(
         data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target"
-    ) -> Tuple[pd.Series, pd.DataFrame, np.ndarray]:
+    ) -> tuple[pd.Series, pd.DataFrame, np.ndarray]:
         """Get inputs necessary to compute quantile forecast metrics.
 
         Returns
         -------
-        y_true : pd.Series, shape [num_items * prediction_length]
+        y_true
             Target time series values during the forecast horizon.
-        q_pred : pd.DataFrame, shape [num_items * prediction_length, num_quantiles]
+        q_pred
             Quantile forecast for each predicted quantile level. Column order corresponds to ``quantile_levels``.
-        quantile_levels : np.ndarray, shape [num_quantiles]
+        quantile_levels
             Quantile levels for which the forecasts are generated (as floats).
         """
         quantile_columns = [col for col in predictions.columns if col != "mean"]
@@ -253,7 +253,7 @@ class TimeSeriesScorer:
 
         Returns
         -------
-        horizon_weight:
+        horizon_weight
             None if the input is None, otherwise a numpy array of shape [1, prediction_length].
         """
         if horizon_weight is None:

autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -1,12 +1,10 @@
-from __future__ import annotations
-
 import copy
 import logging
 import os
 import re
 import time
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
+from typing import Any, Optional, Sequence, Union
 
 import pandas as pd
 from typing_extensions import Self
@@ -38,27 +36,27 @@ class TimeSeriesModelBase(ModelBase, ABC):
 
     Parameters
     ----------
-    path : str, default = None
+    path
         Directory location to store all outputs.
         If None, a new unique time-stamped directory is chosen.
-    freq: str
+    freq
         Frequency string (cf. gluonts frequency strings) describing the frequency
         of the time series data. For example, "h" for hourly or "D" for daily data.
-    prediction_length: int
+    prediction_length
         Length of the prediction horizon, i.e., the number of time steps the model
         is fit to forecast.
-    name : str, default = None
+    name
         Name of the subdirectory inside path where model will be saved.
         The final model directory will be os.path.join(path, name)
         If None, defaults to the model's class name: self.__class__.__name__
-    covariate_metadata: CovariateMetadata
+    covariate_metadata
         A mapping of different covariate types known to autogluon.timeseries to column names
         in the data set.
-    eval_metric : Union[str, TimeSeriesScorer], default = "WQL"
+    eval_metric
         Metric by which predictions will be ultimately evaluated on future test data. This only impacts
         ``model.score()``, as eval_metric is not used during training. Available metrics can be found in
         ``autogluon.timeseries.metrics``.
-    hyperparameters : dict, default = None
+    hyperparameters
         Hyperparameters that will be used by the model (can be search spaces instead of fixed values).
         If None, model defaults are used. This is identical to passing an empty dictionary.
     """
@@ -79,7 +77,7 @@ class TimeSeriesModelBase(ModelBase, ABC):
         self,
         path: Optional[str] = None,
         name: Optional[str] = None,
-        hyperparameters: Optional[Dict[str, Any]] = None,
+        hyperparameters: Optional[dict[str, Any]] = None,
         freq: Optional[str] = None,
         prediction_length: int = 1,
         covariate_metadata: Optional[CovariateMetadata] = None,
@@ -119,7 +117,7 @@ class TimeSeriesModelBase(ModelBase, ABC):
         else:
             self.must_drop_median = False
 
-        self._oof_predictions: Optional[List[TimeSeriesDataFrame]] = None
+        self._oof_predictions: Optional[list[TimeSeriesDataFrame]] = None
 
         # user provided hyperparameters and extra arguments that are used during model training
         self._hyperparameters, self._extra_ag_args = self._check_and_split_hyperparameters(hyperparameters)
@@ -147,22 +145,21 @@ class TimeSeriesModelBase(ModelBase, ABC):
 
     @classmethod
     def _check_and_split_hyperparameters(
-        cls, hyperparameters: Optional[Dict[str, Any]] = None
-    ) -> Tuple[Dict[str, Any], Dict[str, Any]]:
-        """
-        Given the user-specified hyperparameters, split into `hyperparameters` and `extra_ag_args`, intended
+        cls, hyperparameters: Optional[dict[str, Any]] = None
+    ) -> tuple[dict[str, Any], dict[str, Any]]:
+        """Given the user-specified hyperparameters, split into `hyperparameters` and `extra_ag_args`, intended
         to be used during model initialization.
 
         Parameters
         ----------
-        hyperparameters : Optional[Dict[str, Any]], default = None
+        hyperparameters
             The model hyperparameters dictionary provided to the model constructor.
 
         Returns
         -------
-        hyperparameters: Dict[str, Any]
+        hyperparameters
             Native model hyperparameters that are passed into the "inner model" AutoGluon wraps
-        extra_ag_args: Dict[str, Any]
+        extra_ag_args
             Special auxiliary parameters that modify the model training process used by AutoGluon
         """
         hyperparameters = copy.deepcopy(hyperparameters) if hyperparameters is not None else dict()
@@ -214,7 +211,7 @@ class TimeSeriesModelBase(ModelBase, ABC):
         return model
 
     @classmethod
-    def load_oof_predictions(cls, path: str, verbose: bool = True) -> List[TimeSeriesDataFrame]:
+    def load_oof_predictions(cls, path: str, verbose: bool = True) -> list[TimeSeriesDataFrame]:
         """Load the cached OOF predictions from disk."""
         return load_pkl.load(path=os.path.join(path, "utils", cls._oof_filename), verbose=verbose)
 
@@ -284,7 +281,7 @@ class TimeSeriesModelBase(ModelBase, ABC):
         return False
 
     @staticmethod
-    def _get_system_resources() -> Dict[str, Any]:
+    def _get_system_resources() -> dict[str, Any]:
         resource_manager = get_resource_manager()
         system_num_cpus = resource_manager.get_cpu_count()
         system_num_gpus = resource_manager.get_gpu_count()
@@ -306,7 +303,8 @@ class TimeSeriesModelBase(ModelBase, ABC):
     def _more_tags(self) -> dict:
         """Encode model properties using tags, similar to sklearn & autogluon.tabular.
 
-        For more details, see `autogluon.core.models.abstract.AbstractModel._get_tags()` and https://scikit-learn.org/stable/_sources/developers/develop.rst.txt.
+        For more details, see `autogluon.core.models.abstract.AbstractModel._get_tags()` and
+        https://scikit-learn.org/stable/_sources/developers/develop.rst.txt.
 
         List of currently supported tags:
         - allow_nan: Can the model handle data with missing values represented by np.nan?
@@ -388,7 +386,7 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, metaclass=
         self,
         path: Optional[str] = None,
         name: Optional[str] = None,
-        hyperparameters: Optional[Dict[str, Any]] = None,
+        hyperparameters: Optional[dict[str, Any]] = None,
         freq: Optional[str] = None,
         prediction_length: int = 1,
         covariate_metadata: Optional[CovariateMetadata] = None,
@@ -428,7 +426,7 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, metaclass=
         )
 
     @property
-    def allowed_hyperparameters(self) -> List[str]:
+    def allowed_hyperparameters(self) -> list[str]:
         """List of hyperparameters allowed by the model."""
         return ["target_scaler", "covariate_regressor", "covariate_scaler"]
 
@@ -445,32 +443,32 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, metaclass=
         Models should not override the `fit` method, but instead override the `_fit` method which
         has the same arguments.
 
-        Other Parameters
-        ----------------
-        train_data : TimeSeriesDataFrame
+        Parameters
+        ----------
+        train_data
             The training data provided in the library's `autogluon.timeseries.dataset.TimeSeriesDataFrame`
             format.
-        val_data : TimeSeriesDataFrame, optional
+        val_data
             The validation data set in the same format as training data.
-        time_limit : float, default = None
+        time_limit
             Time limit in seconds to adhere to when fitting model.
             Ideally, model should early stop during fit to avoid going over the time limit if specified.
-        num_cpus : int, default = 'auto'
+        num_cpus
             How many CPUs to use during fit.
             This is counted in virtual cores, not in physical cores.
             If 'auto', model decides.
-        num_gpus : int, default = 'auto'
+        num_gpus
             How many GPUs to use during fit.
             If 'auto', model decides.
-        verbosity : int, default = 2
+        verbosity
             Verbosity levels range from 0 to 4 and control how much information is printed.
             Higher levels correspond to more detailed print statements (you can set verbosity = 0 to suppress warnings).
-        **kwargs :
+        **kwargs
             Any additional fit arguments a model supports.
 
         Returns
         -------
-        model: AbstractTimeSeriesModel
+        model
             The fitted model object
         """
         start_time = time.monotonic()
@@ -553,7 +551,7 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, metaclass=
                 "as hyperparameters when initializing or use `hyperparameter_tune` instead."
             )
 
-    def _log_unused_hyperparameters(self, extra_allowed_hyperparameters: list[str] | None = None) -> None:
+    def _log_unused_hyperparameters(self, extra_allowed_hyperparameters: Optional[list[str]] = None) -> None:
         """Log a warning if unused hyperparameters were provided to the model."""
         allowed_hyperparameters = self.allowed_hyperparameters
         if extra_allowed_hyperparameters is not None:
@@ -581,15 +579,15 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, metaclass=
 
         Parameters
         ----------
-        data: Union[TimeSeriesDataFrame, Dict[str, Optional[TimeSeriesDataFrame]]]
+        data
             The dataset where each time series is the "context" for predictions. For ensemble models that depend on
             the predictions of other models, this method may accept a dictionary of previous models' predictions.
-        known_covariates : Optional[TimeSeriesDataFrame]
+        known_covariates
             A TimeSeriesDataFrame containing the values of the known covariates during the forecast horizon.
 
         Returns
         -------
-        predictions: TimeSeriesDataFrame
+        predictions
             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.
@@ -705,12 +703,12 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, metaclass=
 
         Parameters
         ----------
-        data: TimeSeriesDataFrame
+        data
             Dataset used for scoring.
 
         Returns
         -------
-        score: float
+        score
             The computed forecast evaluation score on the last `self.prediction_length`
             time steps of each time series.
         """
@@ -745,6 +743,6 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, metaclass=
         known_covariates: Optional[TimeSeriesDataFrame] = None,
         is_train: bool = False,
         **kwargs,
-    ) -> Tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
+    ) -> tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
         """Method that implements model-specific preprocessing logic."""
         return data, known_covariates

autogluon/timeseries/models/abstract/tunable.py

@@ -5,7 +5,7 @@ import os
 import time
 from abc import ABC, abstractmethod
 from contextlib import nullcontext
-from typing import Any, Dict, Optional, Tuple, Union
+from typing import Any, Optional, Union
 
 from typing_extensions import Self
 
@@ -43,7 +43,7 @@ class TimeSeriesTunable(Tunable, ABC):
         refit_every_n_windows: Optional[int] = 1,
         hyperparameter_tune_kwargs: Union[str, dict] = "auto",
         time_limit: Optional[float] = None,
-    ) -> Tuple[Dict[str, Any], Any]:
+    ) -> tuple[dict[str, Any], Any]:
         hpo_executor = self._get_default_hpo_executor()
         hpo_executor.initialize(
             hyperparameter_tune_kwargs, default_num_trials=default_num_trials, time_limit=time_limit
@@ -144,14 +144,14 @@ class TimeSeriesTunable(Tunable, ABC):
         """
         return None
 
-    def get_minimum_resources(self, is_gpu_available: bool = False) -> Dict[str, Union[int, float]]:
+    def get_minimum_resources(self, is_gpu_available: bool = False) -> dict[str, Union[int, float]]:
         return {
             "num_cpus": 1,
         }
 
     def _save_with_data(
         self, train_data: TimeSeriesDataFrame, val_data: Optional[TimeSeriesDataFrame]
-    ) -> Tuple[str, str]:
+    ) -> tuple[str, str]:
         self.path = os.path.abspath(self.path)
         self.path_root = self.path.rsplit(self.name, 1)[0]
 
@@ -173,7 +173,7 @@ class TimeSeriesTunable(Tunable, ABC):
         pass
 
     @abstractmethod
-    def _get_search_space(self) -> Dict[str, Any]:
+    def _get_search_space(self) -> dict[str, Any]:
         pass
 
     @abstractmethod
@@ -185,5 +185,5 @@ class TimeSeriesTunable(Tunable, ABC):
 
     @staticmethod
     @abstractmethod
-    def _get_system_resources() -> Dict[str, Any]:
+    def _get_system_resources() -> dict[str, Any]:
         pass