docling-core 2.77.0__tar.gz → 2.78.0__tar.gz

{docling_core-2.77.0 → docling_core-2.78.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-core
-Version: 2.77.0
+Version: 2.78.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.77.0 → docling_core-2.78.0}/docling_core/transforms/chunker/hierarchical_chunker.py

@@ -6,6 +6,7 @@ import logging
 from collections.abc import Iterator
 from typing import Annotated, Any, Optional, Union
 
+import pandas as pd
 from pydantic import ConfigDict, Field
 from typing_extensions import override
 
@@ -45,6 +46,25 @@ _logger = logging.getLogger(__name__)
 class TripletTableSerializer(BaseTableSerializer):
     """Triplet-based table item serializer."""
 
+    @staticmethod
+    def _flatten_table_text(table_df: pd.DataFrame) -> str:
+        """Last-resort fallback that turns a table into plain text.
+
+        The preferred output of this serializer is the triplet form
+        'row, column = value'. When that comes out empty - for example on
+        single-cell RichTableCell layout tables where the header and row
+        labels are blank - we fall back to this helper so the table still
+        contributes something chunkable and does not end up consuming its
+        sibling refs.
+
+        Cells are read row by row, blanks are skipped, and the remaining
+        values are joined with '. '. So a table like [['A', ''], ['B', 'C']]
+        becomes 'A. B. C'.
+        """
+        return ". ".join(
+            text for row in table_df.itertuples(index=False, name=None) for value in row if (text := str(value).strip())
+        )
+
     @override
     def serialize(
         self,
@@ -56,6 +76,7 @@ class TripletTableSerializer(BaseTableSerializer):
     ) -> SerializationResult:
         """Serializes the passed item."""
         parts: list[SerializationResult] = []
+        shared_visited = kwargs.get("visited")
 
         cap_res = doc_serializer.serialize_captions(
             item=item,
@@ -65,40 +86,60 @@ class TripletTableSerializer(BaseTableSerializer):
             parts.append(cap_res)
 
         if item.self_ref not in doc_serializer.get_excluded_refs(**kwargs):
+            table_text = ""
+            local_kwargs = {**kwargs, "visited": set(shared_visited)} if shared_visited is not None else kwargs
             table_df = item._export_to_dataframe_with_options(
                 doc,
                 doc_serializer=doc_serializer,
-                **kwargs,
+                **local_kwargs,
             )
+
+            # Header-only tables produce a dataframe with 0 rows. Emit the
+            # header text directly instead of dropping the table on the floor.
+            if table_df.shape[0] == 0 and len(table_df.columns) > 0:
+                table_text = ". ".join(text for col in table_df.columns if (text := str(col).strip()))
+
             if table_df.shape[0] >= 1 and table_df.shape[1] >= 1:
+                fallback_df = table_df
                 # Handle single-column tables
                 if table_df.shape[1] == 1:
                     # For single-column tables, use first row as column name
                     # and remaining rows as values
                     col_name = str(table_df.iloc[0, 0]).strip()
                     values = [str(val).strip() for val in table_df.iloc[1:, 0].to_list()]
-                    table_text_parts = [f"{col_name} = {val}" for val in values]
-                    table_text = ". ".join(table_text_parts)
-                    parts.append(create_ser_result(text=table_text, span_source=item))
+                    if values:
+                        table_text_parts = [f"{col_name} = {val}" for val in values]
+                        table_text = ". ".join(table_text_parts)
+                    else:
+                        # Single-row single-column table: emit the cell text
+                        table_text = col_name
                 else:
                     # For multi-column tables
                     # copy header as first row and shift all rows by one
-                    table_df.loc[-1] = table_df.columns  # type: ignore[call-overload]
-                    table_df.index = table_df.index + 1
-                    table_df = table_df.sort_index()
+                    triplet_df = table_df.copy()
+                    triplet_df.loc[-1] = triplet_df.columns  # type: ignore[call-overload]
+                    triplet_df.index = triplet_df.index + 1
+                    triplet_df = triplet_df.sort_index()
 
-                    rows = [str(item).strip() for item in table_df.iloc[:, 0].to_list()]
-                    cols = [str(item).strip() for item in table_df.iloc[0, :].to_list()]
+                    rows = [str(item).strip() for item in triplet_df.iloc[:, 0].to_list()]
+                    cols = [str(item).strip() for item in triplet_df.iloc[0, :].to_list()]
 
-                    nrows = table_df.shape[0]
-                    ncols = table_df.shape[1]
+                    nrows = triplet_df.shape[0]
+                    ncols = triplet_df.shape[1]
                     table_text_parts = [
-                        f"{rows[i]}, {cols[j]} = {str(table_df.iloc[i, j]).strip()}"
+                        f"{rows[i]}, {cols[j]} = {str(triplet_df.iloc[i, j]).strip()}"
                         for i in range(1, nrows)
                         for j in range(1, ncols)
                     ]
                     table_text = ". ".join(table_text_parts)
-                    parts.append(create_ser_result(text=table_text, span_source=item))
+
+                if not table_text:
+                    table_text = self._flatten_table_text(fallback_df)
+
+            if table_text:
+                if shared_visited is not None:
+                    shared_visited.update(local_kwargs["visited"])
+                parts.append(create_ser_result(text=table_text, span_source=item))
 
         text_res = "\n\n".join([r.text for r in parts])
 

{docling_core-2.77.0 → docling_core-2.78.0}/docling_core/transforms/serializer/html.py

@@ -230,7 +230,7 @@ class HTMLTextSerializer(BaseModel, BaseTextSerializer):
             # Regular text item
             text = get_html_tag_with_text_direction(html_tag="p", text=text)
 
-        # Apply formatting and hyperlinks
+        # Apply formatting and hyperlinks to the parent's own text+tag.
         if not post_processed:
             text = doc_serializer.post_process(
                 text=text,
@@ -238,6 +238,23 @@ class HTMLTextSerializer(BaseModel, BaseTextSerializer):
                 hyperlink=item.hyperlink,
             )
 
+        # Recurse into children for branches that don't already consume them.
+        # has_inline_repr already consumed the single InlineGroup child; ListItem
+        # recursion is handled inline in its branch above.
+        if not has_inline_repr and not isinstance(item, ListItem) and item.children:
+            nested_text = "\n".join(
+                r.text
+                for r in doc_serializer.get_parts(
+                    item=item,
+                    is_inline_scope=is_inline_scope,
+                    visited=my_visited,
+                    **kwargs,
+                )
+                if r.text
+            )
+            if nested_text:
+                text = f"{text}\n{nested_text}" if text else nested_text
+
         if text:
             text_res = create_ser_result(text=text, span_source=item)
             res_parts.append(text_res)
@@ -945,6 +962,8 @@ class HTMLMetaSerializer(BaseModel, BaseMetaSerializer):
 
     def _serialize_meta_field(self, meta: BaseMeta, name: str) -> Optional[str]:
         if (field_val := getattr(meta, name)) is not None:
+            is_html_markup = False
+
             if isinstance(field_val, SummaryMetaField):
                 txt = field_val.text
             elif isinstance(field_val, LanguageMetaField):
@@ -952,14 +971,13 @@ class HTMLMetaSerializer(BaseModel, BaseMetaSerializer):
             elif isinstance(field_val, EntitiesMetaField):
                 txt = ", ".join(
                     (
-                        f"{html.escape(mention.text)} "
-                        f"({html.escape(mention.label)}, [{mention.charspan[0]},{mention.charspan[1]}])"
+                        f"{mention.text} ({mention.label}, [{mention.charspan[0]},{mention.charspan[1]}])"
                         if mention.label is not None and mention.charspan
-                        else f"{html.escape(mention.text)} ({html.escape(mention.label)})"
+                        else f"{mention.text} ({mention.label})"
                         if mention.label is not None
-                        else f"{html.escape(mention.text)} ([{mention.charspan[0]},{mention.charspan[1]}])"
+                        else f"{mention.text} ([{mention.charspan[0]},{mention.charspan[1]}])"
                         if mention.charspan
-                        else html.escape(mention.text)
+                        else mention.text
                     )
                     for mention in field_val.mentions
                 )
@@ -975,19 +993,30 @@ class HTMLMetaSerializer(BaseModel, BaseMetaSerializer):
                 table_content = temp_table.export_to_html(temp_doc).strip()
                 if table_content:
                     txt = table_content
+                    is_html_markup = True
                 else:
                     return None
             elif isinstance(field_val, CodeMetaField):
                 lang = field_val.language.value.lower() if field_val.language else ""
-                code_class = f' class="language-{html.escape(lang)}"' if lang else ""
-                txt = f'<pre class="docling-meta-code"><code{code_class}>{html.escape(field_val.text)}</code></pre>'
+                escaped_lang = html.escape(lang)
+                escaped_code = html.escape(field_val.text)
+                code_class = f' class="language-{escaped_lang}"' if lang else ""
+                txt = f'<pre class="docling-meta-code"><code{code_class}>{escaped_code}</code></pre>'
+                is_html_markup = True
             elif tmp := str(field_val or ""):
                 txt = tmp
             else:
                 return None
+
+            # Escape plain text content for safe HTML output.
+            # HTML markup fields (TabularChartMetaField, CodeMetaField) are already properly formatted.
+            if not is_html_markup:
+                txt = html.escape(txt, quote=False)
+
+            escaped_name = html.escape(name, quote=True)
             return (
-                f'<div class="docling-meta-field" data-meta-{name}>'
-                f'<span class="docling-meta-field-label">{name}:</span> '
+                f'<div class="docling-meta-field" data-meta-name="{escaped_name}">'
+                f'<span class="docling-meta-field-label">{escaped_name}:</span> '
                 f'<span class="docling-meta-field-value">{txt}</span>'
                 f"</div>"
             )

{docling_core-2.77.0 → docling_core-2.78.0}/docling_core/transforms/serializer/html_styles.py

@@ -113,9 +113,6 @@ def _get_css_for_split_page() -> str:
         font-weight: bold;
         color: #444;
     }
-    .docling-meta-field[data-meta-classification] {
-        text-align: left;
-    }
     pre.docling-meta-code {
         background-color: #1e1e1e;
         color: #d4d4d4;
@@ -287,9 +284,6 @@ def _get_css_for_single_column() -> str:
         font-weight: bold;
         color: #444;
     }
-    .docling-meta-field[data-meta-classification] {
-        text-align: left;
-    }
     pre.docling-meta-code {
         background-color: #1e1e1e;
         color: #d4d4d4;

{docling_core-2.77.0 → docling_core-2.78.0}/docling_core/types/doc/__init__.py

@@ -43,6 +43,7 @@ from .document import (
     MoleculeMetaField,
     NodeItem,
     OrderedList,
+    Orientation,
     PageItem,
     PictureBarChartData,
     PictureChartData,

{docling_core-2.77.0 → docling_core-2.78.0}/docling_core/types/doc/document.py

@@ -385,12 +385,28 @@ AnyTableCell = Annotated[
 ]
 
 
+class Orientation(str, Enum):
+    """Counter-clockwise rotation of a table on the page, in degrees.
+
+    Follows the convention used by PIL/Pillow's ``Image.rotate``: positive
+    angles rotate the table counter-clockwise. ``ROT_0`` / ``ROT_180`` keep
+    rows running horizontally on the page; ``ROT_90`` / ``ROT_270`` turn
+    rows into vertical stripes.
+    """
+
+    ROT_0 = "rot_0"  # no rotation; row 0 at top, rows horizontal
+    ROT_90 = "rot_90"  # 90° CCW; row 0 on the left, rows are vertical stripes
+    ROT_180 = "rot_180"  # 180°; row 0 at bottom (upside-down), rows horizontal
+    ROT_270 = "rot_270"  # 270° CCW (= 90° CW); row 0 on the right, rows are vertical stripes
+
+
 class TableData(BaseModel):  # TBD
     """BaseTableData."""
 
     table_cells: list[AnyTableCell] = []
     num_rows: int = 0
     num_cols: int = 0
+    orientation: Orientation = Orientation.ROT_0
 
     @computed_field  # type: ignore
     @property
@@ -577,15 +593,23 @@ class TableData(BaseModel):  # TBD
     def get_row_bounding_boxes(self, *, minimal: bool = True) -> dict[int, BoundingBox]:
         """Get the bounding box for each row in the table.
 
+        Layout follows the table's ``orientation`` field: ``ROT_0`` / ``ROT_180``
+        keep rows running left-to-right on the page; ``ROT_90`` / ``ROT_270``
+        turn rows into vertical stripes. This affects both the axis along which
+        span cells extend a row's bbox and, when ``minimal=False``, the axis
+        equalized across rows.
+
         Args:
             minimal: If True (default), returns the minimal bounding box for each
-                row based on its cells. If False, all rows will have uniform
-                horizontal extent (same x0/x1 values) spanning the full table width.
+                row based on its cells. If False, all rows will have a uniform
+                extent perpendicular to the row direction (l/r for ROT_0/ROT_180,
+                t/b for ROT_90/ROT_270).
 
         Returns:
             dict[int, BoundingBox]: A dictionary mapping row indices to their
             bounding boxes. Only rows with cells that have bounding boxes are included.
         """
+        horizontal = self.orientation in (Orientation.ROT_0, Orientation.ROT_180)
         coords = []
         for cell in self.table_cells:
             if cell.bbox is not None:
@@ -616,35 +640,68 @@ class TableData(BaseModel):  # TBD
                 min_row_span = min(row_cells_with_bbox.keys())
                 row_bbox: BoundingBox = BoundingBox.enclosing_bbox(row_cells_with_bbox[min_row_span])
 
+                # Spanning cells extend along the row's natural axis:
+                # horizontal table → row runs l/r; vertical table → row runs t/b.
                 for rspan, bboxs in row_cells_with_bbox.items():
                     for bbox in bboxs:
-                        row_bbox.l = min(row_bbox.l, bbox.l)
-                        row_bbox.r = max(row_bbox.r, bbox.r)
+                        if horizontal:
+                            row_bbox.l = min(row_bbox.l, bbox.l)
+                            row_bbox.r = max(row_bbox.r, bbox.r)
+                        else:
+                            if bbox.coord_origin == CoordOrigin.TOPLEFT:
+                                row_bbox.t = min(row_bbox.t, bbox.t)
+                                row_bbox.b = max(row_bbox.b, bbox.b)
+                            else:  # BOTTOMLEFT
+                                row_bbox.t = max(row_bbox.t, bbox.t)
+                                row_bbox.b = min(row_bbox.b, bbox.b)
 
                 row_bboxes[row_idx] = row_bbox
 
-        # If not minimal, make all rows have uniform horizontal extent
+        # If not minimal, make all rows have uniform extent on the axis
+        # perpendicular to the row direction.
         if not minimal and row_bboxes:
-            global_l = min(bbox.l for bbox in row_bboxes.values())
-            global_r = max(bbox.r for bbox in row_bboxes.values())
-            for bbox in row_bboxes.values():
-                bbox.l = global_l
-                bbox.r = global_r
+            if horizontal:
+                # Rows run left-to-right; equalize horizontal extent.
+                global_l = min(bbox.l for bbox in row_bboxes.values())
+                global_r = max(bbox.r for bbox in row_bboxes.values())
+                for bbox in row_bboxes.values():
+                    bbox.l = global_l
+                    bbox.r = global_r
+            else:
+                # Vertical table: rows are vertical stripes; equalize vertical extent.
+                first_bbox = next(iter(row_bboxes.values()))
+                if first_bbox.coord_origin == CoordOrigin.TOPLEFT:
+                    global_t = min(bbox.t for bbox in row_bboxes.values())
+                    global_b = max(bbox.b for bbox in row_bboxes.values())
+                else:  # BOTTOMLEFT
+                    global_t = max(bbox.t for bbox in row_bboxes.values())
+                    global_b = min(bbox.b for bbox in row_bboxes.values())
+                for bbox in row_bboxes.values():
+                    bbox.t = global_t
+                    bbox.b = global_b
 
         return row_bboxes
 
     def get_column_bounding_boxes(self, *, minimal: bool = True) -> dict[int, BoundingBox]:
         """Get the bounding box for each column in the table.
 
+        Layout follows the table's ``orientation`` field: ``ROT_0`` / ``ROT_180``
+        keep columns running top-to-bottom on the page; ``ROT_90`` / ``ROT_270``
+        turn columns into horizontal stripes. This affects both the axis along
+        which span cells extend a column's bbox and, when ``minimal=False``, the
+        axis equalized across columns.
+
         Args:
             minimal: If True (default), returns the minimal bounding box for each
-                column based on its cells. If False, all columns will have uniform
-                vertical extent (same y0/y1 values) spanning the full table height.
+                column based on its cells. If False, all columns will have a
+                uniform extent perpendicular to the column direction (t/b for
+                ROT_0/ROT_180, l/r for ROT_90/ROT_270).
 
         Returns:
             dict[int, BoundingBox]: A dictionary mapping column indices to their
             bounding boxes. Only columns with cells that have bounding boxes are included.
         """
+        horizontal = self.orientation in (Orientation.ROT_0, Orientation.ROT_180)
         coords = []
         for cell in self.table_cells:
             if cell.bbox is not None:
@@ -675,31 +732,46 @@ class TableData(BaseModel):  # TBD
                 min_col_span = min(col_cells_with_bbox.keys())
                 col_bbox: BoundingBox = BoundingBox.enclosing_bbox(col_cells_with_bbox[min_col_span])
 
+                # Spanning cells extend along the column's natural axis:
+                # horizontal table → column runs t/b; vertical table → column runs l/r.
                 for rspan, bboxs in col_cells_with_bbox.items():
                     for bbox in bboxs:
-                        if bbox.coord_origin == CoordOrigin.TOPLEFT:
-                            col_bbox.b = max(col_bbox.b, bbox.b)
-                            col_bbox.t = min(col_bbox.t, bbox.t)
-
-                        elif bbox.coord_origin == CoordOrigin.BOTTOMLEFT:
-                            col_bbox.b = min(col_bbox.b, bbox.b)
-                            col_bbox.t = max(col_bbox.t, bbox.t)
+                        if horizontal:
+                            if bbox.coord_origin == CoordOrigin.TOPLEFT:
+                                col_bbox.b = max(col_bbox.b, bbox.b)
+                                col_bbox.t = min(col_bbox.t, bbox.t)
+                            elif bbox.coord_origin == CoordOrigin.BOTTOMLEFT:
+                                col_bbox.b = min(col_bbox.b, bbox.b)
+                                col_bbox.t = max(col_bbox.t, bbox.t)
+                        else:
+                            col_bbox.l = min(col_bbox.l, bbox.l)
+                            col_bbox.r = max(col_bbox.r, bbox.r)
 
                 col_bboxes[col_idx] = col_bbox
 
-        # If not minimal, make all columns have uniform vertical extent
+        # If not minimal, make all columns have uniform extent on the axis
+        # perpendicular to the column direction.
         if not minimal and col_bboxes:
-            # Get the coord_origin from the first bbox (they're all the same)
-            first_bbox = next(iter(col_bboxes.values()))
-            if first_bbox.coord_origin == CoordOrigin.TOPLEFT:
-                global_t = min(bbox.t for bbox in col_bboxes.values())
-                global_b = max(bbox.b for bbox in col_bboxes.values())
-            else:  # BOTTOMLEFT
-                global_t = max(bbox.t for bbox in col_bboxes.values())
-                global_b = min(bbox.b for bbox in col_bboxes.values())
-            for bbox in col_bboxes.values():
-                bbox.t = global_t
-                bbox.b = global_b
+            if horizontal:
+                # Columns run top-to-bottom; equalize vertical extent.
+                # Get the coord_origin from the first bbox (they're all the same)
+                first_bbox = next(iter(col_bboxes.values()))
+                if first_bbox.coord_origin == CoordOrigin.TOPLEFT:
+                    global_t = min(bbox.t for bbox in col_bboxes.values())
+                    global_b = max(bbox.b for bbox in col_bboxes.values())
+                else:  # BOTTOMLEFT
+                    global_t = max(bbox.t for bbox in col_bboxes.values())
+                    global_b = min(bbox.b for bbox in col_bboxes.values())
+                for bbox in col_bboxes.values():
+                    bbox.t = global_t
+                    bbox.b = global_b
+            else:
+                # Vertical table: columns are horizontal stripes; equalize horizontal extent.
+                global_l = min(bbox.l for bbox in col_bboxes.values())
+                global_r = max(bbox.r for bbox in col_bboxes.values())
+                for bbox in col_bboxes.values():
+                    bbox.l = global_l
+                    bbox.r = global_r
 
         return col_bboxes
 

{docling_core-2.77.0 → docling_core-2.78.0}/docling_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-core
-Version: 2.77.0
+Version: 2.78.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.77.0 → docling_core-2.78.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "docling-core"
-version = "2.77.0"  # DO NOT EDIT, updated automatically
+version = "2.78.0"  # DO NOT EDIT, updated automatically
 description = "A python library to define and validate data types in Docling."
 license = "MIT"
 license-files = ["LICENSE"]
@@ -113,7 +113,7 @@ dev = [
     "pandas-stubs~=2.1",
     "ipykernel~=6.29",
     "coverage~=7.6",
-    "pytest~=8.3",
+    "pytest~=9.0.3",
     "pytest-cov>=6.1.1",
     "python-semantic-release~=7.32",
     'tree-sitter-java-orchard (>=0.3.0,<1.0.0); python_version >= "3.10"',