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

deepdoctection/extern/tpdetect.py

@@ -19,9 +19,10 @@
 TP Faster RCNN model as predictor for deepdoctection pipeline
 """
 
+from abc import ABC
 from copy import copy
 from pathlib import Path
-from typing import List, Mapping, Optional, Sequence, Union
+from typing import Dict, List, Mapping, Optional, Sequence, Union
 
 from ..utils.detection_types import ImageType, Requirement
 from ..utils.file_utils import get_tensorflow_requirement, get_tensorpack_requirement, tensorpack_available
@@ -36,7 +37,46 @@ if tensorpack_available():
     from .tp.tpfrcnn.predict import tp_predict_image
 
 
-class TPFrcnnDetector(TensorpackPredictor, ObjectDetector):
+class TPFrcnnDetectorMixin(ObjectDetector, ABC):
+    """Base class for TP FRCNN detector. This class only implements the basic wrapper functions"""
+
+    def __init__(self, categories: Mapping[str, TypeOrStr], filter_categories: Optional[Sequence[TypeOrStr]] = None):
+        self.categories = copy(categories)  # type: ignore
+        if filter_categories:
+            filter_categories = [get_type(cat) for cat in filter_categories]
+        self.filter_categories = filter_categories
+        self._tp_categories = self._map_to_tp_categories(categories)
+
+    def _map_category_names(self, detection_results: List[DetectionResult]) -> List[DetectionResult]:
+        """
+        Populating category names to detection results
+
+        :param detection_results: list of detection results
+        :return: List of detection results with attribute class_name populated
+        """
+        filtered_detection_result: List[DetectionResult] = []
+        for result in detection_results:
+            result.class_name = self._tp_categories[str(result.class_id)]
+            if self.filter_categories:
+                if result.class_name not in self.filter_categories:
+                    filtered_detection_result.append(result)
+            else:
+                filtered_detection_result.append(result)
+        return filtered_detection_result
+
+    @staticmethod
+    def _map_to_tp_categories(categories: Mapping[str, TypeOrStr]) -> Dict[str, ObjectTypes]:
+        categories = {str(key): get_type(categories[val]) for key, val in enumerate(categories, 1)}
+        categories["0"] = get_type("background")
+        return categories  # type: ignore
+
+    @staticmethod
+    def get_name(path_weights: str, architecture: str) -> str:
+        """Returns the name of the model"""
+        return f"Tensorpack_{architecture}" + "_".join(Path(path_weights).parts[-2:])
+
+
+class TPFrcnnDetector(TensorpackPredictor, TPFrcnnDetectorMixin):
     """
     Tensorpack Faster-RCNN implementation with FPN and optional Cascade-RCNN. The backbones Resnet-50, Resnet-101 and
     their Resnext counterparts are also available. Normalization options (group normalization, synchronized batch
@@ -87,19 +127,23 @@ class TPFrcnnDetector(TensorpackPredictor, ObjectDetector):
         :param filter_categories: The model might return objects that are not supposed to be predicted and that should
                                   be filtered. Pass a list of category names that must not be returned
         """
-        self.name = "_".join(Path(path_weights).parts[-3:])
         self.path_yaml = path_yaml
+
         self.categories = copy(categories)  # type: ignore
         self.config_overwrite = config_overwrite
         if filter_categories:
             filter_categories = [get_type(cat) for cat in filter_categories]
         self.filter_categories = filter_categories
-        model = TPFrcnnDetector.set_model(path_yaml, self.categories, config_overwrite)
-        super().__init__(model, path_weights, ignore_mismatch)
+        model = TPFrcnnDetector.get_wrapped_model(path_yaml, self.categories, config_overwrite)
+        TensorpackPredictor.__init__(self, model, path_weights, ignore_mismatch)
+        TPFrcnnDetectorMixin.__init__(self, categories, filter_categories)
+
+        self.name = self.get_name(path_weights, self._model.cfg.TAG)
+        self.model_id = self.get_model_id()
         assert self._number_gpus > 0, "Model only support inference with GPU"
 
     @staticmethod
-    def set_model(
+    def get_wrapped_model(
         path_yaml: str, categories: Mapping[str, ObjectTypes], config_overwrite: Union[List[str], None]
     ) -> ResNetFPNModel:
         """
@@ -138,23 +182,6 @@ class TPFrcnnDetector(TensorpackPredictor, ObjectDetector):
         )
         return self._map_category_names(detection_results)
 
-    def _map_category_names(self, detection_results: List[DetectionResult]) -> List[DetectionResult]:
-        """
-        Populating category names to detection results
-
-        :param detection_results: list of detection results
-        :return: List of detection results with attribute class_name populated
-        """
-        filtered_detection_result: List[DetectionResult] = []
-        for result in detection_results:
-            result.class_name = self._model.cfg.DATA.CLASS_DICT[str(result.class_id)]
-            if self.filter_categories:
-                if result.class_name not in self.filter_categories:
-                    filtered_detection_result.append(result)
-            else:
-                filtered_detection_result.append(result)
-        return filtered_detection_result
-
     @classmethod
     def get_requirements(cls) -> List[Requirement]:
         return [get_tensorflow_requirement(), get_tensorpack_requirement()]

deepdoctection/mapper/d2struct.py

@@ -93,7 +93,7 @@ def image_to_d2_frcnn_training(
         annotations.append(mapped_ann)
 
         if add_mask:
-            raise NotImplementedError
+            raise NotImplementedError("Segmentation in deepdoctection is not supported")
 
     output["annotations"] = annotations
 

deepdoctection/mapper/hfstruct.py

@@ -81,7 +81,7 @@ def image_to_hf_detr_training(
         annotations.append(mapped_ann)
 
     if add_mask:
-        raise NotImplementedError
+        raise NotImplementedError("Segmentation in deepdoctection is not supported")
 
     output["annotations"] = annotations
 

deepdoctection/mapper/laylmstruct.py

@@ -146,7 +146,7 @@ def image_to_raw_layoutlm_features(
             raise TypeError(f"char_cat must be of type ContainerAnnotation but is of type {type(char_cat)}")
         word = char_cat.value
         if not isinstance(word, str):
-            raise ValueError(f"word must be of type str but is of type {type(word)}")
+            raise TypeError(f"word must be of type str but is of type {type(word)}")
         all_words.append(word)
 
         box = ann.get_bounding_box(dp.image_id)

deepdoctection/mapper/maputils.py

@@ -28,8 +28,8 @@ import numpy as np
 from tabulate import tabulate
 from termcolor import colored
 
-from ..datapoint.box import BoundingBoxError
 from ..utils.detection_types import DP, BaseExceptionType, S, T
+from ..utils.error import AnnotationError, BoundingBoxError, ImageError, UUIDError
 from ..utils.logger import LoggingRecord, logger
 from ..utils.settings import ObjectTypes
 
@@ -72,7 +72,18 @@ class MappingContextManager:
         """
         if (
             exc_type
-            in (KeyError, ValueError, IndexError, AssertionError, TypeError, BoundingBoxError, FileNotFoundError)
+            in (
+                KeyError,
+                ValueError,
+                IndexError,
+                AssertionError,
+                TypeError,
+                FileNotFoundError,
+                BoundingBoxError,
+                AnnotationError,
+                ImageError,
+                UUIDError,
+            )
             and exc_tb is not None
         ):
             frame_summary = traceback.extract_tb(exc_tb)[0]

deepdoctection/mapper/prodigystruct.py

@@ -128,7 +128,7 @@ def prodigy_to_image(
             else:
                 label = span["label"]
             if not isinstance(label, str):
-                raise ValueError("label could not assigned to be a string")
+                raise TypeError("label must be a string")
 
             annotation = ImageAnnotation(
                 category_name=label,

deepdoctection/mapper/pubstruct.py

@@ -75,12 +75,14 @@ def _cell_token(html: Sequence[str]) -> List[List[int]]:
 def _item_spans(html: Sequence[str], index_cells: Sequence[Sequence[int]], item: str) -> List[List[int]]:
     item_spans = [
         [
-            int(html[index_cell - 1].replace(item + "=", "").replace('"', ""))
-            if (item in html[index_cell - 1] and html[index_cell] == ">")
-            else (
-                int(html[index_cell - 2].replace(item + "=", "").replace('"', ""))
-                if (item in html[index_cell - 2] and html[index_cell] == ">")
-                else 1
+            (
+                int(html[index_cell - 1].replace(item + "=", "").replace('"', ""))
+                if (item in html[index_cell - 1] and html[index_cell] == ">")
+                else (
+                    int(html[index_cell - 2].replace(item + "=", "").replace('"', ""))
+                    if (item in html[index_cell - 2] and html[index_cell] == ">")
+                    else 1
+                )
             )
             for index_cell in index_cell_per_row
         ]
@@ -210,9 +212,7 @@ def _add_items(image: Image, item_type: str, categories_name_as_key: Dict[str, s
         items = image.get_annotation(category_names=TableType.item)
         item_type_anns = [ann for ann in items if ann.get_sub_category(TableType.item).category_name == item_type]
         item_type_anns.sort(
-            key=lambda x: x.bounding_box.cx  # type: ignore
-            if item_type == LayoutType.column
-            else x.bounding_box.cy  # type: ignore
+            key=lambda x: (x.bounding_box.cx if item_type == LayoutType.column else x.bounding_box.cy)  # type: ignore
         )
         if table.bounding_box:
             tmp_item_xy = table.bounding_box.uly + 1.0 if item_type == LayoutType.row else table.bounding_box.ulx + 1.0
@@ -389,7 +389,7 @@ def pub_to_image_uncur(  # pylint: disable=R0914
     with MappingContextManager(str(idx)) as mapping_context:
         max_rs, max_cs = 0, 0
         if idx is None:
-            raise ValueError("No valid datapoint external id")
+            raise TypeError("imgid is None but must be a string")
 
         image = Image(file_name=os.path.split(dp["filename"])[1], location=dp["filename"], external_id=idx)
 

deepdoctection/mapper/tpstruct.py

@@ -67,7 +67,7 @@ def image_to_tp_frcnn_training(
         all_categories.append(ann.category_id)
 
         if add_mask:
-            raise NotImplementedError
+            raise NotImplementedError()
 
     output["gt_boxes"] = np.asarray(all_boxes, dtype="float32")
     output["gt_labels"] = np.asarray(all_categories, dtype="int32")

deepdoctection/pipe/anngen.py

@@ -42,11 +42,14 @@ class DatapointManager:
     The manager is part of each `PipelineComponent`.
     """
 
-    def __init__(self) -> None:
+    def __init__(self, service_id: str, model_id: Optional[str] = None) -> None:
         self._datapoint: Optional[Image] = None
         self._cache_anns: Dict[str, ImageAnnotation] = {}
         self.datapoint_is_passed: bool = False
         self.category_id_mapping: Optional[Mapping[int, int]] = None
+        self.service_id = service_id
+        self.model_id = model_id
+        self.session_id: Optional[str] = None
 
     @property
     def datapoint(self) -> Image:
@@ -55,7 +58,7 @@ class DatapointManager:
         """
         if self._datapoint is not None:
             return self._datapoint
-        raise ValueError("no datapoint passed")
+        raise ValueError("No datapoint passed")
 
     @datapoint.setter
     def datapoint(self, dp: Image) -> None:
@@ -154,6 +157,9 @@ class DatapointManager:
                 bounding_box=box,
                 category_id=str(detect_result.class_id),
                 score=detect_result.score,
+                service_id=self.service_id,
+                model_id=self.model_id,
+                session_id=self.session_id,
             )
             if to_annotation_id is not None:
                 parent_ann = self._cache_anns[to_annotation_id]
@@ -208,7 +214,14 @@ class DatapointManager:
                 "annotation_id": annotation_id,
             },
         ) as annotation_context:
-            cat_ann = CategoryAnnotation(category_name=category_name, category_id=str(category_id), score=score)
+            cat_ann = CategoryAnnotation(
+                category_name=category_name,
+                category_id=str(category_id),
+                score=score,
+                service_id=self.service_id,
+                model_id=self.model_id,
+                session_id=self.session_id,
+            )
             self._cache_anns[annotation_id].dump_sub_category(sub_cat_key, cat_ann)
         if annotation_context.context_error:
             return None
@@ -246,7 +259,13 @@ class DatapointManager:
             },
         ) as annotation_context:
             cont_ann = ContainerAnnotation(
-                category_name=category_name, category_id=str(category_id), value=value, score=score
+                category_name=category_name,
+                category_id=str(category_id),
+                value=value,
+                score=score,
+                service_id=self.service_id,
+                model_id=self.model_id,
+                session_id=self.session_id,
             )
             self._cache_anns[annotation_id].dump_sub_category(sub_cat_key, cont_ann)
         if annotation_context.context_error:
@@ -257,7 +276,7 @@ class DatapointManager:
         self,
         summary_key: ObjectTypes,
         summary_name: ObjectTypes,
-        summary_number: int,
+        summary_number: Optional[int] = None,
         summary_value: Optional[str] = None,
         summary_score: Optional[float] = None,
         annotation_id: Optional[str] = None,
@@ -294,16 +313,24 @@ class DatapointManager:
                 "annotation_id": annotation_id,
             },
         ) as annotation_context:
-            if summary_value:
+            if summary_value is not None:
                 ann = ContainerAnnotation(
                     category_name=summary_name,
-                    category_id=str(summary_number),
+                    category_id=str(summary_number) if summary_number is not None else "",
                     value=summary_value,
                     score=summary_score,
+                    service_id=self.service_id,
+                    model_id=self.model_id,
+                    session_id=self.session_id,
                 )
             else:
                 ann = CategoryAnnotation(
-                    category_name=summary_name, category_id=str(summary_number), score=summary_score
+                    category_name=summary_name,
+                    category_id=str(summary_number) if summary_number is not None else "",
+                    score=summary_score,
+                    service_id=self.service_id,
+                    model_id=self.model_id,
+                    session_id=self.session_id,
                 )
             image.summary.dump_sub_category(summary_key, ann, image.image_id)
 

deepdoctection/pipe/base.py

@@ -23,12 +23,14 @@ from abc import ABC, abstractmethod
 from collections import defaultdict
 from copy import deepcopy
 from typing import Any, Callable, DefaultDict, Dict, List, Mapping, Optional, Set, Union
+from uuid import uuid1
 
 from ..dataflow import DataFlow, MapData
 from ..datapoint.image import Image
 from ..extern.base import ImageTransformer, ObjectDetector, PdfMiner, TextRecognizer
 from ..utils.context import timed_operation
 from ..utils.detection_types import JsonDict
+from ..utils.identifier import get_uuid_from_str
 from .anngen import DatapointManager
 
 
@@ -58,8 +60,9 @@ class PipelineComponent(ABC):
                      pipeline. Use something that describe the task of the pipeline.
         """
         self.name = name
+        self.service_id = self.get_service_id()
         self._meta_has_all_types()
-        self.dp_manager = DatapointManager()
+        self.dp_manager = DatapointManager(self.service_id)
         self.timer_on = False
 
     @abstractmethod
@@ -75,7 +78,7 @@ class PipelineComponent(ABC):
         As a simplified interface `serve` does not have to return a dp. The data point is passed on within
         pipelines internally (via `pass_datapoint`).
         """
-        raise NotImplementedError
+        raise NotImplementedError()
 
     def pass_datapoint(self, dp: Image) -> Image:
         """
@@ -109,7 +112,7 @@ class PipelineComponent(ABC):
         """
         Clone an instance
         """
-        raise NotImplementedError
+        raise NotImplementedError()
 
     @abstractmethod
     def get_meta_annotation(self) -> JsonDict:
@@ -122,7 +125,7 @@ class PipelineComponent(ABC):
         `summaries` with values: A list of summary sub categories
         :return: Dict with meta infos as just described
         """
-        raise NotImplementedError
+        raise NotImplementedError()
 
     def _meta_has_all_types(self) -> None:
         if not {"image_annotations", "sub_categories", "relationships", "summaries"}.issubset(
@@ -133,6 +136,12 @@ class PipelineComponent(ABC):
                 f"Got {self.get_meta_annotation().keys()}"
             )
 
+    def get_service_id(self) -> str:
+        """
+        Get the generating model
+        """
+        return get_uuid_from_str(self.name)[:8]
+
 
 class PredictorPipelineComponent(PipelineComponent, ABC):
     """
@@ -151,10 +160,11 @@ class PredictorPipelineComponent(PipelineComponent, ABC):
         """
         self.predictor = predictor
         super().__init__(name)
+        self.dp_manager = DatapointManager(self.service_id, self.predictor.model_id)
 
     @abstractmethod
     def clone(self) -> "PredictorPipelineComponent":
-        raise NotImplementedError
+        raise NotImplementedError()
 
 
 class LanguageModelPipelineComponent(PipelineComponent, ABC):
@@ -175,15 +185,15 @@ class LanguageModelPipelineComponent(PipelineComponent, ABC):
         """
 
         self.tokenizer = tokenizer
-        self.mapping_to_lm_input_func = mapping_to_lm_input_func
         super().__init__(name)
+        self.mapping_to_lm_input_func = mapping_to_lm_input_func
 
     @abstractmethod
     def clone(self) -> "LanguageModelPipelineComponent":
         """
         Clone an instance
         """
-        raise NotImplementedError
+        raise NotImplementedError()
 
 
 class ImageTransformPipelineComponent(PipelineComponent, ABC):
@@ -206,7 +216,7 @@ class ImageTransformPipelineComponent(PipelineComponent, ABC):
         """
         Clone an instance
         """
-        raise NotImplementedError
+        raise NotImplementedError()
 
 
 class Pipeline(ABC):
@@ -228,7 +238,7 @@ class Pipeline(ABC):
 
             layout = LayoutPipeComponent(layout_detector ...)
             text = TextExtractPipeComponent(text_detector ...)
-            simple_pipe = MyPipeline (pipeline_component = [layout, text])
+            simple_pipe = MyPipeline(pipeline_component = [layout, text])
             doc_dataflow = simple_pipe.analyze(input = path / to / dir)
 
             for page in doc_dataflow:
@@ -238,6 +248,18 @@ class Pipeline(ABC):
     model or already processed further).
 
     In addition to `analyze`, the internal `_entry` is used to bundle preprocessing steps.
+
+    It is possible to set a session id for the pipeline. This is useful for logging purposes. The session id can be
+    either passed to the pipeline via the `analyze` method or generated automatically.
+
+    To generate a session_id automatically:
+
+    **Example:**
+
+           pipe = MyPipeline(pipeline_component = [layout, text])
+           pipe.set_session_id = True
+
+           df = pipe.analyze(input = "path/to/dir") # session_id is generated automatically
     """
 
     def __init__(self, pipeline_component_list: List[PipelineComponent]) -> None:
@@ -245,6 +267,7 @@ class Pipeline(ABC):
         :param pipeline_component_list: A list of pipeline components.
         """
         self.pipe_component_list = pipeline_component_list
+        self.set_session_id = False
 
     @abstractmethod
     def _entry(self, **kwargs: Any) -> DataFlow:
@@ -254,14 +277,17 @@ class Pipeline(ABC):
 
         :param kwargs: Arguments, for dynamic customizing of the processing or for the transfer of processing types
         """
-        raise NotImplementedError
+        raise NotImplementedError()
 
-    def _build_pipe(self, df: DataFlow) -> DataFlow:
+    def _build_pipe(self, df: DataFlow, session_id: Optional[str] = None) -> DataFlow:
         """
         Composition of the backbone
         """
+        if session_id is None and self.set_session_id:
+            session_id = self.get_session_id()
         for component in self.pipe_component_list:
             component.timer_on = True
+            component.dp_manager.session_id = session_id
             df = component.predict_dataflow(df)
         return df
 
@@ -277,7 +303,7 @@ class Pipeline(ABC):
 
         can be triggered.
         """
-        raise NotImplementedError
+        raise NotImplementedError()
 
     def get_meta_annotation(self) -> JsonDict:
         """
@@ -301,22 +327,30 @@ class Pipeline(ABC):
             for key, value in meta_anns["relationships"].items():
                 pipeline_populations["relationships"][key].update(value)
             pipeline_populations["summaries"].extend(meta_anns["summaries"])  # type: ignore
-
+        pipeline_populations["sub_categories"] = dict(pipeline_populations["sub_categories"])  # type: ignore
+        pipeline_populations["relationships"] = dict(pipeline_populations["relationships"])  # type: ignore
         return pipeline_populations
 
     def get_pipeline_info(
-        self, position: Optional[int] = None, name: Optional[str] = None
-    ) -> Union[Mapping[int, str], str, int]:
+        self, service_id: Optional[str] = None, name: Optional[str] = None
+    ) -> Union[str, Mapping[str, str]]:
         """Get pipeline information: Returns a dictionary with a description of each pipeline component
-        :param position: position of the pipeline component in the pipeline
+        :param service_id: service_id of the pipeline component to search for
         :param name: name of the pipeline component to search for
         :return: Either a full dictionary with position and name of all pipeline components or the name, if the position
                  has been passed or the position if the name has been passed.
         """
-        comp_info = {key: comp.name for key, comp in enumerate(self.pipe_component_list)}
+        comp_info = {comp.service_id: comp.name for comp in self.pipe_component_list}
         comp_info_name_as_key = {value: key for key, value in comp_info.items()}
-        if position is not None:
-            return comp_info[position]
+        if service_id is not None:
+            return comp_info[service_id]
         if name is not None:
             return comp_info_name_as_key[name]
         return comp_info
+
+    @staticmethod
+    def get_session_id() -> str:
+        """
+        Get the generating a session id
+        """
+        return str(uuid1())[:8]

deepdoctection/pipe/cell.py

@@ -24,9 +24,11 @@ from typing import Dict, List, Mapping, Optional, Sequence, Union
 
 import numpy as np
 
+from ..datapoint.annotation import ImageAnnotation
+from ..datapoint.box import crop_box_from_image
 from ..datapoint.image import Image
 from ..extern.base import DetectionResult, ObjectDetector, PdfMiner
-from ..utils.detection_types import JsonDict
+from ..utils.detection_types import ImageType, JsonDict
 from ..utils.settings import ObjectTypes, Relationships
 from ..utils.transform import PadTransform
 from .base import PredictorPipelineComponent
@@ -181,18 +183,14 @@ class SubImageLayoutService(PredictorPipelineComponent):
         """
         sub_image_anns = dp.get_annotation_iter(category_names=self.sub_image_name)
         for sub_image_ann in sub_image_anns:
-            if sub_image_ann.image is None:
-                raise ValueError("sub_image_ann.image is None, but must be an image")
-            np_image = sub_image_ann.image.image
-            if self.padder:
-                np_image = self.padder.apply_image(np_image)
-            detect_result_list = self.predictor.predict(np_image)
+            np_image = self.prepare_np_image(sub_image_ann)
+            detect_result_list = self.predictor.predict(np_image)  # type: ignore
             if self.padder and detect_result_list:
                 boxes = np.array([detect_result.box for detect_result in detect_result_list])
                 boxes_orig = self.padder.inverse_apply_coords(boxes)
                 for idx, detect_result in enumerate(detect_result_list):
                     detect_result.box = boxes_orig[idx, :].tolist()
-            if self.detect_result_generator:
+            if self.detect_result_generator and sub_image_ann.image:
                 self.detect_result_generator.width = sub_image_ann.image.width
                 self.detect_result_generator.height = sub_image_ann.image.height
                 detect_result_list = self.detect_result_generator.create_detection_result(detect_result_list)
@@ -235,3 +233,26 @@ class SubImageLayoutService(PredictorPipelineComponent):
             deepcopy(self.detect_result_generator),
             padder_clone,
         )
+
+    def prepare_np_image(self, sub_image_ann: ImageAnnotation) -> ImageType:
+        """Maybe crop and pad a np_array before passing it to the predictor.
+
+        Note that we currently assume to a two level hierachy of images, e.g. we can crop a sub-image from the base
+        image, e.g. the original input but we cannot crop a sub-image from an image which is itself a sub-image.
+
+        :param sub_image_ann: ImageAnnotation to be processed
+        :return: processed np_image
+        """
+        if sub_image_ann.image is None:
+            raise ValueError("sub_image_ann.image is None, but must be an datapoint.Image")
+        np_image = sub_image_ann.image.image
+        if np_image is None and self.dp_manager.datapoint.image is not None:
+            np_image = crop_box_from_image(
+                self.dp_manager.datapoint.image,
+                sub_image_ann.get_bounding_box(self.dp_manager.datapoint.image_id),
+                self.dp_manager.datapoint.width,
+                self.dp_manager.datapoint.height,
+            )
+        if self.padder:
+            np_image = self.padder.apply_image(np_image)
+        return np_image

deepdoctection/pipe/common.py

@@ -93,8 +93,8 @@ class MatchingService(PipelineComponent):
 
     def __init__(
         self,
-        parent_categories: Union[TypeOrStr, List[TypeOrStr]],
-        child_categories: Union[TypeOrStr, List[TypeOrStr]],
+        parent_categories: Union[TypeOrStr, Sequence[TypeOrStr]],
+        child_categories: Union[TypeOrStr, Sequence[TypeOrStr]],
         matching_rule: Literal["iou", "ioa"],
         threshold: float,
         use_weighted_intersections: bool = False,
@@ -112,8 +112,16 @@ class MatchingService(PipelineComponent):
                                            value calibrate the ioa.
         :param max_parent_only: Will assign to each child at most one parent with maximum ioa
         """
-        self.parent_categories = parent_categories
-        self.child_categories = child_categories
+        self.parent_categories = (
+            [get_type(parent_categories)]  # type: ignore
+            if not isinstance(parent_categories, (list, set))
+            else [get_type(parent_category) for parent_category in parent_categories]
+        )
+        self.child_categories = (
+            [get_type(child_categories)]  # type: ignore
+            if not isinstance(child_categories, (list, set))
+            else [get_type(child_category) for child_category in child_categories]
+        )
         assert matching_rule in ["iou", "ioa"], "segment rule must be either iou or ioa"
         self.matching_rule = matching_rule
         self.threshold = threshold

deepdoctection/pipe/doctectionpipe.py

@@ -82,7 +82,6 @@ def _proto_process(
     else:
         path_tmp = path
     logger.info(LoggingRecord(f"Processing {file_name}", {"path": path_tmp, "df": path_tmp, "file_name": file_name}))
-    # logger.info("Processing %s", file_name, {"path": path_tmp, "df": path_tmp, "file_name": file_name})
     return dp
 
 
@@ -221,9 +220,10 @@ class DoctectionPipe(Pipeline):
         """
 
         output = kwargs.get("output", "page")
+        session_id = kwargs.get("session_id")
         assert output in ("page", "image", "dict"), "output must be either page image or dict"
         df = self._entry(**kwargs)
-        df = self._build_pipe(df)
+        df = self._build_pipe(df, session_id=session_id)  # type: ignore
         if output == "page":
             df = self.dataflow_to_page(df)
         elif output == "dict":