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

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,14 +289,12 @@ 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
@@ -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'.

doctr/utils/reconstitution.py

@@ -1,9 +1,9 @@
-# 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
-from typing import Any, Dict, Optional
+from typing import Any
 
 import numpy as np
 from anyascii import anyascii
@@ -18,7 +18,7 @@ __all__ = ["synthesize_page", "synthesize_kie_page"]
 ROTATION_WARNING = False
 
 
-def _warn_rotation(entry: Dict[str, Any]) -> None:  # pragma: no cover
+def _warn_rotation(entry: dict[str, Any]) -> None:  # pragma: no cover
     global ROTATION_WARNING
     if not ROTATION_WARNING and len(entry["geometry"]) == 4:
         logging.warning("Polygons with larger rotations will lead to inaccurate rendering")
@@ -27,11 +27,11 @@ def _warn_rotation(entry: Dict[str, Any]) -> None:  # pragma: no cover
 
 def _synthesize(
     response: Image.Image,
-    entry: Dict[str, Any],
+    entry: dict[str, Any],
     w: int,
     h: int,
     draw_proba: bool = False,
-    font_family: Optional[str] = None,
+    font_family: str | None = None,
     smoothing_factor: float = 0.75,
     min_font_size: int = 6,
     max_font_size: int = 50,
@@ -111,9 +111,9 @@ def _synthesize(
 
 
 def synthesize_page(
-    page: Dict[str, Any],
+    page: dict[str, Any],
     draw_proba: bool = False,
-    font_family: Optional[str] = None,
+    font_family: str | None = None,
     smoothing_factor: float = 0.95,
     min_font_size: int = 8,
     max_font_size: int = 50,
@@ -121,7 +121,6 @@ def synthesize_page(
     """Draw a the content of the element page (OCR response) on a blank page.
 
     Args:
-    ----
         page: exported Page object to represent
         draw_proba: if True, draw words in colors to represent confidence. Blue: p=1, red: p=0
         font_family: family of the font
@@ -130,7 +129,6 @@ def synthesize_page(
         max_font_size: maximum font size
 
     Returns:
-    -------
         the synthesized page
     """
     # Draw template
@@ -174,14 +172,13 @@ def synthesize_page(
 
 
 def synthesize_kie_page(
-    page: Dict[str, Any],
+    page: dict[str, Any],
     draw_proba: bool = False,
-    font_family: Optional[str] = None,
+    font_family: str | None = None,
 ) -> np.ndarray:
     """Draw a the content of the element page (OCR response) on a blank page.
 
     Args:
-    ----
         page: exported Page object to represent
         draw_proba: if True, draw words in colors to represent confidence. Blue: p=1, red: p=0
         font_family: family of the font
@@ -190,7 +187,6 @@ def synthesize_kie_page(
         max_font_size: maximum font size
 
     Returns:
-    -------
         the synthesized page
     """
     # Draw template

doctr/utils/repr.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.
 
 # Adapted from https://github.com/pytorch/torch/blob/master/torch/nn/modules/module.py
 
-from typing import List
 
 __all__ = ["NestedObject"]
 
@@ -25,7 +24,7 @@ def _addindent(s_, num_spaces):
 class NestedObject:
     """Base class for all nested objects in doctr"""
 
-    _children_names: List[str]
+    _children_names: list[str]
 
     def extra_repr(self) -> str:
         return ""