docling-core 2.44.2__py3-none-any.whl → 2.46.0__py3-none-any.whl

docling_core/transforms/serializer/common.py

@@ -359,6 +359,7 @@ class DocSerializer(BaseModel, BaseDocSerializer):
                 item=item,
                 doc_serializer=self,
                 doc=self.doc,
+                visited=my_visited,
                 **my_kwargs,
             )
         elif isinstance(item, PictureItem):

docling_core/transforms/serializer/doctags.py

@@ -157,6 +157,7 @@ class DocTagsTableSerializer(BaseTableSerializer):
         item: TableItem,
         doc_serializer: BaseDocSerializer,
         doc: DoclingDocument,
+        visited: Optional[set[str]] = None,
         **kwargs: Any,
     ) -> SerializationResult:
         """Serializes the passed item."""
@@ -179,6 +180,7 @@ class DocTagsTableSerializer(BaseTableSerializer):
                 add_cell_text=params.add_table_cell_text,
                 xsize=params.xsize,
                 ysize=params.ysize,
+                visited=visited,
             )
             res_parts.append(create_ser_result(text=otsl_text, span_source=item))
 

docling_core/transforms/serializer/html.py

@@ -65,8 +65,8 @@ from docling_core.types.doc.document import (
     PictureItem,
     PictureMoleculeData,
     PictureTabularChartData,
+    RichTableCell,
     SectionHeaderItem,
-    TableCell,
     TableItem,
     TextItem,
     TitleItem,
@@ -346,9 +346,6 @@ class HTMLTableSerializer(BaseTableSerializer):
         **kwargs: Any,
     ) -> SerializationResult:
         """Serializes the passed table item to HTML."""
-        nrows = item.data.num_rows
-        ncols = item.data.num_cols
-
         res_parts: list[SerializationResult] = []
         cap_res = doc_serializer.serialize_captions(item=item, tag="caption", **kwargs)
         if cap_res.text:
@@ -356,11 +353,11 @@ class HTMLTableSerializer(BaseTableSerializer):
 
         if item.self_ref not in doc_serializer.get_excluded_refs(**kwargs):
             body = ""
+            span_source: Union[DocItem, list[SerializationResult]] = []
 
-            for i in range(nrows):
+            for i, row in enumerate(item.data.grid):
                 body += "<tr>"
-                for j in range(ncols):
-                    cell: TableCell = item.data.grid[i][j]
+                for j, cell in enumerate(row):
 
                     rowspan, rowstart = (
                         cell.row_span,
@@ -376,7 +373,16 @@ class HTMLTableSerializer(BaseTableSerializer):
                     if colstart != j:
                         continue
 
-                    content = html.escape(cell.text.strip())
+                    if isinstance(cell, RichTableCell):
+                        ser_res = doc_serializer.serialize(
+                            item=cell.ref.resolve(doc=doc), **kwargs
+                        )
+                        content = ser_res.text
+                        span_source = [ser_res]
+                    else:
+                        content = html.escape(cell.text.strip())
+                        span_source = item
+
                     celltag = "td"
                     if cell.column_header or cell.row_header or cell.row_section:
                         celltag = "th"
@@ -389,14 +395,14 @@ class HTMLTableSerializer(BaseTableSerializer):
 
                     text_dir = get_text_direction(content)
                     if text_dir == "rtl":
-                        opening_tag += f' dir="{dir}"'
+                        opening_tag += f' dir="{text_dir}"'
 
                     body += f"<{opening_tag}>{content}</{celltag}>"
                 body += "</tr>"
 
             if body:
                 body = f"<tbody>{body}</tbody>"
-                res_parts.append(create_ser_result(text=body, span_source=item))
+                res_parts.append(create_ser_result(text=body, span_source=span_source))
 
         text_res = "".join([r.text for r in res_parts])
         text_res = f"<table>{text_res}</table>" if text_res else ""
@@ -1057,7 +1063,7 @@ class HTMLDocSerializer(DocSerializer):
         if self.params.html_head is not None:
             return self.params.html_head
 
-        head_parts = ["<head>", '<meta charset="UTF-8">']
+        head_parts = ["<head>", '<meta charset="UTF-8"/>']
 
         # Add metadata if requested
         if params.add_document_metadata:
@@ -1067,7 +1073,7 @@ class HTMLDocSerializer(DocSerializer):
                 head_parts.append("<title>Docling Document</title>")
 
             head_parts.append(
-                '<meta name="generator" content="Docling HTML Serializer">'
+                '<meta name="generator" content="Docling HTML Serializer"/>'
             )
 
         # Add default styles or custom CSS

docling_core/transforms/serializer/markdown.py

@@ -55,6 +55,7 @@ from docling_core.types.doc.document import (
     PictureItem,
     PictureMoleculeData,
     PictureTabularChartData,
+    RichTableCell,
     SectionHeaderItem,
     TableItem,
     TextItem,
@@ -320,7 +321,13 @@ class MarkdownTableSerializer(BaseTableSerializer):
                 [
                     # make sure that md tables are not broken
                     # due to newline chars in the text
-                    col.text.replace("\n", " ")
+                    (
+                        doc_serializer.serialize(
+                            item=col.ref.resolve(doc=doc), **kwargs
+                        ).text
+                        if isinstance(col, RichTableCell)
+                        else col.text
+                    ).replace("\n", " ")
                     for col in row
                 ]
                 for row in item.data.grid

docling_core/types/doc/__init__.py

@@ -7,6 +7,7 @@
 
 from .base import BoundingBox, CoordOrigin, ImageRefMode, Size
 from .document import (
+    AnyTableCell,
     BaseAnnotation,
     ChartBar,
     ChartLine,
@@ -52,6 +53,7 @@ from .document import (
     PictureTabularChartData,
     ProvenanceItem,
     RefItem,
+    RichTableCell,
     Script,
     SectionHeaderItem,
     TableCell,

docling_core/types/doc/document.py

@@ -3,7 +3,6 @@
 import base64
 import copy
 import hashlib
-import itertools
 import json
 import logging
 import mimetypes
@@ -35,7 +34,7 @@ from pydantic import (
     validate_call,
 )
 from tabulate import tabulate
-from typing_extensions import Annotated, Self, deprecated
+from typing_extensions import Annotated, Self, deprecated, override
 
 from docling_core.search.package import VERSION_PATTERN
 from docling_core.types.base import _JSON_POINTER_REGEX
@@ -54,14 +53,14 @@ from docling_core.types.doc.labels import (
     GroupLabel,
     PictureClassificationLabel,
 )
-from docling_core.types.doc.tokens import _LOC_PREFIX, DocumentToken, TableToken
-from docling_core.types.doc.utils import relative_path
+from docling_core.types.doc.tokens import DocumentToken, TableToken
+from docling_core.types.doc.utils import parse_otsl_table_content, relative_path
 
 _logger = logging.getLogger(__name__)
 
 Uint64 = typing.Annotated[int, Field(ge=0, le=(2**64 - 1))]
 LevelNumber = typing.Annotated[int, Field(ge=1, le=100)]
-CURRENT_VERSION: Final = "1.5.0"
+CURRENT_VERSION: Final = "1.6.0"
 
 DEFAULT_EXPORT_LABELS = {
     DocItemLabel.TITLE,
@@ -326,7 +325,7 @@ class TableCell(BaseModel):
                 in data
             ):
                 return data
-            text = data["bbox"].get("token", "")
+            text = data.get("bbox", {}).get("token", "")
             if not len(text):
                 text_cells = data.pop("text_cell_bboxes", None)
                 if text_cells:
@@ -338,11 +337,39 @@ class TableCell(BaseModel):
 
         return data
 
+    def _get_text(self, doc: Optional["DoclingDocument"] = None, **kwargs: Any) -> str:
+        return self.text
+
+
+class RichTableCell(TableCell):
+    """RichTableCell."""
+
+    ref: "RefItem"
+
+    @override
+    def _get_text(self, doc: Optional["DoclingDocument"] = None, **kwargs: Any) -> str:
+        from docling_core.transforms.serializer.markdown import MarkdownDocSerializer
+
+        if doc is not None:
+            doc_serializer = kwargs.pop(
+                "doc_serializer", MarkdownDocSerializer(doc=doc)
+            )
+            ser_res = doc_serializer.serialize(item=self.ref.resolve(doc=doc), **kwargs)
+            return ser_res.text
+        else:
+            return "<!-- rich cell -->"
+
+
+AnyTableCell = Annotated[
+    Union[RichTableCell, TableCell],
+    Field(union_mode="left_to_right"),
+]
+
 
 class TableData(BaseModel):  # TBD
     """BaseTableData."""
 
-    table_cells: List[TableCell] = []
+    table_cells: List[AnyTableCell] = []
     num_rows: int = 0
     num_cols: int = 0
 
@@ -381,7 +408,9 @@ class TableData(BaseModel):  # TBD
 
         return table_data
 
-    def remove_rows(self, indices: List[int]) -> List[List[TableCell]]:
+    def remove_rows(
+        self, indices: List[int], doc: Optional["DoclingDocument"] = None
+    ) -> List[List[TableCell]]:
         """Remove rows from the table by their indices.
 
         :param indices: List[int]: A list of indices of the rows to remove. (Starting from 0)
@@ -393,6 +422,7 @@ class TableData(BaseModel):  # TBD
 
         indices = sorted(indices, reverse=True)
 
+        refs_to_remove = []
         all_removed_cells = []
         for row_index in indices:
             if row_index < 0 or row_index >= self.num_rows:
@@ -404,6 +434,10 @@ class TableData(BaseModel):  # TBD
             end_idx = start_idx + self.num_cols
             removed_cells = self.table_cells[start_idx:end_idx]
 
+            for cell in removed_cells:
+                if isinstance(cell, RichTableCell):
+                    refs_to_remove.append(cell.ref)
+
             # Remove the cells from the table
             self.table_cells = self.table_cells[:start_idx] + self.table_cells[end_idx:]
 
@@ -418,9 +452,18 @@ class TableData(BaseModel):  # TBD
 
             all_removed_cells.append(removed_cells)
 
+        if refs_to_remove:
+            if doc is None:
+                _logger.warning(
+                    "When table contains rich cells, `doc` argument must be provided, "
+                    "otherwise rich cell content will be left dangling."
+                )
+            else:
+                doc._delete_items(refs_to_remove)
+
         return all_removed_cells
 
-    def pop_row(self) -> List[TableCell]:
+    def pop_row(self, doc: Optional["DoclingDocument"] = None) -> List[TableCell]:
         """Remove and return the last row from the table.
 
         :returns: List[TableCell]: A list of TableCell objects representing the popped row.
@@ -428,16 +471,18 @@ class TableData(BaseModel):  # TBD
         if self.num_rows == 0:
             raise IndexError("Cannot pop from an empty table.")
 
-        return self.remove_row(self.num_rows - 1)
+        return self.remove_row(self.num_rows - 1, doc=doc)
 
-    def remove_row(self, row_index: int) -> List[TableCell]:
+    def remove_row(
+        self, row_index: int, doc: Optional["DoclingDocument"] = None
+    ) -> List[TableCell]:
         """Remove a row from the table by its index.
 
         :param row_index: int: The index of the row to remove. (Starting from 0)
 
         :returns: List[TableCell]: A list of TableCell objects representing the removed row.
         """
-        return self.remove_rows([row_index])[0]
+        return self.remove_rows([row_index], doc=doc)[0]
 
     def insert_rows(
         self, row_index: int, rows: List[List[str]], after: bool = False
@@ -1510,8 +1555,15 @@ class TableItem(FloatingItem):
 
     annotations: List[TableAnnotationType] = []
 
-    def export_to_dataframe(self) -> pd.DataFrame:
+    def export_to_dataframe(
+        self, doc: Optional["DoclingDocument"] = None
+    ) -> pd.DataFrame:
         """Export the table as a Pandas DataFrame."""
+        if doc is None:
+            _logger.warning(
+                "Usage of TableItem.export_to_dataframe() without `doc` argument is deprecated."
+            )
+
         if self.data.num_rows == 0 or self.data.num_cols == 0:
             return pd.DataFrame()
 
@@ -1540,14 +1592,15 @@ class TableItem(FloatingItem):
             columns = ["" for _ in range(self.data.num_cols)]
             for i in range(num_headers):
                 for j, cell in enumerate(self.data.grid[i]):
-                    col_name = cell.text
+                    col_name = cell._get_text(doc=doc)
                     if columns[j] != "":
                         col_name = f".{col_name}"
                     columns[j] += col_name
 
         # Create table data
         table_data = [
-            [cell.text for cell in row] for row in self.data.grid[num_headers:]
+            [cell._get_text(doc=doc) for cell in row]
+            for row in self.data.grid[num_headers:]
         ]
 
         # Create DataFrame
@@ -1578,7 +1631,7 @@ class TableItem(FloatingItem):
 
                     # make sure that md tables are not broken
                     # due to newline chars in the text
-                    text = col.text
+                    text = col._get_text(doc=doc)
                     text = text.replace("\n", " ")
                     tmp.append(text)
 
@@ -1624,6 +1677,7 @@ class TableItem(FloatingItem):
         add_cell_text: bool = True,
         xsize: int = 500,
         ysize: int = 500,
+        **kwargs: Any,
     ) -> str:
         """Export the table as OTSL."""
         # Possible OTSL tokens...
@@ -1640,6 +1694,9 @@ class TableItem(FloatingItem):
         # Headers (column, row, section row):
         # "ched", "rhed", "srow"
 
+        from docling_core.transforms.serializer.doctags import DocTagsDocSerializer
+
+        doc_serializer = DocTagsDocSerializer(doc=doc)
         body = []
         nrows = self.data.num_rows
         ncols = self.data.num_cols
@@ -1653,7 +1710,9 @@ class TableItem(FloatingItem):
         for i in range(nrows):
             for j in range(ncols):
                 cell: TableCell = self.data.grid[i][j]
-                content = cell.text.strip()
+                content = cell._get_text(
+                    doc=doc, doc_serializer=doc_serializer, **kwargs
+                ).strip()
                 rowspan, rowstart = (
                     cell.row_span,
                     cell.start_row_offset_idx,
@@ -2305,6 +2364,15 @@ class DoclingDocument(BaseModel):
                 refs_to_be_deleted=refs_to_be_deleted,
                 lookup=lookup,
             )
+            if isinstance(node, TableItem):
+                for cell in node.data.table_cells:
+                    if isinstance(cell, RichTableCell):
+                        path = cell.ref._split_ref_to_path()
+                        cell.ref = self._update_ref_with_lookup(
+                            item_label=path[1],
+                            item_index=int(path[2]),
+                            lookup=lookup,
+                        )
 
         # Update the self_ref reference
         if node.parent is not None:
@@ -3946,16 +4014,22 @@ class DoclingDocument(BaseModel):
         """num_pages."""
         return len(self.pages.values())
 
-    def validate_tree(self, root) -> bool:
+    def validate_tree(self, root: NodeItem) -> bool:
         """validate_tree."""
-        res = []
         for child_ref in root.children:
             child = child_ref.resolve(self)
-            if child.parent.resolve(self) != root:
+            if child.parent.resolve(self) != root or not self.validate_tree(child):
                 return False
-            res.append(self.validate_tree(child))
 
-        return all(res) or len(res) == 0
+        if isinstance(root, TableItem):
+            for cell in root.data.table_cells:
+                if isinstance(cell, RichTableCell) and (
+                    (par_ref := cell.ref.resolve(self).parent) is None
+                    or par_ref.resolve(self) != root
+                ):
+                    return False
+
+        return True
 
     def iterate_items(
         self,
@@ -3964,7 +4038,7 @@ class DoclingDocument(BaseModel):
         traverse_pictures: bool = False,
         page_no: Optional[int] = None,
         included_content_layers: Optional[set[ContentLayer]] = None,
-        _level: int = 0,  # fixed parameter, carries through the node nesting level
+        _level: int = 0,  # deprecated
     ) -> typing.Iterable[Tuple[NodeItem, int]]:  # tuple of node and level
         """Iterate elements with level."""
         for item, stack in self._iterate_items_with_stack(
@@ -4688,181 +4762,6 @@ class DoclingDocument(BaseModel):
                 bbox = None
             return caption_item, bbox
 
-        def otsl_parse_texts(texts, tokens):
-            split_word = TableToken.OTSL_NL.value
-            # CLEAN tokens from extra tags, only structural OTSL allowed
-            clean_tokens = []
-            for t in tokens:
-                if t in [
-                    TableToken.OTSL_ECEL.value,
-                    TableToken.OTSL_FCEL.value,
-                    TableToken.OTSL_LCEL.value,
-                    TableToken.OTSL_UCEL.value,
-                    TableToken.OTSL_XCEL.value,
-                    TableToken.OTSL_NL.value,
-                    TableToken.OTSL_CHED.value,
-                    TableToken.OTSL_RHED.value,
-                    TableToken.OTSL_SROW.value,
-                ]:
-                    clean_tokens.append(t)
-            tokens = clean_tokens
-            split_row_tokens = [
-                list(y)
-                for x, y in itertools.groupby(tokens, lambda z: z == split_word)
-                if not x
-            ]
-
-            table_cells = []
-            r_idx = 0
-            c_idx = 0
-
-            def count_right(tokens, c_idx, r_idx, which_tokens):
-                span = 0
-                c_idx_iter = c_idx
-                while tokens[r_idx][c_idx_iter] in which_tokens:
-                    c_idx_iter += 1
-                    span += 1
-                    if c_idx_iter >= len(tokens[r_idx]):
-                        return span
-                return span
-
-            def count_down(tokens, c_idx, r_idx, which_tokens):
-                span = 0
-                r_idx_iter = r_idx
-                while tokens[r_idx_iter][c_idx] in which_tokens:
-                    r_idx_iter += 1
-                    span += 1
-                    if r_idx_iter >= len(tokens):
-                        return span
-                return span
-
-            for i, text in enumerate(texts):
-                cell_text = ""
-                if text in [
-                    TableToken.OTSL_FCEL.value,
-                    TableToken.OTSL_ECEL.value,
-                    TableToken.OTSL_CHED.value,
-                    TableToken.OTSL_RHED.value,
-                    TableToken.OTSL_SROW.value,
-                ]:
-                    row_span = 1
-                    col_span = 1
-                    right_offset = 1
-                    if text != TableToken.OTSL_ECEL.value:
-                        cell_text = texts[i + 1]
-                        right_offset = 2
-
-                    # Check next element(s) for lcel / ucel / xcel,
-                    # set properly row_span, col_span
-                    next_right_cell = ""
-                    if i + right_offset < len(texts):
-                        next_right_cell = texts[i + right_offset]
-
-                    next_bottom_cell = ""
-                    if r_idx + 1 < len(split_row_tokens):
-                        if c_idx < len(split_row_tokens[r_idx + 1]):
-                            next_bottom_cell = split_row_tokens[r_idx + 1][c_idx]
-
-                    if next_right_cell in [
-                        TableToken.OTSL_LCEL.value,
-                        TableToken.OTSL_XCEL.value,
-                    ]:
-                        # we have horisontal spanning cell or 2d spanning cell
-                        col_span += count_right(
-                            split_row_tokens,
-                            c_idx + 1,
-                            r_idx,
-                            [TableToken.OTSL_LCEL.value, TableToken.OTSL_XCEL.value],
-                        )
-                    if next_bottom_cell in [
-                        TableToken.OTSL_UCEL.value,
-                        TableToken.OTSL_XCEL.value,
-                    ]:
-                        # we have a vertical spanning cell or 2d spanning cell
-                        row_span += count_down(
-                            split_row_tokens,
-                            c_idx,
-                            r_idx + 1,
-                            [TableToken.OTSL_UCEL.value, TableToken.OTSL_XCEL.value],
-                        )
-
-                    table_cells.append(
-                        TableCell(
-                            text=cell_text.strip(),
-                            row_span=row_span,
-                            col_span=col_span,
-                            start_row_offset_idx=r_idx,
-                            end_row_offset_idx=r_idx + row_span,
-                            start_col_offset_idx=c_idx,
-                            end_col_offset_idx=c_idx + col_span,
-                        )
-                    )
-                if text in [
-                    TableToken.OTSL_FCEL.value,
-                    TableToken.OTSL_ECEL.value,
-                    TableToken.OTSL_CHED.value,
-                    TableToken.OTSL_RHED.value,
-                    TableToken.OTSL_SROW.value,
-                    TableToken.OTSL_LCEL.value,
-                    TableToken.OTSL_UCEL.value,
-                    TableToken.OTSL_XCEL.value,
-                ]:
-                    c_idx += 1
-                if text == TableToken.OTSL_NL.value:
-                    r_idx += 1
-                    c_idx = 0
-            return table_cells, split_row_tokens
-
-        def otsl_extract_tokens_and_text(s: str):
-            # Pattern to match anything enclosed by < >
-            # (including the angle brackets themselves)
-            pattern = r"(<[^>]+>)"
-            # Find all tokens (e.g. "<otsl>", "<loc_140>", etc.)
-            tokens = re.findall(pattern, s)
-            # Remove any tokens that start with "<loc_"
-            tokens = [
-                token
-                for token in tokens
-                if not (
-                    token.startswith(rf"<{_LOC_PREFIX}")
-                    or token
-                    in [
-                        rf"<{DocumentToken.OTSL.value}>",
-                        rf"</{DocumentToken.OTSL.value}>",
-                    ]
-                )
-            ]
-            # Split the string by those tokens to get the in-between text
-            text_parts = re.split(pattern, s)
-            text_parts = [
-                token
-                for token in text_parts
-                if not (
-                    token.startswith(rf"<{_LOC_PREFIX}")
-                    or token
-                    in [
-                        rf"<{DocumentToken.OTSL.value}>",
-                        rf"</{DocumentToken.OTSL.value}>",
-                    ]
-                )
-            ]
-            # Remove any empty or purely whitespace strings from text_parts
-            text_parts = [part for part in text_parts if part.strip()]
-
-            return tokens, text_parts
-
-        def parse_table_content(otsl_content: str) -> TableData:
-            tokens, mixed_texts = otsl_extract_tokens_and_text(otsl_content)
-            table_cells, split_row_tokens = otsl_parse_texts(mixed_texts, tokens)
-
-            return TableData(
-                num_rows=len(split_row_tokens),
-                num_cols=(
-                    max(len(row) for row in split_row_tokens) if split_row_tokens else 0
-                ),
-                table_cells=table_cells,
-            )
-
         def extract_chart_type(text_chunk: str):
             label = None
             chart_labels = [
@@ -5094,7 +4993,7 @@ class DoclingDocument(BaseModel):
                 doc_label = tag_to_doclabel.get(tag_name, DocItemLabel.TEXT)
 
                 if tag_name == DocumentToken.OTSL.value:
-                    table_data = parse_table_content(full_chunk)
+                    table_data = parse_otsl_table_content(full_chunk)
                     caption, caption_bbox = extract_caption(full_chunk)
                     if caption is not None and caption_bbox is not None:
                         caption.prov.append(
@@ -5137,7 +5036,7 @@ class DoclingDocument(BaseModel):
                     table_data = None
                     chart_type = None
                     if tag_name == DocumentToken.CHART.value:
-                        table_data = parse_table_content(full_chunk)
+                        table_data = parse_otsl_table_content(full_chunk)
                         chart_type = extract_chart_type(full_chunk)
                     if image:
                         if bbox:
@@ -5500,7 +5399,9 @@ class DoclingDocument(BaseModel):
                         grid.append([])
                         for j, cell in enumerate(row):
                             if j < 10:
-                                text = get_text(text=cell.text, max_text_len=16)
+                                text = get_text(
+                                    cell._get_text(doc=self), max_text_len=16
+                                )
                                 grid[-1].append(text)
 
                     result.append("\n" + tabulate(grid) + "\n")
@@ -5683,69 +5584,196 @@ class DoclingDocument(BaseModel):
                 )
         return self
 
+    class _DocIndex(BaseModel):
+        """A document merge buffer."""
+
+        groups: list[GroupItem] = []
+        texts: list[TextItem] = []
+        pictures: list[PictureItem] = []
+        tables: list[TableItem] = []
+        key_value_items: list[KeyValueItem] = []
+        form_items: list[FormItem] = []
+
+        pages: dict[int, PageItem] = {}
+
+        _body: Optional[GroupItem] = None
+        _max_page: int = 0
+        _names: list[str] = []
+
+        def get_item_list(self, key: str) -> list[NodeItem]:
+            return getattr(self, key)
+
+        def index(self, doc: "DoclingDocument") -> None:
+
+            orig_ref_to_new_ref: dict[str, str] = {}
+            page_delta = self._max_page - min(doc.pages.keys()) + 1 if doc.pages else 0
+
+            if self._body is None:
+                self._body = GroupItem(**doc.body.model_dump(exclude={"children"}))
+
+            self._names.append(doc.name)
+
+            # collect items in traversal order
+            for item, _ in doc.iterate_items(
+                with_groups=True,
+                traverse_pictures=True,
+                included_content_layers={c for c in ContentLayer},
+            ):
+                key = item.self_ref.split("/")[1]
+                is_body = key == "body"
+                new_cref = (
+                    "#/body" if is_body else f"#/{key}/{len(self.get_item_list(key))}"
+                )
+                # register cref mapping:
+                orig_ref_to_new_ref[item.self_ref] = new_cref
+
+                if not is_body:
+                    new_item = copy.deepcopy(item)
+                    new_item.children = []
+
+                    # put item in the right list
+                    self.get_item_list(key).append(new_item)
+
+                    # update item's self reference
+                    new_item.self_ref = new_cref
+
+                    if isinstance(new_item, DocItem):
+                        # update page numbers
+                        # NOTE other prov sources (e.g. GraphCell) currently not covered
+                        for prov in new_item.prov:
+                            prov.page_no += page_delta
+
+                    if item.parent:
+                        # set item's parent
+                        new_parent_cref = orig_ref_to_new_ref[item.parent.cref]
+                        new_item.parent = RefItem(cref=new_parent_cref)
+
+                        # add item to parent's children
+                        path_components = new_parent_cref.split("/")
+                        num_components = len(path_components)
+                        if num_components == 3:
+                            _, parent_key, parent_index_str = path_components
+                            parent_index = int(parent_index_str)
+                            parent_item = self.get_item_list(parent_key)[parent_index]
+
+                            # update captions field (not possible in iterate_items order):
+                            if isinstance(parent_item, FloatingItem):
+                                for cap_it, cap in enumerate(parent_item.captions):
+                                    if cap.cref == item.self_ref:
+                                        parent_item.captions[cap_it] = RefItem(
+                                            cref=new_cref
+                                        )
+                                        break
+
+                            # update rich table cells references:
+                            if isinstance(parent_item, TableItem):
+                                for cell in parent_item.data.table_cells:
+                                    if (
+                                        isinstance(cell, RichTableCell)
+                                        and cell.ref.cref == item.self_ref
+                                    ):
+                                        cell.ref.cref = new_cref
+                                        break
+
+                        elif num_components == 2 and path_components[1] == "body":
+                            parent_item = self._body
+                        else:
+                            raise RuntimeError(
+                                f"Unsupported ref format: {new_parent_cref}"
+                            )
+                        parent_item.children.append(RefItem(cref=new_cref))
+
+            # update pages
+            new_max_page = None
+            for page_nr in doc.pages:
+                new_page = copy.deepcopy(doc.pages[page_nr])
+                new_page_nr = page_nr + page_delta
+                new_page.page_no = new_page_nr
+                self.pages[new_page_nr] = new_page
+                if new_max_page is None or new_page_nr > new_max_page:
+                    new_max_page = new_page_nr
+            if new_max_page is not None:
+                self._max_page = new_max_page
+
+        def get_name(self) -> str:
+            return " + ".join(self._names)
+
+    def _update_from_index(self, doc_index: "_DocIndex") -> None:
+        if doc_index._body is not None:
+            self.body = doc_index._body
+        self.groups = doc_index.groups
+        self.texts = doc_index.texts
+        self.pictures = doc_index.pictures
+        self.tables = doc_index.tables
+        self.key_value_items = doc_index.key_value_items
+        self.form_items = doc_index.form_items
+        self.pages = doc_index.pages
+        self.name = doc_index.get_name()
+
     def _normalize_references(self) -> None:
-        """Normalize ref numbering by ordering node items as per iterate_items()."""
-        new_body = GroupItem(**self.body.model_dump(exclude={"children"}))
-
-        item_lists: dict[str, list[NodeItem]] = {
-            "groups": [],
-            "texts": [],
-            "pictures": [],
-            "tables": [],
-            "key_value_items": [],
-            "form_items": [],
-        }
-        orig_ref_to_new_ref: dict[str, str] = {}
+        doc_index = DoclingDocument._DocIndex()
+        doc_index.index(doc=self)
+        self._update_from_index(doc_index)
+
+    @classmethod
+    def concatenate(cls, docs: Sequence["DoclingDocument"]) -> "DoclingDocument":
+        """Concatenate multiple documents into a single document."""
+        doc_index = DoclingDocument._DocIndex()
+        for doc in docs:
+            doc_index.index(doc=doc)
+
+        res_doc = DoclingDocument(name=" + ".join([doc.name for doc in docs]))
+        res_doc._update_from_index(doc_index)
+        return res_doc
+
+    def _validate_rules(self):
+        def validate_list_group(doc: DoclingDocument, item: ListGroup):
+            for ref in item.children:
+                child = ref.resolve(doc)
+                if not isinstance(child, ListItem):
+                    raise ValueError(
+                        f"ListGroup {item.self_ref} contains non-ListItem {child.self_ref} ({child.label=})"
+                    )
+
+        def validate_list_item(doc: DoclingDocument, item: ListItem):
+            if item.parent is None:
+                raise ValueError(f"ListItem {item.self_ref} has no parent")
+            if not isinstance(item.parent.resolve(doc), ListGroup):
+                raise ValueError(
+                    f"ListItem {item.self_ref} has non-ListGroup parent: {item.parent.cref}"
+                )
+
+        def validate_group(doc: DoclingDocument, item: GroupItem):
+            if (
+                item.parent and not item.children
+            ):  # tolerate empty body, but not other groups
+                raise ValueError(f"Group {item.self_ref} has no children")
 
-        # collect items in traversal order
         for item, _ in self.iterate_items(
             with_groups=True,
             traverse_pictures=True,
             included_content_layers={c for c in ContentLayer},
         ):
-            key = item.self_ref.split("/")[1]
-            is_body = key == "body"
-            new_cref = "#/body" if is_body else f"#/{key}/{len(item_lists[key])}"
-            # register cref mapping:
-            orig_ref_to_new_ref[item.self_ref] = new_cref
-
-            if not is_body:
-                new_item = copy.deepcopy(item)
-                new_item.children = []
-
-                # put item in the right list
-                item_lists[key].append(new_item)
-
-                # update item's self reference
-                new_item.self_ref = new_cref
-
-                if item.parent:
-                    # set item's parent
-                    new_parent_cref = orig_ref_to_new_ref[item.parent.cref]
-                    new_item.parent = RefItem(cref=new_parent_cref)
-
-                    # add item to parent's children
-                    path_components = new_parent_cref.split("/")
-                    num_components = len(path_components)
-                    parent_node: NodeItem
-                    if num_components == 3:
-                        _, parent_key, parent_index_str = path_components
-                        parent_index = int(parent_index_str)
-                        parent_node = item_lists[parent_key][parent_index]
-                    elif num_components == 2 and path_components[1] == "body":
-                        parent_node = new_body
-                    else:
-                        raise RuntimeError(f"Unsupported ref format: {new_parent_cref}")
-                    parent_node.children.append(RefItem(cref=new_cref))
-
-        # update document
-        self.groups = item_lists["groups"]  # type: ignore
-        self.texts = item_lists["texts"]  # type: ignore
-        self.pictures = item_lists["pictures"]  # type: ignore
-        self.tables = item_lists["tables"]  # type: ignore
-        self.key_value_items = item_lists["key_value_items"]  # type: ignore
-        self.form_items = item_lists["form_items"]  # type: ignore
-        self.body = new_body
+            if isinstance(item, ListGroup):
+                validate_list_group(self, item)
+
+            elif isinstance(item, GroupItem):
+                validate_group(self, item)
+
+            elif isinstance(item, ListItem):
+                validate_list_item(self, item)
+
+    def add_table_cell(self, table_item: TableItem, cell: TableCell) -> None:
+        """Add a table cell to the table."""
+        if isinstance(cell, RichTableCell):
+            item = cell.ref.resolve(doc=self)
+            if isinstance(item, NodeItem) and (
+                (not item.parent) or item.parent.cref != table_item.self_ref
+            ):
+                raise ValueError(
+                    f"Trying to add cell with another parent {item.parent} to {table_item.self_ref}"
+                )
+        table_item.data.table_cells.append(cell)
 
 
 # deprecated aliases (kept for backwards compatibility):

docling_core/types/doc/utils.py

@@ -6,9 +6,16 @@
 """Utils for document types."""
 
 import html
+import itertools
+import re
 import unicodedata
 from pathlib import Path
-from typing import Optional
+from typing import TYPE_CHECKING, List, Optional, Tuple
+
+from docling_core.types.doc.tokens import _LOC_PREFIX, DocumentToken, TableToken
+
+if TYPE_CHECKING:
+    from docling_core.types.doc.document import TableCell, TableData
 
 
 def relative_path(src: Path, target: Path) -> Path:
@@ -84,3 +91,192 @@ def get_text_direction(text: str) -> str:
         or rtl_chars > len(text) / 2
         else "ltr"
     )
+
+
+def otsl_extract_tokens_and_text(s: str) -> Tuple[List[str], List[str]]:
+    """Extract OTSL tokens and text from an OTSL string."""
+    # Pattern to match anything enclosed by < >
+    # (including the angle brackets themselves)
+    pattern = r"(<[^>]+>)"
+    # Find all tokens (e.g. "<otsl>", "<loc_140>", etc.)
+    tokens = re.findall(pattern, s)
+    # Remove any tokens that start with "<loc_"
+    tokens = [
+        token
+        for token in tokens
+        if not (
+            token.startswith(rf"<{_LOC_PREFIX}")
+            or token
+            in [
+                rf"<{DocumentToken.OTSL.value}>",
+                rf"</{DocumentToken.OTSL.value}>",
+            ]
+        )
+    ]
+    # Split the string by those tokens to get the in-between text
+    text_parts = re.split(pattern, s)
+    text_parts = [
+        token
+        for token in text_parts
+        if not (
+            token.startswith(rf"<{_LOC_PREFIX}")
+            or token
+            in [
+                rf"<{DocumentToken.OTSL.value}>",
+                rf"</{DocumentToken.OTSL.value}>",
+            ]
+        )
+    ]
+    # Remove any empty or purely whitespace strings from text_parts
+    text_parts = [part for part in text_parts if part.strip()]
+
+    return tokens, text_parts
+
+
+def otsl_parse_texts(
+    texts: List[str], tokens: List[str]
+) -> Tuple[List["TableCell"], List[List[str]]]:
+    """Parse OTSL texts and tokens into table cells."""
+    from docling_core.types.doc.document import TableCell
+
+    split_word = TableToken.OTSL_NL.value
+    # CLEAN tokens from extra tags, only structural OTSL allowed
+    clean_tokens = []
+    for t in tokens:
+        if t in [
+            TableToken.OTSL_ECEL.value,
+            TableToken.OTSL_FCEL.value,
+            TableToken.OTSL_LCEL.value,
+            TableToken.OTSL_UCEL.value,
+            TableToken.OTSL_XCEL.value,
+            TableToken.OTSL_NL.value,
+            TableToken.OTSL_CHED.value,
+            TableToken.OTSL_RHED.value,
+            TableToken.OTSL_SROW.value,
+        ]:
+            clean_tokens.append(t)
+    tokens = clean_tokens
+    split_row_tokens = [
+        list(y)
+        for x, y in itertools.groupby(tokens, lambda z: z == split_word)
+        if not x
+    ]
+
+    table_cells = []
+    r_idx = 0
+    c_idx = 0
+
+    def count_right(
+        tokens: List[List[str]], c_idx: int, r_idx: int, which_tokens: List[str]
+    ) -> int:
+        span = 0
+        c_idx_iter = c_idx
+        while tokens[r_idx][c_idx_iter] in which_tokens:
+            c_idx_iter += 1
+            span += 1
+            if c_idx_iter >= len(tokens[r_idx]):
+                return span
+        return span
+
+    def count_down(
+        tokens: List[List[str]], c_idx: int, r_idx: int, which_tokens: List[str]
+    ) -> int:
+        span = 0
+        r_idx_iter = r_idx
+        while tokens[r_idx_iter][c_idx] in which_tokens:
+            r_idx_iter += 1
+            span += 1
+            if r_idx_iter >= len(tokens):
+                return span
+        return span
+
+    for i, text in enumerate(texts):
+        cell_text = ""
+        if text in [
+            TableToken.OTSL_FCEL.value,
+            TableToken.OTSL_ECEL.value,
+            TableToken.OTSL_CHED.value,
+            TableToken.OTSL_RHED.value,
+            TableToken.OTSL_SROW.value,
+        ]:
+            row_span = 1
+            col_span = 1
+            right_offset = 1
+            if text != TableToken.OTSL_ECEL.value:
+                cell_text = texts[i + 1]
+                right_offset = 2
+
+            # Check next element(s) for lcel / ucel / xcel,
+            # set properly row_span, col_span
+            next_right_cell = ""
+            if i + right_offset < len(texts):
+                next_right_cell = texts[i + right_offset]
+
+            next_bottom_cell = ""
+            if r_idx + 1 < len(split_row_tokens):
+                if c_idx < len(split_row_tokens[r_idx + 1]):
+                    next_bottom_cell = split_row_tokens[r_idx + 1][c_idx]
+
+            if next_right_cell in [
+                TableToken.OTSL_LCEL.value,
+                TableToken.OTSL_XCEL.value,
+            ]:
+                # we have horizontal spanning cell or 2d spanning cell
+                col_span += count_right(
+                    split_row_tokens,
+                    c_idx + 1,
+                    r_idx,
+                    [TableToken.OTSL_LCEL.value, TableToken.OTSL_XCEL.value],
+                )
+            if next_bottom_cell in [
+                TableToken.OTSL_UCEL.value,
+                TableToken.OTSL_XCEL.value,
+            ]:
+                # we have a vertical spanning cell or 2d spanning cell
+                row_span += count_down(
+                    split_row_tokens,
+                    c_idx,
+                    r_idx + 1,
+                    [TableToken.OTSL_UCEL.value, TableToken.OTSL_XCEL.value],
+                )
+
+            table_cells.append(
+                TableCell(
+                    text=cell_text.strip(),
+                    row_span=row_span,
+                    col_span=col_span,
+                    start_row_offset_idx=r_idx,
+                    end_row_offset_idx=r_idx + row_span,
+                    start_col_offset_idx=c_idx,
+                    end_col_offset_idx=c_idx + col_span,
+                )
+            )
+        if text in [
+            TableToken.OTSL_FCEL.value,
+            TableToken.OTSL_ECEL.value,
+            TableToken.OTSL_CHED.value,
+            TableToken.OTSL_RHED.value,
+            TableToken.OTSL_SROW.value,
+            TableToken.OTSL_LCEL.value,
+            TableToken.OTSL_UCEL.value,
+            TableToken.OTSL_XCEL.value,
+        ]:
+            c_idx += 1
+        if text == TableToken.OTSL_NL.value:
+            r_idx += 1
+            c_idx = 0
+    return table_cells, split_row_tokens
+
+
+def parse_otsl_table_content(otsl_content: str) -> "TableData":
+    """Parse OTSL content into TableData."""
+    from docling_core.types.doc.document import TableData
+
+    tokens, mixed_texts = otsl_extract_tokens_and_text(otsl_content)
+    table_cells, split_row_tokens = otsl_parse_texts(mixed_texts, tokens)
+
+    return TableData(
+        num_rows=len(split_row_tokens),
+        num_cols=(max(len(row) for row in split_row_tokens) if split_row_tokens else 0),
+        table_cells=table_cells,
+    )

docling_core/utils/legacy.py

@@ -252,7 +252,7 @@ def docling_document_to_legacy(doc: DoclingDocument, fallback_filaname: str = "f
 
                             spans = list(_make_spans(cell, item))
                             table_data[i][j] = GlmTableCell(
-                                text=cell.text,
+                                text=cell._get_text(doc=doc),
                                 bbox=(
                                     cell.bbox.as_tuple()
                                     if cell.bbox is not None

{docling_core-2.44.2.dist-info → docling_core-2.46.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-core
-Version: 2.44.2
+Version: 2.46.0
 Summary: A python library to define and validate data types in Docling.
 Author-email: Cesar Berrospi Ramis <ceb@zurich.ibm.com>, Panos Vagenas <pva@zurich.ibm.com>, Michele Dolfi <dol@zurich.ibm.com>, Christoph Auer <cau@zurich.ibm.com>, Peter Staar <taa@zurich.ibm.com>
 Maintainer-email: Panos Vagenas <pva@zurich.ibm.com>, Michele Dolfi <dol@zurich.ibm.com>, Christoph Auer <cau@zurich.ibm.com>, Peter Staar <taa@zurich.ibm.com>, Cesar Berrospi Ramis <ceb@zurich.ibm.com>

{docling_core-2.44.2.dist-info → docling_core-2.46.0.dist-info}/RECORD

@@ -28,11 +28,11 @@ docling_core/transforms/chunker/tokenizer/huggingface.py,sha256=aZ_RNQIzcNkAHGHZ
 docling_core/transforms/chunker/tokenizer/openai.py,sha256=zt2kwcC-r8MafeEG0CESab8E4RIC9aaFXxxnxOGyTMA,918
 docling_core/transforms/serializer/__init__.py,sha256=CECQlMoCDUxkg4RAUdC3itA3I3qFhKhe2HcYghN6_xw,105
 docling_core/transforms/serializer/base.py,sha256=TI8Epj7gyxdTet9j-Rs4o5U09gfACfAIVoirlschviM,7266
-docling_core/transforms/serializer/common.py,sha256=0TNEGoA_rJ-qkVYp-X8SMUr3jTrbf6TRzPzwufYh5JM,19114
-docling_core/transforms/serializer/doctags.py,sha256=TD0yAm1qSVy-GsE6svpUAI-Yqjcf2rrTZ3ac9YU3gbE,19858
-docling_core/transforms/serializer/html.py,sha256=KnSMjtNZlBMfkuhtgB8T70iQSTfG_E8FFDfVRRo9WNs,38087
+docling_core/transforms/serializer/common.py,sha256=RwfdzZ9FRSHQjKM0vskg1CVqar0Z_ms38arSlLAgITc,19150
+docling_core/transforms/serializer/doctags.py,sha256=VXPjAZPhBur7LaEeuqH9k31TgZWSN32lK8z8rJXzFwY,19935
+docling_core/transforms/serializer/html.py,sha256=GRfRaqFIb4FXRMplB4Agl4fSNa5jsHV7P4tBtFMro9I,38453
 docling_core/transforms/serializer/html_styles.py,sha256=-jBwS4EU7yfKoz0GSoxhwx90OmIKieO6TwPw57IuxcA,4692
-docling_core/transforms/serializer/markdown.py,sha256=VwonuAkuOPmQM7ibDIGvQBHOqhTcTJ_t187fLQQiNPo,23951
+docling_core/transforms/serializer/markdown.py,sha256=hilGM1yWpbbRTjuEjfBRrhavspD5vFF_6SDvlKx8BrM,24230
 docling_core/transforms/visualizer/__init__.py,sha256=gUfF25yiJ_KO46ZIUNqZQOZGy2PLx6gnnr6AZYxKHXI,35
 docling_core/transforms/visualizer/base.py,sha256=aEF7b3rHq6DVdX8zDYEPoq55BHDYe4Hh_97lBdcW4lY,555
 docling_core/transforms/visualizer/key_value_visualizer.py,sha256=fp7nFLy4flOSiavdRgg5y1Mu7WVLIDGh1zEHsq8kgVM,8979
@@ -41,13 +41,13 @@ docling_core/transforms/visualizer/reading_order_visualizer.py,sha256=muqmaxOBao
 docling_core/transforms/visualizer/table_visualizer.py,sha256=iJPjk-XQSSCH3oujcjPMz-redAwNNHseZ41lFyd-u3k,8097
 docling_core/types/__init__.py,sha256=MVRSgsk5focwGyAplh_TRR3dEecIXpd98g_u3zZ5HXo,260
 docling_core/types/base.py,sha256=PusJskRVL19y-hq0BgXr5e8--QEqSqLnFNJ8UbOqW88,8318
-docling_core/types/doc/__init__.py,sha256=8hOhm5W9mArf3zwgfoMxDs1pHizhLFSAZlLu1tPBBRk,1641
+docling_core/types/doc/__init__.py,sha256=Vsl3oJV3_BLpS7rIwvahhcWOwmEBvj7ZbQzQCCl-IQk,1678
 docling_core/types/doc/base.py,sha256=i98y4IF250adR-8BSS374K90fwfwG-vBfWh14tLC5Cs,15906
-docling_core/types/doc/document.py,sha256=-cL4eGFRbQHgXAsCG8zALxAx-IoanvkqG5E1zvKOMxI,201012
+docling_core/types/doc/document.py,sha256=Ab-JOc6fkzocXP3PcxPRXJPjLOhOTYo_0571vSr6VXo,202093
 docling_core/types/doc/labels.py,sha256=-W1-LW6z0J9F9ExJqR0Wd1WeqWTaY3Unm-j1UkQGlC4,7330
 docling_core/types/doc/page.py,sha256=35h1xdtCM3-AaN8Dim9jDseZIiw-3GxpB-ofF-H2rQQ,41878
 docling_core/types/doc/tokens.py,sha256=z22l9J81_sg9CYMvOuLmPuLsNT7h_s7wao2UT89DvI8,9278
-docling_core/types/doc/utils.py,sha256=JpAi7x9DHksFlIj_gRJPcSZOHa8AHvVPEO_K9aSnw4c,2608
+docling_core/types/doc/utils.py,sha256=wKC9SJgS4ZKdoYPAlNuRyncv9RIEewzVCBmwbUmbA6E,9106
 docling_core/types/gen/__init__.py,sha256=C6TuCfvpSnSL5XDOFMcYHUY2-i08vvfOGRcdu6Af0pI,124
 docling_core/types/gen/generic.py,sha256=l4CZ4_Lb8ONG36WNJWbKX5hGKvTh_yU-hXp5hsm7uVU,844
 docling_core/types/io/__init__.py,sha256=7QYvFRaDE0AzBg8e7tvsVNlLBbCbAbQ9rP2TU8aXR1k,350
@@ -73,12 +73,12 @@ docling_core/utils/alias.py,sha256=B6Lqvss8CbaNARHLR4qSmNh9OkB6LvqTpxfsFmkLAFo,8
 docling_core/utils/file.py,sha256=CSNclJGL2OwLIc8DQFdoLxr22FUc4_UC7zS6pNrFfkQ,6858
 docling_core/utils/generate_docs.py,sha256=BdKAoduWXOc7YMvcmlhjoJOFlUxij1ybxglj6LZDtC8,2290
 docling_core/utils/generate_jsonschema.py,sha256=uNX1O5XnjyB5nA66XqZXTt3YbGuR2tyi_OhHepHYtZg,1654
-docling_core/utils/legacy.py,sha256=5lghO48OEcV9V51tRnH3YSKgLtdqhr-Q5C_OcJZ8TOs,24392
+docling_core/utils/legacy.py,sha256=G7ed8fkBpIO8hG3DKEY83cHsrKJHyvDst_1jSdgBXMI,24406
 docling_core/utils/validate.py,sha256=aQ11UbFyl8iD_N7yTTZmm_VVeXz8KcCyn3GLXgkfYRM,2049
 docling_core/utils/validators.py,sha256=azcrndLzhNkTWnbFSu9shJ5D3j_znnLrIFA5R8hzmGU,2798
-docling_core-2.44.2.dist-info/licenses/LICENSE,sha256=2M9-6EoQ1sxFztTOkXGAtwUDJvnWaAHdB9BYWVwGkIw,1087
-docling_core-2.44.2.dist-info/METADATA,sha256=IZWVMKuPPpzd3ksiFXTPUu3FSw13zuwa5qyaLWlBEyY,6453
-docling_core-2.44.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-docling_core-2.44.2.dist-info/entry_points.txt,sha256=ER4zROQWkFMHIrY-oqY5E4HeCcCIg8dLkNztYGxdb7c,59
-docling_core-2.44.2.dist-info/top_level.txt,sha256=O-tcXpGiurlud-1ZxMq1b-OmrfAVA4sajcgWU32RtfA,13
-docling_core-2.44.2.dist-info/RECORD,,
+docling_core-2.46.0.dist-info/licenses/LICENSE,sha256=2M9-6EoQ1sxFztTOkXGAtwUDJvnWaAHdB9BYWVwGkIw,1087
+docling_core-2.46.0.dist-info/METADATA,sha256=txMHh-7y8N3RiJ_M_HbrsvzRyGPJVXv8UcA6_DpAfok,6453
+docling_core-2.46.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+docling_core-2.46.0.dist-info/entry_points.txt,sha256=ER4zROQWkFMHIrY-oqY5E4HeCcCIg8dLkNztYGxdb7c,59
+docling_core-2.46.0.dist-info/top_level.txt,sha256=O-tcXpGiurlud-1ZxMq1b-OmrfAVA4sajcgWU32RtfA,13
+docling_core-2.46.0.dist-info/RECORD,,