deepdoctection 0.32__py3-none-any.whl → 0.34__py3-none-any.whl

deepdoctection/pipe/anngen.py

@@ -19,11 +19,11 @@
 Module for datapoint populating helpers
 """
 from dataclasses import asdict
-from typing import Dict, List, Mapping, Optional, Union
+from typing import Mapping, Optional, Union
 
 import numpy as np
 
-from ..datapoint.annotation import CategoryAnnotation, ContainerAnnotation, ImageAnnotation, SummaryAnnotation
+from ..datapoint.annotation import DEFAULT_CATEGORY_ID, CategoryAnnotation, ContainerAnnotation, ImageAnnotation
 from ..datapoint.box import BoundingBox, local_to_global_coords, rescale_coords
 from ..datapoint.image import Image
 from ..extern.base import DetectionResult
@@ -44,7 +44,7 @@ class DatapointManager:
 
     def __init__(self, service_id: str, model_id: Optional[str] = None) -> None:
         self._datapoint: Optional[Image] = None
-        self._cache_anns: Dict[str, ImageAnnotation] = {}
+        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
@@ -155,7 +155,7 @@ class DatapointManager:
             ann = ImageAnnotation(
                 category_name=detect_result.class_name,
                 bounding_box=box,
-                category_id=str(detect_result.class_id),
+                category_id=detect_result.class_id,
                 score=detect_result.score,
                 service_id=self.service_id,
                 model_id=self.model_id,
@@ -174,7 +174,7 @@ class DatapointManager:
                     raise ValueError("image cannot be None")
                 ann.image.set_embedding(parent_ann.annotation_id, ann.bounding_box)
                 ann.image.set_embedding(self.datapoint.image_id, ann_global_box)
-                parent_ann.dump_relationship(Relationships.child, ann.annotation_id)
+                parent_ann.dump_relationship(Relationships.CHILD, ann.annotation_id)
 
             self.datapoint.dump(ann)
             self._cache_anns[ann.annotation_id] = ann
@@ -189,7 +189,7 @@ class DatapointManager:
     def set_category_annotation(
         self,
         category_name: ObjectTypes,
-        category_id: Optional[Union[str, int]],
+        category_id: Optional[int],
         sub_cat_key: ObjectTypes,
         annotation_id: str,
         score: Optional[float] = None,
@@ -216,7 +216,7 @@ class DatapointManager:
         ) as annotation_context:
             cat_ann = CategoryAnnotation(
                 category_name=category_name,
-                category_id=str(category_id),
+                category_id=category_id if category_id is not None else DEFAULT_CATEGORY_ID,
                 score=score,
                 service_id=self.service_id,
                 model_id=self.model_id,
@@ -230,10 +230,10 @@ class DatapointManager:
     def set_container_annotation(
         self,
         category_name: ObjectTypes,
-        category_id: Optional[Union[str, int]],
+        category_id: Optional[int],
         sub_cat_key: ObjectTypes,
         annotation_id: str,
-        value: Union[str, List[str]],
+        value: Union[str, list[str]],
         score: Optional[float] = None,
     ) -> Optional[str]:
         """
@@ -260,7 +260,7 @@ class DatapointManager:
         ) as annotation_context:
             cont_ann = ContainerAnnotation(
                 category_name=category_name,
-                category_id=str(category_id),
+                category_id=category_id if category_id is not None else DEFAULT_CATEGORY_ID,
                 value=value,
                 score=score,
                 service_id=self.service_id,
@@ -272,6 +272,33 @@ class DatapointManager:
             return None
         return cont_ann.annotation_id
 
+    def set_relationship_annotation(
+        self, relationship_name: ObjectTypes, target_annotation_id: str, annotation_id: str
+    ) -> Optional[str]:
+        """
+        Create a relationship annotation and dump it to the target annotation.
+
+        :param relationship_name: The relationship key
+        :param target_annotation_id: Annotation_id of the parent `ImageAnnotation`
+        :param annotation_id: The annotation_id to dump the relationship to
+
+        :return: Annotation_id of the parent `ImageAnnotation` for references if the dumpy has been successful
+        """
+        self.assert_datapoint_passed()
+        with MappingContextManager(
+            dp_name=self.datapoint.file_name,
+            filter_level="annotation",
+            relationship_annotation={
+                "relationship_name": relationship_name.value,
+                "target_annotation_id": target_annotation_id,
+                "annotation_id": annotation_id,
+            },
+        ) as annotation_context:
+            self._cache_anns[target_annotation_id].dump_relationship(relationship_name, annotation_id)
+        if annotation_context.context_error:
+            return None
+        return target_annotation_id
+
     def set_summary_annotation(
         self,
         summary_key: ObjectTypes,
@@ -299,8 +326,6 @@ class DatapointManager:
         else:
             image = self.datapoint
         assert image is not None, image
-        if image.summary is None:
-            image.summary = SummaryAnnotation()
 
         ann: Union[CategoryAnnotation, ContainerAnnotation]
         with MappingContextManager(
@@ -316,7 +341,7 @@ class DatapointManager:
             if summary_value is not None:
                 ann = ContainerAnnotation(
                     category_name=summary_name,
-                    category_id=str(summary_number) if summary_number is not None else "",
+                    category_id=summary_number if summary_number else DEFAULT_CATEGORY_ID,
                     value=summary_value,
                     score=summary_score,
                     service_id=self.service_id,
@@ -326,7 +351,7 @@ class DatapointManager:
             else:
                 ann = CategoryAnnotation(
                     category_name=summary_name,
-                    category_id=str(summary_number) if summary_number is not None else "",
+                    category_id=summary_number if summary_number is not None else DEFAULT_CATEGORY_ID,
                     score=summary_score,
                     service_id=self.service_id,
                     model_id=self.model_id,

deepdoctection/pipe/base.py

@@ -19,21 +19,33 @@
 """
 Module for the base class for building pipelines
 """
+from __future__ import annotations
+
 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 dataclasses import dataclass, field
+from typing import Any, Mapping, Optional, 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 ..utils.settings import ObjectTypes
 from .anngen import DatapointManager
 
 
+@dataclass(frozen=True)
+class MetaAnnotation:
+    """A immutable dataclass that stores information about what `Image` are being
+    modified through a pipeline compoenent."""
+
+    image_annotations: tuple[ObjectTypes, ...] = field(default=())
+    sub_categories: dict[ObjectTypes, set[ObjectTypes]] = field(default_factory=dict)
+    relationships: dict[ObjectTypes, set[ObjectTypes]] = field(default_factory=dict)
+    summaries: tuple[ObjectTypes, ...] = field(default=())
+
+
 class PipelineComponent(ABC):
     """
     Base class for pipeline components. Pipeline components are the parts that make up a pipeline. They contain the
@@ -54,15 +66,14 @@ class PipelineComponent(ABC):
                  planned.
     """
 
-    def __init__(self, name: str):
+    def __init__(self, name: str, model_id: Optional[str] = None) -> None:
         """
         :param name: The name of the pipeline component. The name will be used to identify a pipeline component in a
                      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.service_id)
+        self.dp_manager = DatapointManager(self.service_id, model_id)
         self.timer_on = False
 
     @abstractmethod
@@ -108,14 +119,14 @@ class PipelineComponent(ABC):
         return MapData(df, self.pass_datapoint)
 
     @abstractmethod
-    def clone(self) -> "PipelineComponent":
+    def clone(self) -> PipelineComponent:
         """
         Clone an instance
         """
         raise NotImplementedError()
 
     @abstractmethod
-    def get_meta_annotation(self) -> JsonDict:
+    def get_meta_annotation(self) -> MetaAnnotation:
         """
         Get a dict of list of annotation type. The dict must contain
 
@@ -127,96 +138,53 @@ class PipelineComponent(ABC):
         """
         raise NotImplementedError()
 
-    def _meta_has_all_types(self) -> None:
-        if not {"image_annotations", "sub_categories", "relationships", "summaries"}.issubset(
-            set(self.get_meta_annotation().keys())
-        ):
-            raise TypeError(
-                f" 'get_meta_annotation' must return dict with all required keys. "
-                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):
-    """
-    Lightweight abstract pipeline component class with `predictor`. Object detectors that only read in images as
-    numpy array and return `DetectResult`s are currently permitted.
-    """
-
-    def __init__(
-        self,
-        name: str,
-        predictor: Union[ObjectDetector, PdfMiner, TextRecognizer],
-    ) -> None:
+    def clear_predictor(self) -> None:
         """
-        :param name: Will be passed to base class
-        :param predictor: An Object detector for predicting
+        Clear the predictor of the pipeline component if it has one. Needed for model updates during training.
         """
-        self.predictor = predictor
-        super().__init__(name)
-        self.dp_manager = DatapointManager(self.service_id, self.predictor.model_id)
+        raise NotImplementedError(
+            "Maybe you forgot to implement this method in your pipeline component. This might "
+            "be the case when you run evaluation during training and need to update the "
+            "trained model in your pipeline component."
+        )
 
-    @abstractmethod
-    def clone(self) -> "PredictorPipelineComponent":
-        raise NotImplementedError()
-
-
-class LanguageModelPipelineComponent(PipelineComponent, ABC):
-    """
-    Abstract pipeline component class with two attributes `tokenizer` and `language_model` .
-    """
-
-    def __init__(
-        self,
-        name: str,
-        tokenizer: Any,
-        mapping_to_lm_input_func: Callable[..., Callable[[Image], Optional[Any]]],
-    ):
+    def has_predictor(self) -> bool:
         """
-        :param name: Will be passed to base class
-        :param tokenizer: Tokenizer, typing allows currently anything. This will be changed in the future
-        :param mapping_to_lm_input_func: Function mapping image to layout language model features
+        Check if the pipeline component has a predictor
         """
+        if hasattr(self, "predictor"):
+            if self.predictor is not None:
+                return True
+        return False
 
-        self.tokenizer = tokenizer
-        super().__init__(name)
-        self.mapping_to_lm_input_func = mapping_to_lm_input_func
-
-    @abstractmethod
-    def clone(self) -> "LanguageModelPipelineComponent":
+    def _undo(self, dp: Image) -> Image:
         """
-        Clone an instance
+        Undo the processing of the pipeline component. It will remove `ImageAnnotation`, `CategoryAnnotation` and
+        `ContainerAnnotation` with the service_id of the pipeline component.
         """
-        raise NotImplementedError()
-
-
-class ImageTransformPipelineComponent(PipelineComponent, ABC):
-    """
-    Abstract pipeline component class with one model to transform images. This component is meant to be used at the
-    beginning of a pipeline
-    """
+        if self.timer_on:
+            with timed_operation(self.__class__.__name__):
+                self.dp_manager.datapoint = dp
+                dp.remove(service_ids=self.service_id)
+        else:
+            self.dp_manager.datapoint = dp
+            dp.remove(service_ids=self.service_id)
+        return self.dp_manager.datapoint
 
-    def __init__(self, name: str, transform_predictor: ImageTransformer):
+    def undo(self, df: DataFlow) -> DataFlow:
         """
-        :param name: Will be passed to base class
-        :param transform_predictor: An `ImageTransformer` for image transformation
-        """
-
-        self.transform_predictor = transform_predictor
-        super().__init__(name)
+        Mapping a datapoint via `_undo` within a dataflow pipeline
 
-    @abstractmethod
-    def clone(self) -> "ImageTransformPipelineComponent":
-        """
-        Clone an instance
+        :param df: An input dataflow of Images
+        :return: A output dataflow of Images
         """
-        raise NotImplementedError()
+        return MapData(df, self._undo)
 
 
 class Pipeline(ABC):
@@ -262,7 +230,7 @@ class Pipeline(ABC):
            df = pipe.analyze(input = "path/to/dir") # session_id is generated automatically
     """
 
-    def __init__(self, pipeline_component_list: List[PipelineComponent]) -> None:
+    def __init__(self, pipeline_component_list: list[PipelineComponent]) -> None:
         """
         :param pipeline_component_list: A list of pipeline components.
         """
@@ -305,7 +273,7 @@ class Pipeline(ABC):
         """
         raise NotImplementedError()
 
-    def get_meta_annotation(self) -> JsonDict:
+    def get_meta_annotation(self) -> MetaAnnotation:
         """
         Collects meta annotations from all pipeline components and summarizes the returned results
 
@@ -313,23 +281,24 @@ class Pipeline(ABC):
                  names and generated sub categories), relationships (dict with category names and generated
                  relationships) as well as summaries (list with sub categories)
         """
-        pipeline_populations: Dict[str, Union[List[str], DefaultDict[str, Set[str]]]] = {
-            "image_annotations": [],
-            "sub_categories": defaultdict(set),
-            "relationships": defaultdict(set),
-            "summaries": [],
-        }
+        image_annotations: list[ObjectTypes] = []
+        sub_categories = defaultdict(set)
+        relationships = defaultdict(set)
+        summaries: list[ObjectTypes] = []
         for component in self.pipe_component_list:
-            meta_anns = deepcopy(component.get_meta_annotation())
-            pipeline_populations["image_annotations"].extend(meta_anns["image_annotations"])  # type: ignore
-            for key, value in meta_anns["sub_categories"].items():
-                pipeline_populations["sub_categories"][key].update(value)
-            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
+            meta_anns = component.get_meta_annotation()
+            image_annotations.extend(meta_anns.image_annotations)
+            for key, value in meta_anns.sub_categories.items():
+                sub_categories[key].update(value)
+            for key, value in meta_anns.relationships.items():
+                relationships[key].update(value)
+            summaries.extend(meta_anns.summaries)
+        return MetaAnnotation(
+            image_annotations=tuple(image_annotations),
+            sub_categories=dict(sub_categories),
+            relationships=dict(relationships),
+            summaries=tuple(summaries),
+        )
 
     def get_pipeline_info(
         self, service_id: Optional[str] = None, name: Optional[str] = None