[MNT] Update ruff linting target version to python 3.10 (#2017)

This PR Updates linting to `py310` target version of `ruff`

Author: phoeenniixx

pytorch_forecasting/_registry/_lookup.py

@@ -160,7 +160,7 @@ def all_objects(
     ROOT = str(Path(__file__).parent.parent)  # package root directory
 
     def _coerce_to_str(obj):
-        if isinstance(obj, (list, tuple)):
+        if isinstance(obj, list | tuple):
             return [_coerce_to_str(o) for o in obj]
         if isclass(obj):
             obj = obj.get_tag("object_type")

pytorch_forecasting/base/_base_pkg.py

@@ -42,10 +42,10 @@ class Base_pkg(_BasePtForecasterV2):
 
     def __init__(
         self,
-        model_cfg: Optional[Union[dict[str, Any], str, Path]] = None,
-        trainer_cfg: Optional[Union[dict[str, Any], str, Path]] = None,
-        datamodule_cfg: Optional[Union[dict[str, Any], str, Path]] = None,
-        ckpt_path: Optional[Union[str, Path]] = None,
+        model_cfg: dict[str, Any] | str | Path | None = None,
+        trainer_cfg: dict[str, Any] | str | Path | None = None,
+        datamodule_cfg: dict[str, Any] | str | Path | None = None,
+        ckpt_path: str | Path | None = None,
     ):
         self.ckpt_path = Path(ckpt_path) if ckpt_path else None
         self.model_cfg = self._load_config(
@@ -74,9 +74,9 @@ def __init__(
 
     @staticmethod
     def _load_config(
-        config: Union[dict, str, Path, None],
-        ckpt_path: Optional[Union[str, Path]] = None,
-        auto_file_name: Optional[str] = None,
+        config: dict | str | Path | None,
+        ckpt_path: str | Path | None = None,
+        auto_file_name: str | None = None,
     ) -> dict:
         """
         Loads configuration from a dictionary, YAML file, or Pickle file.
@@ -157,7 +157,7 @@ def _build_datamodule(self, data: TimeSeries) -> LightningDataModule:
         return datamodule_cls(data, **self.datamodule_cfg)
 
     def _load_dataloader(
-        self, data: Union[TimeSeries, LightningDataModule, DataLoader]
+        self, data: TimeSeries | LightningDataModule | DataLoader
     ) -> DataLoader:
         """Converts various data input types into a DataLoader for prediction."""
         if isinstance(data, TimeSeries):  # D1 Layer
@@ -191,11 +191,11 @@ def _save_artifact(self, output_dir: Path):
 
     def fit(
         self,
-        data: Union[TimeSeries, LightningDataModule],
+        data: TimeSeries | LightningDataModule,
         # todo: we should create a base data_module for different data_modules
         save_ckpt: bool = True,
-        ckpt_dir: Union[str, Path] = "checkpoints",
-        ckpt_kwargs: Optional[dict[str, Any]] = None,
+        ckpt_dir: str | Path = "checkpoints",
+        ckpt_kwargs: dict[str, Any] | None = None,
         **trainer_fit_kwargs,
     ):
         """
@@ -265,10 +265,10 @@ def fit(
 
     def predict(
         self,
-        data: Union[TimeSeries, LightningDataModule, DataLoader],
-        output_dir: Optional[Union[str, Path]] = None,
+        data: TimeSeries | LightningDataModule | DataLoader,
+        output_dir: str | Path | None = None,
         **kwargs,
-    ) -> Union[dict[str, torch.Tensor], None]:
+    ) -> dict[str, torch.Tensor] | None:
         """
         Generate predictions by wrapping the model's predict method.
 

pytorch_forecasting/callbacks/predict.py

@@ -29,7 +29,7 @@ class PredictCallback(BasePredictionWriter):
     def __init__(
         self,
         mode: str = "prediction",
-        return_info: Optional[list[str]] = None,
+        return_info: list[str] | None = None,
         mode_kwargs: dict[str, Any] = None,
     ):
         super().__init__(write_interval="epoch")

pytorch_forecasting/data/_tslib_data_module.py

@@ -2,7 +2,8 @@
 Experimental data module for integrating `tslib` time series deep learning library.
 """
 
-from typing import Any, Optional, Union
+from collections.abc import Callable
+from typing import Any, Optional
 import warnings
 
 from lightning.pytorch import LightningDataModule
@@ -20,7 +21,7 @@
 from pytorch_forecasting.data.timeseries._timeseries_v2 import TimeSeries
 from pytorch_forecasting.utils._coerce import _coerce_to_dict
 
-NORMALIZER = Union[TorchNormalizer, EncoderNormalizer, NaNLabelEncoder]
+NORMALIZER = TorchNormalizer | EncoderNormalizer | NaNLabelEncoder
 
 
 class _TslibDataset(Dataset):
@@ -294,21 +295,21 @@ def __init__(
         freq: str = "h",
         add_relative_time_idx: bool = False,
         add_target_scales: bool = False,
-        target_normalizer: Union[
-            NORMALIZER, str, list[NORMALIZER], tuple[NORMALIZER], None
-        ] = "auto",  # noqa: E501
-        scalers: Optional[
-            dict[
-                str,
-                Union[StandardScaler, RobustScaler, TorchNormalizer, EncoderNormalizer],
-            ]
-        ] = None,  # noqa: E501
+        target_normalizer: NORMALIZER
+        | str
+        | list[NORMALIZER]
+        | tuple[NORMALIZER]
+        | None = "auto",  # noqa: E501
+        scalers: dict[
+            str, StandardScaler | RobustScaler | TorchNormalizer | EncoderNormalizer
+        ]
+        | None = None,  # noqa: E501
         shuffle: bool = True,
         window_stride: int = 1,
         batch_size: int = 32,
         num_workers: int = 0,
         train_val_test_split: tuple[float, float, float] = (0.7, 0.15, 0.15),
-        collate_fn: Optional[callable] = None,
+        collate_fn: Callable | None = None,
         **kwargs,
     ) -> None:
         super().__init__()
@@ -670,7 +671,7 @@ def _create_windows(self, indices: torch.Tensor) -> list[tuple[int, int, int, in
 
         return windows
 
-    def setup(self, stage: Optional[str] = None) -> None:
+    def setup(self, stage: str | None = None) -> None:
         """
         Setup the data module by preparing the datasets for training,
         testing and validation.
@@ -879,7 +880,7 @@ def collate_fn(batch):
                 [x["static_continuous_features"] for x, _ in batch]
             )
 
-        if isinstance(batch[0][1], (list, tuple)):
+        if isinstance(batch[0][1], list | tuple):
             num_targets = len(batch[0][1])
             y_batch = []
             for i in range(num_targets):

pytorch_forecasting/data/data_module.py

@@ -23,7 +23,7 @@
 from pytorch_forecasting.data.timeseries import TimeSeries
 from pytorch_forecasting.utils._coerce import _coerce_to_dict
 
-NORMALIZER = Union[TorchNormalizer, NaNLabelEncoder, EncoderNormalizer]
+NORMALIZER = TorchNormalizer | EncoderNormalizer | NaNLabelEncoder
 
 
 class EncoderDecoderTimeSeriesDataModule(LightningDataModule):
@@ -85,25 +85,25 @@ def __init__(
         self,
         time_series_dataset: TimeSeries,
         max_encoder_length: int = 30,
-        min_encoder_length: Optional[int] = None,
+        min_encoder_length: int | None = None,
         max_prediction_length: int = 1,
-        min_prediction_length: Optional[int] = None,
-        min_prediction_idx: Optional[int] = None,
+        min_prediction_length: int | None = None,
+        min_prediction_idx: int | None = None,
         allow_missing_timesteps: bool = False,
         add_relative_time_idx: bool = False,
         add_target_scales: bool = False,
-        add_encoder_length: Union[bool, str] = "auto",
-        target_normalizer: Union[
-            NORMALIZER, str, list[NORMALIZER], tuple[NORMALIZER], None
-        ] = "auto",
-        categorical_encoders: Optional[dict[str, NaNLabelEncoder]] = None,
-        scalers: Optional[
-            dict[
-                str,
-                Union[StandardScaler, RobustScaler, TorchNormalizer, EncoderNormalizer],
-            ]
-        ] = None,
-        randomize_length: Union[None, tuple[float, float], bool] = False,
+        add_encoder_length: bool | str = "auto",
+        target_normalizer: NORMALIZER
+        | str
+        | list[NORMALIZER]
+        | tuple[NORMALIZER]
+        | None = "auto",
+        categorical_encoders: dict[str, NaNLabelEncoder] | None = None,
+        scalers: dict[
+            str, StandardScaler | RobustScaler | TorchNormalizer | EncoderNormalizer
+        ]
+        | None = None,
+        randomize_length: None | tuple[float, float] | bool = False,
         batch_size: int = 32,
         num_workers: int = 0,
         train_val_test_split: tuple = (0.7, 0.15, 0.15),
@@ -623,7 +623,7 @@ def _create_windows(self, indices: torch.Tensor) -> list[tuple[int, int, int, in
 
         return windows
 
-    def setup(self, stage: Optional[str] = None):
+    def setup(self, stage: str | None = None):
         """Prepare the datasets for training, validation, testing, or prediction.
 
         Parameters
@@ -746,7 +746,7 @@ def collate_fn(batch):
                 [x["static_continuous_features"] for x, _ in batch]
             )
 
-        if isinstance(batch[0][1], (list, tuple)):
+        if isinstance(batch[0][1], list | tuple):
             num_targets = len(batch[0][1])
             y_batch = []
             for i in range(num_targets):