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

deepdoctection/extern/hflayoutlm.py

@@ -200,7 +200,6 @@ class HFLayoutLmTokenClassifierBase(LMTokenClassifier, ABC):
         :param device: The device (cpu,"cuda"), where to place the model.
         """
 
-        self.name = "_".join(Path(path_weights).parts[-3:])
         if categories is None:
             if categories_semantics is None:
                 raise ValueError("If categories is None then categories_semantics cannot be None")
@@ -302,6 +301,11 @@ class HFLayoutLmTokenClassifierBase(LMTokenClassifier, ABC):
             self.device,
         )
 
+    @staticmethod
+    def get_name(path_weights: str, architecture: str) -> str:
+        """Returns the name of the model"""
+        return f"Transformers_{architecture}_" + "_".join(Path(path_weights).parts[-2:])
+
 
 class HFLayoutLmTokenClassifier(HFLayoutLmTokenClassifierBase):
     """
@@ -357,10 +361,9 @@ class HFLayoutLmTokenClassifier(HFLayoutLmTokenClassifierBase):
         :param categories: If you have a pre-trained model you can pass a complete dict of NER categories
         :param device: The device (cpu,"cuda"), where to place the model.
         """
-        config = PretrainedConfig.from_pretrained(pretrained_model_name_or_path=path_config_json)
-        self.model = LayoutLMForTokenClassification.from_pretrained(
-            pretrained_model_name_or_path=path_weights, config=config
-        )
+        self.name = self.get_name(path_weights, "LayoutLM")
+        self.model_id = self.get_model_id()
+        self.model = self.get_wrapped_model(path_config_json, path_weights)
         super().__init__(path_config_json, path_weights, categories_semantics, categories_bio, categories, device)
 
     def predict(self, **encodings: Union[List[List[str]], "torch.Tensor"]) -> List[TokenClassResult]:
@@ -388,6 +391,18 @@ class HFLayoutLmTokenClassifier(HFLayoutLmTokenClassifierBase):
 
         return self._map_category_names(results)
 
+    @staticmethod
+    def get_wrapped_model(path_config_json: str, path_weights: str) -> Any:
+        """
+        Get the inner (wrapped) model.
+
+        :param path_config_json: path to .json config file
+        :param path_weights: path to model artifact
+        :return: 'nn.Module'
+        """
+        config = PretrainedConfig.from_pretrained(pretrained_model_name_or_path=path_config_json)
+        return LayoutLMForTokenClassification.from_pretrained(pretrained_model_name_or_path=path_weights, config=config)
+
 
 class HFLayoutLmv2TokenClassifier(HFLayoutLmTokenClassifierBase):
     """
@@ -445,10 +460,9 @@ class HFLayoutLmv2TokenClassifier(HFLayoutLmTokenClassifierBase):
         :param categories: If you have a pre-trained model you can pass a complete dict of NER categories
         :param device: The device (cpu,"cuda"), where to place the model.
         """
-        config = LayoutLMv2Config.from_pretrained(pretrained_model_name_or_path=path_config_json)
-        self.model = LayoutLMv2ForTokenClassification.from_pretrained(
-            pretrained_model_name_or_path=path_weights, config=config
-        )
+        self.name = self.get_name(path_weights, "LayoutLMv2")
+        self.model_id = self.get_model_id()
+        self.model = self.get_wrapped_model(path_config_json, path_weights)
         super().__init__(path_config_json, path_weights, categories_semantics, categories_bio, categories, device)
 
     def predict(self, **encodings: Union[List[List[str]], "torch.Tensor"]) -> List[TokenClassResult]:
@@ -489,6 +503,20 @@ class HFLayoutLmv2TokenClassifier(HFLayoutLmTokenClassifierBase):
         """
         return {"image_width": 224, "image_height": 224}
 
+    @staticmethod
+    def get_wrapped_model(path_config_json: str, path_weights: str) -> Any:
+        """
+        Get the inner (wrapped) model.
+
+        :param path_config_json: path to .json config file
+        :param path_weights: path to model artifact
+        :return: 'nn.Module'
+        """
+        config = LayoutLMv2Config.from_pretrained(pretrained_model_name_or_path=path_config_json)
+        return LayoutLMv2ForTokenClassification.from_pretrained(
+            pretrained_model_name_or_path=path_weights, config=config
+        )
+
 
 class HFLayoutLmv3TokenClassifier(HFLayoutLmTokenClassifierBase):
     """
@@ -546,10 +574,9 @@ class HFLayoutLmv3TokenClassifier(HFLayoutLmTokenClassifierBase):
         :param categories: If you have a pre-trained model you can pass a complete dict of NER categories
         :param device: The device (cpu,"cuda"), where to place the model.
         """
-        config = LayoutLMv3Config.from_pretrained(pretrained_model_name_or_path=path_config_json)
-        self.model = LayoutLMv3ForTokenClassification.from_pretrained(
-            pretrained_model_name_or_path=path_weights, config=config
-        )
+        self.name = self.get_name(path_weights, "LayoutLMv3")
+        self.model_id = self.get_model_id()
+        self.model = self.get_wrapped_model(path_config_json, path_weights)
         super().__init__(path_config_json, path_weights, categories_semantics, categories_bio, categories, device)
 
     def predict(self, **encodings: Union[List[List[str]], "torch.Tensor"]) -> List[TokenClassResult]:
@@ -592,6 +619,20 @@ class HFLayoutLmv3TokenClassifier(HFLayoutLmTokenClassifierBase):
             "pixel_std": np.array(IMAGENET_DEFAULT_STD, dtype=np.float32),
         }
 
+    @staticmethod
+    def get_wrapped_model(path_config_json: str, path_weights: str) -> Any:
+        """
+        Get the inner (wrapped) model.
+
+        :param path_config_json: path to .json config file
+        :param path_weights: path to model artifact
+        :return: 'nn.Module'
+        """
+        config = LayoutLMv3Config.from_pretrained(pretrained_model_name_or_path=path_config_json)
+        return LayoutLMv3ForTokenClassification.from_pretrained(
+            pretrained_model_name_or_path=path_weights, config=config
+        )
+
 
 class HFLayoutLmSequenceClassifierBase(LMSequenceClassifier, ABC):
     """
@@ -607,7 +648,6 @@ class HFLayoutLmSequenceClassifierBase(LMSequenceClassifier, ABC):
         categories: Mapping[str, TypeOrStr],
         device: Optional[Literal["cpu", "cuda"]] = None,
     ):
-        self.name = "_".join(Path(path_weights).parts[-3:])
         self.path_config = path_config_json
         self.path_weights = path_weights
         self.categories = copy(categories)  # type: ignore
@@ -691,6 +731,11 @@ class HFLayoutLmSequenceClassifierBase(LMSequenceClassifier, ABC):
         boxes = boxes.to(self.device)
         return input_ids, attention_mask, token_type_ids, boxes
 
+    @staticmethod
+    def get_name(path_weights: str, architecture: str) -> str:
+        """Returns the name of the model"""
+        return f"Transformers_{architecture}_" + "_".join(Path(path_weights).parts[-2:])
+
 
 class HFLayoutLmSequenceClassifier(HFLayoutLmSequenceClassifierBase):
     """
@@ -730,6 +775,8 @@ class HFLayoutLmSequenceClassifier(HFLayoutLmSequenceClassifierBase):
         categories: Mapping[str, TypeOrStr],
         device: Optional[Literal["cpu", "cuda"]] = None,
     ):
+        self.name = self.get_name(path_weights, "LayoutLM")
+        self.model_id = self.get_model_id()
         config = PretrainedConfig.from_pretrained(pretrained_model_name_or_path=path_config_json)
         self.model = LayoutLMForSequenceClassification.from_pretrained(
             pretrained_model_name_or_path=path_weights, config=config
@@ -751,6 +798,20 @@ class HFLayoutLmSequenceClassifier(HFLayoutLmSequenceClassifierBase):
         result.class_name = self.categories[str(result.class_id)]
         return result
 
+    @staticmethod
+    def get_wrapped_model(path_config_json: str, path_weights: str) -> Any:
+        """
+        Get the inner (wrapped) model.
+
+        :param path_config_json: path to .json config file
+        :param path_weights: path to model artifact
+        :return: 'nn.Module'
+        """
+        config = PretrainedConfig.from_pretrained(pretrained_model_name_or_path=path_config_json)
+        return LayoutLMForSequenceClassification.from_pretrained(
+            pretrained_model_name_or_path=path_weights, config=config
+        )
+
 
 class HFLayoutLmv2SequenceClassifier(HFLayoutLmSequenceClassifierBase):
     """
@@ -790,10 +851,9 @@ class HFLayoutLmv2SequenceClassifier(HFLayoutLmSequenceClassifierBase):
         categories: Mapping[str, TypeOrStr],
         device: Optional[Literal["cpu", "cuda"]] = None,
     ):
-        config = LayoutLMv2Config.from_pretrained(pretrained_model_name_or_path=path_config_json)
-        self.model = LayoutLMv2ForSequenceClassification.from_pretrained(
-            pretrained_model_name_or_path=path_weights, config=config
-        )
+        self.name = self.get_name(path_weights, "LayoutLMv2")
+        self.model_id = self.get_model_id()
+        self.model = self.get_wrapped_model(path_config_json, path_weights)
         super().__init__(path_config_json, path_weights, categories, device)
 
     def predict(self, **encodings: Union[List[List[str]], "torch.Tensor"]) -> SequenceClassResult:
@@ -818,6 +878,20 @@ class HFLayoutLmv2SequenceClassifier(HFLayoutLmSequenceClassifierBase):
         """
         return {"image_width": 224, "image_height": 224}
 
+    @staticmethod
+    def get_wrapped_model(path_config_json: str, path_weights: str) -> Any:
+        """
+        Get the inner (wrapped) model.
+
+        :param path_config_json: path to .json config file
+        :param path_weights: path to model artifact
+        :return: 'nn.Module'
+        """
+        config = LayoutLMv2Config.from_pretrained(pretrained_model_name_or_path=path_config_json)
+        return LayoutLMv2ForSequenceClassification.from_pretrained(
+            pretrained_model_name_or_path=path_weights, config=config
+        )
+
 
 class HFLayoutLmv3SequenceClassifier(HFLayoutLmSequenceClassifierBase):
     """
@@ -857,10 +931,9 @@ class HFLayoutLmv3SequenceClassifier(HFLayoutLmSequenceClassifierBase):
         categories: Mapping[str, TypeOrStr],
         device: Optional[Literal["cpu", "cuda"]] = None,
     ):
-        config = LayoutLMv3Config.from_pretrained(pretrained_model_name_or_path=path_config_json)
-        self.model = LayoutLMv3ForSequenceClassification.from_pretrained(
-            pretrained_model_name_or_path=path_weights, config=config
-        )
+        self.name = self.get_name(path_weights, "LayoutLMv3")
+        self.model_id = self.get_model_id()
+        self.model = self.get_wrapped_model(path_config_json, path_weights)
         super().__init__(path_config_json, path_weights, categories, device)
 
     def predict(self, **encodings: Union[List[List[str]], "torch.Tensor"]) -> SequenceClassResult:
@@ -890,3 +963,17 @@ class HFLayoutLmv3SequenceClassifier(HFLayoutLmSequenceClassifierBase):
             "pixel_mean": np.array(IMAGENET_DEFAULT_MEAN, dtype=np.float32),
             "pixel_std": np.array(IMAGENET_DEFAULT_STD, dtype=np.float32),
         }
+
+    @staticmethod
+    def get_wrapped_model(path_config_json: str, path_weights: str) -> Any:
+        """
+        Get the inner (wrapped) model.
+
+        :param path_config_json: path to .json config file
+        :param path_weights: path to model artifact
+        :return: 'nn.Module'
+        """
+        config = LayoutLMv3Config.from_pretrained(pretrained_model_name_or_path=path_config_json)
+        return LayoutLMv3ForSequenceClassification.from_pretrained(
+            pretrained_model_name_or_path=path_weights, config=config
+        )

deepdoctection/extern/pdftext.py

@@ -65,7 +65,8 @@ class PdfPlumberTextDetector(PdfMiner):
     """
 
     def __init__(self) -> None:
-        self.name = "pdfplumber"
+        self.name = "Pdfplumber"
+        self.model_id = self.get_model_id()
         self.categories = {"1": LayoutType.word}
 
     def predict(self, pdf_bytes: bytes) -> List[DetectionResult]:

deepdoctection/extern/pt/ptutils.py

@@ -20,6 +20,7 @@ Torch related utils
 """
 
 
+from ...utils.error import DependencyError
 from ...utils.file_utils import pytorch_available
 
 
@@ -31,7 +32,7 @@ def set_torch_auto_device() -> "torch.device":  # type: ignore
         from torch import cuda, device  # pylint: disable=C0415
 
         return device("cuda" if cuda.is_available() else "cpu")
-    raise ModuleNotFoundError("Pytorch must be installed")
+    raise DependencyError("Pytorch must be installed")
 
 
 def get_num_gpu() -> int:
@@ -45,4 +46,4 @@ def get_num_gpu() -> int:
         from torch import cuda  # pylint: disable=C0415
 
         return cuda.device_count()
-    raise ModuleNotFoundError("Pytorch must be installed")
+    raise DependencyError("Pytorch must be installed")

deepdoctection/extern/tessocr.py

@@ -19,21 +19,24 @@
 Tesseract OCR engine for text extraction
 """
 import shlex
+import string
 import subprocess
 import sys
 from errno import ENOENT
 from itertools import groupby
 from os import environ
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Mapping, Optional, Union
 
-import numpy as np
+from packaging.version import InvalidVersion, Version, parse
 
 from ..utils.context import save_tmp_file, timeout_manager
 from ..utils.detection_types import ImageType, Requirement
-from ..utils.file_utils import _TESS_PATH, TesseractNotFound, get_tesseract_requirement
+from ..utils.error import DependencyError, TesseractError
+from ..utils.file_utils import _TESS_PATH, get_tesseract_requirement
 from ..utils.metacfg import config_to_cli_str, set_config_by_yaml
-from ..utils.settings import LayoutType, ObjectTypes
-from .base import DetectionResult, ObjectDetector, PredictorBase
+from ..utils.settings import LayoutType, ObjectTypes, PageType
+from ..utils.viz import viz_handler
+from .base import DetectionResult, ImageTransformer, ObjectDetector, PredictorBase
 
 # copy and paste with some light modifications from https://github.com/madmaze/pytesseract/tree/master/pytesseract
 
@@ -57,18 +60,6 @@ _LANG_CODE_TO_TESS_LANG_CODE = {
 }
 
 
-class TesseractError(RuntimeError):
-    """
-    Tesseract Error
-    """
-
-    def __init__(self, status: int, message: str) -> None:
-        super().__init__()
-        self.status = status
-        self.message = message
-        self.args = (status, message)
-
-
 def _subprocess_args() -> Dict[str, Any]:
     # See https://github.com/pyinstaller/pyinstaller/wiki/Recipe-subprocess
     # for reference and comments.
@@ -109,7 +100,7 @@ def _run_tesseract(tesseract_args: List[str]) -> None:
     except OSError as error:
         if error.errno != ENOENT:
             raise error from error
-        raise TesseractNotFound("Tesseract not found. Please install or add to your PATH.") from error
+        raise DependencyError("Tesseract not found. Please install or add to your PATH.") from error
 
     with timeout_manager(proc, 0) as error_string:
         if proc.returncode:
@@ -119,6 +110,50 @@ def _run_tesseract(tesseract_args: List[str]) -> None:
             )
 
 
+def get_tesseract_version() -> Version:
+    """
+    Returns Version object of the Tesseract version
+    """
+    try:
+        output = subprocess.check_output(
+            ["tesseract", "--version"],
+            stderr=subprocess.STDOUT,
+            env=environ,
+            stdin=subprocess.DEVNULL,
+        )
+    except OSError as error:
+        raise DependencyError("Tesseract not found. Please install or add to your PATH.") from error
+
+    raw_version = output.decode("utf-8")
+    str_version, *_ = raw_version.lstrip(string.printable[10:]).partition(" ")
+    str_version, *_ = str_version.partition("-")
+
+    try:
+        version = parse(str_version)
+        assert version >= Version("3.05")
+    except (AssertionError, InvalidVersion) as error:
+        raise SystemExit(f'Invalid tesseract version: "{raw_version}"') from error
+
+    return version
+
+
+def image_to_angle(image: ImageType) -> Mapping[str, str]:
+    """
+    Generating a tmp file and running tesseract to get the orientation of the image.
+
+    :param image: Image in np.array.
+    :return: A dictionary with keys 'Orientation in degrees' and 'Orientation confidence'.
+    """
+    with save_tmp_file(image, "tess_") as (tmp_name, input_file_name):
+        _run_tesseract(_input_to_cli_str("osd", "--psm 0", 0, input_file_name, tmp_name))
+        with open(tmp_name + ".osd", "rb") as output_file:
+            output = output_file.read().decode("utf-8")
+
+    return {
+        key_value[0]: key_value[1] for key_value in (line.split(": ") for line in output.split("\n") if len(line) >= 2)
+    }
+
+
 def image_to_dict(image: ImageType, lang: str, config: str) -> Dict[str, List[Union[str, int, float]]]:
     """
     This is more or less pytesseract.image_to_data with a dict as returned value.
@@ -220,7 +255,6 @@ def predict_text(np_img: ImageType, supported_languages: str, text_lines: bool,
     :return: A list of tesseract extractions wrapped in DetectionResult
     """
 
-    np_img = np_img.astype(np.uint8)
     results = image_to_dict(np_img, supported_languages, config)
     all_results = []
 
@@ -249,6 +283,16 @@ def predict_text(np_img: ImageType, supported_languages: str, text_lines: bool,
     return all_results
 
 
+def predict_rotation(np_img: ImageType) -> Mapping[str, str]:
+    """
+    Predicts the rotation of an image using the Tesseract OCR engine.
+
+    :param np_img: numpy array of the image
+    :return: A dictionary with keys 'Orientation in degrees' and 'Orientation confidence'
+    """
+    return image_to_angle(np_img)
+
+
 class TesseractOcrDetector(ObjectDetector):
     """
     Text object detector based on Tesseracts OCR engine. Note that tesseract has to be installed separately.
@@ -292,7 +336,9 @@ class TesseractOcrDetector(ObjectDetector):
         :param config_overwrite: Overwrite config parameters defined by the yaml file with new values.
                                  E.g. ["oem=14"]
         """
-        self.name = _TESS_PATH
+        self.name = self.get_name()
+        self.model_id = self.get_model_id()
+
         if config_overwrite is None:
             config_overwrite = []
 
@@ -316,13 +362,13 @@ class TesseractOcrDetector(ObjectDetector):
         :param np_img: image as numpy array
         :return: A list of DetectionResult
         """
-        detection_results = predict_text(
+
+        return predict_text(
             np_img,
             supported_languages=self.config.LANGUAGES,
             text_lines=self.config.LINES,
             config=config_to_cli_str(self.config, "LANGUAGES", "LINES"),
         )
-        return detection_results
 
     @classmethod
     def get_requirements(cls) -> List[Requirement]:
@@ -342,3 +388,69 @@ class TesseractOcrDetector(ObjectDetector):
         :param language: `Languages`
         """
         self.config.LANGUAGES = _LANG_CODE_TO_TESS_LANG_CODE.get(language, language.value)
+
+    @staticmethod
+    def get_name() -> str:
+        """Returns the name of the model"""
+        return f"Tesseract_{get_tesseract_version()}"
+
+
+class TesseractRotationTransformer(ImageTransformer):
+    """
+    The `TesseractRotationTransformer` class is a specialized image transformer that is designed to handle image
+    rotation in the context of Optical Character Recognition (OCR) tasks. It inherits from the `ImageTransformer`
+    base class and implements methods for predicting and applying rotation transformations to images.
+
+    The `predict` method determines the angle of the rotated image. It can only handle angles that are multiples of 90
+    degrees.
+    This method uses the Tesseract OCR engine to predict the rotation angle of an image.
+
+    The `transform` method applies the predicted rotation to the image, effectively rotating the image backwards.
+    This method uses either the Pillow library or OpenCV for the rotation operation, depending on the configuration.
+
+    This class can be particularly useful in OCR tasks where the orientation of the text in the image matters.
+    The class also provides methods for cloning itself and for getting the requirements of the Tesseract OCR system.
+
+    **Example:**
+                    transformer = TesseractRotationTransformer()
+                    detection_result = transformer.predict(np_img)
+                    rotated_image = transformer.transform(np_img, detection_result)
+    """
+
+    def __init__(self) -> None:
+        self.name = _TESS_PATH + "-rotation"
+
+    def transform(self, np_img: ImageType, specification: DetectionResult) -> ImageType:
+        """
+        Applies the predicted rotation to the image, effectively rotating the image backwards.
+        This method uses either the Pillow library or OpenCV for the rotation operation, depending on the configuration.
+
+        :param np_img: The input image as a numpy array.
+        :param specification: A `DetectionResult` object containing the predicted rotation angle.
+        :return: The rotated image as a numpy array.
+        """
+        return viz_handler.rotate_image(np_img, specification.angle)  # type: ignore
+
+    def predict(self, np_img: ImageType) -> DetectionResult:
+        """
+        Determines the angle of the rotated image. It can only handle angles that are multiples of 90 degrees.
+        This method uses the Tesseract OCR engine to predict the rotation angle of an image.
+
+        :param np_img: The input image as a numpy array.
+        :return: A `DetectionResult` object containing the predicted rotation angle and confidence.
+        """
+        output_dict = predict_rotation(np_img)
+        return DetectionResult(
+            angle=float(output_dict["Orientation in degrees"]), score=float(output_dict["Orientation confidence"])
+        )
+
+    @classmethod
+    def get_requirements(cls) -> List[Requirement]:
+        return [get_tesseract_requirement()]
+
+    def clone(self) -> PredictorBase:
+        return self.__class__()
+
+    @staticmethod
+    def possible_category() -> PageType:
+        return PageType.angle

deepdoctection/extern/texocr.py

@@ -120,6 +120,8 @@ class TextractOcrDetector(ObjectDetector):
         :param credentials_kwargs: `aws_access_key_id`, `aws_secret_access_key` or `aws_session_token`
         """
         self.name = "textract"
+        self.model_id = self.get_model_id()
+
         self.text_lines = text_lines
         self.client = boto3.client("textract", **credentials_kwargs)
         if self.text_lines:

deepdoctection/extern/tp/tpcompat.py

@@ -55,7 +55,7 @@ class ModelDescWithConfig(ModelDesc, ABC):  # type: ignore
 
         :return: Tuple of list input and list output names. The names must coincide with tensor within the model.
         """
-        raise NotImplementedError
+        raise NotImplementedError()
 
 
 class TensorpackPredictor(ABC):
@@ -106,14 +106,14 @@ class TensorpackPredictor(ABC):
 
     @staticmethod
     @abstractmethod
-    def set_model(
+    def get_wrapped_model(
         path_yaml: str, categories: Mapping[str, ObjectTypes], config_overwrite: Union[List[str], None]
     ) -> ModelDescWithConfig:
         """
         Implement the config generation, its modification and instantiate a version of the model. See
         `pipe.tpfrcnn.TPFrcnnDetector` for an example
         """
-        raise NotImplementedError
+        raise NotImplementedError()
 
     @abstractmethod
     def predict(self, np_img: Any) -> Any:
@@ -121,7 +121,7 @@ class TensorpackPredictor(ABC):
         Implement, how `self.tp_predictor` is invoked and raw prediction results are generated. Do use only raw
         objects and nothing, which is related to the DD API.
         """
-        raise NotImplementedError
+        raise NotImplementedError()
 
     @property
     def model(self) -> ModelDescWithConfig:

deepdoctection/extern/tp/tpfrcnn/preproc.py

@@ -18,6 +18,7 @@ from tensorpack.dataflow.imgaug import AugmentorList, ImageAugmentor
 
 from ....datapoint.convert import box_to_point4, point4_to_box
 from ....utils.detection_types import ImageType, JsonDict
+from ....utils.error import MalformedData
 from ....utils.logger import log_once
 from .common import filter_boxes_inside_shape, np_iou
 from .modeling.model_fpn import get_all_anchors_fpn
@@ -27,12 +28,6 @@ from .utils.np_box_ops import ioa as np_ioa
 # pylint: enable=import-error
 
 
-class MalformedData(BaseException):
-    """
-    Exception class for malformed data
-    """
-
-
 def augment(dp: JsonDict, imgaug_list: List[ImageAugmentor], add_mask: bool) -> JsonDict:
     """
     Augment an image according to a list of augmentors.
@@ -62,7 +57,7 @@ def augment(dp: JsonDict, imgaug_list: List[ImageAugmentor], add_mask: bool) ->
         assert np.min(np_area(gt_boxes)) > 0, "some boxes have zero area"
 
     if add_mask:
-        raise NotImplementedError
+        raise NotImplementedError()
 
     return dp