deepdoctection 0.39.7__tar.gz → 0.40.0__tar.gz

{deepdoctection-0.39.7 → deepdoctection-0.40.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepdoctection
-Version: 0.39.7
+Version: 0.40.0
 Summary: Repository for Document AI
 Home-page: https://github.com/deepdoctection/deepdoctection
 Author: Dr. Janis Meyer

{deepdoctection-0.39.7 → deepdoctection-0.40.0}/deepdoctection/__init__.py

@@ -25,7 +25,7 @@ from .utils.logger import LoggingRecord, logger
 
 # pylint: enable=wrong-import-position
 
-__version__ = "0.39.7"
+__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-0.39.7 → deepdoctection-0.40.0}/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-0.39.7 → deepdoctection-0.40.0}/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-0.39.7 → deepdoctection-0.40.0}/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-0.39.7 → deepdoctection-0.40.0}/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)

{deepdoctection-0.39.7 → deepdoctection-0.40.0}/deepdoctection/mapper/match.py

@@ -34,13 +34,15 @@ from ..utils.settings import TypeOrStr
 
 def match_anns_by_intersection(
     dp: Image,
-    parent_ann_category_names: Union[TypeOrStr, Sequence[TypeOrStr]],
-    child_ann_category_names: Union[TypeOrStr, Sequence[TypeOrStr]],
     matching_rule: Literal["iou", "ioa"],
     threshold: float,
     use_weighted_intersections: bool = False,
+    parent_ann_category_names: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
+    child_ann_category_names: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
     parent_ann_ids: Optional[Union[Sequence[str], str]] = None,
     child_ann_ids: Optional[Union[str, Sequence[str]]] = None,
+    parent_ann_service_ids: Optional[Union[str, Sequence[str]]] = None,
+    child_ann_service_ids: Optional[Union[str, Sequence[str]]] = None,
     max_parent_only: bool = False,
 ) -> tuple[Any, Any, Sequence[ImageAnnotation], Sequence[ImageAnnotation]]:
     """
@@ -87,13 +89,19 @@ def match_anns_by_intersection(
                            dates which are not in the list.
     :param child_ann_ids: Additional filter condition. If some ids are selected, it will ignore all other children
                           candidates which are not in the list.
+    :param parent_ann_service_ids: Additional filter condition. If some ids are selected, it will ignore all other
+                                   parent candidates which are not in the list.
+    :param child_ann_service_ids: Additional filter condition. If some ids are selected, it will ignore all other
+                                  children candidates which are not in the list.
     :param max_parent_only: Will assign to each child at most one parent with maximum ioa
     :return: child indices, parent indices (see Example), list of parent ids and list of children ids.
     """
 
     assert matching_rule in ["iou", "ioa"], "matching rule must be either iou or ioa"
 
-    child_anns = dp.get_annotation(annotation_ids=child_ann_ids, category_names=child_ann_category_names)
+    child_anns = dp.get_annotation(
+        annotation_ids=child_ann_ids, category_names=child_ann_category_names, service_ids=child_ann_service_ids
+    )
     child_ann_boxes = np.array(
         [
             ann.get_bounding_box(dp.image_id).transform(dp.width, dp.height, absolute_coords=True).to_list(mode="xyxy")
@@ -101,7 +109,9 @@ def match_anns_by_intersection(
         ]
     )
 
-    parent_anns = dp.get_annotation(annotation_ids=parent_ann_ids, category_names=parent_ann_category_names)
+    parent_anns = dp.get_annotation(
+        annotation_ids=parent_ann_ids, category_names=parent_ann_category_names, service_ids=parent_ann_service_ids
+    )
     parent_ann_boxes = np.array(
         [
             ann.get_bounding_box(dp.image_id).transform(dp.width, dp.height, absolute_coords=True).to_list(mode="xyxy")
@@ -147,10 +157,12 @@ def match_anns_by_intersection(
 
 def match_anns_by_distance(
     dp: Image,
-    parent_ann_category_names: Union[TypeOrStr, Sequence[TypeOrStr]],
-    child_ann_category_names: Union[TypeOrStr, Sequence[TypeOrStr]],
+    parent_ann_category_names:  Optional[Union[TypeOrStr, Sequence[TypeOrStr]]]=None,
+    child_ann_category_names:  Optional[Union[TypeOrStr, Sequence[TypeOrStr]]]=None,
     parent_ann_ids: Optional[Union[Sequence[str], str]] = None,
     child_ann_ids: Optional[Union[str, Sequence[str]]] = None,
+    parent_ann_service_ids: Optional[Union[str, Sequence[str]]] = None,
+    child_ann_service_ids: Optional[Union[str, Sequence[str]]] = None,
 ) -> list[tuple[ImageAnnotation, ImageAnnotation]]:
     """
     Generates pairs of parent and child annotations by calculating the euclidean distance between the centers of the
@@ -164,11 +176,19 @@ def match_anns_by_distance(
                            dates which are not in the list.
     :param child_ann_ids: Additional filter condition. If some ids are selected, it will ignore all other children
                           candidates which are not in the list.
+    :param parent_ann_service_ids: Additional filter condition. If some ids are selected, it will ignore all other
+                                   parent candidates which are not in the list.
+    :param child_ann_service_ids: Additional filter condition. If some ids are selected, it will ignore all other
+                                  children candidates which are not in the list.
     :return:
     """
 
-    parent_anns = dp.get_annotation(annotation_ids=parent_ann_ids, category_names=parent_ann_category_names)
-    child_anns = dp.get_annotation(annotation_ids=child_ann_ids, category_names=child_ann_category_names)
+    parent_anns = dp.get_annotation(
+        annotation_ids=parent_ann_ids, category_names=parent_ann_category_names, service_ids=parent_ann_service_ids
+    )
+    child_anns = dp.get_annotation(
+        annotation_ids=child_ann_ids, category_names=child_ann_category_names, service_ids=child_ann_service_ids
+    )
     child_centers = [block.get_bounding_box(dp.image_id).center for block in child_anns]
     parent_centers = [block.get_bounding_box(dp.image_id).center for block in parent_anns]
     if child_centers and parent_centers:

{deepdoctection-0.39.7 → deepdoctection-0.40.0}/deepdoctection/pipe/anngen.py

@@ -75,27 +75,6 @@ class DatapointManager:
         """
         assert self.datapoint_is_passed, "Pass datapoint to  DatapointManager before creating anns"
 
-    def maybe_map_category_id(self, category_id: Union[str, int]) -> int:
-        """
-        Maps categories if a category id mapping is provided in `__init__`.
-
-        :param category_id: category id via integer or string.
-        :return: mapped category id
-        """
-        if self.category_id_mapping is None:
-            return int(category_id)
-        return self.category_id_mapping[int(category_id)]
-
-    def set_category_id_mapping(self, category_id_mapping: Mapping[int, int]) -> None:
-        """
-        In many cases the category ids sent back from a model have to be modified. Pass a mapping from model
-        category ids to target annotation category ids.
-
-        :param category_id_mapping: A mapping of model category ids (sent from DetectionResult) to category ids (saved
-                                    in annotations)
-        """
-        self.category_id_mapping = category_id_mapping
-
     def set_image_annotation(
         self,
         detect_result: DetectionResult,
@@ -127,13 +106,10 @@ class DatapointManager:
         :return: the annotation_id of the generated image annotation
         """
         self.assert_datapoint_passed()
-        if detect_result.class_id is None:
-            raise ValueError("class_id of detect_result cannot be None")
         if not isinstance(detect_result.box, (list, np.ndarray)):
             raise TypeError(
                 f"detect_result.box must be of type list or np.ndarray, but is of type {(type(detect_result.box))}"
             )
-        detect_result.class_id = self.maybe_map_category_id(detect_result.class_id)
         with MappingContextManager(
             dp_name=self.datapoint.file_name, filter_level="annotation", detect_result=asdict(detect_result)
         ) as annotation_context:
@@ -155,7 +131,7 @@ class DatapointManager:
             ann = ImageAnnotation(
                 category_name=detect_result.class_name,
                 bounding_box=box,
-                category_id=detect_result.class_id,
+                category_id=detect_result.class_id if detect_result.class_id is not None else DEFAULT_CATEGORY_ID,
                 score=detect_result.score,
                 service_id=self.service_id,
                 model_id=self.model_id,

{deepdoctection-0.39.7 → deepdoctection-0.40.0}/deepdoctection/pipe/common.py

@@ -22,6 +22,7 @@ from __future__ import annotations
 
 import os
 from copy import deepcopy
+from dataclasses import dataclass, field
 from typing import Literal, Mapping, Optional, Sequence, Union
 
 import numpy as np
@@ -49,24 +50,30 @@ class ImageCroppingService(PipelineComponent):
     generally not stored.
     """
 
-    def __init__(self, category_names: Union[TypeOrStr, Sequence[TypeOrStr]]):
+    def __init__(
+        self, category_names: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
+             service_ids: Optional[Sequence[str]] = None
+    ) -> None:
         """
         :param category_names: A single name or a list of category names to crop
         """
-
-        self.category_names = (
-            (category_names,)
-            if isinstance(category_names, str)
-            else tuple(get_type(category_name) for category_name in category_names)
-        )
+        if category_names is None:
+            self.category_names = None
+        else:
+            self.category_names = (
+                (category_names,)
+                if isinstance(category_names, str)
+                else tuple(get_type(category_name) for category_name in category_names)
+            )
+        self.service_ids = service_ids
         super().__init__("image_crop")
 
     def serve(self, dp: Image) -> None:
-        for ann in dp.get_annotation(category_names=self.category_names):
+        for ann in dp.get_annotation(category_names=self.category_names, service_ids=self.service_ids):
             dp.image_ann_to_image(ann.annotation_id, crop_image=True)
 
     def clone(self) -> ImageCroppingService:
-        return self.__class__(self.category_names)
+        return self.__class__(self.category_names, self.service_ids)
 
     def get_meta_annotation(self) -> MetaAnnotation:
         return MetaAnnotation(image_annotations=(), sub_categories={}, relationships={}, summaries=())
@@ -124,8 +131,10 @@ class IntersectionMatcher:
     def match(
         self,
         dp: Image,
-        parent_categories: Union[TypeOrStr, Sequence[TypeOrStr]],
-        child_categories: Union[TypeOrStr, Sequence[TypeOrStr]],
+        parent_categories: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
+        child_categories: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
+        parent_ann_service_ids: Optional[Union[str, Sequence[str]]] = None,
+        child_ann_service_ids: Optional[Union[str, Sequence[str]]] = None,
     ) -> list[tuple[str, str]]:
         """
         The matching algorithm
@@ -133,6 +142,10 @@ class IntersectionMatcher:
         :param dp: datapoint image
         :param parent_categories: list of categories to be used a for parent class. Will generate a child-relationship
         :param child_categories: list of categories to be used for a child class.
+        :param parent_ann_service_ids: Additional filter condition. If some ids are selected, it will ignore all other
+                                        parent candidates which are not in the list.
+        :param child_ann_service_ids: Additional filter condition. If some ids are selected, it will ignore all other
+                                        children candidates which are not in the list.
 
         :return: A list of tuples with parent and child annotation ids
         """
@@ -144,6 +157,8 @@ class IntersectionMatcher:
             threshold=self.threshold,
             use_weighted_intersections=self.use_weighted_intersections,
             max_parent_only=self.max_parent_only,
+            parent_ann_service_ids=parent_ann_service_ids,
+            child_ann_service_ids=child_ann_service_ids,
         )
 
         matched_child_anns = np.take(child_anns, child_index)  # type: ignore
@@ -174,8 +189,10 @@ class NeighbourMatcher:
     def match(
         self,
         dp: Image,
-        parent_categories: Union[TypeOrStr, Sequence[TypeOrStr]],
-        child_categories: Union[TypeOrStr, Sequence[TypeOrStr]],
+        parent_categories: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
+        child_categories: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
+        parent_ann_service_ids: Optional[Union[str, Sequence[str]]] = None,
+        child_ann_service_ids: Optional[Union[str, Sequence[str]]] = None,
     ) -> list[tuple[str, str]]:
         """
         The matching algorithm
@@ -183,16 +200,54 @@ class NeighbourMatcher:
         :param dp: datapoint image
         :param parent_categories: list of categories to be used a for parent class. Will generate a child-relationship
         :param child_categories: list of categories to be used for a child class.
+        :param parent_ann_service_ids: Additional filter condition. If some ids are selected, it will ignore all other
+                                        parent candidates which are not in the list.
+        :param child_ann_service_ids: Additional filter condition. If some ids are selected, it will ignore all other
+                                        children candidates which are not in the list.
 
         :return: A list of tuples with parent and child annotation ids
         """
 
         return [
             (pair[0].annotation_id, pair[1].annotation_id)
-            for pair in match_anns_by_distance(dp, parent_categories, child_categories)
+            for pair in match_anns_by_distance(
+                dp,
+                parent_ann_category_names=parent_categories,
+                child_ann_category_names=child_categories,
+                parent_ann_service_ids=parent_ann_service_ids,
+                child_ann_service_ids=child_ann_service_ids,
+            )
         ]
 
 
+@dataclass
+class FamilyCompound:
+    """
+    A family compound is a set of parent and child categories that are related by a relationship key. The parent
+    categories will receive a relationship to the child categories.
+    """
+
+    relationship_key: Relationships
+    parent_categories: Optional[Union[ObjectTypes, Sequence[ObjectTypes]]] = field(default=None)
+    child_categories: Optional[Union[ObjectTypes, Sequence[ObjectTypes]]] = field(default=None)
+    parent_ann_service_ids: Optional[Union[str, Sequence[str]]] = field(default=None)
+    child_ann_service_ids: Optional[Union[str, Sequence[str]]] = field(default=None)
+
+    def __post_init__(self) -> None:
+        if isinstance(self.parent_categories, str):
+            self.parent_categories = (get_type(self.parent_categories),)
+        elif self.parent_categories is not None:
+            self.parent_categories = tuple(get_type(parent) for parent in self.parent_categories)
+        if isinstance(self.child_categories, str):
+            self.child_categories = (get_type(self.child_categories),)
+        elif self.child_categories is not None:
+            self.child_categories = tuple(get_type(child) for child in self.child_categories)
+        if isinstance(self.parent_ann_service_ids, str):
+            self.parent_ann_service_ids = (self.parent_ann_service_ids,)
+        if isinstance(self.child_ann_service_ids, str):
+            self.child_ann_service_ids = (self.child_ann_service_ids,)
+
+
 @pipeline_component_registry.register("MatchingService")
 class MatchingService(PipelineComponent):
     """
@@ -202,28 +257,15 @@ class MatchingService(PipelineComponent):
 
     def __init__(
         self,
-        parent_categories: Union[TypeOrStr, Sequence[TypeOrStr]],
-        child_categories: Union[TypeOrStr, Sequence[TypeOrStr]],
+        family_compounds: Sequence[FamilyCompound],
         matcher: Union[IntersectionMatcher, NeighbourMatcher],
-        relationship_key: Relationships,
     ) -> None:
         """
-        :param parent_categories: list of categories to be used a for parent class. Will generate a child-relationship
-        :param child_categories: list of categories to be used for a child class.
-
+        :param family_compounds: A list of FamilyCompounds
+        :param matcher: A matcher object
         """
-        self.parent_categories = (
-            (get_type(parent_categories),)
-            if isinstance(parent_categories, str)
-            else tuple(get_type(category_name) for category_name in parent_categories)
-        )
-        self.child_categories = (
-            (get_type(child_categories),)
-            if isinstance(child_categories, str)
-            else (tuple(get_type(category_name) for category_name in child_categories))
-        )
+        self.family_compounds = family_compounds
         self.matcher = matcher
-        self.relationship_key = relationship_key
         super().__init__("matching")
 
     def serve(self, dp: Image) -> None:
@@ -233,20 +275,31 @@ class MatchingService(PipelineComponent):
 
         :param dp: datapoint image
         """
-
-        matched_pairs = self.matcher.match(dp, self.parent_categories, self.child_categories)
-
-        for pair in matched_pairs:
-            self.dp_manager.set_relationship_annotation(self.relationship_key, pair[0], pair[1])
+        for family_compound in self.family_compounds:
+            matched_pairs = self.matcher.match(
+                dp,
+                parent_categories=family_compound.parent_categories,
+                child_categories=family_compound.child_categories,
+                parent_ann_service_ids=family_compound.parent_ann_service_ids,
+                child_ann_service_ids=family_compound.child_ann_service_ids,
+            )
+
+            for pair in matched_pairs:
+                self.dp_manager.set_relationship_annotation(family_compound.relationship_key, pair[0], pair[1])
 
     def clone(self) -> PipelineComponent:
-        return self.__class__(self.parent_categories, self.child_categories, self.matcher, self.relationship_key)
+        return self.__class__(self.family_compounds, self.matcher)
 
     def get_meta_annotation(self) -> MetaAnnotation:
+        relationships: dict[ObjectTypes, set[ObjectTypes]] = {}
+        for family_compound in self.family_compounds:
+            if family_compound.parent_categories is not None:
+                for parent_category in family_compound.parent_categories:
+                    relationships[parent_category] = {family_compound.relationship_key}  # type: ignore
         return MetaAnnotation(
             image_annotations=(),
             sub_categories={},
-            relationships={parent: {Relationships.CHILD} for parent in self.parent_categories},
+            relationships=relationships,
             summaries=(),
         )