python-doctr 0.10.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

doctr/transforms/modules/base.py

@@ -1,11 +1,12 @@
-# Copyright (C) 2021-2024, Mindee.
+# Copyright (C) 2021-2025, Mindee.
 
 # This program is licensed under the Apache License 2.0.
 # See LICENSE or go to <https://opensource.org/licenses/Apache-2.0> for full license details.
 
 import math
 import random
-from typing import Any, Callable, List, Optional, Tuple, Union
+from collections.abc import Callable
+from typing import Any
 
 import numpy as np
 
@@ -21,37 +22,36 @@ class SampleCompose(NestedObject):
 
     .. tabs::
 
-        .. tab:: TensorFlow
+        .. tab:: PyTorch
 
             .. code:: python
 
                 >>> import numpy as np
-                >>> import tensorflow as tf
+                >>> import torch
                 >>> from doctr.transforms import SampleCompose, ImageTransform, ColorInversion, RandomRotate
-                >>> transfo = SampleCompose([ImageTransform(ColorInversion((32, 32))), RandomRotate(30)])
-                >>> out, out_boxes = transfo(tf.random.uniform(shape=[64, 64, 3], minval=0, maxval=1), np.zeros((2, 4)))
+                >>> transfos = SampleCompose([ImageTransform(ColorInversion((32, 32))), RandomRotate(30)])
+                >>> out, out_boxes = transfos(torch.rand(8, 64, 64, 3), np.zeros((2, 4)))
 
-        .. tab:: PyTorch
+        .. tab:: TensorFlow
 
             .. code:: python
 
                 >>> import numpy as np
-                >>> import torch
+                >>> import tensorflow as tf
                 >>> from doctr.transforms import SampleCompose, ImageTransform, ColorInversion, RandomRotate
-                >>> transfos = SampleCompose([ImageTransform(ColorInversion((32, 32))), RandomRotate(30)])
-                >>> out, out_boxes = transfos(torch.rand(8, 64, 64, 3), np.zeros((2, 4)))
+                >>> transfo = SampleCompose([ImageTransform(ColorInversion((32, 32))), RandomRotate(30)])
+                >>> out, out_boxes = transfo(tf.random.uniform(shape=[64, 64, 3], minval=0, maxval=1), np.zeros((2, 4)))
 
     Args:
-    ----
         transforms: list of transformation modules
     """
 
-    _children_names: List[str] = ["sample_transforms"]
+    _children_names: list[str] = ["sample_transforms"]
 
-    def __init__(self, transforms: List[Callable[[Any, Any], Tuple[Any, Any]]]) -> None:
+    def __init__(self, transforms: list[Callable[[Any, Any], tuple[Any, Any]]]) -> None:
         self.sample_transforms = transforms
 
-    def __call__(self, x: Any, target: Any) -> Tuple[Any, Any]:
+    def __call__(self, x: Any, target: Any) -> tuple[Any, Any]:
         for t in self.sample_transforms:
             x, target = t(x, target)
 
@@ -63,35 +63,34 @@ class ImageTransform(NestedObject):
 
     .. tabs::
 
-        .. tab:: TensorFlow
+        .. tab:: PyTorch
 
             .. code:: python
 
-                >>> import tensorflow as tf
+                >>> import torch
                 >>> from doctr.transforms import ImageTransform, ColorInversion
                 >>> transfo = ImageTransform(ColorInversion((32, 32)))
-                >>> out, _ = transfo(tf.random.uniform(shape=[64, 64, 3], minval=0, maxval=1), None)
+                >>> out, _ = transfo(torch.rand(8, 64, 64, 3), None)
 
-        .. tab:: PyTorch
+        .. tab:: TensorFlow
 
             .. code:: python
 
-                >>> import torch
+                >>> import tensorflow as tf
                 >>> from doctr.transforms import ImageTransform, ColorInversion
                 >>> transfo = ImageTransform(ColorInversion((32, 32)))
-                >>> out, _ = transfo(torch.rand(8, 64, 64, 3), None)
+                >>> out, _ = transfo(tf.random.uniform(shape=[64, 64, 3], minval=0, maxval=1), None)
 
     Args:
-    ----
         transform: the image transformation module to wrap
     """
 
-    _children_names: List[str] = ["img_transform"]
+    _children_names: list[str] = ["img_transform"]
 
     def __init__(self, transform: Callable[[Any], Any]) -> None:
         self.img_transform = transform
 
-    def __call__(self, img: Any, target: Any) -> Tuple[Any, Any]:
+    def __call__(self, img: Any, target: Any) -> tuple[Any, Any]:
         img = self.img_transform(img)
         return img, target
 
@@ -102,26 +101,25 @@ class ColorInversion(NestedObject):
 
     .. tabs::
 
-        .. tab:: TensorFlow
+        .. tab:: PyTorch
 
             .. code:: python
 
-                >>> import tensorflow as tf
+                >>> import torch
                 >>> from doctr.transforms import ColorInversion
                 >>> transfo = ColorInversion(min_val=0.6)
-                >>> out = transfo(tf.random.uniform(shape=[8, 64, 64, 3], minval=0, maxval=1))
+                >>> out = transfo(torch.rand(8, 64, 64, 3))
 
-        .. tab:: PyTorch
+        .. tab:: TensorFlow
 
             .. code:: python
 
-                >>> import torch
+                >>> import tensorflow as tf
                 >>> from doctr.transforms import ColorInversion
                 >>> transfo = ColorInversion(min_val=0.6)
-                >>> out = transfo(torch.rand(8, 64, 64, 3))
+                >>> out = transfo(tf.random.uniform(shape=[8, 64, 64, 3], minval=0, maxval=1))
 
     Args:
-    ----
         min_val: range [min_val, 1] to colorize RGB pixels
     """
 
@@ -140,35 +138,34 @@ class OneOf(NestedObject):
 
     .. tabs::
 
-        .. tab:: TensorFlow
+        .. tab:: PyTorch
 
             .. code:: python
 
-                >>> import tensorflow as tf
+                >>> import torch
                 >>> from doctr.transforms import OneOf
                 >>> transfo = OneOf([JpegQuality(), Gamma()])
-                >>> out = transfo(tf.random.uniform(shape=[64, 64, 3], minval=0, maxval=1))
+                >>> out = transfo(torch.rand(1, 64, 64, 3))
 
-        .. tab:: PyTorch
+        .. tab:: TensorFlow
 
             .. code:: python
 
-                >>> import torch
+                >>> import tensorflow as tf
                 >>> from doctr.transforms import OneOf
                 >>> transfo = OneOf([JpegQuality(), Gamma()])
-                >>> out = transfo(torch.rand(1, 64, 64, 3))
+                >>> out = transfo(tf.random.uniform(shape=[64, 64, 3], minval=0, maxval=1))
 
     Args:
-    ----
         transforms: list of transformations, one only will be picked
     """
 
-    _children_names: List[str] = ["transforms"]
+    _children_names: list[str] = ["transforms"]
 
-    def __init__(self, transforms: List[Callable[[Any], Any]]) -> None:
+    def __init__(self, transforms: list[Callable[[Any], Any]]) -> None:
         self.transforms = transforms
 
-    def __call__(self, img: Any, target: Optional[np.ndarray] = None) -> Union[Any, Tuple[Any, np.ndarray]]:
+    def __call__(self, img: Any, target: np.ndarray | None = None) -> Any | tuple[Any, np.ndarray]:
         # Pick transformation
         transfo = self.transforms[int(random.random() * len(self.transforms))]
         # Apply
@@ -180,26 +177,25 @@ class RandomApply(NestedObject):
 
     .. tabs::
 
-        .. tab:: TensorFlow
+        .. tab:: PyTorch
 
             .. code:: python
 
-                >>> import tensorflow as tf
+                >>> import torch
                 >>> from doctr.transforms import RandomApply
                 >>> transfo = RandomApply(Gamma(), p=.5)
-                >>> out = transfo(tf.random.uniform(shape=[64, 64, 3], minval=0, maxval=1))
+                >>> out = transfo(torch.rand(1, 64, 64, 3))
 
-        .. tab:: PyTorch
+        .. tab:: TensorFlow
 
             .. code:: python
 
-                >>> import torch
+                >>> import tensorflow as tf
                 >>> from doctr.transforms import RandomApply
                 >>> transfo = RandomApply(Gamma(), p=.5)
-                >>> out = transfo(torch.rand(1, 64, 64, 3))
+                >>> out = transfo(tf.random.uniform(shape=[64, 64, 3], minval=0, maxval=1))
 
     Args:
-    ----
         transform: transformation to apply
         p: probability to apply
     """
@@ -211,7 +207,7 @@ class RandomApply(NestedObject):
     def extra_repr(self) -> str:
         return f"transform={self.transform}, p={self.p}"
 
-    def __call__(self, img: Any, target: Optional[np.ndarray] = None) -> Union[Any, Tuple[Any, np.ndarray]]:
+    def __call__(self, img: Any, target: np.ndarray | None = None) -> Any | tuple[Any, np.ndarray]:
         if random.random() < self.p:
             return self.transform(img) if target is None else self.transform(img, target)  # type: ignore[call-arg]
         return img if target is None else (img, target)
@@ -224,9 +220,7 @@ class RandomRotate(NestedObject):
         :align: center
 
     Args:
-    ----
-        max_angle: maximum angle for rotation, in degrees. Angles will be uniformly picked in
-            [-max_angle, max_angle]
+        max_angle: maximum angle for rotation, in degrees. Angles will be uniformly picked in [-max_angle, max_angle]
         expand: whether the image should be padded before the rotation
     """
 
@@ -237,7 +231,7 @@ class RandomRotate(NestedObject):
     def extra_repr(self) -> str:
         return f"max_angle={self.max_angle}, expand={self.expand}"
 
-    def __call__(self, img: Any, target: np.ndarray) -> Tuple[Any, np.ndarray]:
+    def __call__(self, img: Any, target: np.ndarray) -> tuple[Any, np.ndarray]:
         angle = random.uniform(-self.max_angle, self.max_angle)
         r_img, r_polys = F.rotate_sample(img, target, angle, self.expand)
         # Removes deleted boxes
@@ -249,19 +243,18 @@ class RandomCrop(NestedObject):
     """Randomly crop a tensor image and its boxes
 
     Args:
-    ----
         scale: tuple of floats, relative (min_area, max_area) of the crop
         ratio: tuple of float, relative (min_ratio, max_ratio) where ratio = h/w
     """
 
-    def __init__(self, scale: Tuple[float, float] = (0.08, 1.0), ratio: Tuple[float, float] = (0.75, 1.33)) -> None:
+    def __init__(self, scale: tuple[float, float] = (0.08, 1.0), ratio: tuple[float, float] = (0.75, 1.33)) -> None:
         self.scale = scale
         self.ratio = ratio
 
     def extra_repr(self) -> str:
         return f"scale={self.scale}, ratio={self.ratio}"
 
-    def __call__(self, img: Any, target: np.ndarray) -> Tuple[Any, np.ndarray]:
+    def __call__(self, img: Any, target: np.ndarray) -> tuple[Any, np.ndarray]:
         scale = random.uniform(self.scale[0], self.scale[1])
         ratio = random.uniform(self.ratio[0], self.ratio[1])
 

doctr/transforms/modules/pytorch.py

@@ -1,21 +1,29 @@
-# Copyright (C) 2021-2024, Mindee.
+# Copyright (C) 2021-2025, Mindee.
 
 # This program is licensed under the Apache License 2.0.
 # See LICENSE or go to <https://opensource.org/licenses/Apache-2.0> for full license details.
 
 import math
-from typing import Optional, Tuple, Union
 
 import numpy as np
 import torch
 from PIL.Image import Image
+from scipy.ndimage import gaussian_filter
 from torch.nn.functional import pad
 from torchvision.transforms import functional as F
 from torchvision.transforms import transforms as T
 
 from ..functional.pytorch import random_shadow
 
-__all__ = ["Resize", "GaussianNoise", "ChannelShuffle", "RandomHorizontalFlip", "RandomShadow", "RandomResize"]
+__all__ = [
+    "Resize",
+    "GaussianNoise",
+    "ChannelShuffle",
+    "RandomHorizontalFlip",
+    "RandomShadow",
+    "RandomResize",
+    "GaussianBlur",
+]
 
 
 class Resize(T.Resize):
@@ -23,7 +31,7 @@ class Resize(T.Resize):
 
     def __init__(
         self,
-        size: Union[int, Tuple[int, int]],
+        size: int | tuple[int, int],
         interpolation=F.InterpolationMode.BILINEAR,
         preserve_aspect_ratio: bool = False,
         symmetric_pad: bool = False,
@@ -38,8 +46,8 @@ class Resize(T.Resize):
     def forward(
         self,
         img: torch.Tensor,
-        target: Optional[np.ndarray] = None,
-    ) -> Union[torch.Tensor, Tuple[torch.Tensor, np.ndarray]]:
+        target: np.ndarray | None = None,
+    ) -> torch.Tensor | tuple[torch.Tensor, np.ndarray]:
         if isinstance(self.size, int):
             target_ratio = img.shape[-2] / img.shape[-1]
         else:
@@ -122,7 +130,6 @@ class GaussianNoise(torch.nn.Module):
     >>> out = transfo(torch.rand((3, 224, 224)))
 
     Args:
-    ----
         mean : mean of the gaussian distribution
         std : std of the gaussian distribution
     """
@@ -136,14 +143,47 @@ class GaussianNoise(torch.nn.Module):
         # Reshape the distribution
         noise = self.mean + 2 * self.std * torch.rand(x.shape, device=x.device) - self.std
         if x.dtype == torch.uint8:
-            return (x + 255 * noise).round().clamp(0, 255).to(dtype=torch.uint8)
+            return (x + 255 * noise).round().clamp(0, 255).to(dtype=torch.uint8)  # type: ignore[attr-defined]
         else:
-            return (x + noise.to(dtype=x.dtype)).clamp(0, 1)
+            return (x + noise.to(dtype=x.dtype)).clamp(0, 1)  # type: ignore[attr-defined]
 
     def extra_repr(self) -> str:
         return f"mean={self.mean}, std={self.std}"
 
 
+class GaussianBlur(torch.nn.Module):
+    """Apply Gaussian Blur to the input tensor
+
+    >>> import torch
+    >>> from doctr.transforms import GaussianBlur
+    >>> transfo = GaussianBlur(sigma=(0.0, 1.0))
+
+    Args:
+        sigma : standard deviation range for the gaussian kernel
+    """
+
+    def __init__(self, sigma: tuple[float, float]) -> None:
+        super().__init__()
+        self.sigma_range = sigma
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        # Sample a random sigma value within the specified range
+        sigma = torch.empty(1).uniform_(*self.sigma_range).item()
+
+        # Apply Gaussian blur along spatial dimensions only
+        blurred = torch.tensor(
+            gaussian_filter(
+                x.numpy(),
+                sigma=sigma,
+                mode="reflect",
+                truncate=4.0,
+            ),
+            dtype=x.dtype,
+            device=x.device,
+        )
+        return blurred
+
+
 class ChannelShuffle(torch.nn.Module):
     """Randomly shuffle channel order of a given image"""
 
@@ -159,9 +199,7 @@ class ChannelShuffle(torch.nn.Module):
 class RandomHorizontalFlip(T.RandomHorizontalFlip):
     """Randomly flip the input image horizontally"""
 
-    def forward(
-        self, img: Union[torch.Tensor, Image], target: np.ndarray
-    ) -> Tuple[Union[torch.Tensor, Image], np.ndarray]:
+    def forward(self, img: torch.Tensor | Image, target: np.ndarray) -> tuple[torch.Tensor | Image, np.ndarray]:
         if torch.rand(1) < self.p:
             _img = F.hflip(img)
             _target = target.copy()
@@ -183,11 +221,10 @@ class RandomShadow(torch.nn.Module):
     >>> out = transfo(torch.rand((3, 64, 64)))
 
     Args:
-    ----
         opacity_range : minimum and maximum opacity of the shade
     """
 
-    def __init__(self, opacity_range: Optional[Tuple[float, float]] = None) -> None:
+    def __init__(self, opacity_range: tuple[float, float] | None = None) -> None:
         super().__init__()
         self.opacity_range = opacity_range if isinstance(opacity_range, tuple) else (0.2, 0.8)
 
@@ -196,7 +233,7 @@ class RandomShadow(torch.nn.Module):
         try:
             if x.dtype == torch.uint8:
                 return (
-                    (
+                    (  # type: ignore[attr-defined]
                         255
                         * random_shadow(
                             x.to(dtype=torch.float32) / 255,
@@ -225,20 +262,19 @@ class RandomResize(torch.nn.Module):
     >>> out = transfo(torch.rand((3, 64, 64)))
 
     Args:
-    ----
         scale_range: range of the resizing factor for width and height (independently)
         preserve_aspect_ratio: whether to preserve the aspect ratio of the image,
-            given a float value, the aspect ratio will be preserved with this probability
+        given a float value, the aspect ratio will be preserved with this probability
         symmetric_pad: whether to symmetrically pad the image,
-            given a float value, the symmetric padding will be applied with this probability
+        given a float value, the symmetric padding will be applied with this probability
         p: probability to apply the transformation
     """
 
     def __init__(
         self,
-        scale_range: Tuple[float, float] = (0.3, 0.9),
-        preserve_aspect_ratio: Union[bool, float] = False,
-        symmetric_pad: Union[bool, float] = False,
+        scale_range: tuple[float, float] = (0.3, 0.9),
+        preserve_aspect_ratio: bool | float = False,
+        symmetric_pad: bool | float = False,
         p: float = 0.5,
     ) -> None:
         super().__init__()
@@ -248,7 +284,7 @@ class RandomResize(torch.nn.Module):
         self.p = p
         self._resize = Resize
 
-    def forward(self, img: torch.Tensor, target: np.ndarray) -> Tuple[torch.Tensor, np.ndarray]:
+    def forward(self, img: torch.Tensor, target: np.ndarray) -> tuple[torch.Tensor, np.ndarray]:
         if torch.rand(1) < self.p:
             scale_h = np.random.uniform(*self.scale_range)
             scale_w = np.random.uniform(*self.scale_range)

doctr/transforms/modules/tensorflow.py

@@ -1,10 +1,11 @@
-# Copyright (C) 2021-2024, Mindee.
+# Copyright (C) 2021-2025, Mindee.
 
 # This program is licensed under the Apache License 2.0.
 # See LICENSE or go to <https://opensource.org/licenses/Apache-2.0> for full license details.
 
 import random
-from typing import Any, Callable, Iterable, List, Optional, Tuple, Union
+from collections.abc import Callable, Iterable
+from typing import Any
 
 import numpy as np
 import tensorflow as tf
@@ -43,13 +44,12 @@ class Compose(NestedObject):
     >>> out = transfos(tf.random.uniform(shape=[64, 64, 3], minval=0, maxval=1))
 
     Args:
-    ----
         transforms: list of transformation modules
     """
 
-    _children_names: List[str] = ["transforms"]
+    _children_names: list[str] = ["transforms"]
 
-    def __init__(self, transforms: List[Callable[[Any], Any]]) -> None:
+    def __init__(self, transforms: list[Callable[[Any], Any]]) -> None:
         self.transforms = transforms
 
     def __call__(self, x: Any) -> Any:
@@ -68,7 +68,6 @@ class Resize(NestedObject):
     >>> out = transfo(tf.random.uniform(shape=[64, 64, 3], minval=0, maxval=1))
 
     Args:
-    ----
         output_size: expected output size
         method: interpolation method
         preserve_aspect_ratio: if `True`, preserve aspect ratio and pad the rest with zeros
@@ -77,7 +76,7 @@ class Resize(NestedObject):
 
     def __init__(
         self,
-        output_size: Union[int, Tuple[int, int]],
+        output_size: int | tuple[int, int],
         method: str = "bilinear",
         preserve_aspect_ratio: bool = False,
         symmetric_pad: bool = False,
@@ -104,8 +103,8 @@ class Resize(NestedObject):
     def __call__(
         self,
         img: tf.Tensor,
-        target: Optional[np.ndarray] = None,
-    ) -> Union[tf.Tensor, Tuple[tf.Tensor, np.ndarray]]:
+        target: np.ndarray | None = None,
+    ) -> tf.Tensor | tuple[tf.Tensor, np.ndarray]:
         input_dtype = img.dtype
         self.output_size = (
             (self.output_size, self.output_size) if isinstance(self.output_size, int) else self.output_size
@@ -164,12 +163,11 @@ class Normalize(NestedObject):
     >>> out = transfo(tf.random.uniform(shape=[8, 64, 64, 3], minval=0, maxval=1))
 
     Args:
-    ----
         mean: average value per channel
         std: standard deviation per channel
     """
 
-    def __init__(self, mean: Tuple[float, float, float], std: Tuple[float, float, float]) -> None:
+    def __init__(self, mean: tuple[float, float, float], std: tuple[float, float, float]) -> None:
         self.mean = tf.constant(mean)
         self.std = tf.constant(std)
 
@@ -191,7 +189,6 @@ class LambdaTransformation(NestedObject):
     >>> out = transfo(tf.random.uniform(shape=[8, 64, 64, 3], minval=0, maxval=1))
 
     Args:
-    ----
         fn: the function to be applied to the input tensor
     """
 
@@ -229,7 +226,6 @@ class RandomBrightness(NestedObject):
     >>> out = transfo(tf.random.uniform(shape=[8, 64, 64, 3], minval=0, maxval=1))
 
     Args:
-    ----
         max_delta: offset to add to each pixel is randomly picked in [-max_delta, max_delta]
         p: probability to apply transformation
     """
@@ -254,7 +250,6 @@ class RandomContrast(NestedObject):
     >>> out = transfo(tf.random.uniform(shape=[8, 64, 64, 3], minval=0, maxval=1))
 
     Args:
-    ----
         delta: multiplicative factor is picked in [1-delta, 1+delta] (reduce contrast if factor<1)
     """
 
@@ -278,7 +273,6 @@ class RandomSaturation(NestedObject):
     >>> out = transfo(tf.random.uniform(shape=[8, 64, 64, 3], minval=0, maxval=1))
 
     Args:
-    ----
         delta: multiplicative factor is picked in [1-delta, 1+delta] (reduce saturation if factor<1)
     """
 
@@ -301,7 +295,6 @@ class RandomHue(NestedObject):
     >>> out = transfo(tf.random.uniform(shape=[8, 64, 64, 3], minval=0, maxval=1))
 
     Args:
-    ----
         max_delta: offset to add to each pixel is randomly picked in [-max_delta, max_delta]
     """
 
@@ -324,7 +317,6 @@ class RandomGamma(NestedObject):
     >>> out = transfo(tf.random.uniform(shape=[8, 64, 64, 3], minval=0, maxval=1))
 
     Args:
-    ----
         min_gamma: non-negative real number, lower bound for gamma param
         max_gamma: non-negative real number, upper bound for gamma
         min_gain: lower bound for constant multiplier
@@ -362,7 +354,6 @@ class RandomJpegQuality(NestedObject):
     >>> out = transfo(tf.random.uniform(shape=[64, 64, 3], minval=0, maxval=1))
 
     Args:
-    ----
         min_quality: int between [0, 100]
         max_quality: int between [0, 100]
     """
@@ -387,12 +378,11 @@ class GaussianBlur(NestedObject):
     >>> out = transfo(tf.random.uniform(shape=[64, 64, 3], minval=0, maxval=1))
 
     Args:
-    ----
         kernel_shape: size of the blurring kernel
         std: min and max value of the standard deviation
     """
 
-    def __init__(self, kernel_shape: Union[int, Iterable[int]], std: Tuple[float, float]) -> None:
+    def __init__(self, kernel_shape: int | Iterable[int], std: tuple[float, float]) -> None:
         self.kernel_shape = kernel_shape
         self.std = std
 
@@ -430,7 +420,6 @@ class GaussianNoise(NestedObject):
     >>> out = transfo(tf.random.uniform(shape=[64, 64, 3], minval=0, maxval=1))
 
     Args:
-    ----
         mean : mean of the gaussian distribution
         std : std of the gaussian distribution
     """
@@ -465,7 +454,6 @@ class RandomHorizontalFlip(NestedObject):
     >>> out = transfo(image, target)
 
     Args:
-    ----
         p : probability of Horizontal Flip
     """
 
@@ -473,7 +461,7 @@ class RandomHorizontalFlip(NestedObject):
         super().__init__()
         self.p = p
 
-    def __call__(self, img: Union[tf.Tensor, np.ndarray], target: np.ndarray) -> Tuple[tf.Tensor, np.ndarray]:
+    def __call__(self, img: tf.Tensor | np.ndarray, target: np.ndarray) -> tuple[tf.Tensor, np.ndarray]:
         if np.random.rand(1) <= self.p:
             _img = tf.image.flip_left_right(img)
             _target = target.copy()
@@ -495,11 +483,10 @@ class RandomShadow(NestedObject):
     >>> out = transfo(tf.random.uniform(shape=[64, 64, 3], minval=0, maxval=1))
 
     Args:
-    ----
         opacity_range : minimum and maximum opacity of the shade
     """
 
-    def __init__(self, opacity_range: Optional[Tuple[float, float]] = None) -> None:
+    def __init__(self, opacity_range: tuple[float, float] | None = None) -> None:
         super().__init__()
         self.opacity_range = opacity_range if isinstance(opacity_range, tuple) else (0.2, 0.8)
 
@@ -530,20 +517,19 @@ class RandomResize(NestedObject):
     >>> out = transfo(tf.random.uniform(shape=[64, 64, 3], minval=0, maxval=1))
 
     Args:
-    ----
         scale_range: range of the resizing factor for width and height (independently)
         preserve_aspect_ratio: whether to preserve the aspect ratio of the image,
-            given a float value, the aspect ratio will be preserved with this probability
+        given a float value, the aspect ratio will be preserved with this probability
         symmetric_pad: whether to symmetrically pad the image,
-            given a float value, the symmetric padding will be applied with this probability
+        given a float value, the symmetric padding will be applied with this probability
         p: probability to apply the transformation
     """
 
     def __init__(
         self,
-        scale_range: Tuple[float, float] = (0.3, 0.9),
-        preserve_aspect_ratio: Union[bool, float] = False,
-        symmetric_pad: Union[bool, float] = False,
+        scale_range: tuple[float, float] = (0.3, 0.9),
+        preserve_aspect_ratio: bool | float = False,
+        symmetric_pad: bool | float = False,
         p: float = 0.5,
     ):
         super().__init__()
@@ -553,7 +539,7 @@ class RandomResize(NestedObject):
         self.p = p
         self._resize = Resize
 
-    def __call__(self, img: tf.Tensor, target: np.ndarray) -> Tuple[tf.Tensor, np.ndarray]:
+    def __call__(self, img: tf.Tensor, target: np.ndarray) -> tuple[tf.Tensor, np.ndarray]:
         if np.random.rand(1) <= self.p:
             scale_h = random.uniform(*self.scale_range)
             scale_w = random.uniform(*self.scale_range)

doctr/utils/common_types.py

@@ -1,18 +1,17 @@
-# Copyright (C) 2021-2024, Mindee.
+# Copyright (C) 2021-2025, Mindee.
 
 # This program is licensed under the Apache License 2.0.
 # See LICENSE or go to <https://opensource.org/licenses/Apache-2.0> for full license details.
 
 from pathlib import Path
-from typing import List, Tuple, Union
 
 __all__ = ["Point2D", "BoundingBox", "Polygon4P", "Polygon", "Bbox"]
 
 
-Point2D = Tuple[float, float]
-BoundingBox = Tuple[Point2D, Point2D]
-Polygon4P = Tuple[Point2D, Point2D, Point2D, Point2D]
-Polygon = List[Point2D]
-AbstractPath = Union[str, Path]
-AbstractFile = Union[AbstractPath, bytes]
-Bbox = Tuple[float, float, float, float]
+Point2D = tuple[float, float]
+BoundingBox = tuple[Point2D, Point2D]
+Polygon4P = tuple[Point2D, Point2D, Point2D, Point2D]
+Polygon = list[Point2D]
+AbstractPath = str | Path
+AbstractFile = AbstractPath | bytes
+Bbox = tuple[float, float, float, float]