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

deepdoctection/mapper/d2struct.py

@@ -22,17 +22,17 @@ visualising
 from __future__ import annotations
 
 import os.path
-from typing import Dict, List, Mapping, Optional, Sequence, Tuple, Union
+from typing import Mapping, Optional, Sequence, Union
 
 import numpy as np
 from lazy_imports import try_import
 
-from ..datapoint.annotation import ImageAnnotation
+from ..datapoint.annotation import DEFAULT_CATEGORY_ID, ImageAnnotation
 from ..datapoint.image import Image
 from ..extern.pt.nms import batched_nms
 from ..mapper.maputils import curry
-from ..utils.detection_types import JsonDict
-from ..utils.settings import ObjectTypes, TypeOrStr, get_type
+from ..utils.settings import DefaultType, ObjectTypes, TypeOrStr, get_type
+from ..utils.types import Detectron2Dict
 
 with try_import() as pt_import_guard:
     import torch
@@ -41,7 +41,7 @@ with try_import() as d2_import_guard:
     from detectron2.structures import BoxMode
 
 with try_import() as wb_import_guard:
-    from wandb import Classes
+    from wandb import Classes  # type: ignore
     from wandb import Image as Wbimage
 
 
@@ -49,8 +49,8 @@ with try_import() as wb_import_guard:
 def image_to_d2_frcnn_training(
     dp: Image,
     add_mask: bool = False,
-    category_names: Optional[Union[str, ObjectTypes, Sequence[Union[str, ObjectTypes]]]] = None,
-) -> Optional[JsonDict]:
+    category_names: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
+) -> Optional[Detectron2Dict]:
     """
     Maps an image to a standard dataset dict as described in
     <https://detectron2.readthedocs.io/en/latest/tutorials/datasets.html>. It further checks if the image is physically
@@ -66,7 +66,7 @@ def image_to_d2_frcnn_training(
     if not os.path.isfile(dp.location) and dp.image is None:
         return None
 
-    output: JsonDict = {"file_name": str(dp.location)}
+    output: Detectron2Dict = {"file_name": str(dp.location)}
 
     if dp.image is not None:
         output["image"] = dp.image.astype("float32")
@@ -87,10 +87,10 @@ def image_to_d2_frcnn_training(
             box = box.transform(dp.width, dp.height, absolute_coords=True)
 
         # Detectron2 does not fully support BoxMode.XYXY_REL
-        mapped_ann: Dict[str, Union[str, int, List[float]]] = {
+        mapped_ann: dict[str, Union[str, int, list[float]]] = {
             "bbox_mode": BoxMode.XYXY_ABS,
             "bbox": box.to_list(mode="xyxy"),
-            "category_id": int(ann.category_id) - 1,
+            "category_id": ann.category_id - 1,
         }
         annotations.append(mapped_ann)
 
@@ -149,23 +149,23 @@ def pt_nms_image_annotations(
 
 def _get_category_attributes(
     ann: ImageAnnotation, cat_to_sub_cat: Optional[Mapping[ObjectTypes, ObjectTypes]] = None
-) -> Tuple[str, str, Optional[float]]:
+) -> tuple[ObjectTypes, int, Optional[float]]:
     if cat_to_sub_cat:
         sub_cat_key = cat_to_sub_cat.get(get_type(ann.category_name))
         if sub_cat_key in ann.sub_categories:
             sub_cat = ann.get_sub_category(sub_cat_key)
-            return sub_cat.category_name, sub_cat.category_id, sub_cat.score
-        return "", "", 0.0
-    return ann.category_name, ann.category_id, ann.score
+            return get_type(sub_cat.category_name), sub_cat.category_id, sub_cat.score
+        return DefaultType.DEFAULT_TYPE, DEFAULT_CATEGORY_ID, 0.0
+    return get_type(ann.category_name), ann.category_id, ann.score
 
 
 @curry
 def to_wandb_image(
     dp: Image,
-    categories: Mapping[str, TypeOrStr],
-    sub_categories: Optional[Mapping[str, TypeOrStr]] = None,
+    categories: Mapping[int, TypeOrStr],
+    sub_categories: Optional[Mapping[int, TypeOrStr]] = None,
     cat_to_sub_cat: Optional[Mapping[ObjectTypes, ObjectTypes]] = None,
-) -> Tuple[str, Wbimage]:
+) -> tuple[str, Wbimage]:
     """
     Converting a deepdoctection image into a wandb image
 
@@ -185,11 +185,11 @@ def to_wandb_image(
     anns = dp.get_annotation(category_names=list(categories.values()))
 
     if sub_categories:
-        class_labels = {int(key): val for key, val in sub_categories.items()}
-        class_set = Classes([{"name": val, "id": int(key)} for key, val in sub_categories.items()])
+        class_labels = dict(sub_categories.items())
+        class_set = Classes([{"name": val, "id": key} for key, val in sub_categories.items()])
     else:
-        class_labels = {int(key): val for key, val in categories.items()}
-        class_set = Classes([{"name": val, "id": int(key)} for key, val in categories.items()])
+        class_set = Classes([{"name": val, "id": key} for key, val in categories.items()])
+        class_labels = dict(categories.items())
 
     for ann in anns:
         bounding_box = ann.get_bounding_box(dp.image_id)
@@ -200,7 +200,7 @@ def to_wandb_image(
             box = {
                 "position": {"middle": bounding_box.center, "width": bounding_box.width, "height": bounding_box.height},
                 "domain": "pixel",
-                "class_id": int(category_id),
+                "class_id": category_id,
                 "box_caption": category_name,
             }
             if score:

deepdoctection/mapper/hfstruct.py

@@ -23,7 +23,7 @@ from __future__ import annotations
 
 import os
 from dataclasses import dataclass, field
-from typing import Dict, List, Literal, Optional, Sequence, Union
+from typing import Literal, Optional, Sequence, Union
 
 import numpy as np
 from lazy_imports import try_import
@@ -31,9 +31,9 @@ from lazy_imports import try_import
 from ..datapoint.image import Image
 from ..mapper.maputils import curry
 from ..mapper.misc import get_load_image_func
-from ..utils.detection_types import JsonDict
-from ..utils.settings import ObjectTypes
+from ..utils.settings import TypeOrStr
 from ..utils.transform import PadTransform
+from ..utils.types import JsonDict
 
 with try_import() as tr_import_guard:
     from transformers import BatchFeature, DetrFeatureExtractor
@@ -43,7 +43,7 @@ with try_import() as tr_import_guard:
 def image_to_hf_detr_training(
     dp: Image,
     add_mask: bool = False,
-    category_names: Optional[Union[str, ObjectTypes, Sequence[Union[str, ObjectTypes]]]] = None,
+    category_names: Optional[Union[TypeOrStr, Sequence[Union[TypeOrStr]]]] = None,
 ) -> Optional[JsonDict]:
     """
     Maps an image to a detr input datapoint dict, that, after collating can be used for training.
@@ -76,11 +76,11 @@ def image_to_hf_detr_training(
     for ann in anns:
         box = ann.get_bounding_box(dp.image_id)
 
-        mapped_ann: Dict[str, Union[str, int, float, List[float]]] = {
+        mapped_ann: dict[str, Union[str, int, float, list[float]]] = {
             "id": "".join([c for c in ann.annotation_id if c.isdigit()])[:8],
             "image_id": "".join([c for c in dp.image_id if c.isdigit()])[:8],
             "bbox": box.to_list(mode="xywh"),
-            "category_id": int(ann.category_id) - 1,
+            "category_id": ann.category_id - 1,
             "area": box.area,
         }
         annotations.append(mapped_ann)
@@ -108,7 +108,7 @@ class DetrDataCollator:
     padder: Optional[PadTransform] = None
     return_tensors: Optional[Literal["pt"]] = field(default="pt")
 
-    def __call__(self, raw_features: List[JsonDict]) -> BatchFeature:
+    def __call__(self, raw_features: list[JsonDict]) -> BatchFeature:
         """
         Creating BatchFeature from a list of dict of raw features.
 

deepdoctection/mapper/laylmstruct.py

@@ -24,7 +24,7 @@ from __future__ import annotations
 
 import random
 from dataclasses import dataclass, field
-from typing import Any, Callable, Dict, List, Literal, NewType, Optional, Sequence, Union
+from typing import Any, Callable, Literal, NewType, Optional, Sequence, Union
 
 import numpy as np
 import numpy.typing as npt
@@ -34,9 +34,9 @@ from ..datapoint.annotation import ContainerAnnotation
 from ..datapoint.convert import box_to_point4, point4_to_box
 from ..datapoint.image import Image
 from ..datapoint.view import Page
-from ..utils.detection_types import JsonDict
 from ..utils.settings import DatasetType, LayoutType, PageType, Relationships, WordType
 from ..utils.transform import ResizeTransform, normalize_image
+from ..utils.types import JsonDict
 from .maputils import curry
 
 with try_import() as import_guard:
@@ -69,7 +69,7 @@ A DataCollator is a function that takes a list of samples from a Dataset and col
 of PyTorch/TensorFlow tensors or NumPy arrays.
 """
 
-DataCollator = NewType("DataCollator", Callable[[List[InputDataClass]], Dict[str, Any]])  # type: ignore
+DataCollator = NewType("DataCollator", Callable[[list[InputDataClass]], dict[str, Any]])  # type: ignore
 
 _CLS_BOX = [0.0, 0.0, 1000.0, 1000.0]
 _SEP_BOX = [1000.0, 1000.0, 1000.0, 1000.0]
@@ -125,9 +125,9 @@ def image_to_raw_layoutlm_features(
     all_ann_ids = []
     all_words = []
     all_boxes = []
-    all_labels: List[int] = []
+    all_labels: list[int] = []
 
-    anns = dp.get_annotation_iter(category_names=LayoutType.word)
+    anns = dp.get_annotation(category_names=LayoutType.WORD)
 
     word_id_to_segment_box = {}
     if segment_positions:
@@ -139,12 +139,12 @@ def image_to_raw_layoutlm_features(
             if not bounding_box.absolute_coords:
                 bounding_box = bounding_box.transform(dp.width, dp.height, absolute_coords=True)
             word_id_to_segment_box.update(
-                {word_ann: bounding_box for word_ann in segm_ann.get_relationship(Relationships.child)}
+                {word_ann: bounding_box for word_ann in segm_ann.get_relationship(Relationships.CHILD)}
             )
 
     for ann in anns:
         all_ann_ids.append(ann.annotation_id)
-        char_cat = ann.get_sub_category(WordType.characters)
+        char_cat = ann.get_sub_category(WordType.CHARACTERS)
         if not isinstance(char_cat, ContainerAnnotation):
             raise TypeError(f"char_cat must be of type ContainerAnnotation but is of type {type(char_cat)}")
         word = char_cat.value
@@ -158,15 +158,15 @@ def image_to_raw_layoutlm_features(
         all_boxes.append(word_id_to_segment_box.get(ann.annotation_id, box).to_list(mode="xyxy"))
 
         if (
-            WordType.token_tag in ann.sub_categories or WordType.token_class in ann.sub_categories
-        ) and dataset_type == DatasetType.token_classification:
+            WordType.TOKEN_TAG in ann.sub_categories or WordType.TOKEN_CLASS in ann.sub_categories
+        ) and dataset_type == DatasetType.TOKEN_CLASSIFICATION:
             if use_token_tag:
-                all_labels.append(int(ann.get_sub_category(WordType.token_tag).category_id) - 1)
+                all_labels.append(ann.get_sub_category(WordType.TOKEN_TAG).category_id - 1)
             else:
-                all_labels.append(int(ann.get_sub_category(WordType.token_class).category_id) - 1)
+                all_labels.append(ann.get_sub_category(WordType.TOKEN_CLASS).category_id - 1)
 
-    if dp.summary is not None and dataset_type == DatasetType.sequence_classification:
-        all_labels.append(int(dp.summary.get_sub_category(PageType.document_type).category_id) - 1)
+    if dataset_type == DatasetType.SEQUENCE_CLASSIFICATION:
+        all_labels.append(dp.summary.get_sub_category(PageType.DOCUMENT_TYPE).category_id - 1)
 
     boxes = np.asarray(all_boxes, dtype="float32")
     if boxes.ndim == 1:
@@ -234,7 +234,7 @@ def layoutlm_features_to_pt_tensors(features: LayoutLMFeatures) -> LayoutLMFeatu
 
 
 def _tokenize_with_sliding_window(
-    raw_features: List[Union[RawLayoutLMFeatures, RawLMFeatures]],
+    raw_features: list[Union[RawLayoutLMFeatures, RawLMFeatures]],
     tokenizer: PreTrainedTokenizerFast,
     sliding_window_stride: int,
     max_batch_size: int,
@@ -385,7 +385,7 @@ def _tokenize_with_sliding_window(
                 )
             )
 
-    slided_tokenized_inputs: Dict[str, Union[List[Union[str, int]], torch.Tensor]] = {}
+    slided_tokenized_inputs: dict[str, Union[list[Union[str, int]], torch.Tensor]] = {}
     if return_tensors == "pt":
         slided_tokenized_inputs["overflow_to_sample_mapping"] = torch.tensor(overflow_to_sample_mapping)
         slided_tokenized_inputs["input_ids"] = torch.tensor(all_input_ids)
@@ -402,7 +402,7 @@ def _tokenize_with_sliding_window(
 
 
 def raw_features_to_layoutlm_features(
-    raw_features: Union[RawLayoutLMFeatures, RawLMFeatures, List[Union[RawLayoutLMFeatures, RawLMFeatures]]],
+    raw_features: Union[RawLayoutLMFeatures, RawLMFeatures, list[Union[RawLayoutLMFeatures, RawLMFeatures]]],
     tokenizer: PreTrainedTokenizerFast,
     padding: Literal["max_length", "do_not_pad", "longest"] = "max_length",
     truncation: bool = True,
@@ -447,11 +447,11 @@ def raw_features_to_layoutlm_features(
         raw_features = [raw_features]
 
     _has_token_labels = (
-        raw_features[0]["dataset_type"] == DatasetType.token_classification
+        raw_features[0]["dataset_type"] == DatasetType.TOKEN_CLASSIFICATION
         and raw_features[0].get("labels") is not None
     )
     _has_sequence_labels = (
-        raw_features[0]["dataset_type"] == DatasetType.sequence_classification
+        raw_features[0]["dataset_type"] == DatasetType.SEQUENCE_CLASSIFICATION
         and raw_features[0].get("labels") is not None
     )
     _has_labels = bool(_has_token_labels or _has_sequence_labels)
@@ -620,7 +620,7 @@ class LayoutLMDataCollator:
         if self.return_overflowing_tokens:
             assert self.truncation, self.truncation
 
-    def __call__(self, raw_features: Union[RawLayoutLMFeatures, List[RawLayoutLMFeatures]]) -> LayoutLMFeatures:
+    def __call__(self, raw_features: Union[RawLayoutLMFeatures, list[RawLayoutLMFeatures]]) -> LayoutLMFeatures:
         """
         Calling the DataCollator to form model inputs for training and inference. Takes a single raw
         :param raw_features: A dictionary with the following arguments: `image_id, width, height, ann_ids, words,
@@ -741,7 +741,7 @@ def image_to_raw_lm_features(
     dp: Image,
     dataset_type: Optional[Literal["sequence_classification", "token_classification"]] = None,
     use_token_tag: bool = True,
-    text_container: Optional[LayoutType] = LayoutType.word,
+    text_container: Optional[LayoutType] = LayoutType.WORD,
     floating_text_block_categories: Optional[Sequence[LayoutType]] = None,
     include_residual_text_container: bool = False,
 ) -> Optional[RawLMFeatures]:
@@ -787,9 +787,7 @@ def image_to_raw_lm_features(
     elif text_["token_classes"]:
         raw_features["labels"] = text_["token_classes"]
     elif page.document_type is not None:
-        document_type_id = (
-            int(page.image_orig.summary.get_sub_category(PageType.document_type).category_id) - 1  # type: ignore
-        )
+        document_type_id = page.image_orig.summary.get_sub_category(PageType.DOCUMENT_TYPE).category_id - 1
         raw_features["labels"] = [document_type_id]
 
     raw_features["dataset_type"] = dataset_type
@@ -806,7 +804,7 @@ def image_to_lm_features(
     return_overflowing_tokens: bool = False,
     return_tensors: Optional[Literal["pt"]] = "pt",
     sliding_window_stride: int = 0,
-    text_container: Optional[LayoutType] = LayoutType.word,
+    text_container: Optional[LayoutType] = LayoutType.WORD,
     floating_text_block_categories: Optional[Sequence[LayoutType]] = None,
     include_residual_text_container: bool = False,
 ) -> Optional[LayoutLMFeatures]:

deepdoctection/mapper/maputils.py

@@ -24,16 +24,16 @@ import functools
 import itertools
 import traceback
 from types import TracebackType
-from typing import Any, Callable, Dict, Mapping, Optional, Sequence, Union
+from typing import Any, Callable, Mapping, Optional, Sequence, Union
 
 import numpy as np
 from tabulate import tabulate
 from termcolor import colored
 
-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
+from ..utils.types import DP, BaseExceptionType, S, T
 
 __all__ = ["MappingContextManager", "DefaultMapper", "maybe_get_fake_score", "LabelSummarizer", "curry"]
 
@@ -45,7 +45,7 @@ class MappingContextManager:
     """
 
     def __init__(
-        self, dp_name: Optional[str] = None, filter_level: str = "image", **kwargs: Dict[str, Optional[str]]
+        self, dp_name: Optional[str] = None, filter_level: str = "image", **kwargs: dict[str, Optional[str]]
     ) -> None:
         """
         :param dp_name: A name for the datapoint to be mapped
@@ -81,6 +81,7 @@ class MappingContextManager:
                 AssertionError,
                 TypeError,
                 FileNotFoundError,
+                AttributeError,
                 BoundingBoxError,
                 AnnotationError,
                 ImageError,
@@ -192,7 +193,7 @@ class LabelSummarizer:
 
     """
 
-    def __init__(self, categories: Mapping[str, ObjectTypes]) -> None:
+    def __init__(self, categories: Mapping[int, ObjectTypes]) -> None:
         """
         :param categories: A dict of categories as given as in categories.get_categories().
         """
@@ -210,11 +211,11 @@ class LabelSummarizer:
         np_item = np.asarray(item, dtype="int8")
         self.summary += np.histogram(np_item, bins=self.hist_bins)[0]
 
-    def get_summary(self) -> Dict[str, np.int32]:
+    def get_summary(self) -> dict[int, int]:
         """
         Get a dictionary with category ids and the number dumped
         """
-        return dict(list(zip(self.categories.keys(), self.summary.astype(np.int32))))
+        return dict(list(zip(self.categories.keys(), self.summary.tolist())))
 
     def print_summary_histogram(self, dd_logic: bool = True) -> None:
         """
@@ -223,11 +224,9 @@ class LabelSummarizer:
         :param dd_logic: Follow dd category convention when printing histogram (last background bucket omitted).
         """
         if dd_logic:
-            data = list(itertools.chain(*[[self.categories[str(i)].value, v] for i, v in enumerate(self.summary, 1)]))
+            data = list(itertools.chain(*[[self.categories[i].value, v] for i, v in enumerate(self.summary, 1)]))
         else:
-            data = list(
-                itertools.chain(*[[self.categories[str(i + 1)].value, v] for i, v in enumerate(self.summary[:-1])])
-            )
+            data = list(itertools.chain(*[[self.categories[i + 1].value, v] for i, v in enumerate(self.summary[:-1])]))
         num_columns = min(6, len(data))
         total_img_anns = sum(data[1::2])
         data.extend([None] * ((num_columns - len(data) % num_columns) % num_columns))

deepdoctection/mapper/match.py

@@ -19,10 +19,11 @@
 Module for matching detections according to various matching rules
 """
 
-from typing import Any, Literal, Optional, Sequence, Tuple, Union
+from typing import Any, Literal, Optional, Sequence, Union
 
 import numpy as np
 from numpy.typing import NDArray
+from scipy.spatial import distance
 
 from ..datapoint.annotation import ImageAnnotation
 from ..datapoint.box import iou
@@ -41,7 +42,7 @@ def match_anns_by_intersection(
     parent_ann_ids: Optional[Union[Sequence[str], str]] = None,
     child_ann_ids: Optional[Union[str, Sequence[str]]] = None,
     max_parent_only: bool = False,
-) -> Tuple[Any, Any, Sequence[ImageAnnotation], Sequence[ImageAnnotation]]:
+) -> tuple[Any, Any, Sequence[ImageAnnotation], Sequence[ImageAnnotation]]:
     """
     Generates an iou/ioa-matrix for parent_ann_categories and child_ann_categories and returns pairs of child/parent
     indices that are above some intersection threshold. It will also return a list of all pre selected parent and child
@@ -164,3 +165,33 @@ def match_anns_by_intersection(
         return [], [], [], []
 
     return child_index, parent_index, child_anns, parent_anns
+
+
+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_ids: Optional[Union[Sequence[str], str]] = None,
+    child_ann_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
+    parent and child bounding boxes. It will return the closest child for each parent. Note, that a child can be
+    assigned multiple times to different parents.
+
+    :param dp: image datapoint
+    :param parent_ann_category_names: single str or list of category names
+    :param child_ann_category_names: single str or list of category names
+    :param parent_ann_ids: Additional filter condition. If some ids are selected, it will ignore all other parent candi-
+                           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.
+    :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)
+    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]
+    child_indices = distance.cdist(parent_centers, child_centers).argmin(axis=1)
+    return [(parent_anns[i], child_anns[j]) for i, j in enumerate(child_indices)]

deepdoctection/mapper/misc.py

@@ -23,14 +23,14 @@ from __future__ import annotations
 
 import ast
 import os
-from typing import List, Mapping, Optional, Sequence, Union
+from typing import Mapping, Optional, Sequence, Union
 
 from lazy_imports import try_import
 
 from ..datapoint.convert import convert_pdf_bytes_to_np_array_v2
 from ..datapoint.image import Image
-from ..utils.detection_types import JsonDict
 from ..utils.fs import get_load_image_func, load_image_from_file
+from ..utils.types import JsonDict
 from ..utils.utils import is_file_extension
 from .maputils import MappingContextManager, curry
 
@@ -135,7 +135,7 @@ def maybe_remove_image_from_category(dp: Image, category_names: Optional[Union[s
     return dp
 
 
-def image_ann_to_image(dp: Image, category_names: Union[str, List[str]], crop_image: bool = True) -> Image:
+def image_ann_to_image(dp: Image, category_names: Union[str, list[str]], crop_image: bool = True) -> Image:
     """
     Adds `image` to annotations with given category names
 
@@ -145,7 +145,7 @@ def image_ann_to_image(dp: Image, category_names: Union[str, List[str]], crop_im
     :return: Image
     """
 
-    img_anns = dp.get_annotation_iter(category_names=category_names)
+    img_anns = dp.get_annotation(category_names=category_names)
     for ann in img_anns:
         dp.image_ann_to_image(annotation_id=ann.annotation_id, crop_image=crop_image)
 
@@ -154,7 +154,7 @@ def image_ann_to_image(dp: Image, category_names: Union[str, List[str]], crop_im
 
 @curry
 def maybe_ann_to_sub_image(
-    dp: Image, category_names_sub_image: Union[str, List[str]], category_names: Union[str, List[str]], add_summary: bool
+    dp: Image, category_names_sub_image: Union[str, list[str]], category_names: Union[str, list[str]], add_summary: bool
 ) -> Image:
     """
     Assigns to sub image with given category names all annotations with given category names whose bounding box lie
@@ -196,7 +196,6 @@ def xml_to_dict(dp: JsonDict, xslt_obj: etree.XSLT) -> JsonDict:
     """
 
     output = str(xslt_obj(dp["xml"]))
-    output = ast.literal_eval(output.replace('<?xml version="1.0"?>', ""))
     dp.pop("xml")
-    dp["json"] = output
+    dp["json"] = ast.literal_eval(output.replace('<?xml version="1.0"?>', ""))
     return dp

deepdoctection/mapper/pascalstruct.py

@@ -20,25 +20,25 @@ Module for mapping annotations in iiitar13k style structure
 """
 
 import os
-from typing import Dict, Optional
+from typing import Optional
 
 from ..datapoint.annotation import ImageAnnotation
 from ..datapoint.box import BoundingBox
 from ..datapoint.image import Image
-from ..utils.detection_types import JsonDict
 from ..utils.fs import load_image_from_file
 from ..utils.settings import get_type
+from ..utils.types import JsonDict
 from .maputils import MappingContextManager, curry, maybe_get_fake_score
 
 
 @curry
 def pascal_voc_dict_to_image(
     dp: JsonDict,
-    categories_name_as_key: Dict[str, str],
+    categories_name_as_key: dict[str, int],
     load_image: bool,
     filter_empty_image: bool,
     fake_score: bool,
-    category_name_mapping: Optional[Dict[str, str]] = None,
+    category_name_mapping: Optional[dict[str, str]] = None,
 ) -> Optional[Image]:
     """
     Map a dataset in a structure equivalent to iiitar13k annotation style to image format

deepdoctection/mapper/prodigystruct.py

@@ -23,8 +23,8 @@ import os
 from typing import Mapping, Optional, Sequence
 
 from ..datapoint import BoundingBox, Image, ImageAnnotation
-from ..utils.detection_types import JsonDict, Pathlike
-from ..utils.settings import ObjectTypes
+from ..utils.settings import ObjectTypes, get_type
+from ..utils.types import JsonDict, PathLikeOrStr
 from .maputils import MappingContextManager, curry, maybe_get_fake_score
 
 _PRODIGY_IMAGE_PREFIX = "data:image/png;base64,"
@@ -33,10 +33,10 @@ _PRODIGY_IMAGE_PREFIX = "data:image/png;base64,"
 @curry
 def prodigy_to_image(
     dp: JsonDict,
-    categories_name_as_key: Mapping[str, str],
+    categories_name_as_key: Mapping[ObjectTypes, int],
     load_image: bool,
     fake_score: bool,
-    path_reference_ds: Optional[Pathlike] = None,
+    path_reference_ds: Optional[PathLikeOrStr] = None,
     accept_only_answer: bool = False,
     category_name_mapping: Optional[Mapping[str, str]] = None,
 ) -> Optional[Image]:
@@ -133,7 +133,7 @@ def prodigy_to_image(
             annotation = ImageAnnotation(
                 category_name=label,
                 bounding_box=bbox,
-                category_id=categories_name_as_key[label],
+                category_id=categories_name_as_key[get_type(label)],
                 score=score,
                 external_id=external_id,
             )
@@ -163,7 +163,7 @@ def image_to_prodigy(dp: Image, category_names: Optional[Sequence[ObjectTypes]]
     output["image_id"] = dp.image_id
 
     spans = []
-    for ann in dp.get_annotation_iter(category_names=category_names):
+    for ann in dp.get_annotation(category_names=category_names):
         bounding_box = ann.get_bounding_box(dp.image_id)
         if not bounding_box.absolute_coords:
             bounding_box = bounding_box.transform(dp.width, dp.height, absolute_coords=True)