Migrate from Tuple -> tuple in torch/utils/data (pytorch#144255)

Pull Request resolved: pytorch#144255
Approved by: https://github.com/andrewkho

Author: bobrenjc93

torch/utils/data/_utils/collate.py

@@ -12,7 +12,7 @@
 import contextlib
 import copy
 import re
-from typing import Callable, Dict, Optional, Tuple, Type, Union
+from typing import Callable, Dict, Optional, Type, Union
 
 import torch
 
@@ -118,7 +118,7 @@ def default_convert(data):
 def collate(
     batch,
     *,
-    collate_fn_map: Optional[Dict[Union[Type, Tuple[Type, ...]], Callable]] = None,
+    collate_fn_map: Optional[Dict[Union[Type, tuple[Type, ...]], Callable]] = None,
 ):
     r"""
     General collate function that handles collection type of element within each batch.
@@ -243,7 +243,7 @@ def collate(
 def collate_tensor_fn(
     batch,
     *,
-    collate_fn_map: Optional[Dict[Union[Type, Tuple[Type, ...]], Callable]] = None,
+    collate_fn_map: Optional[Dict[Union[Type, tuple[Type, ...]], Callable]] = None,
 ):
     elem = batch[0]
     out = None
@@ -275,7 +275,7 @@ def collate_tensor_fn(
 def collate_numpy_array_fn(
     batch,
     *,
-    collate_fn_map: Optional[Dict[Union[Type, Tuple[Type, ...]], Callable]] = None,
+    collate_fn_map: Optional[Dict[Union[Type, tuple[Type, ...]], Callable]] = None,
 ):
     elem = batch[0]
     # array of string classes and object
@@ -288,36 +288,36 @@ def collate_numpy_array_fn(
 def collate_numpy_scalar_fn(
     batch,
     *,
-    collate_fn_map: Optional[Dict[Union[Type, Tuple[Type, ...]], Callable]] = None,
+    collate_fn_map: Optional[Dict[Union[Type, tuple[Type, ...]], Callable]] = None,
 ):
     return torch.as_tensor(batch)
 
 
 def collate_float_fn(
     batch,
     *,
-    collate_fn_map: Optional[Dict[Union[Type, Tuple[Type, ...]], Callable]] = None,
+    collate_fn_map: Optional[Dict[Union[Type, tuple[Type, ...]], Callable]] = None,
 ):
     return torch.tensor(batch, dtype=torch.float64)
 
 
 def collate_int_fn(
     batch,
     *,
-    collate_fn_map: Optional[Dict[Union[Type, Tuple[Type, ...]], Callable]] = None,
+    collate_fn_map: Optional[Dict[Union[Type, tuple[Type, ...]], Callable]] = None,
 ):
     return torch.tensor(batch)
 
 
 def collate_str_fn(
     batch,
     *,
-    collate_fn_map: Optional[Dict[Union[Type, Tuple[Type, ...]], Callable]] = None,
+    collate_fn_map: Optional[Dict[Union[Type, tuple[Type, ...]], Callable]] = None,
 ):
     return batch
 
 
-default_collate_fn_map: Dict[Union[Type, Tuple[Type, ...]], Callable] = {
+default_collate_fn_map: Dict[Union[Type, tuple[Type, ...]], Callable] = {
     torch.Tensor: collate_tensor_fn
 }
 with contextlib.suppress(ImportError):

torch/utils/data/datapipes/gen_pyi.py

@@ -2,7 +2,7 @@
 import os
 import pathlib
 from collections import defaultdict
-from typing import Any, Dict, List, Set, Tuple, Union
+from typing import Any, Dict, List, Set, Union
 
 
 def materialize_lines(lines: List[str], indentation: int) -> str:
@@ -19,7 +19,7 @@ def gen_from_template(
     dir: str,
     template_name: str,
     output_name: str,
-    replacements: List[Tuple[str, Any, int]],
+    replacements: List[tuple[str, Any, int]],
 ):
     template_path = os.path.join(dir, template_name)
     output_path = os.path.join(dir, output_name)
@@ -75,7 +75,7 @@ def extract_class_name(line: str) -> str:
 
 def parse_datapipe_file(
     file_path: str,
-) -> Tuple[Dict[str, str], Dict[str, str], Set[str], Dict[str, List[str]]]:
+) -> tuple[Dict[str, str], Dict[str, str], Set[str], Dict[str, List[str]]]:
     """Given a path to file, parses the file and returns a dictionary of method names to function signatures."""
     method_to_signature, method_to_class_name, special_output_type = {}, {}, set()
     doc_string_dict = defaultdict(list)
@@ -127,7 +127,7 @@ def parse_datapipe_file(
 
 def parse_datapipe_files(
     file_paths: Set[str],
-) -> Tuple[Dict[str, str], Dict[str, str], Set[str], Dict[str, List[str]]]:
+) -> tuple[Dict[str, str], Dict[str, str], Set[str], Dict[str, List[str]]]:
     (
         methods_and_signatures,
         methods_and_class_names,

torch/utils/data/datapipes/iter/combining.py

@@ -12,7 +12,6 @@
     Literal,
     Optional,
     Sized,
-    Tuple,
     TypeVar,
 )
 
@@ -54,7 +53,7 @@ class ConcaterIterDataPipe(IterDataPipe):
         [0, 1, 2, 0, 1, 2, 3, 4]
     """
 
-    datapipes: Tuple[IterDataPipe]
+    datapipes: tuple[IterDataPipe]
 
     def __init__(self, *datapipes: IterDataPipe):
         if len(datapipes) == 0:
@@ -668,7 +667,7 @@ def __del__(self):
 
 
 @functional_datapipe("zip")
-class ZipperIterDataPipe(IterDataPipe[Tuple[_T_co]]):
+class ZipperIterDataPipe(IterDataPipe[tuple[_T_co]]):
     r"""
     Aggregates elements into a tuple from each of the input DataPipes (functional name: ``zip``).
 
@@ -685,7 +684,7 @@ class ZipperIterDataPipe(IterDataPipe[Tuple[_T_co]]):
         [(0, 10, 20), (1, 11, 21), (2, 12, 22), (3, 13, 23), (4, 14, 24)]
     """
 
-    datapipes: Tuple[IterDataPipe]
+    datapipes: tuple[IterDataPipe]
 
     def __init__(self, *datapipes: IterDataPipe):
         if not all(isinstance(dp, IterDataPipe) for dp in datapipes):
@@ -695,7 +694,7 @@ def __init__(self, *datapipes: IterDataPipe):
         super().__init__()
         self.datapipes = datapipes  # type: ignore[assignment]
 
-    def __iter__(self) -> Iterator[Tuple[_T_co]]:
+    def __iter__(self) -> Iterator[tuple[_T_co]]:
         iterators = [iter(datapipe) for datapipe in self.datapipes]
         yield from zip(*iterators)
 

torch/utils/data/datapipes/iter/fileopener.py

@@ -1,6 +1,6 @@
 # mypy: allow-untyped-defs
 from io import IOBase
-from typing import Iterable, Optional, Tuple
+from typing import Iterable, Optional
 
 from torch.utils.data.datapipes._decorator import functional_datapipe
 from torch.utils.data.datapipes.datapipe import IterDataPipe
@@ -13,7 +13,7 @@
 
 
 @functional_datapipe("open_files")
-class FileOpenerIterDataPipe(IterDataPipe[Tuple[str, IOBase]]):
+class FileOpenerIterDataPipe(IterDataPipe[tuple[str, IOBase]]):
     r"""
     Given pathnames, opens files and yield pathname and file stream in a tuple (functional name: ``open_files``).
 

torch/utils/data/datapipes/iter/routeddecoder.py

@@ -1,5 +1,5 @@
 from io import BufferedIOBase
-from typing import Any, Callable, Iterable, Iterator, Sized, Tuple
+from typing import Any, Callable, Iterable, Iterator, Sized
 
 from torch.utils.data.datapipes._decorator import functional_datapipe
 from torch.utils.data.datapipes.datapipe import IterDataPipe
@@ -16,7 +16,7 @@
 
 
 @functional_datapipe("routed_decode")
-class RoutedDecoderIterDataPipe(IterDataPipe[Tuple[str, Any]]):
+class RoutedDecoderIterDataPipe(IterDataPipe[tuple[str, Any]]):
     r"""
     Decodes binary streams from input DataPipe, yields pathname and decoded data in a tuple.
 
@@ -38,12 +38,12 @@ class RoutedDecoderIterDataPipe(IterDataPipe[Tuple[str, Any]]):
 
     def __init__(
         self,
-        datapipe: Iterable[Tuple[str, BufferedIOBase]],
+        datapipe: Iterable[tuple[str, BufferedIOBase]],
         *handlers: Callable,
         key_fn: Callable = extension_extract_fn,
     ) -> None:
         super().__init__()
-        self.datapipe: Iterable[Tuple[str, BufferedIOBase]] = datapipe
+        self.datapipe: Iterable[tuple[str, BufferedIOBase]] = datapipe
         if not handlers:
             handlers = (decoder_basichandlers, decoder_imagehandler("torch"))
         self.decoder = Decoder(*handlers, key_fn=key_fn)
@@ -57,7 +57,7 @@ def __init__(
     def add_handler(self, *handler: Callable) -> None:
         self.decoder.add_handler(*handler)
 
-    def __iter__(self) -> Iterator[Tuple[str, Any]]:
+    def __iter__(self) -> Iterator[tuple[str, Any]]:
         for data in self.datapipe:
             pathname = data[0]
             result = self.decoder(data)

torch/utils/data/datapipes/iter/selecting.py

@@ -1,5 +1,5 @@
 # mypy: allow-untyped-defs
-from typing import Callable, Iterator, Tuple, TypeVar
+from typing import Callable, Iterator, TypeVar
 
 from torch.utils.data.datapipes._decorator import functional_datapipe
 from torch.utils.data.datapipes.dataframe import dataframe_wrapper as df_wrapper
@@ -78,7 +78,7 @@ def __iter__(self) -> Iterator[_T_co]:
             else:
                 StreamWrapper.close_streams(data)
 
-    def _returnIfTrue(self, data: _T) -> Tuple[bool, _T]:
+    def _returnIfTrue(self, data: _T) -> tuple[bool, _T]:
         condition = self._apply_filter_fn(data)
 
         if df_wrapper.is_column(condition):

torch/utils/data/datapipes/iter/sharding.py

@@ -1,6 +1,6 @@
 # mypy: allow-untyped-defs
 from enum import IntEnum
-from typing import Dict, Sized, Tuple
+from typing import Dict, Sized
 
 from torch.utils.data.datapipes._decorator import functional_datapipe
 from torch.utils.data.datapipes.datapipe import IterDataPipe
@@ -43,7 +43,7 @@ class ShardingFilterIterDataPipe(_ShardingIterDataPipe):
     def __init__(self, source_datapipe: IterDataPipe, sharding_group_filter=None):
         self.source_datapipe = source_datapipe
         self.sharding_group_filter = sharding_group_filter
-        self.groups: Dict[int, Tuple[int, int]] = {}
+        self.groups: Dict[int, tuple[int, int]] = {}
         self.num_of_instances = 1
         self.instance_id = 0
         self._update_num_of_instances()

torch/utils/data/datapipes/iter/streamreader.py

@@ -1,5 +1,5 @@
 from io import IOBase
-from typing import Iterator, Optional, Tuple
+from typing import Iterator, Optional
 
 from torch.utils.data.datapipes._decorator import functional_datapipe
 from torch.utils.data.datapipes.datapipe import IterDataPipe
@@ -9,7 +9,7 @@
 
 
 @functional_datapipe("read_from_stream")
-class StreamReaderIterDataPipe(IterDataPipe[Tuple[str, bytes]]):
+class StreamReaderIterDataPipe(IterDataPipe[tuple[str, bytes]]):
     r"""
     Given IO streams and their label names, yield bytes with label name as tuple.
 
@@ -30,12 +30,12 @@ class StreamReaderIterDataPipe(IterDataPipe[Tuple[str, bytes]]):
     """
 
     def __init__(
-        self, datapipe: IterDataPipe[Tuple[str, IOBase]], chunk: Optional[int] = None
+        self, datapipe: IterDataPipe[tuple[str, IOBase]], chunk: Optional[int] = None
     ):
         self.datapipe = datapipe
         self.chunk = chunk
 
-    def __iter__(self) -> Iterator[Tuple[str, bytes]]:
+    def __iter__(self) -> Iterator[tuple[str, bytes]]:
         for furl, stream in self.datapipe:
             while True:
                 d = stream.read(self.chunk)

torch/utils/data/datapipes/map/combining.py

@@ -1,5 +1,5 @@
 # mypy: allow-untyped-defs
-from typing import Sized, Tuple, TypeVar
+from typing import Sized, TypeVar
 
 from torch.utils.data.datapipes._decorator import functional_datapipe
 from torch.utils.data.datapipes.datapipe import MapDataPipe
@@ -34,7 +34,7 @@ class ConcaterMapDataPipe(MapDataPipe):
         [0, 1, 2, 0, 1, 2]
     """
 
-    datapipes: Tuple[MapDataPipe]
+    datapipes: tuple[MapDataPipe]
 
     def __init__(self, *datapipes: MapDataPipe):
         if len(datapipes) == 0:
@@ -59,7 +59,7 @@ def __len__(self) -> int:
 
 
 @functional_datapipe("zip")
-class ZipperMapDataPipe(MapDataPipe[Tuple[_T_co, ...]]):
+class ZipperMapDataPipe(MapDataPipe[tuple[_T_co, ...]]):
     r"""
     Aggregates elements into a tuple from each of the input DataPipes (functional name: ``zip``).
 
@@ -78,7 +78,7 @@ class ZipperMapDataPipe(MapDataPipe[Tuple[_T_co, ...]]):
         [(0, 10), (1, 11), (2, 12)]
     """
 
-    datapipes: Tuple[MapDataPipe[_T_co], ...]
+    datapipes: tuple[MapDataPipe[_T_co], ...]
 
     def __init__(self, *datapipes: MapDataPipe[_T_co]) -> None:
         if len(datapipes) == 0:
@@ -89,7 +89,7 @@ def __init__(self, *datapipes: MapDataPipe[_T_co]) -> None:
             raise TypeError("Expected all inputs to be `Sized`")
         self.datapipes = datapipes
 
-    def __getitem__(self, index) -> Tuple[_T_co, ...]:
+    def __getitem__(self, index) -> tuple[_T_co, ...]:
         res = []
         for dp in self.datapipes:
             try:

torch/utils/data/datapipes/utils/common.py

@@ -5,7 +5,7 @@
 import os
 import warnings
 from io import IOBase
-from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, Union
+from typing import Any, Callable, Dict, Iterable, List, Optional, Union
 
 from torch.utils._import_utils import dill_available
 
@@ -231,7 +231,7 @@ def get_file_binaries_from_pathnames(
         yield pathname, StreamWrapper(open(pathname, mode, encoding=encoding))
 
 
-def validate_pathname_binary_tuple(data: Tuple[str, IOBase]):
+def validate_pathname_binary_tuple(data: tuple[str, IOBase]):
     if not isinstance(data, tuple):
         raise TypeError(
             f"pathname binary data should be tuple type, but it is type {type(data)}"