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

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

@@ -26,8 +26,8 @@ from lazy_imports import try_import
 
 from ..datapoint.annotation import ImageAnnotation
 from ..datapoint.image import Image
-from ..utils.detection_types import JsonDict
-from ..utils.settings import ObjectTypes
+from ..utils.settings import TypeOrStr
+from ..utils.types import JsonDict
 from .maputils import curry
 
 with try_import() as import_guard:
@@ -39,7 +39,7 @@ with try_import() as import_guard:
 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

deepdoctection/mapper/xfundstruct.py

@@ -25,7 +25,6 @@ from itertools import chain
 from typing import Mapping, Optional
 
 from ..datapoint import BoundingBox, CategoryAnnotation, ContainerAnnotation, Image, ImageAnnotation
-from ..utils.detection_types import JsonDict
 from ..utils.fs import load_image_from_file
 from ..utils.settings import (
     BioTag,
@@ -37,17 +36,18 @@ from ..utils.settings import (
     get_type,
     token_class_tag_to_token_class_with_tag,
 )
+from ..utils.types import FunsdDict
 from .maputils import MappingContextManager, curry, maybe_get_fake_score
 
 
 @curry
 def xfund_to_image(
-    dp: JsonDict,
+    dp: FunsdDict,
     load_image: bool,
     fake_score: bool,
-    categories_dict_name_as_key: Mapping[str, str],
+    categories_dict_name_as_key: Mapping[ObjectTypes, int],
     token_class_names_mapping: Mapping[str, str],
-    ner_token_to_id_mapping: Mapping[ObjectTypes, Mapping[ObjectTypes, Mapping[ObjectTypes, str]]],
+    ner_token_to_id_mapping: Mapping[ObjectTypes, Mapping[ObjectTypes, Mapping[ObjectTypes, int]]],
 ) -> Optional[Image]:
     """
     Map a datapoint of annotation structure as given as from xfund or funsd dataset in to an Image structure
@@ -75,9 +75,9 @@ def xfund_to_image(
 
     _, file_name = os.path.split(full_path)
     external_id = dp.get("uid")
-    tag_to_id_mapping = ner_token_to_id_mapping[LayoutType.word][WordType.tag]
-    token_class_to_id_mapping = ner_token_to_id_mapping[LayoutType.word][WordType.token_class]
-    token_tag_to_id_mapping = ner_token_to_id_mapping[LayoutType.word][WordType.token_tag]
+    tag_to_id_mapping = ner_token_to_id_mapping[LayoutType.WORD][WordType.TAG]
+    token_class_to_id_mapping = ner_token_to_id_mapping[LayoutType.WORD][WordType.TOKEN_CLASS]
+    token_tag_to_id_mapping = ner_token_to_id_mapping[LayoutType.WORD][WordType.TOKEN_TAG]
 
     with MappingContextManager(file_name) as mapping_context:
         image = Image(file_name=file_name, location=full_path, external_id=external_id)
@@ -101,16 +101,16 @@ def xfund_to_image(
             bbox = BoundingBox(absolute_coords=True, ulx=box[0], uly=box[1], lrx=box[2], lry=box[3])
             score = maybe_get_fake_score(fake_score)
             entity_ann = ImageAnnotation(
-                category_name=LayoutType.text,
+                category_name=LayoutType.TEXT,
                 bounding_box=bbox,
-                category_id=categories_dict_name_as_key[LayoutType.text],
+                category_id=categories_dict_name_as_key[LayoutType.TEXT],
                 score=score,
             )
             category_name = token_class_names_mapping[entity["label"]]
             sub_cat_semantic = CategoryAnnotation(
                 category_name=category_name, category_id=token_class_to_id_mapping[get_type(category_name)]
             )
-            entity_ann.dump_sub_category(WordType.token_class, sub_cat_semantic)
+            entity_ann.dump_sub_category(WordType.TOKEN_CLASS, sub_cat_semantic)
             image.dump(entity_ann)
 
             words = entity.get("words")
@@ -122,61 +122,61 @@ def xfund_to_image(
                 score = maybe_get_fake_score(fake_score)
 
                 ann = ImageAnnotation(
-                    category_name=LayoutType.word,
+                    category_name=LayoutType.WORD,
                     bounding_box=bbox,
-                    category_id=categories_dict_name_as_key[LayoutType.word],
+                    category_id=categories_dict_name_as_key[LayoutType.WORD],
                     score=score,
                 )
                 image.dump(ann)
-                entity_ann.dump_relationship(Relationships.child, ann.annotation_id)
+                entity_ann.dump_relationship(Relationships.CHILD, ann.annotation_id)
                 sub_cat_semantic = CategoryAnnotation(
                     category_name=category_name, category_id=token_class_to_id_mapping[get_type(category_name)]
                 )
-                ann.dump_sub_category(WordType.token_class, sub_cat_semantic)
-                sub_cat_chars = ContainerAnnotation(category_name=WordType.characters, value=word["text"])
-                ann.dump_sub_category(WordType.characters, sub_cat_chars)
-                if sub_cat_semantic.category_name == TokenClasses.other:
+                ann.dump_sub_category(WordType.TOKEN_CLASS, sub_cat_semantic)
+                sub_cat_chars = ContainerAnnotation(category_name=WordType.CHARACTERS, value=word["text"])
+                ann.dump_sub_category(WordType.CHARACTERS, sub_cat_chars)
+                if sub_cat_semantic.category_name == TokenClasses.OTHER:
                     sub_cat_tag = CategoryAnnotation(
-                        category_name=BioTag.outside, category_id=tag_to_id_mapping[BioTag.outside]
+                        category_name=BioTag.OUTSIDE, category_id=tag_to_id_mapping[BioTag.OUTSIDE]
                     )
-                    ann.dump_sub_category(WordType.tag, sub_cat_tag)
+                    ann.dump_sub_category(WordType.TAG, sub_cat_tag)
                     # populating ner token to be used for training and evaluation
                     sub_cat_ner_tok = CategoryAnnotation(
-                        category_name=BioTag.outside, category_id=token_tag_to_id_mapping[BioTag.outside]
+                        category_name=BioTag.OUTSIDE, category_id=token_tag_to_id_mapping[BioTag.OUTSIDE]
                     )
-                    ann.dump_sub_category(WordType.token_tag, sub_cat_ner_tok)
+                    ann.dump_sub_category(WordType.TOKEN_TAG, sub_cat_ner_tok)
                 elif not idx:
                     sub_cat_tag = CategoryAnnotation(
-                        category_name=BioTag.begin, category_id=tag_to_id_mapping[BioTag.begin]
+                        category_name=BioTag.BEGIN, category_id=tag_to_id_mapping[BioTag.BEGIN]
                     )
-                    ann.dump_sub_category(WordType.tag, sub_cat_tag)
+                    ann.dump_sub_category(WordType.TAG, sub_cat_tag)
                     sub_cat_ner_tok = CategoryAnnotation(
                         category_name=token_class_tag_to_token_class_with_tag(
-                            get_type(sub_cat_semantic.category_name), BioTag.begin
+                            get_type(sub_cat_semantic.category_name), BioTag.BEGIN
                         ),
                         category_id=token_tag_to_id_mapping[
                             token_class_tag_to_token_class_with_tag(
-                                get_type(sub_cat_semantic.category_name), BioTag.begin
+                                get_type(sub_cat_semantic.category_name), BioTag.BEGIN
                             )
                         ],
                     )
-                    ann.dump_sub_category(WordType.token_tag, sub_cat_ner_tok)
+                    ann.dump_sub_category(WordType.TOKEN_TAG, sub_cat_ner_tok)
                 else:
                     sub_cat_tag = CategoryAnnotation(
-                        category_name=BioTag.inside, category_id=tag_to_id_mapping[BioTag.inside]
+                        category_name=BioTag.INSIDE, category_id=tag_to_id_mapping[BioTag.INSIDE]
                     )
-                    ann.dump_sub_category(WordType.tag, sub_cat_tag)
+                    ann.dump_sub_category(WordType.TAG, sub_cat_tag)
                     sub_cat_ner_tok = CategoryAnnotation(
                         category_name=token_class_tag_to_token_class_with_tag(
-                            get_type(sub_cat_semantic.category_name), BioTag.inside
+                            get_type(sub_cat_semantic.category_name), BioTag.INSIDE
                         ),
                         category_id=token_tag_to_id_mapping[
                             token_class_tag_to_token_class_with_tag(
-                                get_type(sub_cat_semantic.category_name), BioTag.inside
+                                get_type(sub_cat_semantic.category_name), BioTag.INSIDE
                             )
                         ],
                     )
-                    ann.dump_sub_category(WordType.token_tag, sub_cat_ner_tok)
+                    ann.dump_sub_category(WordType.TOKEN_TAG, sub_cat_ner_tok)
 
                 entity_id_to_ann_id[entity["id"]].append(ann.annotation_id)
                 ann_id_to_entity_id[ann.annotation_id] = entity["id"]
@@ -184,7 +184,7 @@ def xfund_to_image(
             entity_id_to_entity_link_id[entity["id"]].extend(entity["linking"])
 
         # now populating semantic links
-        word_anns = image.get_annotation(category_names=LayoutType.word)
+        word_anns = image.get_annotation(category_names=LayoutType.WORD)
         for word in word_anns:
             entity_id = ann_id_to_entity_id[word.annotation_id]
             all_linked_entities = list(chain(*entity_id_to_entity_link_id[entity_id]))
@@ -193,7 +193,7 @@ def xfund_to_image(
                 ann_ids.extend(entity_id_to_ann_id[linked_entity])
             for ann_id in ann_ids:
                 if ann_id != word.annotation_id:
-                    word.dump_relationship(Relationships.semantic_entity_link, ann_id)
+                    word.dump_relationship(Relationships.SEMANTIC_ENTITY_LINK, ann_id)
 
     if mapping_context.context_error:
         return None