docling-core 2.97.1__tar.gz → 2.97.2__tar.gz

{docling_core-2.97.1 → docling_core-2.97.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-core
-Version: 2.97.1
+Version: 2.97.2
 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.97.1 → docling_core-2.97.2}/docling_core/transforms/deserializer/doclang.py

@@ -137,6 +137,8 @@ class DocLangDocDeserializer(BaseDocDeserializer, BaseModel):
     # Internal state used while walking the tree (private instance attributes)
     _page_no: int = PrivateAttr(default=1)
     _default_resolution: int = PrivateAttr(default=DOCLANG_DFLT_RESOLUTION)
+    _default_page_width: int = PrivateAttr(default=DOCLANG_DFLT_RESOLUTION)
+    _default_page_height: int = PrivateAttr(default=DOCLANG_DFLT_RESOLUTION)
     _thread_registry: dict[tuple[str, str], NodeItem] = PrivateAttr(default_factory=dict)
     _media_root: Path | None = PrivateAttr(default=None)
     _max_xml_bytes: int = PrivateAttr(default=settings.max_doclang_xml_bytes)
@@ -205,8 +207,11 @@ class DocLangDocDeserializer(BaseDocDeserializer, BaseModel):
         doc = DoclingDocument(name="Document")
         self._page_no = page_no
         self._default_resolution = DOCLANG_DFLT_RESOLUTION
+        self._default_page_width = DOCLANG_DFLT_RESOLUTION
+        self._default_page_height = DOCLANG_DFLT_RESOLUTION
+        self._apply_default_resolution(root)
         self._thread_registry = {}
-        self._ensure_page_exists(doc=doc, page_no=self._page_no, resolution=self._default_resolution)
+        self._ensure_page_exists(doc=doc, page_no=self._page_no)
         self._parse_document_root(doc=doc, root=root)
         return doc
 
@@ -232,7 +237,7 @@ class DocLangDocDeserializer(BaseDocDeserializer, BaseModel):
 
     def _advance_page_break(self, *, doc: DoclingDocument) -> None:
         self._page_no += 1
-        self._ensure_page_exists(doc=doc, page_no=self._page_no, resolution=self._default_resolution)
+        self._ensure_page_exists(doc=doc, page_no=self._page_no)
 
     def _provenance_from_nodes_with_page_breaks(
         self,
@@ -320,9 +325,9 @@ class DocLangDocDeserializer(BaseDocDeserializer, BaseModel):
         }:
             self._parse_text_like(doc=doc, el=el, parent=parent)
         elif name == DocLangToken.PAGE_BREAK.value:
-            # Start a new page; keep a default square page using the configured resolution
+            # Start a new page using the document's declared default resolution
             self._page_no += 1
-            self._ensure_page_exists(doc=doc, page_no=self._page_no, resolution=self._default_resolution)
+            self._ensure_page_exists(doc=doc, page_no=self._page_no)
             self._source_recorder.bind_page(el, self._page_no)
         elif name == DocLangToken.HEADING.value:
             self._parse_heading(doc=doc, el=el, parent=parent)
@@ -1291,7 +1296,7 @@ class DocLangDocDeserializer(BaseDocDeserializer, BaseModel):
 
             is_virtual_text = self._is_list_item_virtual_text(all_content_nodes)
 
-            if not all_content_nodes:
+            if self._first_non_whitespace_node(all_content_nodes) is None:
                 # Empty list item (just ldiv, no content)
                 doc.add_list_item(
                     text="",
@@ -2183,10 +2188,36 @@ class DocLangDocDeserializer(BaseDocDeserializer, BaseModel):
         return "".join(out)
 
     # --------- Location helpers ---------
-    def _ensure_page_exists(self, *, doc: DoclingDocument, page_no: int, resolution: int) -> None:
-        # If the page already exists, do nothing; otherwise add with a square size based on resolution
-        if page_no not in doc.pages:
-            doc.add_page(page_no=page_no, size=Size(width=resolution, height=resolution))
+    def _ensure_page_exists(self, *, doc: DoclingDocument, page_no: int, resolution: int | None = None) -> None:
+        # If the page already exists, do nothing. A per-<location> resolution attribute
+        # (rare/legacy) forces a square page; otherwise use the document default size,
+        # which honours a non-square <default_resolution>.
+        if page_no in doc.pages:
+            return
+        if resolution is not None:
+            size = Size(width=resolution, height=resolution)
+        else:
+            size = Size(width=self._default_page_width, height=self._default_page_height)
+        doc.add_page(page_no=page_no, size=size)
+
+    def _apply_default_resolution(self, root: Element) -> None:
+        """Read <default_resolution width height/> so pages use the declared coordinate space."""
+        elems = root.getElementsByTagName("default_resolution")
+        if not elems:
+            return
+        el = cast(Element, elems[0])
+        try:
+            width = int(el.getAttribute("width") or 0)
+            height = int(el.getAttribute("height") or 0)
+        except ValueError:
+            return
+        if width > 0:
+            self._default_page_width = width
+        if height > 0:
+            self._default_page_height = height
+        # Scalar fallback for <location resolution="..."> value space (square docs only).
+        if width > 0:
+            self._default_resolution = width
 
     def _extract_provenance(self, *, doc: DoclingDocument, el: Element) -> list[ProvenanceItem]:
         head_nodes, _ = self._split_element_children_head_body(el)

{docling_core-2.97.1 → docling_core-2.97.2}/docling_core/transforms/serializer/common.py

@@ -52,6 +52,7 @@ from docling_core.types.doc import (
     PictureDataType,
     PictureItem,
     PictureMoleculeData,
+    RichTableCell,
     Script,
     TableAnnotationType,
     TableItem,
@@ -188,7 +189,8 @@ class CommonParams(BaseModel):
     """Common serialization parameters."""
 
     # allowlists with non-recursive semantics, i.e. if a list group node is outside the
-    # range and some of its children items are within, they will be serialized
+    # range and some of its children items are within, they will be serialized.
+    # Table cell subtrees are content of their table and are excluded with it.
     labels: set[DocItemLabel] = _DEFAULT_LABELS
     layers: set[ContentLayer] = _DEFAULT_LAYERS
     pages: set[int] | None = None  # None means all pages are allowed
@@ -313,6 +315,22 @@ class DocSerializer(BaseModel, BaseDocSerializer):
                     )
                 )
             }
+            # Rich cells own subtrees, unlike plain cells whose content lives in data.
+            # Exclude both representations with the table; leave captions independent.
+            for table in self.doc.tables:
+                if table.self_ref in refs or table.content_layer not in params.layers:
+                    refs.add(table.self_ref)
+                    for cell in table.data.table_cells:
+                        if isinstance(cell, RichTableCell):
+                            refs.update(
+                                node.self_ref
+                                for node, _ in self.doc.iterate_items(
+                                    root=cell.ref.resolve(self.doc),
+                                    with_groups=True,
+                                    traverse_pictures=True,
+                                    included_content_layers=set(ContentLayer),
+                                )
+                            )
             self._excluded_refs_cache[params_json] = refs
         return refs
 

{docling_core-2.97.1 → docling_core-2.97.2}/docling_core/transforms/serializer/markdown.py

@@ -107,33 +107,39 @@ def _mark_subtree_visited(
             _mark_subtree_visited(child_ref.resolve(doc=doc), doc, visited)
 
 
-def _collect_subtree_text(item: NodeItem, doc: DoclingDocument) -> str:
+def _collect_subtree_text(item: NodeItem, doc: DoclingDocument, excluded_refs: set[str]) -> str:
     """Collect all text from *item*'s subtree, flattening nested tables.
 
     Returns a space-joined string of every piece of text found so that the
     content of a nested table is preserved in a flat, readable form.
 
     For TableItems the text is pulled from ``data.grid`` cells directly;
-    children are *not* recursed into because they duplicate the grid content
-    for RichTableCells.  For all other items, ``.text`` is collected and
-    children are visited recursively.
+    RichTableCells are resolved through their references, without visiting the
+    table children again. Exclusions apply during flattening just as they do
+    during normal serialization.
     """
     parts: list[str] = []
 
     if isinstance(item, TableItem):
+        if item.self_ref in excluded_refs:
+            return ""
         for row in item.data.grid:
             for cell in row:
-                if cell.text:
-                    parts.append(cell.text)
+                if isinstance(cell, RichTableCell):
+                    cell_text = _collect_subtree_text(cell.ref.resolve(doc), doc, excluded_refs)
+                else:
+                    cell_text = cell.text
+                if cell_text:
+                    parts.append(cell_text)
         return " ".join(parts)
 
-    if isinstance(item, TextItem) and item.text:
+    if isinstance(item, TextItem) and item.self_ref not in excluded_refs and item.text:
         parts.append(item.text)
 
     if isinstance(item, NodeItem):
         for child_ref in item.children:
             child = child_ref.resolve(doc=doc)
-            child_text = _collect_subtree_text(child, doc)
+            child_text = _collect_subtree_text(child, doc, excluded_refs)
             if child_text:
                 parts.append(child_text)
 
@@ -715,7 +721,7 @@ class MarkdownTableSerializer(BaseTableSerializer):
             visited: set[str] = kwargs.get("visited") or set()
             _mark_subtree_visited(item, doc, visited)
             return create_ser_result(
-                text=_collect_subtree_text(item, doc),
+                text=_collect_subtree_text(item, doc, doc_serializer.get_excluded_refs(**kwargs)),
                 span_source=item,
             )
 

{docling_core-2.97.1 → docling_core-2.97.2}/docling_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-core
-Version: 2.97.1
+Version: 2.97.2
 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.97.1 → docling_core-2.97.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "docling-core"
-version = "2.97.1"  # DO NOT EDIT, updated automatically
+version = "2.97.2"  # DO NOT EDIT, updated automatically
 description = "A python library to define and validate data types in Docling."
 license = "MIT"
 license-files = ["LICENSE"]

{docling_core-2.97.1 → docling_core-2.97.2}/tests/test_deserializer_doclang.py

@@ -795,6 +795,27 @@ def test_roundtrip_nested_list_unordered_in_unordered():
     assert dt2 == dt
 
 
+def test_deserialize_locationless_list_with_empty_item_and_formula():
+    doc = _deserialize(
+        """
+<doclang>
+  <list>
+    <ldiv/>
+    <ldiv/>
+    A.
+    <formula>f(x)</formula>
+    is odd
+  </list>
+</doclang>
+"""
+    )
+
+    assert [item.text for item in doc.texts] == ["", "", "A.", "f(x)", "is odd"]
+    assert doc.texts[3].label == DocItemLabel.FORMULA
+    assert all(not item.prov for item in doc.texts)
+    assert "<location" not in _serialize(doc)
+
+
 def test_roundtrip_nested_list_ordered_in_ordered():
     """Test nested ordered list within ordered list."""
     doc = DoclingDocument(name="t")
@@ -2410,3 +2431,29 @@ def test_unnamed_group_markup_still_wraps_floats() -> None:
     doc = _deserialize(xml, validate=False)
     assert doc.groups == []
     assert len(doc.pictures) == 1
+
+
+def test_default_resolution_sets_page_coordinate_space():
+    """<default_resolution> establishes the page size so locations are not clamped."""
+    import warnings
+
+    xml = (
+        '<doclang version="0.7">'
+        '<head><default_resolution width="2048" height="2048"/></head>'
+        "<text>"
+        '<location value="27"/><location value="14"/>'
+        '<location value="1316"/><location value="1900"/>'
+        "<content>Hello</content></text>"
+        "</doclang>"
+    )
+    doc = _deserialize(xml, validate=False)
+
+    assert doc.pages[1].size.width == 2048
+    assert doc.pages[1].size.height == 2048
+    bbox = doc.texts[0].prov[0].bbox
+    assert (bbox.l, bbox.t, bbox.r, bbox.b) == (27, 14, 1316, 1900)
+
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("always")
+        DoclingDocument.validate_document(doc)
+    assert [w for w in caught if "clamping" in str(w.message)] == []