deepdoctection 0.41.0__tar.gz → 0.42.0__tar.gz

{deepdoctection-0.41.0 → deepdoctection-0.42.0}/PKG-INFO

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

{deepdoctection-0.41.0 → deepdoctection-0.42.0}/deepdoctection/__init__.py

@@ -25,7 +25,7 @@ from .utils.logger import LoggingRecord, logger
 
 # pylint: enable=wrong-import-position
 
-__version__ = "0.41.0"
+__version__ = "0.42.0"
 
 _IMPORT_STRUCTURE = {
     "analyzer": ["config_sanity_checks", "get_dd_analyzer", "ServiceFactory"],
@@ -95,6 +95,7 @@ _IMPORT_STRUCTURE = {
         "Image",
         "Word",
         "Layout",
+        "List",
         "Cell",
         "Table",
         "Page",
@@ -440,7 +441,7 @@ if TYPE_CHECKING:
     from .eval import *
     from .extern import *  # type: ignore
     from .mapper import *  # type: ignore
-    from .pipe import *
+    from .pipe import *  # type: ignore
     from .train import *
     from .utils import *
 

{deepdoctection-0.41.0 → deepdoctection-0.42.0}/deepdoctection/analyzer/_config.py

@@ -40,7 +40,7 @@ cfg.TF.CELL.FILTER = None
 cfg.TF.ITEM.WEIGHTS = "item/model-1620000_inf_only.data-00000-of-00001"
 cfg.TF.ITEM.FILTER = None
 
-cfg.PT.ENFORCE_WEIGHTS = False
+cfg.PT.ENFORCE_WEIGHTS.LAYOUT = True
 cfg.PT.LAYOUT.WEIGHTS = "layout/d2_model_0829999_layout_inf_only.pt"
 cfg.PT.LAYOUT.WEIGHTS_TS = "layout/d2_model_0829999_layout_inf_only.ts"
 cfg.PT.LAYOUT.FILTER = None
@@ -49,6 +49,7 @@ cfg.PT.LAYOUT.PAD.RIGHT = 60
 cfg.PT.LAYOUT.PAD.BOTTOM = 60
 cfg.PT.LAYOUT.PAD.LEFT = 60
 
+cfg.PT.ENFORCE_WEIGHTS.ITEM = True
 cfg.PT.ITEM.WEIGHTS = "item/d2_model_1639999_item_inf_only.pt"
 cfg.PT.ITEM.WEIGHTS_TS = "item/d2_model_1639999_item_inf_only.ts"
 cfg.PT.ITEM.FILTER = None
@@ -57,6 +58,7 @@ cfg.PT.ITEM.PAD.RIGHT = 60
 cfg.PT.ITEM.PAD.BOTTOM = 60
 cfg.PT.ITEM.PAD.LEFT = 60
 
+cfg.PT.ENFORCE_WEIGHTS.CELL = True
 cfg.PT.CELL.WEIGHTS = "cell/d2_model_1849999_cell_inf_only.pt"
 cfg.PT.CELL.WEIGHTS_TS = "cell/d2_model_1849999_cell_inf_only.ts"
 cfg.PT.CELL.FILTER = None
@@ -137,6 +139,7 @@ cfg.TEXT_ORDERING.HEIGHT_TOLERANCE = 2.0
 cfg.TEXT_ORDERING.PARAGRAPH_BREAK = 0.035
 
 cfg.USE_LAYOUT_LINK = False
+cfg.USE_LINE_MATCHER = False
 cfg.LAYOUT_LINK.PARENTAL_CATEGORIES = []
 cfg.LAYOUT_LINK.CHILD_CATEGORIES = []
 

{deepdoctection-0.41.0 → deepdoctection-0.42.0}/deepdoctection/analyzer/dd.py

@@ -32,7 +32,7 @@ from ..extern.pt.ptutils import get_torch_device
 from ..extern.tp.tfutils import disable_tp_layer_logging, get_tf_device
 from ..pipe.doctectionpipe import DoctectionPipe
 from ..utils.env_info import ENV_VARS_TRUE
-from ..utils.file_utils import tensorpack_available
+from ..utils.file_utils import tensorpack_available, detectron2_available
 from ..utils.fs import get_configs_dir_path, get_package_path, maybe_copy_config_to_cache
 from ..utils.logger import LoggingRecord, logger
 from ..utils.metacfg import set_config_by_yaml
@@ -140,6 +140,12 @@ def get_dd_analyzer(
     cfg.LANGUAGE = None
     cfg.LIB = lib
     cfg.DEVICE = device
+    if not detectron2_available() or cfg.PT.LAYOUT.WEIGHTS is None:
+        cfg.PT.ENFORCE_WEIGHTS.LAYOUT=False
+    if not detectron2_available() or cfg.PT.ITEM.WEIGHTS is None:
+        cfg.PT.ENFORCE_WEIGHTS.ITEM=False
+    if not detectron2_available() or cfg.PT.CELL.WEIGHTS is None:
+        cfg.PT.ENFORCE_WEIGHTS.CELL=False
     cfg.freeze()
 
     if config_overwrite:

{deepdoctection-0.41.0 → deepdoctection-0.42.0}/deepdoctection/analyzer/factory.py

@@ -50,7 +50,6 @@ from ..pipe.sub_layout import DetectResultGenerator, SubImageLayoutService
 from ..pipe.text import TextExtractionService
 from ..pipe.transform import SimpleTransformService
 from ..utils.error import DependencyError
-from ..utils.file_utils import detectron2_available
 from ..utils.fs import get_configs_dir_path
 from ..utils.metacfg import AttrDict
 from ..utils.settings import CellType, LayoutType, Relationships
@@ -96,12 +95,13 @@ class ServiceFactory:
         """
         if config.LIB is None:
             raise DependencyError("At least one of the env variables DD_USE_TF or DD_USE_TORCH must be set.")
+
         weights = (
             getattr(config.TF, mode).WEIGHTS
             if config.LIB == "TF"
             else (
                 getattr(config.PT, mode).WEIGHTS
-                if detectron2_available() or config.PT.ENFORCE_WEIGHTS
+                if getattr(config.PT.ENFORCE_WEIGHTS,mode)
                 else getattr(config.PT, mode).WEIGHTS_TS
             )
         )
@@ -240,8 +240,6 @@ class ServiceFactory:
 
         :param config: configuration object
         """
-        if not detectron2_available() and config.LIB == "PT":
-            raise ModuleNotFoundError("LAYOUT_NMS_PAIRS is only available for detectron2")
         if not isinstance(config.LAYOUT_NMS_PAIRS.COMBINATIONS, list) and not isinstance(
             config.LAYOUT_NMS_PAIRS.COMBINATIONS[0], list
         ):
@@ -577,7 +575,14 @@ class ServiceFactory:
                 parent_categories=config.WORD_MATCHING.PARENTAL_CATEGORIES,
                 child_categories=config.TEXT_CONTAINER,
                 relationship_key=Relationships.CHILD,
-            )
+            ),
+            FamilyCompound(
+                parent_categories=[LayoutType.LIST],
+                child_categories=[LayoutType.LIST_ITEM],
+                relationship_key=Relationships.CHILD,
+                create_synthetic_parent=True,
+                synthetic_parent=LayoutType.LIST,
+            ),
         ]
         return MatchingService(
             family_compounds=family_compounds,
@@ -622,6 +627,34 @@ class ServiceFactory:
         """
         return ServiceFactory._build_layout_link_matching_service(config)
 
+    @staticmethod
+    def _build_line_matching_service(config: AttrDict) -> MatchingService:
+        matcher = IntersectionMatcher(
+            matching_rule=config.WORD_MATCHING.RULE,
+            threshold=config.WORD_MATCHING.THRESHOLD,
+            max_parent_only=config.WORD_MATCHING.MAX_PARENT_ONLY,
+        )
+        family_compounds = [
+            FamilyCompound(
+                parent_categories=[LayoutType.LIST],
+                child_categories=[LayoutType.LINE],
+                relationship_key=Relationships.CHILD,
+            ),
+        ]
+        return MatchingService(
+            family_compounds=family_compounds,
+            matcher=matcher,
+        )
+
+    @staticmethod
+    def build_line_matching_service(config: AttrDict) -> MatchingService:
+        """Building a word matching service
+
+        :param config: configuration object
+        :return: MatchingService
+        """
+        return ServiceFactory._build_line_matching_service(config)
+
     @staticmethod
     def _build_text_order_service(config: AttrDict) -> TextOrderService:
         """Building a text order service
@@ -748,6 +781,10 @@ class ServiceFactory:
             layout_link_matching_service = ServiceFactory.build_layout_link_matching_service(config)
             pipe_component_list.append(layout_link_matching_service)
 
+        if config.USE_LINE_MATCHER:
+            line_list_matching_service = ServiceFactory.build_line_matching_service(config)
+            pipe_component_list.append(line_list_matching_service)
+
         page_parsing_service = ServiceFactory.build_page_parsing_service(config)
 
         return DoctectionPipe(pipeline_component_list=pipe_component_list, page_parsing_service=page_parsing_service)

{deepdoctection-0.41.0 → deepdoctection-0.42.0}/deepdoctection/datapoint/view.py

@@ -25,7 +25,6 @@ from copy import copy
 from typing import Any, Mapping, Optional, Sequence, Type, TypedDict, Union, no_type_check
 
 import numpy as np
-from typing_extensions import LiteralString
 
 from ..utils.error import AnnotationError, ImageError
 from ..utils.logger import LoggingRecord, log_once, logger
@@ -285,6 +284,52 @@ class Cell(Layout):
         return set(CellType).union(super().get_attribute_names())
 
 
+class List(Layout):
+    """
+    List specific subclass of `ImageAnnotationBaseView` modelled by `LayoutType`.
+    """
+
+    @property
+    def words(self) -> list[ImageAnnotationBaseView]:
+        """
+        Get a list of `ImageAnnotationBaseView` objects with `LayoutType` defined by `text_container`.
+        It will only select those among all annotations that have an entry in `Relationships.child` .
+        """
+        all_words: list[ImageAnnotationBaseView] = []
+
+        for list_item in self.list_items:
+            all_words.extend(list_item.words)  # type: ignore
+        return all_words
+
+    def get_ordered_words(self) -> list[ImageAnnotationBaseView]:
+        """Returns a list of words order by reading order. Words with no reading order will not be returned"""
+        try:
+            list_items = self.list_items
+            all_words = []
+            list_items.sort(key=lambda x: x.bbox[1])
+            for list_item in list_items:
+                all_words.extend(list_item.get_ordered_words()) # type: ignore
+            return all_words
+        except (TypeError, AnnotationError):
+            return super().get_ordered_words()
+
+    @property
+    def list_items(self) -> list[ImageAnnotationBaseView]:
+        """
+        A list of a list items.
+        """
+        all_relation_ids = self.get_relationship(Relationships.CHILD)
+        list_items = self.base_page.get_annotation(
+            annotation_ids=all_relation_ids,
+            category_names=(
+                LayoutType.LIST_ITEM,
+                LayoutType.LINE,
+            ),
+        )
+        list_items.sort(key=lambda x: x.bbox[1])
+        return list_items
+
+
 class Table(Layout):
     """
     Table specific sub class of `ImageAnnotationBaseView` modelled by `TableType`.
@@ -372,7 +417,7 @@ class Table(Layout):
             category_names=[LayoutType.CELL, CellType.SPANNING], annotation_ids=all_relation_ids
         )
         row_cells = list(
-            filter(lambda c: row_number in (c.row_number, c.row_number + c.row_span), all_cells)  # type: ignore
+            filter(lambda c: c.row_number <= row_number <= c.row_number + c.row_span - 1, all_cells)  # type: ignore
         )
         row_cells.sort(key=lambda c: c.column_number)  # type: ignore
         column_header_cells = self.column_header_cells
@@ -560,6 +605,7 @@ IMAGE_ANNOTATION_TO_LAYOUTS: dict[ObjectTypes, Type[Union[Layout, Table, Word]]]
     LayoutType.TABLE_ROTATED: Table,
     LayoutType.WORD: Word,
     LayoutType.CELL: Cell,
+    LayoutType.LIST: List,
     CellType.SPANNING: Cell,
     CellType.ROW_HEADER: Cell,
     CellType.COLUMN_HEADER: Cell,
@@ -573,6 +619,7 @@ class ImageDefaults(TypedDict):
     text_container: LayoutType
     floating_text_block_categories: tuple[Union[LayoutType, CellType], ...]
     text_block_categories: tuple[Union[LayoutType, CellType], ...]
+    residual_layouts: tuple[LayoutType, ...]
 
 
 IMAGE_DEFAULTS: ImageDefaults = {
@@ -591,6 +638,7 @@ IMAGE_DEFAULTS: ImageDefaults = {
         LayoutType.FIGURE,
         CellType.SPANNING,
     ),
+    "residual_layouts": (LayoutType.LINE,),
 }
 
 
@@ -770,19 +818,8 @@ class Page(Image):
         """
         return self.get_annotation(category_names=self._get_residual_layout())
 
-    def _get_residual_layout(self) -> list[LiteralString]:
-        layouts = copy(list(self.floating_text_block_categories))
-        layouts.extend(
-            [
-                LayoutType.TABLE,
-                LayoutType.FIGURE,
-                self.text_container,
-                LayoutType.CELL,
-                LayoutType.ROW,
-                LayoutType.COLUMN,
-            ]
-        )
-        return [layout for layout in LayoutType if layout not in layouts]
+    def _get_residual_layout(self) -> tuple[LayoutType, ...]:
+        return IMAGE_DEFAULTS["residual_layouts"]
 
     @classmethod
     def from_image(

{deepdoctection-0.41.0 → deepdoctection-0.42.0}/deepdoctection/extern/doctrocr.py

@@ -424,7 +424,8 @@ class DoctrTextRecognizer(TextRecognizer):
             custom_configs.pop("task", None)
             recognition_configs["mean"] = custom_configs.pop("mean")
             recognition_configs["std"] = custom_configs.pop("std")
-            batch_size = custom_configs.pop("batch_size")
+            if "batch_size" in custom_configs:
+                batch_size = custom_configs.pop("batch_size")
         recognition_configs["batch_size"] = batch_size
 
         if isinstance(architecture, str):

{deepdoctection-0.41.0 → deepdoctection-0.42.0}/deepdoctection/mapper/d2struct.py

@@ -102,7 +102,7 @@ def image_to_d2_frcnn_training(
     return output
 
 
-def pt_nms_image_annotations(
+def pt_nms_image_annotations_depr(
     anns: Sequence[ImageAnnotation], threshold: float, image_id: Optional[str] = None, prio: str = ""
 ) -> Sequence[str]:
     """
@@ -147,6 +147,69 @@ def pt_nms_image_annotations(
     return []
 
 
+def pt_nms_image_annotations(
+    anns: Sequence[ImageAnnotation], threshold: float, image_id: Optional[str] = None, prio: str = ""
+) -> Sequence[str]:
+    """
+    Processing given image annotations through NMS. This is useful, if you want to supress some specific image
+    annotation, e.g. given by name or returned through different predictors. This is the pt version, for tf check
+    `mapper.tpstruct`
+
+    :param anns: A sequence of ImageAnnotations. All annotations will be treated as if they belong to one category
+    :param threshold: NMS threshold
+    :param image_id: id in order to get the embedding bounding box
+    :param prio: If an annotation has prio, it will overwrite its given score to 1 so that it will never be suppressed
+    :return: A list of annotation_ids that belong to the given input sequence and that survive the NMS process
+    """
+    if len(anns) == 1:
+        return [anns[0].annotation_id]
+
+    if not anns:
+        return []
+
+    # First, identify priority annotations that should always be kept
+    priority_ann_ids = []
+
+    if prio:
+        for ann in anns:
+            if ann.category_name == prio:
+                priority_ann_ids.append(ann.annotation_id)
+
+    # If all annotations are priority or none are left for NMS, return all priority IDs
+    if len(priority_ann_ids) == len(anns):
+        return priority_ann_ids
+
+    def priority_to_confidence(ann: ImageAnnotation, priority: str) -> float:
+        if ann.category_name == priority:
+            return 1.0
+        if ann.score:
+            return ann.score
+        raise ValueError("score cannot be None")
+
+    # Perform NMS only on non-priority annotations
+    ann_ids = np.array([ann.annotation_id for ann in anns], dtype="object")
+
+    # Get boxes for non-priority annotations
+    boxes = torch.tensor(
+        [ann.get_bounding_box(image_id).to_list(mode="xyxy") for ann in anns if ann.bounding_box is not None]
+    )
+
+    scores = torch.tensor([priority_to_confidence(ann, prio) for ann in anns])
+    class_mask = torch.ones(len(boxes), dtype=torch.uint8)
+
+    keep = batched_nms(boxes, scores, class_mask, threshold)
+    kept_ids = ann_ids[keep]
+
+    # Convert to list if necessary
+    if isinstance(kept_ids, str):
+        kept_ids = [kept_ids]
+    elif not isinstance(kept_ids, list):
+        kept_ids = kept_ids.tolist()
+
+    # Combine priority annotations with surviving non-priority annotations
+    return list(set(priority_ann_ids + kept_ids))
+
+
 def _get_category_attributes(
     ann: ImageAnnotation, cat_to_sub_cat: Optional[Mapping[ObjectTypes, ObjectTypes]] = None
 ) -> tuple[ObjectTypes, int, Optional[float]]:

{deepdoctection-0.41.0 → deepdoctection-0.42.0}/deepdoctection/mapper/tpstruct.py

@@ -95,11 +95,21 @@ def tf_nms_image_annotations(
     """
     if len(anns) == 1:
         return [anns[0].annotation_id]
+
     if not anns:
         return []
-    ann_ids = np.array([ann.annotation_id for ann in anns], dtype="object")
 
-    boxes = convert_to_tensor([ann.get_bounding_box(image_id).to_list(mode="xyxy") for ann in anns])
+    # First, identify priority annotations that should always be kept
+    priority_ann_ids = []
+
+    if prio:
+        for ann in anns:
+            if ann.category_name == prio:
+                priority_ann_ids.append(ann.annotation_id)
+
+    # If all annotations are priority or none are left for NMS, return all priority IDs
+    if len(priority_ann_ids) == len(anns):
+        return priority_ann_ids
 
     def priority_to_confidence(ann: ImageAnnotation, priority: str) -> float:
         if ann.category_name == priority:
@@ -108,10 +118,24 @@ def tf_nms_image_annotations(
             return ann.score
         raise ValueError("score cannot be None")
 
+    # Perform NMS only on non-priority annotations
+    ann_ids = np.array([ann.annotation_id for ann in anns], dtype="object")
+
+    # Get boxes for non-priority annotations
+    boxes = convert_to_tensor([ann.get_bounding_box(image_id).to_list(mode="xyxy") for ann in anns if ann.bounding_box
+                               is not None])
+
     scores = convert_to_tensor([priority_to_confidence(ann, prio) for ann in anns])
     class_mask = convert_to_tensor(len(boxes), dtype=uint8)
+
     keep = non_max_suppression(boxes, scores, class_mask, iou_threshold=threshold)
-    ann_ids_keep = ann_ids[keep]
-    if not isinstance(ann_ids_keep, str):
-        return ann_ids_keep.tolist()
-    return []
+    kept_ids = ann_ids[keep]
+
+    # Convert to list if necessary
+    if isinstance(kept_ids, str):
+        kept_ids = [kept_ids]
+    elif not isinstance(kept_ids, list):
+        kept_ids = kept_ids.tolist()
+
+    # Combine priority annotations with surviving non-priority annotations
+    return list(set(priority_ann_ids + kept_ids))

{deepdoctection-0.41.0 → deepdoctection-0.42.0}/deepdoctection/pipe/common.py

@@ -30,6 +30,7 @@ import numpy as np
 from ..dataflow import DataFlow, MapData
 from ..datapoint.image import Image
 from ..datapoint.view import IMAGE_DEFAULTS, Page
+from ..extern.base import DetectionResult
 from ..mapper.match import match_anns_by_distance, match_anns_by_intersection
 from ..mapper.misc import to_image
 from ..utils.settings import LayoutType, ObjectTypes, Relationships, TypeOrStr, get_type
@@ -51,9 +52,9 @@ class ImageCroppingService(PipelineComponent):
     """
 
     def __init__(
-        self,
-        category_names: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
-        service_ids: Optional[Sequence[str]] = None,
+            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
@@ -106,11 +107,11 @@ class IntersectionMatcher:
     """
 
     def __init__(
-        self,
-        matching_rule: Literal["iou", "ioa"],
-        threshold: float,
-        use_weighted_intersections: bool = False,
-        max_parent_only: bool = False,
+            self,
+            matching_rule: Literal["iou", "ioa"],
+            threshold: float,
+            use_weighted_intersections: bool = False,
+            max_parent_only: bool = False,
     ) -> None:
         """
         :param matching_rule: "iou" or "ioa"
@@ -130,12 +131,12 @@ class IntersectionMatcher:
         self.max_parent_only = max_parent_only
 
     def match(
-        self,
-        dp: Image,
-        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,
+            self,
+            dp: Image,
+            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
@@ -188,12 +189,12 @@ class NeighbourMatcher:
     """
 
     def match(
-        self,
-        dp: Image,
-        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,
+            self,
+            dp: Image,
+            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
@@ -233,6 +234,8 @@ class FamilyCompound:
     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)
+    create_synthetic_parent: bool = field(default=False)
+    synthetic_parent: Optional[ObjectTypes] = field(default=None)
 
     def __post_init__(self) -> None:
         if isinstance(self.parent_categories, str):
@@ -257,9 +260,9 @@ class MatchingService(PipelineComponent):
     """
 
     def __init__(
-        self,
-        family_compounds: Sequence[FamilyCompound],
-        matcher: Union[IntersectionMatcher, NeighbourMatcher],
+            self,
+            family_compounds: Sequence[FamilyCompound],
+            matcher: Union[IntersectionMatcher, NeighbourMatcher],
     ) -> None:
         """
         :param family_compounds: A list of FamilyCompounds
@@ -287,6 +290,28 @@ class MatchingService(PipelineComponent):
 
             for pair in matched_pairs:
                 self.dp_manager.set_relationship_annotation(family_compound.relationship_key, pair[0], pair[1])
+            if family_compound.synthetic_parent:
+                parent_anns = dp.get_annotation(category_names=family_compound.parent_categories)
+                child_anns = dp.get_annotation(category_names=family_compound.child_categories)
+                child_ann_ids = []
+                for parent in parent_anns:
+                    if family_compound.relationship_key in parent.relationships:
+                        child_ann_ids.extend(parent.get_relationship(family_compound.relationship_key))
+                detect_result_list = []
+                for child_ann in child_anns:
+                    if child_ann.annotation_id not in child_ann_ids:
+                        detect_result_list.append(DetectionResult(
+                            class_name=family_compound.synthetic_parent,
+                            box=child_ann.get_bounding_box(dp.image_id).to_list(mode="xyxy"),
+                            absolute_coords=child_ann.get_bounding_box(dp.image_id).absolute_coords,
+                            relationships={family_compound.relationship_key: child_ann.annotation_id}))
+                for detect_result in detect_result_list:
+                    annotation_id = self.dp_manager.set_image_annotation(detect_result)
+                    if annotation_id is not None and detect_result.relationships is not None:
+                        self.dp_manager.set_relationship_annotation(family_compound.relationship_key,
+                                                                    annotation_id,
+                                                                    detect_result.relationships.get(
+                                                                        family_compound.relationship_key, None))
 
     def clone(self) -> PipelineComponent:
         return self.__class__(self.family_compounds, self.matcher)
@@ -316,10 +341,10 @@ class PageParsingService(PipelineComponent):
     """
 
     def __init__(
-        self,
-        text_container: TypeOrStr,
-        floating_text_block_categories: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
-        include_residual_text_container: bool = True,
+            self,
+            text_container: TypeOrStr,
+            floating_text_block_categories: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
+            include_residual_text_container: bool = True,
     ):
         """
         :param text_container: name of an image annotation that has a CHARS sub category. These annotations will be
@@ -401,10 +426,10 @@ class AnnotationNmsService(PipelineComponent):
     """
 
     def __init__(
-        self,
-        nms_pairs: Sequence[Sequence[TypeOrStr]],
-        thresholds: Union[float, Sequence[float]],
-        priority: Optional[Sequence[Union[Optional[TypeOrStr]]]] = None,
+            self,
+            nms_pairs: Sequence[Sequence[TypeOrStr]],
+            thresholds: Union[float, Sequence[float]],
+            priority: Optional[Sequence[Union[Optional[TypeOrStr]]]] = None,
     ):
         """
         :param nms_pairs: Groups of categories, either as string or by `ObjectType`.

{deepdoctection-0.41.0 → deepdoctection-0.42.0}/deepdoctection/pipe/segment.py

@@ -441,6 +441,7 @@ def segment_table(
         matching_rule=segment_rule,
         threshold=threshold_rows,
         use_weighted_intersections=True,
+        # Rows and columns are child annotations of the table.
         parent_ann_ids=child_ann_ids,
         child_ann_ids=child_ann_ids,
     )
@@ -452,6 +453,7 @@ def segment_table(
         matching_rule=segment_rule,
         threshold=threshold_cols,
         use_weighted_intersections=True,
+        # Rows and columns are child annotations of the table.
         parent_ann_ids=child_ann_ids,
         child_ann_ids=child_ann_ids,
     )
@@ -624,6 +626,7 @@ def segment_pubtables(
         matching_rule=segment_rule,
         threshold=threshold_rows,
         use_weighted_intersections=True,
+        # Rows and columns are child annotations of the table.
         parent_ann_ids=child_ann_ids,
         child_ann_ids=child_ann_ids,
     )
@@ -635,6 +638,7 @@ def segment_pubtables(
         matching_rule=segment_rule,
         threshold=threshold_cols,
         use_weighted_intersections=True,
+        # Rows and columns are child annotations of the table.
         parent_ann_ids=child_ann_ids,
         child_ann_ids=child_ann_ids,
     )

{deepdoctection-0.41.0 → deepdoctection-0.42.0}/deepdoctection/train/hf_detr_train.py

@@ -276,7 +276,7 @@ def train_hf_detr(
 
     if path_weights != "":
         model = TableTransformerForObjectDetection.from_pretrained(
-            pretrained_model_name_or_path=path_weights, config=config
+            pretrained_model_name_or_path=path_weights, config=config, ignore_mismatched_sizes=True
         )
     else:
         model = TableTransformerForObjectDetection(config)

{deepdoctection-0.41.0 → deepdoctection-0.42.0}/deepdoctection.egg-info/PKG-INFO

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