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

doctr/utils/data.py

@@ -1,4 +1,4 @@
-# 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.
@@ -13,7 +13,6 @@ import urllib
 import urllib.error
 import urllib.request
 from pathlib import Path
-from typing import Optional, Union
 
 from tqdm.auto import tqdm
 
@@ -25,7 +24,7 @@ HASH_REGEX = re.compile(r"-([a-f0-9]*)\.")
 USER_AGENT = "mindee/doctr"
 
 
-def _urlretrieve(url: str, filename: Union[Path, str], chunk_size: int = 1024) -> None:
+def _urlretrieve(url: str, filename: Path | str, chunk_size: int = 1024) -> None:
     with open(filename, "wb") as fh:
         with urllib.request.urlopen(urllib.request.Request(url, headers={"User-Agent": USER_AGENT})) as response:
             with tqdm(total=response.length) as pbar:
@@ -36,7 +35,7 @@ def _urlretrieve(url: str, filename: Union[Path, str], chunk_size: int = 1024) -
                     fh.write(chunk)
 
 
-def _check_integrity(file_path: Union[str, Path], hash_prefix: str) -> bool:
+def _check_integrity(file_path: str | Path, hash_prefix: str) -> bool:
     with open(file_path, "rb") as f:
         sha_hash = hashlib.sha256(f.read()).hexdigest()
 
@@ -45,10 +44,10 @@ def _check_integrity(file_path: Union[str, Path], hash_prefix: str) -> bool:
 
 def download_from_url(
     url: str,
-    file_name: Optional[str] = None,
-    hash_prefix: Optional[str] = None,
-    cache_dir: Optional[str] = None,
-    cache_subdir: Optional[str] = None,
+    file_name: str | None = None,
+    hash_prefix: str | None = None,
+    cache_dir: str | None = None,
+    cache_subdir: str | None = None,
 ) -> Path:
     """Download a file using its URL
 
@@ -56,7 +55,6 @@ def download_from_url(
     >>> download_from_url("https://yoursource.com/yourcheckpoint-yourhash.zip")
 
     Args:
-    ----
         url: the URL of the file to download
         file_name: optional name of the file once downloaded
         hash_prefix: optional expected SHA256 hash of the file
@@ -64,11 +62,9 @@ def download_from_url(
         cache_subdir: subfolder to use in the cache
 
     Returns:
-    -------
         the location of the downloaded file
 
     Note:
-    ----
         You can change cache directory location by using `DOCTR_CACHE_DIR` environment variable.
     """
     if not isinstance(file_name, str):
@@ -96,7 +92,7 @@ def download_from_url(
         # Create folder hierarchy
         folder_path.mkdir(parents=True, exist_ok=True)
     except OSError:
-        error_message = f"Failed creating cache direcotry at {folder_path}"
+        error_message = f"Failed creating cache directory at {folder_path}"
         if os.environ.get("DOCTR_CACHE_DIR", ""):
             error_message += " using path from 'DOCTR_CACHE_DIR' environment variable."
         else:
@@ -112,7 +108,7 @@ def download_from_url(
     except (urllib.error.URLError, IOError) as e:
         if url[:5] == "https":
             url = url.replace("https:", "http:")
-            print("Failed download. Trying https -> http instead." f" Downloading {url} to {file_path}")
+            print(f"Failed download. Trying https -> http instead. Downloading {url} to {file_path}")
             _urlretrieve(url, file_path)
         else:
             raise e

doctr/utils/fonts.py

@@ -1,29 +1,24 @@
-# 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 logging
 import platform
-from typing import Optional, Union
 
 from PIL import ImageFont
 
 __all__ = ["get_font"]
 
 
-def get_font(
-    font_family: Optional[str] = None, font_size: int = 13
-) -> Union[ImageFont.FreeTypeFont, ImageFont.ImageFont]:
+def get_font(font_family: str | None = None, font_size: int = 13) -> ImageFont.FreeTypeFont | ImageFont.ImageFont:
     """Resolves a compatible ImageFont for the system
 
     Args:
-    ----
         font_family: the font family to use
         font_size: the size of the font upon rendering
 
     Returns:
-    -------
         the Pillow font
     """
     # Font selection

doctr/utils/geometry.py

@@ -1,11 +1,10 @@
-# 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 copy import deepcopy
 from math import ceil
-from typing import List, Optional, Tuple, Union
 
 import cv2
 import numpy as np
@@ -34,11 +33,9 @@ def bbox_to_polygon(bbox: BoundingBox) -> Polygon4P:
     """Convert a bounding box to a polygon
 
     Args:
-    ----
         bbox: a bounding box
 
     Returns:
-    -------
         a polygon
     """
     return bbox[0], (bbox[1][0], bbox[0][1]), (bbox[0][0], bbox[1][1]), bbox[1]
@@ -48,31 +45,27 @@ def polygon_to_bbox(polygon: Polygon4P) -> BoundingBox:
     """Convert a polygon to a bounding box
 
     Args:
-    ----
         polygon: a polygon
 
     Returns:
-    -------
         a bounding box
     """
     x, y = zip(*polygon)
     return (min(x), min(y)), (max(x), max(y))
 
 
-def detach_scores(boxes: List[np.ndarray]) -> Tuple[List[np.ndarray], List[np.ndarray]]:
+def detach_scores(boxes: list[np.ndarray]) -> tuple[list[np.ndarray], list[np.ndarray]]:
     """Detach the objectness scores from box predictions
 
     Args:
-    ----
         boxes: list of arrays with boxes of shape (N, 5) or (N, 5, 2)
 
     Returns:
-    -------
         a tuple of two lists: the first one contains the boxes without the objectness scores,
         the second one contains the objectness scores
     """
 
-    def _detach(boxes: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+    def _detach(boxes: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
         if boxes.ndim == 2:
             return boxes[:, :-1], boxes[:, -1]
         return boxes[:, :-1], boxes[:, -1, -1]
@@ -81,11 +74,10 @@ def detach_scores(boxes: List[np.ndarray]) -> Tuple[List[np.ndarray], List[np.nd
     return list(loc_preds), list(obj_scores)
 
 
-def resolve_enclosing_bbox(bboxes: Union[List[BoundingBox], np.ndarray]) -> Union[BoundingBox, np.ndarray]:
+def resolve_enclosing_bbox(bboxes: list[BoundingBox] | np.ndarray) -> BoundingBox | np.ndarray:
     """Compute enclosing bbox either from:
 
     Args:
-    ----
         bboxes: boxes in one of the following formats:
 
             - an array of boxes: (*, 4), where boxes have this shape:
@@ -94,7 +86,6 @@ def resolve_enclosing_bbox(bboxes: Union[List[BoundingBox], np.ndarray]) -> Unio
             - a list of BoundingBox
 
     Returns:
-    -------
         a (1, 4) array (enclosing boxarray), or a BoundingBox
     """
     if isinstance(bboxes, np.ndarray):
@@ -105,11 +96,10 @@ def resolve_enclosing_bbox(bboxes: Union[List[BoundingBox], np.ndarray]) -> Unio
         return (min(x), min(y)), (max(x), max(y))
 
 
-def resolve_enclosing_rbbox(rbboxes: List[np.ndarray], intermed_size: int = 1024) -> np.ndarray:
+def resolve_enclosing_rbbox(rbboxes: list[np.ndarray], intermed_size: int = 1024) -> np.ndarray:
     """Compute enclosing rotated bbox either from:
 
     Args:
-    ----
         rbboxes: boxes in one of the following formats:
 
             - an array of boxes: (*, 4, 2), where boxes have this shape:
@@ -119,26 +109,23 @@ def resolve_enclosing_rbbox(rbboxes: List[np.ndarray], intermed_size: int = 1024
         intermed_size: size of the intermediate image
 
     Returns:
-    -------
         a (4, 2) array (enclosing rotated box)
     """
     cloud: np.ndarray = np.concatenate(rbboxes, axis=0)
     # Convert to absolute for minAreaRect
     cloud *= intermed_size
     rect = cv2.minAreaRect(cloud.astype(np.int32))
-    return cv2.boxPoints(rect) / intermed_size  # type: ignore[return-value]
+    return cv2.boxPoints(rect) / intermed_size
 
 
 def rotate_abs_points(points: np.ndarray, angle: float = 0.0) -> np.ndarray:
     """Rotate points counter-clockwise.
 
     Args:
-    ----
         points: array of size (N, 2)
         angle: angle between -90 and +90 degrees
 
     Returns:
-    -------
         Rotated points
     """
     angle_rad = angle * np.pi / 180.0  # compute radian angle for np functions
@@ -148,16 +135,14 @@ def rotate_abs_points(points: np.ndarray, angle: float = 0.0) -> np.ndarray:
     return np.matmul(points, rotation_mat.T)
 
 
-def compute_expanded_shape(img_shape: Tuple[int, int], angle: float) -> Tuple[int, int]:
+def compute_expanded_shape(img_shape: tuple[int, int], angle: float) -> tuple[int, int]:
     """Compute the shape of an expanded rotated image
 
     Args:
-    ----
         img_shape: the height and width of the image
         angle: angle between -90 and +90 degrees
 
     Returns:
-    -------
         the height and width of the rotated image
     """
     points: np.ndarray = np.array([
@@ -174,21 +159,19 @@ def compute_expanded_shape(img_shape: Tuple[int, int], angle: float) -> Tuple[in
 def rotate_abs_geoms(
     geoms: np.ndarray,
     angle: float,
-    img_shape: Tuple[int, int],
+    img_shape: tuple[int, int],
     expand: bool = True,
 ) -> np.ndarray:
     """Rotate a batch of bounding boxes or polygons by an angle around the
     image center.
 
     Args:
-    ----
         geoms: (N, 4) or (N, 4, 2) array of ABSOLUTE coordinate boxes
         angle: anti-clockwise rotation angle in degrees
         img_shape: the height and width of the image
         expand: whether the image should be padded to avoid information loss
 
     Returns:
-    -------
         A batch of rotated polygons (N, 4, 2)
     """
     # Switch to polygons
@@ -214,19 +197,17 @@ def rotate_abs_geoms(
     return rotated_polys
 
 
-def remap_boxes(loc_preds: np.ndarray, orig_shape: Tuple[int, int], dest_shape: Tuple[int, int]) -> np.ndarray:
+def remap_boxes(loc_preds: np.ndarray, orig_shape: tuple[int, int], dest_shape: tuple[int, int]) -> np.ndarray:
     """Remaps a batch of rotated locpred (N, 4, 2) expressed for an origin_shape to a destination_shape.
     This does not impact the absolute shape of the boxes, but allow to calculate the new relative RotatedBbox
     coordinates after a resizing of the image.
 
     Args:
-    ----
         loc_preds: (N, 4, 2) array of RELATIVE loc_preds
         orig_shape: shape of the origin image
         dest_shape: shape of the destination image
 
     Returns:
-    -------
         A batch of rotated loc_preds (N, 4, 2) expressed in the destination referencial
     """
     if len(dest_shape) != 2:
@@ -245,9 +226,9 @@ def remap_boxes(loc_preds: np.ndarray, orig_shape: Tuple[int, int], dest_shape:
 def rotate_boxes(
     loc_preds: np.ndarray,
     angle: float,
-    orig_shape: Tuple[int, int],
+    orig_shape: tuple[int, int],
     min_angle: float = 1.0,
-    target_shape: Optional[Tuple[int, int]] = None,
+    target_shape: tuple[int, int] | None = None,
 ) -> np.ndarray:
     """Rotate a batch of straight bounding boxes (xmin, ymin, xmax, ymax, c) or rotated bounding boxes
     (4, 2) of an angle, if angle > min_angle, around the center of the page.
@@ -255,7 +236,6 @@ def rotate_boxes(
     is done to remove the padding that is created by rotate_page(expand=True)
 
     Args:
-    ----
         loc_preds: (N, 4) or (N, 4, 2) array of RELATIVE boxes
         angle: angle between -90 and +90 degrees
         orig_shape: shape of the origin image
@@ -263,7 +243,6 @@ def rotate_boxes(
         target_shape: shape of the destination image
 
     Returns:
-    -------
         A batch of rotated boxes (N, 4, 2): or a batch of straight bounding boxes
     """
     # Change format of the boxes to rotated boxes
@@ -310,20 +289,18 @@ def rotate_image(
     """Rotate an image counterclockwise by an given angle.
 
     Args:
-    ----
         image: numpy tensor to rotate
         angle: rotation angle in degrees, between -90 and +90
         expand: whether the image should be padded before the rotation
         preserve_origin_shape: if expand is set to True, resizes the final output to the original image size
 
     Returns:
-    -------
         Rotated array, padded by 0 by default.
     """
     # Compute the expanded padding
     exp_img: np.ndarray
     if expand:
-        exp_shape = compute_expanded_shape(image.shape[:2], angle)  # type: ignore[arg-type]
+        exp_shape = compute_expanded_shape(image.shape[:2], angle)
         h_pad, w_pad = (
             int(max(0, ceil(exp_shape[0] - image.shape[0]))),
             int(max(0, ceil(exp_shape[1] - image.shape[1]))),
@@ -344,7 +321,7 @@ def rotate_image(
             # Pad height
             else:
                 h_pad, w_pad = int(rot_img.shape[1] * image.shape[0] / image.shape[1] - rot_img.shape[0]), 0
-            rot_img = np.pad(rot_img, ((h_pad // 2, h_pad - h_pad // 2), (w_pad // 2, w_pad - w_pad // 2), (0, 0)))  # type: ignore[assignment]
+            rot_img = np.pad(rot_img, ((h_pad // 2, h_pad - h_pad // 2), (w_pad // 2, w_pad - w_pad // 2), (0, 0)))
         if preserve_origin_shape:
             # rescale
             rot_img = cv2.resize(rot_img, image.shape[:-1][::-1], interpolation=cv2.INTER_LINEAR)
@@ -356,11 +333,9 @@ def remove_image_padding(image: np.ndarray) -> np.ndarray:
     """Remove black border padding from an image
 
     Args:
-    ----
         image: numpy tensor to remove padding from
 
     Returns:
-    -------
         Image with padding removed
     """
     # Find the bounding box of the non-black region
@@ -390,16 +365,14 @@ def estimate_page_angle(polys: np.ndarray) -> float:
             return 0.0
 
 
-def convert_to_relative_coords(geoms: np.ndarray, img_shape: Tuple[int, int]) -> np.ndarray:
+def convert_to_relative_coords(geoms: np.ndarray, img_shape: tuple[int, int]) -> np.ndarray:
     """Convert a geometry to relative coordinates
 
     Args:
-    ----
         geoms: a set of polygons of shape (N, 4, 2) or of straight boxes of shape (N, 4)
         img_shape: the height and width of the image
 
     Returns:
-    -------
         the updated geometry
     """
     # Polygon
@@ -417,18 +390,16 @@ def convert_to_relative_coords(geoms: np.ndarray, img_shape: Tuple[int, int]) ->
     raise ValueError(f"invalid format for arg `geoms`: {geoms.shape}")
 
 
-def extract_crops(img: np.ndarray, boxes: np.ndarray, channels_last: bool = True) -> List[np.ndarray]:
+def extract_crops(img: np.ndarray, boxes: np.ndarray, channels_last: bool = True) -> list[np.ndarray]:
     """Created cropped images from list of bounding boxes
 
     Args:
-    ----
         img: input image
         boxes: bounding boxes of shape (N, 4) where N is the number of boxes, and the relative
             coordinates (xmin, ymin, xmax, ymax)
         channels_last: whether the channel dimensions is the last one instead of the last one
 
     Returns:
-    -------
         list of cropped images
     """
     if boxes.shape[0] == 0:
@@ -453,11 +424,10 @@ def extract_crops(img: np.ndarray, boxes: np.ndarray, channels_last: bool = True
 
 def extract_rcrops(
     img: np.ndarray, polys: np.ndarray, dtype=np.float32, channels_last: bool = True, assume_horizontal: bool = False
-) -> List[np.ndarray]:
+) -> list[np.ndarray]:
     """Created cropped images from list of rotated bounding boxes
 
     Args:
-    ----
         img: input image
         polys: bounding boxes of shape (N, 4, 2)
         dtype: target data type of bounding boxes
@@ -465,7 +435,6 @@ def extract_rcrops(
         assume_horizontal: whether the boxes are assumed to be only horizontally oriented
 
     Returns:
-    -------
         list of cropped images
     """
     if polys.shape[0] == 0:
@@ -563,4 +532,4 @@ def extract_rcrops(
             )
             for idx in range(_boxes.shape[0])
         ]
-    return crops  # type: ignore[return-value]
+    return crops

doctr/utils/metrics.py

@@ -1,9 +1,8 @@
-# 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 typing import Dict, List, Optional, Tuple
 
 import numpy as np
 from anyascii import anyascii
@@ -21,16 +20,14 @@ __all__ = [
 ]
 
 
-def string_match(word1: str, word2: str) -> Tuple[bool, bool, bool, bool]:
+def string_match(word1: str, word2: str) -> tuple[bool, bool, bool, bool]:
     """Performs string comparison with multiple levels of tolerance
 
     Args:
-    ----
         word1: a string
         word2: another string
 
     Returns:
-    -------
         a tuple with booleans specifying respectively whether the raw strings, their lower-case counterparts, their
             anyascii counterparts and their lower-case anyascii counterparts match
     """
@@ -78,13 +75,12 @@ class TextMatch:
 
     def update(
         self,
-        gt: List[str],
-        pred: List[str],
+        gt: list[str],
+        pred: list[str],
     ) -> None:
         """Update the state of the metric with new predictions
 
         Args:
-        ----
             gt: list of groung-truth character sequences
             pred: list of predicted character sequences
         """
@@ -100,11 +96,10 @@ class TextMatch:
 
         self.total += len(gt)
 
-    def summary(self) -> Dict[str, float]:
+    def summary(self) -> dict[str, float]:
         """Computes the aggregated metrics
 
-        Returns
-        -------
+        Returns:
             a dictionary with the exact match score for the raw data, its lower-case counterpart, its anyascii
             counterpart and its lower-case anyascii counterpart
         """
@@ -130,12 +125,10 @@ def box_iou(boxes_1: np.ndarray, boxes_2: np.ndarray) -> np.ndarray:
     """Computes the IoU between two sets of bounding boxes
 
     Args:
-    ----
         boxes_1: bounding boxes of shape (N, 4) in format (xmin, ymin, xmax, ymax)
         boxes_2: bounding boxes of shape (M, 4) in format (xmin, ymin, xmax, ymax)
 
     Returns:
-    -------
         the IoU matrix of shape (N, M)
     """
     iou_mat: np.ndarray = np.zeros((boxes_1.shape[0], boxes_2.shape[0]), dtype=np.float32)
@@ -160,14 +153,12 @@ def polygon_iou(polys_1: np.ndarray, polys_2: np.ndarray) -> np.ndarray:
     """Computes the IoU between two sets of rotated bounding boxes
 
     Args:
-    ----
         polys_1: rotated bounding boxes of shape (N, 4, 2)
         polys_2: rotated bounding boxes of shape (M, 4, 2)
         mask_shape: spatial shape of the intermediate masks
         use_broadcasting: if set to True, leverage broadcasting speedup by consuming more memory
 
     Returns:
-    -------
         the IoU matrix of shape (N, M)
     """
     if polys_1.ndim != 3 or polys_2.ndim != 3:
@@ -187,16 +178,14 @@ def polygon_iou(polys_1: np.ndarray, polys_2: np.ndarray) -> np.ndarray:
     return iou_mat
 
 
-def nms(boxes: np.ndarray, thresh: float = 0.5) -> List[int]:
+def nms(boxes: np.ndarray, thresh: float = 0.5) -> list[int]:
     """Perform non-max suppression, borrowed from <https://github.com/rbgirshick/fast-rcnn>`_.
 
     Args:
-    ----
         boxes: np array of straight boxes: (*, 5), (xmin, ymin, xmax, ymax, score)
         thresh: iou threshold to perform box suppression.
 
     Returns:
-    -------
         A list of box indexes to keep
     """
     x1 = boxes[:, 0]
@@ -260,7 +249,6 @@ class LocalizationConfusion:
     >>> metric.summary()
 
     Args:
-    ----
         iou_thresh: minimum IoU to consider a pair of prediction and ground truth as a match
         use_polygons: if set to True, predictions and targets will be expected to have rotated format
     """
@@ -278,7 +266,6 @@ class LocalizationConfusion:
         """Updates the metric
 
         Args:
-        ----
             gts: a set of relative bounding boxes either of shape (N, 4) or (N, 5) if they are rotated ones
             preds: a set of relative bounding boxes either of shape (M, 4) or (M, 5) if they are rotated ones
         """
@@ -298,11 +285,10 @@ class LocalizationConfusion:
         self.num_gts += gts.shape[0]
         self.num_preds += preds.shape[0]
 
-    def summary(self) -> Tuple[Optional[float], Optional[float], Optional[float]]:
+    def summary(self) -> tuple[float | None, float | None, float | None]:
         """Computes the aggregated metrics
 
-        Returns
-        -------
+        Returns:
             a tuple with the recall, precision and meanIoU scores
         """
         # Recall
@@ -360,7 +346,6 @@ class OCRMetric:
     >>> metric.summary()
 
     Args:
-    ----
         iou_thresh: minimum IoU to consider a pair of prediction and ground truth as a match
         use_polygons: if set to True, predictions and targets will be expected to have rotated format
     """
@@ -378,13 +363,12 @@ class OCRMetric:
         self,
         gt_boxes: np.ndarray,
         pred_boxes: np.ndarray,
-        gt_labels: List[str],
-        pred_labels: List[str],
+        gt_labels: list[str],
+        pred_labels: list[str],
     ) -> None:
         """Updates the metric
 
         Args:
-        ----
             gt_boxes: a set of relative bounding boxes either of shape (N, 4) or (N, 5) if they are rotated ones
             pred_boxes: a set of relative bounding boxes either of shape (M, 4) or (M, 5) if they are rotated ones
             gt_labels: a list of N string labels
@@ -392,7 +376,7 @@ class OCRMetric:
         """
         if gt_boxes.shape[0] != len(gt_labels) or pred_boxes.shape[0] != len(pred_labels):
             raise AssertionError(
-                "there should be the same number of boxes and string both for the ground truth " "and the predictions"
+                "there should be the same number of boxes and string both for the ground truth and the predictions"
             )
 
         # Compute IoU
@@ -418,11 +402,10 @@ class OCRMetric:
         self.num_gts += gt_boxes.shape[0]
         self.num_preds += pred_boxes.shape[0]
 
-    def summary(self) -> Tuple[Dict[str, Optional[float]], Dict[str, Optional[float]], Optional[float]]:
+    def summary(self) -> tuple[dict[str, float | None], dict[str, float | None], float | None]:
         """Computes the aggregated metrics
 
-        Returns
-        -------
+        Returns:
             a tuple with the recall & precision for each string comparison and the mean IoU
         """
         # Recall
@@ -493,7 +476,6 @@ class DetectionMetric:
     >>> metric.summary()
 
     Args:
-    ----
         iou_thresh: minimum IoU to consider a pair of prediction and ground truth as a match
         use_polygons: if set to True, predictions and targets will be expected to have rotated format
     """
@@ -517,7 +499,6 @@ class DetectionMetric:
         """Updates the metric
 
         Args:
-        ----
             gt_boxes: a set of relative bounding boxes either of shape (N, 4) or (N, 5) if they are rotated ones
             pred_boxes: a set of relative bounding boxes either of shape (M, 4) or (M, 5) if they are rotated ones
             gt_labels: an array of class indices of shape (N,)
@@ -525,7 +506,7 @@ class DetectionMetric:
         """
         if gt_boxes.shape[0] != gt_labels.shape[0] or pred_boxes.shape[0] != pred_labels.shape[0]:
             raise AssertionError(
-                "there should be the same number of boxes and string both for the ground truth " "and the predictions"
+                "there should be the same number of boxes and string both for the ground truth and the predictions"
             )
 
         # Compute IoU
@@ -546,11 +527,10 @@ class DetectionMetric:
         self.num_gts += gt_boxes.shape[0]
         self.num_preds += pred_boxes.shape[0]
 
-    def summary(self) -> Tuple[Optional[float], Optional[float], Optional[float]]:
+    def summary(self) -> tuple[float | None, float | None, float | None]:
         """Computes the aggregated metrics
 
-        Returns
-        -------
+        Returns:
             a tuple with the recall & precision for each class prediction and the mean IoU
         """
         # Recall

doctr/utils/multithreading.py

@@ -1,4 +1,4 @@
-# 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.
@@ -6,15 +6,16 @@
 
 import multiprocessing as mp
 import os
+from collections.abc import Callable, Iterable, Iterator
 from multiprocessing.pool import ThreadPool
-from typing import Any, Callable, Iterable, Iterator, Optional
+from typing import Any
 
 from doctr.file_utils import ENV_VARS_TRUE_VALUES
 
 __all__ = ["multithread_exec"]
 
 
-def multithread_exec(func: Callable[[Any], Any], seq: Iterable[Any], threads: Optional[int] = None) -> Iterator[Any]:
+def multithread_exec(func: Callable[[Any], Any], seq: Iterable[Any], threads: int | None = None) -> Iterator[Any]:
     """Execute a given function in parallel for each element of a given sequence
 
     >>> from doctr.utils.multithreading import multithread_exec
@@ -22,17 +23,14 @@ def multithread_exec(func: Callable[[Any], Any], seq: Iterable[Any], threads: Op
     >>> results = multithread_exec(lambda x: x ** 2, entries)
 
     Args:
-    ----
         func: function to be executed on each element of the iterable
         seq: iterable
         threads: number of workers to be used for multiprocessing
 
     Returns:
-    -------
         iterator of the function's results using the iterable as inputs
 
     Notes:
-    -----
         This function uses ThreadPool from multiprocessing package, which uses `/dev/shm` directory for shared memory.
         If you do not have write permissions for this directory (if you run `doctr` on AWS Lambda for instance),
         you might want to disable multiprocessing. To achieve that, set 'DOCTR_MULTIPROCESSING_DISABLE' to 'TRUE'.