Review python 3.9 type hint and lint

Author: AntoineSimoulin

test/common_utils.py

@@ -8,8 +8,8 @@
 import shutil
 import sys
 import tempfile
-from typing import Sequence, Tuple
 import warnings
+from collections.abc import Sequence
 from subprocess import CalledProcessError, check_output, STDOUT
 
 import numpy as np
@@ -402,12 +402,12 @@ def make_image_pil(*args, **kwargs):
 
 
 def make_keypoints(
-    canvas_size: Tuple[int, int] = DEFAULT_SIZE, *, num_points: int | Sequence[int] = 4, dtype=None, device='cpu'
+    canvas_size: tuple[int, int] = DEFAULT_SIZE, *, num_points: int | Sequence[int] = 4, dtype=None, device="cpu"
 ) -> tv_tensors.KeyPoints:
     """Make the KeyPoints for testing purposes"""
     if isinstance(num_points, int):
         num_points = [num_points]
-    single_coord_shape: Tuple[int, ...] = tuple(num_points) + (1,)
+    single_coord_shape: tuple[int, ...] = tuple(num_points) + (1,)
     y = torch.randint(0, canvas_size[0] - 1, single_coord_shape, dtype=dtype, device=device)
     x = torch.randint(0, canvas_size[1] - 1, single_coord_shape, dtype=dtype, device=device)
     points = torch.cat((x, y), dim=-1)

test/test_transforms_v2.py

@@ -231,10 +231,7 @@ def check_functional_kernel_signature_match(functional, *, kernel, input_type):
     if issubclass(input_type, tv_tensors.TVTensor):
         # We filter out metadata that is implicitly passed to the functional through the input tv_tensor, but has to be
         # explicitly passed to the kernel.
-        explicit_metadata = {
-            tv_tensors.BoundingBoxes: {"format", "canvas_size"},
-            tv_tensors.KeyPoints: {"canvas_size"}
-        }
+        explicit_metadata = {tv_tensors.BoundingBoxes: {"format", "canvas_size"}, tv_tensors.KeyPoints: {"canvas_size"}}
         kernel_params = [param for param in kernel_params if param.name not in explicit_metadata.get(input_type, set())]
 
     functional_params = iter(functional_params)
@@ -338,7 +335,8 @@ def _make_transform_sample(transform, *, image_or_video, adapter):
             canvas_size=size,
             device=device,
         ),
-        keypoints=make_keypoints(canvas_size=size), keypoints_degenerate=tv_tensors.KeyPoints(
+        keypoints=make_keypoints(canvas_size=size),
+        keypoints_degenerate=tv_tensors.KeyPoints(
             [
                 [0, 1],  # left edge
                 [1, 0],  # top edge
@@ -347,8 +345,10 @@ def _make_transform_sample(transform, *, image_or_video, adapter):
                 [size[1], 0],  # top right corner
                 [1, size[0]],  # bottom edge
                 [0, size[0]],  # bottom left corner
-                [size[1], size[0]]  # bottom right corner
-            ], canvas_size=size, device=device
+                [size[1], size[0]],  # bottom right corner
+            ],
+            canvas_size=size,
+            device=device,
         ),
         detection_mask=make_detection_masks(size, device=device),
         segmentation_mask=make_segmentation_mask(size, device=device),
@@ -2362,7 +2362,7 @@ def test_error(self, T):
             F.to_pil_image(imgs[0]),
             tv_tensors.Mask(torch.rand(12, 12)),
             tv_tensors.BoundingBoxes(torch.rand(2, 4), format="XYXY", canvas_size=12),
-            tv_tensors.KeyPoints(torch.rand(2, 2), canvas_size=(12, 12))
+            tv_tensors.KeyPoints(torch.rand(2, 2), canvas_size=(12, 12)),
         ):
             print(type(input_with_bad_type), cutmix_mixup)
             with pytest.raises(ValueError, match="does not support PIL images, "):
@@ -2772,8 +2772,15 @@ def test_functional_signature(self, kernel, input_type):
         check_functional_kernel_signature_match(F.elastic, kernel=kernel, input_type=input_type)
 
     @pytest.mark.parametrize(
-        "make_input", [
-            make_image_tensor, make_image_pil, make_image, make_bounding_boxes, make_segmentation_mask, make_video, make_keypoints
+        "make_input",
+        [
+            make_image_tensor,
+            make_image_pil,
+            make_image,
+            make_bounding_boxes,
+            make_segmentation_mask,
+            make_video,
+            make_keypoints,
         ],
     )
     def test_displacement_error(self, make_input):
@@ -2786,9 +2793,15 @@ def test_displacement_error(self, make_input):
             F.elastic(input, displacement=torch.rand(F.get_size(input)))
 
     @pytest.mark.parametrize(
-        "make_input", [
-            make_image_tensor, make_image_pil, make_image, make_bounding_boxes, make_segmentation_mask, make_video,
-            make_keypoints
+        "make_input",
+        [
+            make_image_tensor,
+            make_image_pil,
+            make_image,
+            make_bounding_boxes,
+            make_segmentation_mask,
+            make_video,
+            make_keypoints,
         ],
     )
     # ElasticTransform needs larger images to avoid the needed internal padding being larger than the actual image
@@ -6297,21 +6310,18 @@ def test_no_valid_input(self, query):
             query(["blah"])
 
     @pytest.mark.parametrize(
-        'boxes', [
-            tv_tensors.BoundingBoxes(torch.tensor([[1, 1, 2, 2]]), format="XYXY", canvas_size=(4, 4))
-        ]
+        "boxes", [tv_tensors.BoundingBoxes(torch.tensor([[1, 1, 2, 2]]), format="XYXY", canvas_size=(4, 4))]
     )
     def test_convert_bounding_boxes_to_points(self, boxes: tv_tensors.BoundingBoxes):
         # TODO: this test can't handle rotated boxes yet
         kp = F.convert_bounding_boxes_to_points(boxes)
-        assert kp.shape == boxes.shape + (2, )
+        assert kp.shape == boxes.shape + (2,)
         assert kp.dtype == boxes.dtype
         # kp is a list of A, B, C, D polygons.
         # If we use A | C, we should get back the XYXY format of bounding box
         reconverted = torch.cat([kp[..., 0, :], kp[..., 2, :]], dim=-1)
         reconverted_bbox = F.convert_bounding_box_format(
-            tv_tensors.BoundingBoxes(
-                reconverted, format=tv_tensors.BoundingBoxFormat.XYXY, canvas_size=kp.canvas_size
-            ), new_format=boxes.format
+            tv_tensors.BoundingBoxes(reconverted, format=tv_tensors.BoundingBoxFormat.XYXY, canvas_size=kp.canvas_size),
+            new_format=boxes.format,
         )
         assert (reconverted_bbox == boxes).all(), f"Invalid reconversion : {reconverted_bbox}"

test/test_transforms_v2_utils.py

@@ -68,7 +68,11 @@ def test_has_any(sample, types, expected):
         ((IMAGE, BOUNDING_BOX, MASK, KEYPOINTS), (tv_tensors.BoundingBoxes, tv_tensors.Mask), True),
         ((IMAGE, BOUNDING_BOX, MASK, KEYPOINTS), (tv_tensors.Mask, tv_tensors.KeyPoints), True),
         ((IMAGE, BOUNDING_BOX, MASK, KEYPOINTS), (tv_tensors.BoundingBoxes, tv_tensors.KeyPoints), True),
-        ((IMAGE, BOUNDING_BOX, MASK, KEYPOINTS), (tv_tensors.BoundingBoxes, tv_tensors.Mask, tv_tensors.KeyPoints), True),
+        (
+            (IMAGE, BOUNDING_BOX, MASK, KEYPOINTS),
+            (tv_tensors.BoundingBoxes, tv_tensors.Mask, tv_tensors.KeyPoints),
+            True,
+        ),
         (
             (IMAGE, BOUNDING_BOX, MASK, KEYPOINTS),
             (tv_tensors.Image, tv_tensors.BoundingBoxes, tv_tensors.Mask, tv_tensors.KeyPoints),

test/test_tv_tensors.py

@@ -2,7 +2,14 @@
 
 import pytest
 import torch
-from common_utils import assert_equal, make_bounding_boxes, make_image, make_keypoints, make_segmentation_mask, make_video
+from common_utils import (
+    assert_equal,
+    make_bounding_boxes,
+    make_image,
+    make_keypoints,
+    make_segmentation_mask,
+    make_video,
+)
 from PIL import Image
 
 from torchvision import tv_tensors
@@ -49,7 +56,26 @@ def test_bbox_dim_error():
         tv_tensors.BoundingBoxes(data_3d, format="XYXY", canvas_size=(32, 32))
 
 
-@pytest.mark.parametrize("data", [torch.randint(0, 32, size=(5, 2)), [[0, 0,], [2, 2,]], [1, 2,]])
+@pytest.mark.parametrize(
+    "data",
+    [
+        torch.randint(0, 32, size=(5, 2)),
+        [
+            [
+                0,
+                0,
+            ],
+            [
+                2,
+                2,
+            ],
+        ],
+        [
+            1,
+            2,
+        ],
+    ],
+)
 def test_keypoints_instance(data):
     kpoint = tv_tensors.KeyPoints(data, canvas_size=(32, 32))
     assert isinstance(kpoint, tv_tensors.KeyPoints)
@@ -82,9 +108,9 @@ def test_new_requires_grad(data, input_requires_grad, expected_requires_grad):
     assert tv_tensor.requires_grad is expected_requires_grad
 
 
-@pytest.mark.parametrize("make_input", [
-    make_image, make_bounding_boxes, make_segmentation_mask, make_video, make_keypoints
-])
+@pytest.mark.parametrize(
+    "make_input", [make_image, make_bounding_boxes, make_segmentation_mask, make_video, make_keypoints]
+)
 def test_isinstance(make_input):
     assert isinstance(make_input(), torch.Tensor)
 
@@ -96,9 +122,9 @@ def test_wrapping_no_copy():
     assert image.data_ptr() == tensor.data_ptr()
 
 
-@pytest.mark.parametrize("make_input", [
-    make_image, make_bounding_boxes, make_segmentation_mask, make_video, make_keypoints
-])
+@pytest.mark.parametrize(
+    "make_input", [make_image, make_bounding_boxes, make_segmentation_mask, make_video, make_keypoints]
+)
 def test_to_wrapping(make_input):
     dp = make_input()
 
@@ -108,9 +134,9 @@ def test_to_wrapping(make_input):
     assert dp_to.dtype is torch.float64
 
 
-@pytest.mark.parametrize("make_input", [
-    make_image, make_bounding_boxes, make_segmentation_mask, make_video, make_keypoints
-])
+@pytest.mark.parametrize(
+    "make_input", [make_image, make_bounding_boxes, make_segmentation_mask, make_video, make_keypoints]
+)
 @pytest.mark.parametrize("return_type", ["Tensor", "TVTensor"])
 def test_to_tv_tensor_reference(make_input, return_type):
     tensor = torch.rand((3, 16, 16), dtype=torch.float64)
@@ -124,9 +150,9 @@ def test_to_tv_tensor_reference(make_input, return_type):
     assert type(tensor) is torch.Tensor
 
 
-@pytest.mark.parametrize("make_input", [
-    make_image, make_bounding_boxes, make_segmentation_mask, make_video, make_keypoints
-])
+@pytest.mark.parametrize(
+    "make_input", [make_image, make_bounding_boxes, make_segmentation_mask, make_video, make_keypoints]
+)
 @pytest.mark.parametrize("return_type", ["Tensor", "TVTensor"])
 def test_clone_wrapping(make_input, return_type):
     dp = make_input()
@@ -138,9 +164,9 @@ def test_clone_wrapping(make_input, return_type):
     assert dp_clone.data_ptr() != dp.data_ptr()
 
 
-@pytest.mark.parametrize("make_input", [
-    make_image, make_bounding_boxes, make_segmentation_mask, make_video, make_keypoints
-])
+@pytest.mark.parametrize(
+    "make_input", [make_image, make_bounding_boxes, make_segmentation_mask, make_video, make_keypoints]
+)
 @pytest.mark.parametrize("return_type", ["Tensor", "TVTensor"])
 def test_requires_grad__wrapping(make_input, return_type):
     dp = make_input(dtype=torch.float)
@@ -155,9 +181,9 @@ def test_requires_grad__wrapping(make_input, return_type):
     assert dp_requires_grad.requires_grad
 
 
-@pytest.mark.parametrize("make_input", [
-    make_image, make_bounding_boxes, make_segmentation_mask, make_video, make_keypoints
-])
+@pytest.mark.parametrize(
+    "make_input", [make_image, make_bounding_boxes, make_segmentation_mask, make_video, make_keypoints]
+)
 @pytest.mark.parametrize("return_type", ["Tensor", "TVTensor"])
 def test_detach_wrapping(make_input, return_type):
     dp = make_input(dtype=torch.float).requires_grad_(True)
@@ -212,9 +238,9 @@ def test_force_subclass_with_metadata(return_type):
     tv_tensors.set_return_type("tensor")
 
 
-@pytest.mark.parametrize("make_input", [
-    make_image, make_bounding_boxes, make_segmentation_mask, make_video, make_keypoints
-])
+@pytest.mark.parametrize(
+    "make_input", [make_image, make_bounding_boxes, make_segmentation_mask, make_video, make_keypoints]
+)
 @pytest.mark.parametrize("return_type", ["Tensor", "TVTensor"])
 def test_other_op_no_wrapping(make_input, return_type):
     dp = make_input()
@@ -226,9 +252,9 @@ def test_other_op_no_wrapping(make_input, return_type):
     assert type(output) is (type(dp) if return_type == "TVTensor" else torch.Tensor)
 
 
-@pytest.mark.parametrize("make_input", [
-    make_image, make_bounding_boxes, make_segmentation_mask, make_video, make_keypoints
-])
+@pytest.mark.parametrize(
+    "make_input", [make_image, make_bounding_boxes, make_segmentation_mask, make_video, make_keypoints]
+)
 @pytest.mark.parametrize(
     "op",
     [
@@ -245,9 +271,9 @@ def test_no_tensor_output_op_no_wrapping(make_input, op):
     assert type(output) is not type(dp)
 
 
-@pytest.mark.parametrize("make_input", [
-    make_image, make_bounding_boxes, make_segmentation_mask, make_video, make_keypoints
-])
+@pytest.mark.parametrize(
+    "make_input", [make_image, make_bounding_boxes, make_segmentation_mask, make_video, make_keypoints]
+)
 @pytest.mark.parametrize("return_type", ["Tensor", "TVTensor"])
 def test_inplace_op_no_wrapping(make_input, return_type):
     dp = make_input()

torchvision/transforms/v2/_utils.py

@@ -2,10 +2,10 @@
 
 import collections.abc
 import numbers
-from collections.abc import Sequence
+from collections.abc import Iterable, Sequence
 from contextlib import suppress
 
-from typing import Any, Callable, Literal, Sequence, Iterable
+from typing import Any, Callable, Literal
 
 import PIL.Image
 import torch

torchvision/transforms/v2/functional/_geometry.py

@@ -2112,7 +2112,9 @@ def _create_identity_grid(size: tuple[int, int], device: torch.device, dtype: to
     return base_grid
 
 
-def elastic_keypoints(keypoints: torch.Tensor, canvas_size: tuple[int, int], displacement: torch.Tensor) -> torch.Tensor:
+def elastic_keypoints(
+    keypoints: torch.Tensor, canvas_size: tuple[int, int], displacement: torch.Tensor
+) -> torch.Tensor:
     expected_shape = (1, canvas_size[0], canvas_size[1], 2)
     if not isinstance(displacement, torch.Tensor):
         raise TypeError("Argument displacement should be a Tensor")

torchvision/transforms/v2/functional/_meta.py

@@ -122,7 +122,7 @@ def get_size_bounding_boxes(bounding_box: tv_tensors.BoundingBoxes) -> list[int]
 
 
 @_register_kernel_internal(get_size, tv_tensors.KeyPoints, tv_tensor_wrapper=False)
-def get_size_keypoints(keypoints: tv_tensors.KeyPoints) -> List[int]:
+def get_size_keypoints(keypoints: tv_tensors.KeyPoints) -> list[int]:
     return list(keypoints.canvas_size)
 
 

torchvision/transforms/v2/functional/_misc.py

@@ -329,8 +329,8 @@ def _to_dtype_tensor_dispatch(inpt: torch.Tensor, dtype: torch.dtype, scale: boo
 
 
 def sanitize_keypoints(
-    keypoints: torch.Tensor, canvas_size: Optional[Tuple[int, int]] = None
-) -> Tuple[torch.Tensor, torch.Tensor]:
+    keypoints: torch.Tensor, canvas_size: Optional[tuple[int, int]] = None
+) -> tuple[torch.Tensor, torch.Tensor]:
     """Removes degenerate/invalid keypoints and returns the corresponding indexing mask.
 
     This removes the keypoints that are outside of their corresponing image.
@@ -345,7 +345,7 @@ def sanitize_keypoints(
 
     Args:
         keypoints (torch.Tensor or class:`~torchvision.tv_tensors.KeyPoints`): The Keypoints being removed
-        canvas_size (Optional[Tuple[int, int]], optional): The canvas_size of the bounding boxes
+        canvas_size (Optional[tuple[int, int]], optional): The canvas_size of the bounding boxes
             (size of the corresponding image/video).
             Must be left to none if ``bounding_boxes`` is a :class:`~torchvision.tv_tensors.KeyPoints` object.
 
@@ -383,7 +383,7 @@ def sanitize_keypoints(
 
 def _get_sanitize_keypoints_mask(
     keypoints: torch.Tensor,
-    canvas_size: Tuple[int, int],
+    canvas_size: tuple[int, int],
 ) -> torch.Tensor:
     image_h, image_w = canvas_size
     x = keypoints[:, 0]