deepdoctection 0.39.6__py3-none-any.whl → 0.40.0__py3-none-any.whl

deepdoctection/__init__.py

@@ -25,7 +25,7 @@ from .utils.logger import LoggingRecord, logger
 
 # pylint: enable=wrong-import-position
 
-__version__ = "0.39.6"
+__version__ = "0.40.0"
 
 _IMPORT_STRUCTURE = {
     "analyzer": ["config_sanity_checks", "get_dd_analyzer", "ServiceFactory"],
@@ -260,6 +260,7 @@ _IMPORT_STRUCTURE = {
         "ImageCroppingService",
         "IntersectionMatcher",
         "NeighbourMatcher",
+        "FamilyCompound",
         "MatchingService",
         "PageParsingService",
         "AnnotationNmsService",

deepdoctection/analyzer/_config.py

@@ -72,7 +72,6 @@ cfg.SEGMENTATION.THRESHOLD_COLS = 0.4
 cfg.SEGMENTATION.FULL_TABLE_TILING = True
 cfg.SEGMENTATION.REMOVE_IOU_THRESHOLD_ROWS = 0.001
 cfg.SEGMENTATION.REMOVE_IOU_THRESHOLD_COLS = 0.001
-cfg.SEGMENTATION.CELL_CATEGORY_ID = 12
 cfg.SEGMENTATION.TABLE_NAME = LayoutType.TABLE
 cfg.SEGMENTATION.PUBTABLES_CELL_NAMES = [
     CellType.SPANNING,

deepdoctection/analyzer/factory.py

@@ -35,13 +35,14 @@ from ..extern.tpdetect import TPFrcnnDetector
 from ..pipe.base import PipelineComponent
 from ..pipe.common import (
     AnnotationNmsService,
+    FamilyCompound,
     IntersectionMatcher,
     MatchingService,
     NeighbourMatcher,
     PageParsingService,
 )
 from ..pipe.doctectionpipe import DoctectionPipe
-from ..pipe.layout import ImageLayoutService
+from ..pipe.layout import ImageLayoutService, skip_if_category_or_service_extracted
 from ..pipe.order import TextOrderService
 from ..pipe.refine import TableSegmentationRefinementService
 from ..pipe.segment import PubtablesSegmentationService, TableSegmentationService
@@ -284,7 +285,6 @@ class ServiceFactory:
         return SubImageLayoutService(
             sub_image_detector=detector,
             sub_image_names=[LayoutType.TABLE, LayoutType.TABLE_ROTATED],
-            category_id_mapping=None,
             detect_result_generator=detect_result_generator,
             padder=padder,
         )
@@ -405,7 +405,6 @@ class ServiceFactory:
                 tile_table_with_items=config.SEGMENTATION.FULL_TABLE_TILING,
                 remove_iou_threshold_rows=config.SEGMENTATION.REMOVE_IOU_THRESHOLD_ROWS,
                 remove_iou_threshold_cols=config.SEGMENTATION.REMOVE_IOU_THRESHOLD_COLS,
-                cell_class_id=config.SEGMENTATION.CELL_CATEGORY_ID,
                 table_name=config.SEGMENTATION.TABLE_NAME,
                 cell_names=config.SEGMENTATION.PUBTABLES_CELL_NAMES,
                 spanning_cell_names=config.SEGMENTATION.PUBTABLES_SPANNING_CELL_NAMES,
@@ -516,6 +515,15 @@ class ServiceFactory:
         """
         return ServiceFactory._build_pdf_miner_text_service(detector)
 
+    @staticmethod
+    def _build_doctr_word_detector_service(detector: DoctrTextlineDetector) -> ImageLayoutService:
+        """Building a Doctr word detector service
+
+        :param detector: DoctrTextlineDetector
+        :return: ImageLayoutService
+        """
+        return ImageLayoutService(layout_detector=detector, to_image=True, crop_image=True)
+
     @staticmethod
     def build_doctr_word_detector_service(detector: DoctrTextlineDetector) -> ImageLayoutService:
         """Building a Doctr word detector service
@@ -523,9 +531,7 @@ class ServiceFactory:
         :param detector: DoctrTextlineDetector
         :return: ImageLayoutService
         """
-        return ImageLayoutService(
-            layout_detector=detector, to_image=True, crop_image=True, skip_if_layout_extracted=True
-        )
+        return ServiceFactory._build_doctr_word_detector_service(detector)
 
     @staticmethod
     def _build_text_extraction_service(
@@ -539,7 +545,6 @@ class ServiceFactory:
         """
         return TextExtractionService(
             detector,
-            skip_if_text_extracted=config.USE_PDF_MINER,
             extract_from_roi=config.TEXT_CONTAINER if config.OCR.USE_DOCTR else None,
         )
 
@@ -567,11 +572,16 @@ class ServiceFactory:
             threshold=config.WORD_MATCHING.THRESHOLD,
             max_parent_only=config.WORD_MATCHING.MAX_PARENT_ONLY,
         )
+        family_compounds = [
+            FamilyCompound(
+                parent_categories=config.WORD_MATCHING.PARENTAL_CATEGORIES,
+                child_categories=config.TEXT_CONTAINER,
+                relationship_key=Relationships.CHILD,
+            )
+        ]
         return MatchingService(
-            parent_categories=config.WORD_MATCHING.PARENTAL_CATEGORIES,
-            child_categories=config.TEXT_CONTAINER,
+            family_compounds=family_compounds,
             matcher=matcher,
-            relationship_key=Relationships.CHILD,
         )
 
     @staticmethod
@@ -591,11 +601,16 @@ class ServiceFactory:
         :return: MatchingService
         """
         neighbor_matcher = NeighbourMatcher()
+        family_compounds = [
+            FamilyCompound(
+                parent_categories=config.LAYOUT_LINK.PARENTAL_CATEGORIES,
+                child_categories=config.LAYOUT_LINK.CHILD_CATEGORIES,
+                relationship_key=Relationships.LAYOUT_LINK,
+            )
+        ]
         return MatchingService(
-            parent_categories=config.LAYOUT_LINK.PARENTAL_CATEGORIES,
-            child_categories=config.LAYOUT_LINK.CHILD_CATEGORIES,
+            family_compounds=family_compounds,
             matcher=neighbor_matcher,
-            relationship_key=Relationships.LAYOUT_LINK,
         )
 
     @staticmethod
@@ -699,9 +714,11 @@ class ServiceFactory:
                 table_refinement_service = ServiceFactory.build_table_refinement_service(config)
                 pipe_component_list.append(table_refinement_service)
 
+        d_text_service_id = ""
         if config.USE_PDF_MINER:
             pdf_miner = ServiceFactory.build_pdf_text_detector(config)
             d_text = ServiceFactory.build_pdf_miner_text_service(pdf_miner)
+            d_text_service_id = d_text.service_id
             pipe_component_list.append(d_text)
 
         # setup ocr
@@ -710,10 +727,14 @@ class ServiceFactory:
             if config.OCR.USE_DOCTR:
                 word_detector = ServiceFactory.build_doctr_word_detector(config)
                 word_service = ServiceFactory.build_doctr_word_detector_service(word_detector)
+                word_service.set_inbound_filter(skip_if_category_or_service_extracted(service_ids=d_text_service_id))
                 pipe_component_list.append(word_service)
 
             ocr_detector = ServiceFactory.build_ocr_detector(config)
             text_extraction_service = ServiceFactory.build_text_extraction_service(config, ocr_detector)
+            text_extraction_service.set_inbound_filter(
+                skip_if_category_or_service_extracted(service_ids=d_text_service_id)
+            )
             pipe_component_list.append(text_extraction_service)
 
         if config.USE_PDF_MINER or config.USE_OCR:

deepdoctection/datapoint/box.py

@@ -18,10 +18,11 @@
 """
 Implementation of BoundingBox class and related methods
 """
+from __future__ import annotations
 
 from dataclasses import dataclass
 from math import ceil, floor
-from typing import Optional, Sequence, no_type_check
+from typing import Optional, Sequence, Union, no_type_check
 
 import numpy as np
 import numpy.typing as npt
@@ -31,7 +32,7 @@ from numpy import float32
 from ..utils.error import BoundingBoxError
 from ..utils.file_utils import cocotools_available
 from ..utils.logger import LoggingRecord, logger
-from ..utils.types import PixelValues
+from ..utils.types import BoxCoordinate, PixelValues
 
 with try_import() as import_guard:
     import pycocotools.mask as coco_mask
@@ -142,96 +143,213 @@ def iou(boxes1: npt.NDArray[float32], boxes2: npt.NDArray[float32]) -> npt.NDArr
     return np_iou(boxes1, boxes2)
 
 
+RELATIVE_COORD_CONVERTER = 10**8
+
+
 @dataclass
 class BoundingBox:
     """
-    Rectangular bounding box dataclass for object detection. Store coordinates and allows several
-    representations. You can define an instance by passing the upper left point along with either height
-    and width or along with the lower right point. Pass absolute_coords = 'True' if you work with image
-    pixel coordinates. If you work with coordinates in the range between (0,1) then pass absolute_coords
-    ='False'. A bounding box is a disposable object. Do not change the coordinates once the have been set but define
-    a new box.
-
-    `absolute_coords` indicates, whether given coordinates are in absolute or in relative terms
-
-    `ulx`: upper left x
+    Rectangular bounding box that stores coordinates and allows different representations.
 
-    `uly`: upper left y
+    This implementation differs from the previous version by using internal integer storage with precision scaling
+    for both absolute and relative coordinates. Coordinates are stored internally as integers (_ulx, _uly, etc.)
+    with relative coordinates multiplied by RELATIVE_COORD_CONVERTER (10^8) for precision. Properties (ulx, uly, etc.)
+    handle the conversion between internal storage and exposed values.
 
-    `lrx`: lower right x
+    You can define an instance by passing:
+    - Upper left point (ulx, uly) + width and height, OR
+    - Upper left point (ulx, uly) + lower right point (lrx, lry)
 
-    `lry`: lower right y
-
-    `height`: height
-
-    `width`: width
+    Notes:
+    - When absolute_coords=True, coordinates will be rounded to integers
+    - When absolute_coords=False, coordinates must be between 0 and 1
+    - The box is validated on initialization to ensure coordinates are valid
     """
 
     absolute_coords: bool
-    ulx: float
-    uly: float
-    lrx: float = 0.0
-    lry: float = 0.0
-    height: float = 0.0
-    width: float = 0.0
+    _ulx: int = 0
+    _uly: int = 0
+    _lrx: int = 0
+    _lry: int = 0
+    _height: int = 0
+    _width: int = 0
+
+    def __init__(
+        self,
+        absolute_coords: bool,
+        ulx: BoxCoordinate,
+        uly: BoxCoordinate,
+        lrx: BoxCoordinate = 0,
+        lry: BoxCoordinate = 0,
+        width: BoxCoordinate = 0,
+        height: BoxCoordinate = 0,
+    ):
+        """
+        Initialize a BoundingBox instance with the specified coordinates.
+
+        This initializer supports two ways of defining a bounding box:
+        1. Using upper-left coordinates (ulx, uly) with width and height
+        2. Using upper-left (ulx, uly) and lower-right (lrx, lry) coordinates
+
+        When absolute_coords is True, coordinates are stored as integers.
+        When absolute_coords is False, coordinates are stored as scaled integers
+        (original float values * RELATIVE_COORD_CONVERTER) for precision.
+
+        :param absolute_coords: Whether coordinates are absolute pixels (True) or normalized [0,1] values (False)
+        :param ulx: Upper-left x-coordinate (float or int)
+        :param uly: Upper-left y-coordinate (float or int)
+        :param lrx: Lower-right x-coordinate (float or int), default 0
+        :param lry: Lower-right y-coordinate (float or int), default 0
+        :param width: Width of the bounding box (float or int), default 0
+        :param height: Height of the bounding box (float or int), default 0
+        """
+        self.absolute_coords = absolute_coords
+        if absolute_coords:
+            self._ulx = round(ulx)
+            self._uly = round(uly)
+            if lrx and lry:
+                self._lrx = round(lrx)
+                self._lry = round(lry)
+            if width and height:
+                self._width = round(width)
+                self._height = round(height)
+        else:
+            self._ulx = round(ulx * RELATIVE_COORD_CONVERTER)
+            self._uly = round(uly * RELATIVE_COORD_CONVERTER)
+            if lrx and lry:
+                self._lrx = round(lrx * RELATIVE_COORD_CONVERTER)
+                self._lry = round(lry * RELATIVE_COORD_CONVERTER)
+            if width and height:
+                self._width = round(width * RELATIVE_COORD_CONVERTER)
+                self._height = round(height * RELATIVE_COORD_CONVERTER)
+        if not self._width and not self._height:
+            self._width = self._lrx - self._ulx
+            self._height = self._lry - self._uly
+        if not self._lrx and not self._lry:
+            self._lrx = self._ulx + self._width
+            self._lry = self._uly + self._height
+        self.__post_init__()
 
     def __post_init__(self) -> None:
-        if self.width == 0.0:
-            if self.lrx is None:
+        if self._width == 0:
+            if self._lrx is None:
                 raise BoundingBoxError("Bounding box not fully initialized")
-            self.width = self.lrx - self.ulx
-        if self.height == 0.0:
-            if self.lry is None:
+            self._width = self._lrx - self._ulx
+        if self._height == 0:
+            if self._lry is None:
                 raise BoundingBoxError("Bounding box not fully initialized")
-            self.height = self.lry - self.uly
+            self._height = self._lry - self._uly
 
-        if self.lrx == 0.0:
-            if self.width is None:
+        if self._lrx == 0:
+            if self._width is None:
                 raise BoundingBoxError("Bounding box not fully initialized")
-            self.lrx = self.ulx + self.width
-        if self.lry == 0.0:
-            if self.height is None:
+            self._lrx = self._ulx + self._width
+        if self._lry == 0:
+            if self._height is None:
                 raise BoundingBoxError("Bounding box not fully initialized")
-            self.lry = self.uly + self.height
+            self._lry = self._uly + self._height
 
-        if not (self.ulx >= 0.0 and self.uly >= 0.0):
-            raise BoundingBoxError("Bounding box ul must be >= (0.,0.)")
-        if not (self.height > 0.0 and self.width > 0.0):
+        if not (self._ulx >= 0 and self._uly >= 0):
+            raise BoundingBoxError("Bounding box ul must be >= (0,0)")
+        if not (self._height > 0 and self._width > 0):
             raise BoundingBoxError(
                 f"bounding box must have height and width >0. Check coords "
                 f"ulx: {self.ulx}, uly: {self.uly}, lrx: {self.lrx}, "
                 f"lry: {self.lry}."
             )
-        if not self.absolute_coords:
-            if not (self.ulx <= 1.0 and self.uly <= 1.0 and self.lrx <= 1.0 and self.lry <= 1.0):
-                raise BoundingBoxError("coordinates must be between 0 and 1")
+        if not self.absolute_coords and not (
+            0 <= self.ulx <= 1 and 0 <= self.uly <= 1 and 0 <= self.lrx <= 1 and 0 <= self.lry <= 1
+        ):
+            raise BoundingBoxError("coordinates must be between 0 and 1")
 
     @property
-    def cx(self) -> float:
-        """
-        Bounding box center x coordinate
-        """
+    def ulx(self) -> BoxCoordinate:
+        """ulx property"""
+        return self._ulx / RELATIVE_COORD_CONVERTER if not self.absolute_coords else self._ulx
+
+    @ulx.setter
+    def ulx(self, value: BoxCoordinate) -> None:
+        """ulx setter"""
+        self._ulx = round(value * RELATIVE_COORD_CONVERTER) if not self.absolute_coords else round(value)
+        self._width = self._lrx - self._ulx
+
+    @property
+    def uly(self) -> BoxCoordinate:
+        """uly property"""
+        return self._uly / RELATIVE_COORD_CONVERTER if not self.absolute_coords else self._uly
+
+    @uly.setter
+    def uly(self, value: BoxCoordinate) -> None:
+        """uly setter"""
+        self._uly = round(value * RELATIVE_COORD_CONVERTER) if not self.absolute_coords else round(value)
+        self._height = self._lry - self._uly
+
+    @property
+    def lrx(self) -> BoxCoordinate:
+        """lrx property"""
+        return self._lrx / RELATIVE_COORD_CONVERTER if not self.absolute_coords else self._lrx
+
+    @lrx.setter
+    def lrx(self, value: BoxCoordinate) -> None:
+        """lrx setter"""
+        self._lrx = round(value * RELATIVE_COORD_CONVERTER) if not self.absolute_coords else round(value)
+        self._width = self._lrx - self._ulx
+
+    @property
+    def lry(self) -> BoxCoordinate:
+        """lry property"""
+        return self._lry / RELATIVE_COORD_CONVERTER if not self.absolute_coords else self._lry
+
+    @lry.setter
+    def lry(self, value: BoxCoordinate) -> None:
+        """lry setter"""
+        self._lry = round(value * RELATIVE_COORD_CONVERTER) if not self.absolute_coords else round(value)
+        self._height = self._lry - self._uly
+
+    @property
+    def width(self) -> BoxCoordinate:
+        """width property"""
+        return self._width / RELATIVE_COORD_CONVERTER if not self.absolute_coords else self._width
+
+    @width.setter
+    def width(self, value: BoxCoordinate) -> None:
+        """width setter"""
+        self._width = round(value * RELATIVE_COORD_CONVERTER) if not self.absolute_coords else round(value)
+        self._lrx = self._ulx + self._width
+
+    @property
+    def height(self) -> BoxCoordinate:
+        """height property"""
+        return self._height / RELATIVE_COORD_CONVERTER if not self.absolute_coords else self._height
+
+    @height.setter
+    def height(self, value: BoxCoordinate) -> None:
+        """height setter"""
+        self._height = round(value * RELATIVE_COORD_CONVERTER) if not self.absolute_coords else round(value)
+        self._lry = self._uly + self._height
+
+    @property
+    def cx(self) -> BoxCoordinate:
+        """cx property"""
+        if self.absolute_coords:
+            return round(self.ulx + 0.5 * self.width)
         return self.ulx + 0.5 * self.width
 
     @property
-    def cy(self) -> float:
-        """
-        Bounding box center y coordinate
-        """
+    def cy(self) -> BoxCoordinate:
+        """cy property"""
+        if self.absolute_coords:
+            return round(self.uly + 0.5 * self.height)
         return self.uly + 0.5 * self.height
 
     @property
-    def center(self) -> list[float]:
-        """
-        Bounding box center [x,y]
-        """
-        return [self.cx, self.cy]
+    def center(self) -> tuple[BoxCoordinate, BoxCoordinate]:
+        """center property"""
+        return (self.cx, self.cy)
 
     @property
-    def area(self) -> float:
-        """
-        Bounding box area
-        """
+    def area(self) -> Union[int, float]:
+        """area property"""
         if self.absolute_coords:
             return self.width * self.height
         raise ValueError("Cannot calculate area, when bounding box coords are relative")
@@ -264,7 +382,7 @@ class BoundingBox:
             * np_poly_scale
         )
 
-    def to_list(self, mode: str, scale_x: float = 1.0, scale_y: float = 1.0) -> list[float]:
+    def to_list(self, mode: str, scale_x: float = 1.0, scale_y: float = 1.0) -> list[BoxCoordinate]:
         """
         Returns the coordinates as list
 
@@ -280,36 +398,62 @@ class BoundingBox:
         """
         assert mode in ("xyxy", "xywh", "poly"), "Not a valid mode"
         if mode == "xyxy":
-            return [
+            return (
+                [
+                    round(self.ulx * scale_x),
+                    round(self.uly * scale_y),
+                    round(self.lrx * scale_x),
+                    round(self.lry * scale_y),
+                ]
+                if self.absolute_coords
+                else [
+                    self.ulx * scale_x,
+                    self.uly * scale_y,
+                    self.lrx * scale_x,
+                    self.lry * scale_y,
+                ]
+            )
+        if mode == "xywh":
+            return (
+                [
+                    round(self.ulx * scale_x),
+                    round(self.uly * scale_y),
+                    round(self.width * scale_x),
+                    round(self.height * scale_y),
+                ]
+                if self.absolute_coords
+                else [self.ulx * scale_x, self.uly * scale_y, self.width * scale_x, self.height * scale_y]
+            )
+        return (
+            [
+                round(self.ulx * scale_x),
+                round(self.uly * scale_y),
+                round(self.lrx * scale_x),
+                round(self.uly * scale_y),
+                round(self.lrx * scale_x),
+                round(self.lry * scale_y),
+                round(self.ulx * scale_x),
+                round(self.lry * scale_y),
+            ]
+            if self.absolute_coords
+            else [
                 self.ulx * scale_x,
                 self.uly * scale_y,
                 self.lrx * scale_x,
+                self.uly * scale_y,
+                self.lrx * scale_x,
                 self.lry * scale_y,
-            ]
-        if mode == "xywh":
-            return [
                 self.ulx * scale_x,
-                self.uly * scale_y,
-                self.width * scale_x,
-                self.height * scale_y,
+                self.lry * scale_y,
             ]
-        return [
-            self.ulx * scale_x,
-            self.uly * scale_y,
-            self.lrx * scale_x,
-            self.uly * scale_y,
-            self.lrx * scale_x,
-            self.lry * scale_y,
-            self.ulx * scale_x,
-            self.lry * scale_y,
-        ]
+        )
 
     def transform(
         self,
         image_width: float,
         image_height: float,
         absolute_coords: bool = False,
-    ) -> "BoundingBox":
+    ) -> BoundingBox:
         """
         Transforms bounding box coordinates into absolute or relative coords. Internally, a new bounding box will be
         created. Changing coordinates requires width and height of the whole image.
@@ -320,8 +464,7 @@ class BoundingBox:
 
         :return: Either a list or np.array.
         """
-
-        if absolute_coords != self.absolute_coords:  # only transforming in this case
+        if absolute_coords != self.absolute_coords:
             if self.absolute_coords:
                 transformed_box = BoundingBox(
                     absolute_coords=not self.absolute_coords,
@@ -344,22 +487,26 @@ class BoundingBox:
     def __str__(self) -> str:
         return f"Bounding Box ulx: {self.ulx}, uly: {self.uly}, lrx: {self.lrx}, lry: {self.lry}"
 
+    def __repr__(self) -> str:
+        return (
+            f"BoundingBox(absolute_coords={self.absolute_coords}, ulx={self.ulx}, uly={self.uly}, lrx={self.lrx},"
+            f" lry={self.lry}, width={self.width}, height={self.height})"
+        )
+
     @staticmethod
     def remove_keys() -> list[str]:
-        """
-        A list of attributes to suspend from as_dict creation.
-        """
-        return ["height", "width"]
+        """Removing keys when converting the dataclass object to a dict"""
+        return ["_height", "_width"]
+
+    @staticmethod
+    def replace_keys() -> dict[str, str]:
+        """Replacing keys when converting the dataclass object to a dict. Useful for backward compatibility"""
+        return {"_ulx": "ulx", "_uly": "uly", "_lrx": "lrx", "_lry": "lry"}
 
     @classmethod
     @no_type_check
-    def from_dict(cls, **kwargs) -> "BoundingBox":
-        """
-        Create `BoundingBox` instance from dict
-
-        :param kwargs: dict with  `BoundingBox` attributes
-        :return: Initialized BoundingBox
-        """
+    def from_dict(cls, **kwargs) -> BoundingBox:
+        """from dict"""
         return cls(**kwargs)
 
 

deepdoctection/datapoint/convert.py

@@ -65,6 +65,10 @@ def as_dict(obj: Any, dict_factory) -> Union[Any]:  # type: ignore
             if hasattr(obj, "remove_keys"):
                 if attribute.name in obj.remove_keys():
                     continue
+            if hasattr(obj, "replace_keys"):
+                old_to_new_keys = obj.replace_keys()
+                if attribute.name in old_to_new_keys:
+                    attribute.name = obj.replace_keys()[attribute.name]
             result.append((attribute.name, value))
         return dict_factory(result)
     if isinstance(obj, (list, tuple)):

deepdoctection/datapoint/image.py

@@ -342,7 +342,7 @@ class Image:
         self,
         category_names: Optional[Union[str, ObjectTypes, Sequence[Union[str, ObjectTypes]]]] = None,
         annotation_ids: Optional[Union[str, Sequence[str]]] = None,
-        service_id: Optional[Union[str, Sequence[str]]] = None,
+        service_ids: Optional[Union[str, Sequence[str]]] = None,
         model_id: Optional[Union[str, Sequence[str]]] = None,
         session_ids: Optional[Union[str, Sequence[str]]] = None,
         ignore_inactive: bool = True,
@@ -356,7 +356,7 @@ class Image:
 
         :param category_names: A single name or list of names
         :param annotation_ids: A single id or list of ids
-        :param service_id: A single service name or list of service names
+        :param service_ids: A single service name or list of service names
         :param model_id: A single model name or list of model names
         :param session_ids: A single session id or list of session ids
         :param ignore_inactive: If set to `True` only active annotations are returned.
@@ -372,7 +372,7 @@ class Image:
             )
 
         ann_ids = [annotation_ids] if isinstance(annotation_ids, str) else annotation_ids
-        service_id = [service_id] if isinstance(service_id, str) else service_id
+        service_ids = [service_ids] if isinstance(service_ids, str) else service_ids
         model_id = [model_id] if isinstance(model_id, str) else model_id
         session_id = [session_ids] if isinstance(session_ids, str) else session_ids
 
@@ -387,8 +387,8 @@ class Image:
         if ann_ids is not None:
             anns = filter(lambda x: x.annotation_id in ann_ids, anns)
 
-        if service_id is not None:
-            anns = filter(lambda x: x.service_id in service_id, anns)
+        if service_ids is not None:
+            anns = filter(lambda x: x.service_id in service_ids, anns)
 
         if model_id is not None:
             anns = filter(lambda x: x.model_id in model_id, anns)

deepdoctection/datapoint/view.py

@@ -659,7 +659,7 @@ class Page(Image):
         self,
         category_names: Optional[Union[str, ObjectTypes, Sequence[Union[str, ObjectTypes]]]] = None,
         annotation_ids: Optional[Union[str, Sequence[str]]] = None,
-        service_id: Optional[Union[str, Sequence[str]]] = None,
+        service_ids: Optional[Union[str, Sequence[str]]] = None,
         model_id: Optional[Union[str, Sequence[str]]] = None,
         session_ids: Optional[Union[str, Sequence[str]]] = None,
         ignore_inactive: bool = True,
@@ -676,7 +676,7 @@ class Page(Image):
 
         :param category_names: A single name or list of names
         :param annotation_ids: A single id or list of ids
-        :param service_id: A single service name or list of service names
+        :param service_ids: A single service name or list of service names
         :param model_id: A single model name or list of model names
         :param session_ids: A single session id or list of session ids
         :param ignore_inactive: If set to `True` only active annotations are returned.
@@ -691,7 +691,7 @@ class Page(Image):
                 else tuple(get_type(cat_name) for cat_name in category_names)
             )
         ann_ids = [annotation_ids] if isinstance(annotation_ids, str) else annotation_ids
-        service_id = [service_id] if isinstance(service_id, str) else service_id
+        service_ids = [service_ids] if isinstance(service_ids, str) else service_ids
         model_id = [model_id] if isinstance(model_id, str) else model_id
         session_id = [session_ids] if isinstance(session_ids, str) else session_ids
 
@@ -706,8 +706,8 @@ class Page(Image):
         if ann_ids is not None:
             anns = filter(lambda x: x.annotation_id in ann_ids, anns)
 
-        if service_id is not None:
-            anns = filter(lambda x: x.generating_service in service_id, anns)
+        if service_ids is not None:
+            anns = filter(lambda x: x.generating_service in service_ids, anns)
 
         if model_id is not None:
             anns = filter(lambda x: x.generating_model in model_id, anns)