deepdoctection 0.31__py3-none-any.whl → 0.33__py3-none-any.whl

deepdoctection/utils/types.py

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+# File: types.py
+
+# Copyright 2021 Dr. Janis Meyer. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Typing sheet for the whole package
+"""
+
+import os
+import queue
+from typing import TYPE_CHECKING, Any, Protocol, Type, TypeVar, Union
+
+import numpy.typing as npt
+import tqdm
+from numpy import uint8
+from typing_extensions import TypeAlias
+
+
+# Type for a general dataclass
+class IsDataclass(Protocol):  # pylint: disable=R0903
+    """
+    type hint for general dataclass
+    """
+
+    __dataclass_fields__: dict[Any, Any]
+
+
+# Numpy image type
+PixelValues = npt.NDArray[uint8]
+# b64 encoded image as string
+B64Str: TypeAlias = str
+# b64 encoded image in bytes
+B64: TypeAlias = bytes
+
+# Typing for curry decorator
+DP = TypeVar("DP")
+S = TypeVar("S")
+T = TypeVar("T")
+
+# Some type hints that must be distinguished when running mypy and linters
+if TYPE_CHECKING:
+    QueueType = queue.Queue[Any]  # pylint: disable=E1136
+    TqdmType = tqdm.tqdm[Any]  # pylint: disable=E1136
+    BaseExceptionType = Type[BaseException]
+
+else:
+    BaseExceptionType = bool
+    QueueType = queue.Queue
+    TqdmType = tqdm.tqdm
+
+
+JsonDict = dict[str, Any]
+
+
+# Some common deepdoctection dict-types
+AnnotationDict: TypeAlias = dict[str, Any]
+ImageDict: TypeAlias = dict[str, Any]
+
+# We use these types for output types of the Page object
+Text_: TypeAlias = dict[str, Any]
+HTML: TypeAlias = str
+csv: TypeAlias = list[list[str]]
+Chunks: TypeAlias = list[tuple[str, str, int, str, str, str, str]]
+
+# Some common dict-types used in common annotation schemes converted from a generic JSON object
+CocoDatapointDict: TypeAlias = dict[str, Any]
+PubtabnetDict: TypeAlias = dict[str, Any]
+FunsdDict: TypeAlias = dict[str, Any]
+Detectron2Dict: TypeAlias = dict[str, Any]
+
+
+# A path to a file, directory etc. can be given as a string or Path object
+PathLikeOrStr: TypeAlias = Union[str, os.PathLike]
+
+# mainly used in utils
+# Type for requirements. A requirement is a Tuple of string and a callable that returns True if the requirement is
+# available
+PackageAvailable: TypeAlias = bool
+ErrorMsg: TypeAlias = str
+Requirement = tuple[str, PackageAvailable, ErrorMsg]
+
+BGR: TypeAlias = tuple[int, int, int]
+
+# A type to collect key val pairs of environ information. Mainly used in env_info.py
+KeyValEnvInfos: TypeAlias = list[tuple[str, str]]
+
+# mainly used in extern
+
+
+# mainly used in eval
+MetricResults: TypeAlias = dict[str, Union[int, float]]

deepdoctection/utils/utils.py

@@ -23,16 +23,16 @@ import inspect
 import os
 from collections.abc import MutableMapping
 from datetime import datetime
-from typing import Any, Callable, Dict, List, Sequence, Set, Union
+from typing import Any, Callable, Sequence, Union
 
 import numpy as np
 
-from .detection_types import Pathlike
+from .types import PathLikeOrStr
 
 
 def delete_keys_from_dict(
-    dictionary: Union[Dict[Any, Any], MutableMapping], keys: Union[str, List[str], Set[str]]  # type: ignore
-) -> Dict[Any, Any]:
+    dictionary: Union[dict[Any, Any], MutableMapping], keys: Union[str, list[str], set[str]]  # type: ignore
+) -> dict[Any, Any]:
     """
     Removing key/value pairs from dictionary. Works for nested dicts as well.
 
@@ -62,7 +62,7 @@ def delete_keys_from_dict(
     return modified_dict
 
 
-def split_string(input_string: str) -> List[str]:
+def split_string(input_string: str) -> list[str]:
     """
     Takes a string, splits between commas and returns a list with split components as list elements
 
@@ -71,7 +71,7 @@ def split_string(input_string: str) -> List[str]:
     return input_string.split(",")
 
 
-def string_to_dict(input_string: str) -> Dict[str, str]:
+def string_to_dict(input_string: str) -> dict[str, str]:
     """
     Takes a string of a form `key1=val1,key2=val2` and returns the corresponding dict
     """
@@ -144,7 +144,7 @@ def get_rng(obj: Any = None) -> np.random.RandomState:
     return np.random.RandomState(seed)
 
 
-def is_file_extension(file_name: Pathlike, extension: Union[str, Sequence[str]]) -> bool:
+def is_file_extension(file_name: PathLikeOrStr, extension: Union[str, Sequence[str]]) -> bool:
     """
     Check if a given file name has a given extension
 

deepdoctection/utils/viz.py

@@ -25,26 +25,26 @@ and
 <https://github.com/facebookresearch/detectron2/blob/main/detectron2/utils/colormap.py>
 """
 
-import ast
 import base64
 import os
 import sys
 from io import BytesIO
-from typing import Any, Dict, List, Optional, Sequence, Tuple, no_type_check
+from typing import Any, Optional, Sequence, no_type_check
 
 import numpy as np
 import numpy.typing as npt
+from lazy_imports import try_import
 from numpy import float32, uint8
 
-from .detection_types import ImageType
-from .env_info import auto_select_viz_library
+from .env_info import ENV_VARS_TRUE, auto_select_viz_library
 from .error import DependencyError
-from .file_utils import get_opencv_requirement, get_pillow_requirement, opencv_available, pillow_available
+from .file_utils import get_opencv_requirement, get_pillow_requirement
+from .types import BGR, B64Str, PathLikeOrStr, PixelValues
 
-if opencv_available():
+with try_import() as cv2_import_guard:
     import cv2
 
-if pillow_available():
+with try_import() as pil_import_guard:
     from PIL import Image, ImageDraw
 
 
@@ -183,7 +183,7 @@ _COLORS = (
 )
 
 
-def random_color(rgb: bool = True, maximum: int = 255) -> Tuple[int, int, int]:
+def random_color(rgb: bool = True, maximum: int = 255) -> tuple[int, int, int]:
     """
     :param rgb: Whether to return RGB colors or BGR colors.
     :param maximum: either 255 or 1
@@ -198,14 +198,14 @@ def random_color(rgb: bool = True, maximum: int = 255) -> Tuple[int, int, int]:
 
 
 def draw_boxes(
-    np_image: ImageType,
+    np_image: PixelValues,
     boxes: npt.NDArray[float32],
-    category_names_list: Optional[List[Optional[str]]] = None,
-    color: Optional[Tuple[int, int, int]] = None,
+    category_names_list: Optional[list[Optional[str]]] = None,
+    color: Optional[BGR] = None,
     font_scale: float = 1.0,
     rectangle_thickness: int = 4,
     box_color_by_category: bool = True,
-) -> ImageType:
+) -> PixelValues:
     """
     Dray bounding boxes with category names into image.
 
@@ -246,7 +246,7 @@ def draw_boxes(
     np_image = np_image.copy()
 
     if np_image.ndim == 2 or (np_image.ndim == 3 and np_image.shape[2] == 1):
-        np_image = cv2.cvtColor(np_image, cv2.COLOR_GRAY2BGR)  # type: ignore
+        np_image = cv2.cvtColor(np_image, cv2.COLOR_GRAY2BGR).astype(np.uint8)
     for i in sorted_inds:
         box = boxes[i, :]
         choose_color = category_to_color.get(category_names_list[i]) if category_to_color is not None else color
@@ -279,7 +279,7 @@ def draw_boxes(
 
 
 @no_type_check
-def interactive_imshow(img: ImageType) -> None:
+def interactive_imshow(img: PixelValues) -> None:
     """
     Display an image in a pop-up window
 
@@ -328,7 +328,7 @@ class VizPackageHandler:
     def __init__(self) -> None:
         """Selecting the image processing library and fonts"""
         package = self._select_package()
-        self.pkg_func_dict: Dict[str, str] = {}
+        self.pkg_func_dict: dict[str, str] = {}
         self.font = None
         self._set_vars(package)
 
@@ -339,8 +339,8 @@ class VizPackageHandler:
         Otherwise it will use Pillow as default package
         :return: either 'pillow' or 'cv2'
         """
-        maybe_cv2 = "cv2" if ast.literal_eval(os.environ.get("USE_DD_OPENCV", "False")) else None
-        maybe_pil = "pillow" if ast.literal_eval(os.environ.get("USE_DD_PILLOW", "True")) else None
+        maybe_cv2 = "cv2" if os.environ.get("USE_DD_OPENCV", "False") in ENV_VARS_TRUE else None
+        maybe_pil = "pillow" if os.environ.get("USE_DD_PILLOW", "True") in ENV_VARS_TRUE else None
 
         if not maybe_cv2 and not maybe_pil:
             raise EnvironmentError(
@@ -386,7 +386,7 @@ class VizPackageHandler:
         package = self._select_package()
         self._set_vars(package)
 
-    def read_image(self, path: str) -> ImageType:
+    def read_image(self, path: PathLikeOrStr) -> PixelValues:
         """Reading an image from file and returning a np.array
 
         :param path: Use /path/to/dir/file_name.[suffix]
@@ -394,16 +394,16 @@ class VizPackageHandler:
         return getattr(self, self.pkg_func_dict["read_image"])(path)
 
     @staticmethod
-    def _cv2_read_image(path: str) -> ImageType:
-        return cv2.imread(path, cv2.IMREAD_COLOR)  # type: ignore
+    def _cv2_read_image(path: PathLikeOrStr) -> PixelValues:
+        return cv2.imread(os.fspath(path), cv2.IMREAD_COLOR).astype(np.uint8)
 
     @staticmethod
-    def _pillow_read_image(path: str) -> ImageType:
-        with Image.open(path).convert("RGB") as image:
+    def _pillow_read_image(path: PathLikeOrStr) -> PixelValues:
+        with Image.open(os.fspath(path)).convert("RGB") as image:
             np_image = np.array(image)[:, :, ::-1]
         return np_image
 
-    def write_image(self, path: str, image: ImageType) -> None:
+    def write_image(self, path: PathLikeOrStr, image: PixelValues) -> None:
         """Writing an image as np.array to a file.
 
         :param path: Use /path/to/dir/file_name.[suffix]
@@ -412,15 +412,15 @@ class VizPackageHandler:
         return getattr(self, self.pkg_func_dict["write_image"])(path, image)
 
     @staticmethod
-    def _cv2_write_image(path: str, image: ImageType) -> None:
-        cv2.imwrite(path, image)
+    def _cv2_write_image(path: PathLikeOrStr, image: PixelValues) -> None:
+        cv2.imwrite(os.fspath(path), image)
 
     @staticmethod
-    def _pillow_write_image(path: str, image: ImageType) -> None:
+    def _pillow_write_image(path: PathLikeOrStr, image: PixelValues) -> None:
         pil_image = Image.fromarray(np.uint8(image[:, :, ::-1]))
-        pil_image.save(path)
+        pil_image.save(os.fspath(path))
 
-    def encode(self, np_image: ImageType) -> bytes:
+    def encode(self, np_image: PixelValues) -> bytes:
         """Converting an image as np.array into a b64 representation
 
         :param np_image: Image as np.array
@@ -428,19 +428,19 @@ class VizPackageHandler:
         return getattr(self, self.pkg_func_dict["encode"])(np_image)
 
     @staticmethod
-    def _cv2_encode(np_image: ImageType) -> bytes:
+    def _cv2_encode(np_image: PixelValues) -> bytes:
         np_encode = cv2.imencode(".png", np_image)
         b_image = np_encode[1].tobytes()
         return b_image
 
     @staticmethod
-    def _pillow_encode(np_image: ImageType) -> bytes:
+    def _pillow_encode(np_image: PixelValues) -> bytes:
         buffered = BytesIO()
         pil_image = Image.fromarray(np.uint8(np_image[:, :, ::-1]))
         pil_image.save(buffered, format="PNG")
         return buffered.getvalue()
 
-    def convert_np_to_b64(self, image: ImageType) -> str:
+    def convert_np_to_b64(self, image: PixelValues) -> str:
         """Converting an image given as np.array into a b64 encoded string
 
         :param image: Image as np.array
@@ -448,18 +448,18 @@ class VizPackageHandler:
         return getattr(self, self.pkg_func_dict["convert_np_to_b64"])(image)
 
     @staticmethod
-    def _cv2_convert_np_to_b64(image: ImageType) -> str:
+    def _cv2_convert_np_to_b64(image: PixelValues) -> str:
         np_encode = cv2.imencode(".png", image)
         return base64.b64encode(np_encode[1]).decode("utf-8")  # type: ignore
 
     @staticmethod
-    def _pillow_convert_np_to_b64(np_image: ImageType) -> str:
+    def _pillow_convert_np_to_b64(np_image: PixelValues) -> str:
         buffered = BytesIO()
         pil_image = Image.fromarray(np.uint8(np_image[:, :, ::-1]))
         pil_image.save(buffered, format="PNG")
         return base64.b64encode(buffered.getvalue()).decode("utf-8")
 
-    def convert_b64_to_np(self, image: str) -> ImageType:
+    def convert_b64_to_np(self, image: B64Str) -> PixelValues:
         """
         Converting an image as b64 encoded string into np.array
 
@@ -469,19 +469,19 @@ class VizPackageHandler:
         return getattr(self, self.pkg_func_dict["convert_b64_to_np"])(image)
 
     @staticmethod
-    def _cv2_convert_b64_to_np(image: str) -> ImageType:
+    def _cv2_convert_b64_to_np(image: B64Str) -> PixelValues:
         np_array = np.fromstring(base64.b64decode(image), np.uint8)  # type: ignore
         np_array = cv2.imdecode(np_array, cv2.IMREAD_COLOR).astype(np.float32)
         return np_array.astype(uint8)
 
     @staticmethod
-    def _pillow_convert_b64_to_np(image: str) -> ImageType:
+    def _pillow_convert_b64_to_np(image: B64Str) -> PixelValues:
         array = base64.b64decode(image)
         im_file = BytesIO(array)
         pil_image = Image.open(im_file)
         return np.array(pil_image)[:, :, ::-1]
 
-    def resize(self, image: ImageType, width: int, height: int, interpolation: str) -> ImageType:
+    def resize(self, image: PixelValues, width: int, height: int, interpolation: str) -> PixelValues:
         """
         Resize a given image to new width, height. Specifying an interpolation method is required. Depending on the
         chosen image library use one of the following:
@@ -498,17 +498,19 @@ class VizPackageHandler:
         return getattr(self, self.pkg_func_dict["resize"])(image, width, height, interpolation)
 
     @staticmethod
-    def _cv2_resize(image: ImageType, width: int, height: int, interpolation: str) -> ImageType:
+    def _cv2_resize(image: PixelValues, width: int, height: int, interpolation: str) -> PixelValues:
         intpol_method_dict = {
             "INTER_NEAREST": cv2.INTER_NEAREST,
             "INTER_LINEAR": cv2.INTER_LINEAR,
             "INTER_AREA": cv2.INTER_AREA,
             "VIZ": cv2.INTER_LINEAR,
         }
-        return cv2.resize(image, (width, height), interpolation=intpol_method_dict[interpolation])  # type: ignore
+        return cv2.resize(image, dsize=(width, height), interpolation=intpol_method_dict[interpolation]).astype(
+            np.uint8
+        )
 
     @staticmethod
-    def _pillow_resize(image: ImageType, width: int, height: int, interpolation: str) -> ImageType:
+    def _pillow_resize(image: PixelValues, width: int, height: int, interpolation: str) -> PixelValues:
         intpol_method_dict = {
             "NEAREST": Image.Resampling.NEAREST,
             "BOX": Image.Resampling.BOX,
@@ -522,7 +524,7 @@ class VizPackageHandler:
         )
         return np.array(pil_image_resized)[:, :, ::-1]
 
-    def get_text_size(self, text: str, font_scale: float) -> Tuple[int, int]:
+    def get_text_size(self, text: str, font_scale: float) -> tuple[int, int]:
         """
         Return the text size for a given font scale
         :param text: text as string
@@ -531,19 +533,19 @@ class VizPackageHandler:
         """
         return getattr(self, self.pkg_func_dict["get_text_size"])(text, font_scale)
 
-    def _cv2_get_text_size(self, text: str, font_scale: float) -> Tuple[int, int]:
+    def _cv2_get_text_size(self, text: str, font_scale: float) -> tuple[int, int]:
         ((width, height), _) = cv2.getTextSize(text, self.font, font_scale, 1)  # type: ignore
         return width, height
 
-    def _pillow_get_text_size(self, text: str, font_scale: float) -> Tuple[int, int]:  # pylint: disable=W0613
+    def _pillow_get_text_size(self, text: str, font_scale: float) -> tuple[int, int]:  # pylint: disable=W0613
         _, _, width, height = self.font.getbbox(text)  # type: ignore
         return width, height
 
     def draw_rectangle(
-        self, np_image: ImageType, box: Tuple[Any, Any, Any, Any], color: Tuple[int, int, int], thickness: int
-    ) -> ImageType:
+        self, np_image: PixelValues, box: tuple[Any, Any, Any, Any], color: tuple[int, int, int], thickness: int
+    ) -> PixelValues:
         """
-        Drawing a rectangle into an image with a given color (b,g,r) and given thickness
+        Drawing a rectangle into an image with a given color (b,g,r) and given thickness.
 
         :param np_image: image
         :param box: box (x_min, y_min, x_max, y_max)
@@ -555,15 +557,15 @@ class VizPackageHandler:
 
     @staticmethod
     def _cv2_draw_rectangle(
-        np_image: ImageType, box: Tuple[Any, Any, Any, Any], color: Sequence[int], thickness: int
-    ) -> ImageType:
+        np_image: PixelValues, box: tuple[Any, Any, Any, Any], color: Sequence[int], thickness: int
+    ) -> PixelValues:
         cv2.rectangle(np_image, (box[0], box[1]), (box[2], box[3]), color=color, thickness=thickness)
         return np_image
 
     @staticmethod
     def _pillow_draw_rectangle(
-        np_image: ImageType, box: Tuple[Any, Any, Any, Any], color: Sequence[int], thickness: int
-    ) -> ImageType:
+        np_image: PixelValues, box: tuple[Any, Any, Any, Any], color: Sequence[int], thickness: int
+    ) -> PixelValues:
         pil_image = Image.fromarray(np.uint8(np_image[:, :, ::-1]))
         draw = ImageDraw.Draw(pil_image)
         draw.rectangle(box, outline=color, width=thickness)  # type: ignore
@@ -572,13 +574,13 @@ class VizPackageHandler:
 
     def draw_text(
         self,
-        np_image: ImageType,
-        pos: Tuple[Any, Any],
+        np_image: PixelValues,
+        pos: tuple[Any, Any],
         text: str,
-        color: Tuple[int, int, int],
+        color: tuple[int, int, int],
         font_scale: float,
         rectangle_thickness: int = 1,
-    ) -> ImageType:
+    ) -> PixelValues:
         """
         Drawing a text into a numpy image. The result will differ between PIL and CV2 (and will not look that good when
         using PIL).
@@ -597,13 +599,13 @@ class VizPackageHandler:
 
     def _cv2_draw_text(
         self,
-        np_image: ImageType,
-        pos: Tuple[Any, Any],
+        np_image: PixelValues,
+        pos: tuple[Any, Any],
         text: str,
-        color: Tuple[int, int, int],
+        color: tuple[int, int, int],
         font_scale: float,
         rectangle_thickness: int,
-    ) -> ImageType:
+    ) -> PixelValues:
         """
         Draw text on an image.
 
@@ -641,13 +643,13 @@ class VizPackageHandler:
 
     @staticmethod
     def _pillow_draw_text(
-        np_image: ImageType,
-        pos: Tuple[Any, Any],
+        np_image: PixelValues,
+        pos: tuple[Any, Any],
         text: str,
-        color: Tuple[int, int, int],  # pylint: disable=W0613
+        color: tuple[int, int, int],  # pylint: disable=W0613
         font_scale: float,  # pylint: disable=W0613
         rectangle_thickness: int,  # pylint: disable=W0613
-    ) -> ImageType:
+    ) -> PixelValues:
         """Draw a text in an image using PIL."""
         # using PIL default font size that does not scale to larger image sizes.
         # Compare with https://github.com/python-pillow/Pillow/issues/6622
@@ -656,11 +658,11 @@ class VizPackageHandler:
         draw.text(pos, text, fill=(0, 0, 0), anchor="lb")
         return np.array(pil_image)[:, :, ::-1]
 
-    def interactive_imshow(self, np_image: ImageType) -> None:
+    def interactive_imshow(self, np_image: PixelValues) -> None:
         """Displaying an image in a separate window"""
         return getattr(self, self.pkg_func_dict["interactive_imshow"])(np_image)
 
-    def _cv2_interactive_imshow(self, np_image: ImageType) -> None:
+    def _cv2_interactive_imshow(self, np_image: PixelValues) -> None:
         """
         Display an image in a pop-up window
 
@@ -681,24 +683,24 @@ class VizPackageHandler:
         elif key == "s":
             cv2.imwrite("out.png", np_image)
         elif key in ["+", "="]:
-            np_image = cv2.resize(np_image, None, fx=1.3, fy=1.3, interpolation=cv2.INTER_CUBIC)  # type: ignore
+            np_image = cv2.resize(np_image, None, fx=1.3, fy=1.3, interpolation=cv2.INTER_CUBIC).astype(np.uint8)
             self._cv2_interactive_imshow(np_image)
         elif key == "-":
-            np_image = cv2.resize(np_image, None, fx=0.7, fy=0.7, interpolation=cv2.INTER_CUBIC)  # type: ignore
+            np_image = cv2.resize(np_image, None, fx=0.7, fy=0.7, interpolation=cv2.INTER_CUBIC).astype(np.uint8)
             self._cv2_interactive_imshow(np_image)
 
     @staticmethod
-    def _pillow_interactive_imshow(np_image: ImageType) -> None:
+    def _pillow_interactive_imshow(np_image: PixelValues) -> None:
         name = "q, x: quit / s: save"
         pil_image = Image.fromarray(np.uint8(np_image[:, :, ::-1]))
         pil_image.show(name)
 
-    def rotate_image(self, np_image: ImageType, angle: int) -> ImageType:
+    def rotate_image(self, np_image: PixelValues, angle: float) -> PixelValues:
         """Rotating an image by some angle"""
         return getattr(self, self.pkg_func_dict["rotate_image"])(np_image, angle)
 
     @staticmethod
-    def _cv2_rotate_image(np_image: ImageType, angle: float) -> ImageType:
+    def _cv2_rotate_image(np_image: PixelValues, angle: float) -> PixelValues:
         # copy & paste from https://stackoverflow.com/questions/43892506
         # /opencv-python-rotate-image-without-cropping-sides
 
@@ -718,16 +720,16 @@ class VizPackageHandler:
         rotation_mat[0, 2] += bound_w / 2 - image_center[0]
         rotation_mat[1, 2] += bound_h / 2 - image_center[1]
 
-        np_image = cv2.warpAffine(  # type: ignore
+        np_image = cv2.warpAffine(
             src=np_image,
             M=rotation_mat,
             dsize=(bound_w, bound_h),
-        )
+        ).astype(np.uint8)
 
         return np_image
 
     @staticmethod
-    def _pillow_rotate_image(np_image: ImageType, angle: int) -> ImageType:
+    def _pillow_rotate_image(np_image: PixelValues, angle: float) -> PixelValues:
         pil_image = Image.fromarray(np.uint8(np_image[:, :, ::-1]))
         pil_image_rotated = pil_image.rotate(angle, expand=True)
         return np.array(pil_image_rotated)[:, :, ::-1]