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

deepdoctection/mapper/match.py

@@ -19,7 +19,7 @@
 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
@@ -41,7 +41,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

deepdoctection/mapper/misc.py

@@ -19,19 +19,22 @@
 Module for small mapping functions
 """
 
+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.file_utils import lxml_available
 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
 
-if lxml_available():
+with try_import() as import_guard:
     from lxml import etree  # pylint: disable=W0611
 
 
@@ -132,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
 
@@ -151,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
@@ -175,7 +178,7 @@ def maybe_ann_to_sub_image(
 
 
 @curry
-def xml_to_dict(dp: JsonDict, xslt_obj: "etree.XSLT") -> JsonDict:
+def xml_to_dict(dp: JsonDict, xslt_obj: etree.XSLT) -> JsonDict:
     """
     Convert a xml object into a dict using a xsl style sheet.
 
@@ -193,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,
             )

deepdoctection/mapper/pubstruct.py

@@ -20,17 +20,16 @@ Module for mapping annotations in pubtabnet style structure
 """
 import itertools
 import os
-from typing import Dict, Iterable, List, Optional, Sequence, Tuple
+from typing import Iterable, Optional, Sequence
 
 import numpy as np
 
 from ..datapoint import BoundingBox, CategoryAnnotation, ContainerAnnotation, ImageAnnotation
-from ..datapoint.annotation import SummaryAnnotation
 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 load_bytes_from_pdf_file, load_image_from_file
-from ..utils.settings import CellType, LayoutType, Relationships, TableType, WordType
+from ..utils.settings import CellType, LayoutType, ObjectTypes, Relationships, SummaryType, TableType, WordType
+from ..utils.types import JsonDict, PubtabnetDict
 from ..utils.utils import is_file_extension
 from .maputils import MappingContextManager, curry, maybe_get_fake_score
 
@@ -52,14 +51,14 @@ def _convert_boxes(dp: JsonDict, height: int) -> JsonDict:
     return dp
 
 
-def _get_table_annotation(dp: JsonDict, category_id: str) -> ImageAnnotation:
+def _get_table_annotation(dp: JsonDict, category_id: int) -> ImageAnnotation:
     ulx, uly, lrx, lry = list(map(float, dp["bbox"]))
     bbox = BoundingBox(absolute_coords=True, ulx=ulx, uly=uly, lrx=lrx, lry=lry)
-    annotation = ImageAnnotation(category_name=LayoutType.table, bounding_box=bbox, category_id=category_id)
+    annotation = ImageAnnotation(category_name=LayoutType.TABLE, bounding_box=bbox, category_id=category_id)
     return annotation
 
 
-def _cell_token(html: Sequence[str]) -> List[List[int]]:
+def _cell_token(html: Sequence[str]) -> list[list[int]]:
     index_rows = [i for i, tag in enumerate(html) if tag == "<tr>"]
     index_cells = [i for i, tag in enumerate(html) if tag in ("<td>", ">")]
     index_rows_tmp = [(index_rows[i], index_rows[i + 1]) for i in range(len(index_rows) - 1)]
@@ -72,7 +71,7 @@ def _cell_token(html: Sequence[str]) -> List[List[int]]:
     return index_cells_tmp
 
 
-def _item_spans(html: Sequence[str], index_cells: Sequence[Sequence[int]], item: str) -> List[List[int]]:
+def _item_spans(html: Sequence[str], index_cells: Sequence[Sequence[int]], item: str) -> list[list[int]]:
     item_spans = [
         [
             (
@@ -102,7 +101,7 @@ def _end_of_header(html: Sequence[str]) -> int:
     return 0
 
 
-def tile_table(row_spans: Sequence[Sequence[int]], col_spans: Sequence[Sequence[int]]) -> List[List[int]]:
+def tile_table(row_spans: Sequence[Sequence[int]], col_spans: Sequence[Sequence[int]]) -> list[list[int]]:
     """
     Tiles a table according the row and column span scheme. A table can be represented as a list of list, where each
     inner list has the same length. Each cell with a cell id can be located according to their row and column spans in
@@ -153,28 +152,25 @@ def tile_table(row_spans: Sequence[Sequence[int]], col_spans: Sequence[Sequence[
     return tiling
 
 
-def _add_items(image: Image, item_type: str, categories_name_as_key: Dict[str, str], pubtables_like: bool) -> Image:
-    item_number = CellType.row_number if item_type == LayoutType.row else CellType.column_number
-    item_span = CellType.row_span if item_type == LayoutType.row else CellType.column_span
+def _add_items(
+    image: Image, item_type: str, categories_name_as_key: dict[ObjectTypes, int], pubtables_like: bool
+) -> Image:
+    item_number = CellType.ROW_NUMBER if item_type == LayoutType.ROW else CellType.COLUMN_NUMBER
+    item_span = CellType.ROW_SPAN if item_type == LayoutType.ROW else CellType.COLUMN_SPAN
 
-    summary_key = TableType.number_of_rows if item_type == LayoutType.row else TableType.number_of_columns
+    summary_key = TableType.NUMBER_OF_ROWS if item_type == LayoutType.ROW else TableType.NUMBER_OF_COLUMNS
 
-    number_of_items = 0
+    category_item = image.summary.get_sub_category(summary_key)
+    number_of_items = category_item.category_id
 
-    if image.summary is not None:
-        category_item = image.summary.get_sub_category(summary_key)
-        number_of_items = int(category_item.category_id)
-
-    cells = image.get_annotation(category_names=LayoutType.cell)
+    cells = image.get_annotation(category_names=LayoutType.CELL)
     table: ImageAnnotation
 
     for item_num in range(1, number_of_items + 1):
         cell_item = list(
-            filter(
-                lambda x: x.get_sub_category(item_number).category_id == str(item_num), cells  # pylint: disable=W0640
-            )
+            filter(lambda x: x.get_sub_category(item_number).category_id == item_num, cells)  # pylint: disable=W0640
         )
-        cell_item = list(filter(lambda x: x.get_sub_category(item_span).category_id == "1", cell_item))
+        cell_item = list(filter(lambda x: x.get_sub_category(item_span).category_id == 1, cell_item))
         if cell_item:
             ulx = min(cell.bounding_box.ulx for cell in cell_item if isinstance(cell.bounding_box, BoundingBox))
 
@@ -185,12 +181,12 @@ def _add_items(image: Image, item_type: str, categories_name_as_key: Dict[str, s
             lry = max(cell.bounding_box.lry for cell in cell_item if isinstance(cell.bounding_box, BoundingBox))
 
             if pubtables_like:
-                tables = image.get_annotation(category_names=LayoutType.table)
+                tables = image.get_annotation(category_names=LayoutType.TABLE)
                 if not tables:
                     raise ValueError("pubtables_like = True requires table")
                 table = tables[0]
 
-                if item_type == LayoutType.row:
+                if item_type == LayoutType.ROW:
                     if table.bounding_box:
                         ulx = table.bounding_box.ulx + 1.0
                         lrx = table.bounding_box.lrx - 1.0
@@ -200,22 +196,22 @@ def _add_items(image: Image, item_type: str, categories_name_as_key: Dict[str, s
                         lry = table.bounding_box.lry - 1.0
 
             item_ann = ImageAnnotation(
-                category_id=categories_name_as_key[TableType.item],
-                category_name=TableType.item,
+                category_id=categories_name_as_key[TableType.ITEM],
+                category_name=TableType.ITEM,
                 bounding_box=BoundingBox(absolute_coords=True, ulx=ulx, uly=uly, lrx=lrx, lry=lry),
             )
             item_sub_ann = CategoryAnnotation(category_name=item_type)
-            item_ann.dump_sub_category(TableType.item, item_sub_ann, image.image_id)
+            item_ann.dump_sub_category(TableType.ITEM, item_sub_ann, image.image_id)
             image.dump(item_ann)
 
     if pubtables_like:  # pubtables_like:
-        items = image.get_annotation(category_names=TableType.item)
-        item_type_anns = [ann for ann in items if ann.get_sub_category(TableType.item).category_name == item_type]
+        items = image.get_annotation(category_names=TableType.ITEM)
+        item_type_anns = [ann for ann in items if ann.get_sub_category(TableType.ITEM).category_name == item_type]
         item_type_anns.sort(
-            key=lambda x: (x.bounding_box.cx if item_type == LayoutType.column else x.bounding_box.cy)  # type: ignore
+            key=lambda x: (x.bounding_box.cx if item_type == LayoutType.COLUMN else x.bounding_box.cy)  # type: ignore
         )
         if table.bounding_box:
-            tmp_item_xy = table.bounding_box.uly + 1.0 if item_type == LayoutType.row else table.bounding_box.ulx + 1.0
+            tmp_item_xy = table.bounding_box.uly + 1.0 if item_type == LayoutType.ROW else table.bounding_box.ulx + 1.0
         for idx, item in enumerate(item_type_anns):
             with MappingContextManager(
                 dp_name=image.file_name,
@@ -230,22 +226,22 @@ def _add_items(image: Image, item_type: str, categories_name_as_key: Dict[str, s
                         if next_box:
                             tmp_next_item_xy = (
                                 (box.lry + next_box.uly) / 2
-                                if item_type == LayoutType.row
+                                if item_type == LayoutType.ROW
                                 else (box.lrx + next_box.ulx) / 2
                             )
                     else:
                         if table.bounding_box:
                             tmp_next_item_xy = (
                                 table.bounding_box.lry - 1.0
-                                if item_type == LayoutType.row
+                                if item_type == LayoutType.ROW
                                 else table.bounding_box.lrx - 1.0
                             )
 
                     new_embedding_box = BoundingBox(
-                        ulx=box.ulx if item_type == LayoutType.row else tmp_item_xy,
-                        uly=tmp_item_xy if item_type == LayoutType.row else box.uly,
-                        lrx=box.lrx if item_type == LayoutType.row else tmp_next_item_xy,
-                        lry=tmp_next_item_xy if item_type == LayoutType.row else box.lry,
+                        ulx=box.ulx if item_type == LayoutType.ROW else tmp_item_xy,
+                        uly=tmp_item_xy if item_type == LayoutType.ROW else box.uly,
+                        lrx=box.lrx if item_type == LayoutType.ROW else tmp_next_item_xy,
+                        lry=tmp_next_item_xy if item_type == LayoutType.ROW else box.lry,
                         absolute_coords=True,
                     )
                     item.bounding_box = new_embedding_box
@@ -255,7 +251,7 @@ def _add_items(image: Image, item_type: str, categories_name_as_key: Dict[str, s
     return image
 
 
-def row_col_cell_ids(tiling: List[List[int]]) -> List[Tuple[int, int, int]]:
+def row_col_cell_ids(tiling: list[list[int]]) -> list[tuple[int, int, int]]:
     """
     Infers absolute rows and columns for every cell from the tiling of a table.
 
@@ -271,7 +267,7 @@ def row_col_cell_ids(tiling: List[List[int]]) -> List[Tuple[int, int, int]]:
     return rows_col_cell_ids
 
 
-def embedding_in_image(dp: Image, html: List[str], categories_name_as_key: Dict[str, str]) -> Image:
+def embedding_in_image(dp: Image, html: list[str], categories_name_as_key: dict[ObjectTypes, int]) -> Image:
     """
     Generating an image, that resembles the output of an analyzer. The layout of the image is table spanning
     the full page, i.e. there is one table image annotation. Moreover, the table annotation has an image, with cells
@@ -286,8 +282,8 @@ def embedding_in_image(dp: Image, html: List[str], categories_name_as_key: Dict[
     image.image = dp.image
     image.set_width_height(dp.width, dp.height)
     table_ann = ImageAnnotation(
-        category_name=LayoutType.table,
-        category_id=categories_name_as_key[LayoutType.table],
+        category_name=LayoutType.TABLE,
+        category_id=categories_name_as_key[LayoutType.TABLE],
         bounding_box=BoundingBox(absolute_coords=True, ulx=0.0, uly=0.0, lrx=dp.width, lry=dp.height),
     )
     image.dump(table_ann)
@@ -297,20 +293,20 @@ def embedding_in_image(dp: Image, html: List[str], categories_name_as_key: Dict[
     # node.
     html.insert(0, "<table>")
     html.append("</table>")
-    if CellType.header not in categories_name_as_key:
+    if CellType.HEADER not in categories_name_as_key:
         html.remove("<thead>")
         html.remove("</thead>")
         if "<tbody>" in html and "</tbody>" in html:
             html.remove("<tbody>")
             html.remove("</tbody>")
 
-    html_ann = ContainerAnnotation(category_name=TableType.html, value=html)
-    table_ann.dump_sub_category(TableType.html, html_ann)
+    html_ann = ContainerAnnotation(category_name=TableType.HTML, value=html)
+    table_ann.dump_sub_category(TableType.HTML, html_ann)
     for ann in dp.get_annotation():
         image.dump(ann)
         assert table_ann.image
         table_ann.image.dump(ann)
-        table_ann.dump_relationship(Relationships.child, ann.annotation_id)
+        table_ann.dump_relationship(Relationships.CHILD, ann.annotation_id)
 
     return image
 
@@ -329,8 +325,8 @@ def nth_index(iterable: Iterable[str], value: str, n: int) -> Optional[int]:
 
 
 def pub_to_image_uncur(  # pylint: disable=R0914
-    dp: JsonDict,
-    categories_name_as_key: Dict[str, str],
+    dp: PubtabnetDict,
+    categories_name_as_key: dict[ObjectTypes, int],
     load_image: bool,
     fake_score: bool,
     rows_and_cols: bool,
@@ -342,7 +338,7 @@ def pub_to_image_uncur(  # pylint: disable=R0914
     Map a datapoint of annotation structure as given in the Pubtabnet dataset to an Image structure.
     <https://github.com/ibm-aur-nlp/PubTabNet>
 
-    :param dp: A datapoint in serialized coco format.
+    :param dp: A datapoint in serialized Pubtabnet format.
     :param categories_name_as_key: A dict of categories, e.g. DatasetCategories.get_categories(name_as_key=True)
     :param load_image: If `True` it will load image to `Image.image`
     :param fake_score: If dp does not contain a score, a fake score with uniform random variables in (0,1)
@@ -407,60 +403,56 @@ def pub_to_image_uncur(  # pylint: disable=R0914
 
         table_ann: Optional[ImageAnnotation] = None
         if is_fintabnet:  # cannot use for synthetic table ann creation
-            table_ann = _get_table_annotation(dp, categories_name_as_key[LayoutType.table])
+            table_ann = _get_table_annotation(dp, categories_name_as_key[LayoutType.TABLE])
             image.dump(table_ann)
 
-        for idx, value in enumerate(
+        for idx, (row_col_cell_id, cell, row_span, col_span) in enumerate(
             zip(rows_cols_cell_ids[::-1], dp["html"]["cells"][::-1], row_spans[::-1], col_spans[::-1])
         ):
-            row_col_cell_id = value[0]
             row_number, col_number, cell_id = row_col_cell_id[0], row_col_cell_id[1], row_col_cell_id[2]
-            cell = value[1]
-            row_span = value[2]
-            col_span = value[3]
 
             if "bbox" in cell:  # empty cells have no box
                 ulx, uly, lrx, lry = list(map(float, cell["bbox"]))
                 cell_bounding_box = BoundingBox(absolute_coords=True, ulx=ulx, uly=uly, lrx=lrx, lry=lry)
                 cell_ann = ImageAnnotation(
-                    category_name=LayoutType.cell,
+                    category_name=LayoutType.CELL,
                     bounding_box=cell_bounding_box,
-                    category_id=categories_name_as_key[LayoutType.cell],
+                    category_id=categories_name_as_key[LayoutType.CELL],
                     score=maybe_get_fake_score(fake_score),
                 )
                 cell_ann.dump_sub_category(
-                    CellType.row_number,
-                    CategoryAnnotation(category_name=CellType.row_number, category_id=str(row_number)),
+                    CellType.ROW_NUMBER,
+                    CategoryAnnotation(category_name=CellType.ROW_NUMBER, category_id=row_number),
                     image.image_id,
                 )
                 cell_ann.dump_sub_category(
-                    CellType.column_number,
-                    CategoryAnnotation(category_name=CellType.column_number, category_id=str(col_number)),
+                    CellType.COLUMN_NUMBER,
+                    CategoryAnnotation(category_name=CellType.COLUMN_NUMBER, category_id=col_number),
                     image.image_id,
                 )
                 cell_ann.dump_sub_category(
-                    CellType.row_span,
-                    CategoryAnnotation(category_name=CellType.row_span, category_id=str(row_span)),
+                    CellType.ROW_SPAN,
+                    CategoryAnnotation(category_name=CellType.ROW_SPAN, category_id=row_span),  # type: ignore
                     image.image_id,
                 )
                 cell_ann.dump_sub_category(
-                    CellType.column_span,
-                    CategoryAnnotation(category_name=CellType.column_span, category_id=str(col_span)),
+                    CellType.COLUMN_SPAN,
+                    CategoryAnnotation(category_name=CellType.COLUMN_SPAN, category_id=col_span),  # type: ignore
                     image.image_id,
                 )
                 if (
-                    int(cell_ann.get_sub_category(CellType.row_span).category_id) > 1
-                    or int(cell_ann.get_sub_category(CellType.column_span).category_id) > 1
+                    cell_ann.get_sub_category(CellType.ROW_SPAN).category_id > 1
+                    or cell_ann.get_sub_category(CellType.COLUMN_SPAN).category_id > 1
                 ):
                     cell_ann.dump_sub_category(
-                        CellType.spanning,
-                        CategoryAnnotation(category_name=CellType.spanning),
+                        CellType.SPANNING,
+                        CategoryAnnotation(category_name=CellType.SPANNING),
                         image.image_id,
                     )
                 else:
                     cell_ann.dump_sub_category(
-                        CellType.spanning,
-                        CategoryAnnotation(category_name=LayoutType.cell),
+                        CellType.SPANNING,
+                        CategoryAnnotation(category_name=LayoutType.CELL),
                         image.image_id,
                     )
 
@@ -468,13 +460,13 @@ def pub_to_image_uncur(  # pylint: disable=R0914
                 max_cs = max(max_cs, col_span)  # type: ignore
 
                 if _has_header:
-                    category_name = CellType.header if cell_id <= end_of_header else CellType.body
+                    category_name = CellType.HEADER if cell_id <= end_of_header else CellType.BODY
                     cell_ann.dump_sub_category(
-                        CellType.header, CategoryAnnotation(category_name=category_name), image.image_id
+                        CellType.HEADER, CategoryAnnotation(category_name=category_name), image.image_id
                     )
                 image.dump(cell_ann)
                 if table_ann is not None:
-                    table_ann.dump_relationship(Relationships.child, cell_ann.annotation_id)
+                    table_ann.dump_relationship(Relationships.CHILD, cell_ann.annotation_id)
 
                 if dd_pipe_like:
                     tokens = cell["tokens"]
@@ -484,47 +476,47 @@ def pub_to_image_uncur(  # pylint: disable=R0914
                     text = "".join(tokens)
                     # we are not separating each word but view the full table content as one word
                     word = ImageAnnotation(
-                        category_name=LayoutType.word,
-                        category_id=categories_name_as_key[LayoutType.word],
+                        category_name=LayoutType.WORD,
+                        category_id=categories_name_as_key[LayoutType.WORD],
                         bounding_box=cell_bounding_box,
                     )
-                    text_container = ContainerAnnotation(category_name=WordType.characters, value=text)
-                    word.dump_sub_category(WordType.characters, text_container)
-                    reading_order = CategoryAnnotation(category_name=Relationships.reading_order, category_id="1")
-                    word.dump_sub_category(Relationships.reading_order, reading_order)
+                    text_container = ContainerAnnotation(category_name=WordType.CHARACTERS, value=text)
+                    word.dump_sub_category(WordType.CHARACTERS, text_container)
+                    reading_order = CategoryAnnotation(category_name=Relationships.READING_ORDER, category_id=1)
+                    word.dump_sub_category(Relationships.READING_ORDER, reading_order)
                     image.dump(word)
-                    cell_ann.dump_relationship(Relationships.child, word.annotation_id)
+                    cell_ann.dump_relationship(Relationships.CHILD, word.annotation_id)
 
                     index = nth_index(html, "<td>", number_of_cells - idx)
                     if index:
                         html.insert(index + 1, cell_ann.annotation_id)
 
-        summary_ann = SummaryAnnotation(external_id=image.image_id + "SUMMARY")
+        summary_ann = CategoryAnnotation(category_name=SummaryType.SUMMARY)
         summary_ann.dump_sub_category(
-            TableType.number_of_rows,
-            CategoryAnnotation(category_name=TableType.number_of_rows, category_id=str(number_of_rows)),
+            TableType.NUMBER_OF_ROWS,
+            CategoryAnnotation(category_name=TableType.NUMBER_OF_ROWS, category_id=number_of_rows),
             image.image_id,
         )
         summary_ann.dump_sub_category(
-            TableType.number_of_columns,
-            CategoryAnnotation(category_name=TableType.number_of_columns, category_id=str(number_of_cols)),
+            TableType.NUMBER_OF_COLUMNS,
+            CategoryAnnotation(category_name=TableType.NUMBER_OF_COLUMNS, category_id=number_of_cols),
             image.image_id,
         )
         summary_ann.dump_sub_category(
-            TableType.max_row_span,
-            CategoryAnnotation(category_name=TableType.max_row_span, category_id=str(max_rs)),
+            TableType.MAX_ROW_SPAN,
+            CategoryAnnotation(category_name=TableType.MAX_ROW_SPAN, category_id=max_rs),
             image.image_id,
         )
         summary_ann.dump_sub_category(
-            TableType.max_col_span,
-            CategoryAnnotation(category_name=TableType.max_col_span, category_id=str(max_cs)),
+            TableType.MAX_COL_SPAN,
+            CategoryAnnotation(category_name=TableType.MAX_COL_SPAN, category_id=max_cs),
             image.image_id,
         )
         image.summary = summary_ann
 
         if rows_and_cols or dd_pipe_like:
-            image = _add_items(image, LayoutType.row, categories_name_as_key, pubtables_like)
-            image = _add_items(image, LayoutType.column, categories_name_as_key, pubtables_like)
+            image = _add_items(image, LayoutType.ROW, categories_name_as_key, pubtables_like)
+            image = _add_items(image, LayoutType.COLUMN, categories_name_as_key, pubtables_like)
 
         if dd_pipe_like:
             image = embedding_in_image(image, html, categories_name_as_key)

deepdoctection/mapper/tpstruct.py

@@ -22,15 +22,15 @@ import os.path
 from typing import Optional, Sequence, Union
 
 import numpy as np
+from lazy_imports import try_import
 
 from ..datapoint.annotation import ImageAnnotation
 from ..datapoint.image import Image
-from ..utils.detection_types import JsonDict
-from ..utils.file_utils import tf_available
-from ..utils.settings import ObjectTypes
+from ..utils.settings import TypeOrStr
+from ..utils.types import JsonDict
 from .maputils import curry
 
-if tf_available():
+with try_import() as import_guard:
     from tensorflow import convert_to_tensor, uint8  # type: ignore # pylint: disable=E0401
     from tensorflow.image import non_max_suppression  # type: ignore # pylint: disable=E0401
 
@@ -39,7 +39,7 @@ if tf_available():
 def image_to_tp_frcnn_training(
     dp: Image,
     add_mask: bool = False,
-    category_names: Optional[Union[str, ObjectTypes, Sequence[Union[str, ObjectTypes]]]] = None,
+    category_names: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
 ) -> Optional[JsonDict]:
     """
     Maps an image to a dict to be consumed by Tensorpack Faster-RCNN bounding box detection. Note, that the returned