docling 2.42.0__py3-none-any.whl → 2.42.2__py3-none-any.whl

docling/backend/html_backend.py

@@ -1,4 +1,5 @@
 import logging
+import re
 import traceback
 from io import BytesIO
 from pathlib import Path
@@ -15,6 +16,7 @@ from docling_core.types.doc import (
     GroupLabel,
     TableCell,
     TableData,
+    TextItem,
 )
 from docling_core.types.doc.document import ContentLayer
 from pydantic import BaseModel
@@ -26,10 +28,14 @@ from docling.datamodel.document import InputDocument
 
 _log = logging.getLogger(__name__)
 
-# tags that generate NodeItem elements
-TAGS_FOR_NODE_ITEMS: Final = [
+DEFAULT_IMAGE_WIDTH = 128
+DEFAULT_IMAGE_HEIGHT = 128
+
+# Tags that initiate distinct Docling items
+_BLOCK_TAGS: Final = {
     "address",
     "details",
+    "figure",
     "h1",
     "h2",
     "h3",
@@ -41,12 +47,9 @@ TAGS_FOR_NODE_ITEMS: Final = [
     "code",
     "ul",
     "ol",
-    "li",
     "summary",
     "table",
-    "figure",
-    "img",
-]
+}
 
 
 class _Context(BaseModel):
@@ -56,12 +59,16 @@ class _Context(BaseModel):
 
 class HTMLDocumentBackend(DeclarativeDocumentBackend):
     @override
-    def __init__(self, in_doc: "InputDocument", path_or_stream: Union[BytesIO, Path]):
+    def __init__(
+        self,
+        in_doc: InputDocument,
+        path_or_stream: Union[BytesIO, Path],
+    ):
         super().__init__(in_doc, path_or_stream)
         self.soup: Optional[Tag] = None
-        # HTML file:
         self.path_or_stream = path_or_stream
-        # Initialise the parents for the hierarchy
+
+        # Initialize the parents for the hierarchy
         self.max_levels = 10
         self.level = 0
         self.parents: dict[int, Optional[Union[DocItem, GroupItem]]] = {}
@@ -70,13 +77,12 @@ class HTMLDocumentBackend(DeclarativeDocumentBackend):
             self.parents[i] = None
 
         try:
-            if isinstance(self.path_or_stream, BytesIO):
-                text_stream = self.path_or_stream.getvalue()
-                self.soup = BeautifulSoup(text_stream, "html.parser")
-            if isinstance(self.path_or_stream, Path):
-                with open(self.path_or_stream, "rb") as f:
-                    html_content = f.read()
-                    self.soup = BeautifulSoup(html_content, "html.parser")
+            raw = (
+                path_or_stream.getvalue()
+                if isinstance(path_or_stream, BytesIO)
+                else Path(path_or_stream).read_bytes()
+            )
+            self.soup = BeautifulSoup(raw, "html.parser")
         except Exception as e:
             raise RuntimeError(
                 "Could not initialize HTML backend for file with "
@@ -96,7 +102,6 @@ class HTMLDocumentBackend(DeclarativeDocumentBackend):
     def unload(self):
         if isinstance(self.path_or_stream, BytesIO):
             self.path_or_stream.close()
-
         self.path_or_stream = None
 
     @classmethod
@@ -106,211 +111,156 @@ class HTMLDocumentBackend(DeclarativeDocumentBackend):
 
     @override
     def convert(self) -> DoclingDocument:
-        # access self.path_or_stream to load stuff
+        _log.debug("Starting HTML conversion...")
+        if not self.is_valid():
+            raise RuntimeError("Invalid HTML document.")
+
         origin = DocumentOrigin(
             filename=self.file.name or "file",
             mimetype="text/html",
             binary_hash=self.document_hash,
         )
-
         doc = DoclingDocument(name=self.file.stem or "file", origin=origin)
-        _log.debug("Trying to convert HTML...")
-
-        if self.is_valid():
-            assert self.soup is not None
-            content = self.soup.body or self.soup
-            # Replace <br> tags with newline characters
-            # TODO: remove style to avoid losing text from tags like i, b, span, ...
-            for br in content("br"):
-                br.replace_with(NavigableString("\n"))
-
-            headers = content.find(["h1", "h2", "h3", "h4", "h5", "h6"])
-            self.content_layer = (
-                ContentLayer.BODY if headers is None else ContentLayer.FURNITURE
-            )
-            self.ctx = _Context()  # reset context
-            self.walk(content, doc)
-        else:
-            raise RuntimeError(
-                f"Cannot convert doc with {self.document_hash} because the backend "
-                "failed to init."
-            )
-        return doc
 
-    def walk(self, tag: Tag, doc: DoclingDocument) -> None:
-        # Iterate over elements in the body of the document
-        text: str = ""
-        for element in tag.children:
-            if isinstance(element, Tag):
-                try:
-                    self.analyze_tag(cast(Tag, element), doc)
-                except Exception as exc_child:
-                    _log.error(
-                        f"Error processing child from tag {tag.name}:\n{traceback.format_exc()}"
-                    )
-                    raise exc_child
-            elif isinstance(element, NavigableString) and not isinstance(
-                element, PreformattedString
-            ):
-                # Floating text outside paragraphs or analyzed tags
-                text += element
-                siblings: list[Tag] = [
-                    item for item in element.next_siblings if isinstance(item, Tag)
-                ]
-                if element.next_sibling is None or any(
-                    item.name in TAGS_FOR_NODE_ITEMS for item in siblings
-                ):
-                    text = text.strip()
-                    if text and tag.name in ["div"]:
-                        doc.add_text(
-                            parent=self.parents[self.level],
-                            label=DocItemLabel.TEXT,
-                            text=text,
-                            content_layer=self.content_layer,
-                        )
-                    text = ""
-
-        return
-
-    def analyze_tag(self, tag: Tag, doc: DoclingDocument) -> None:
-        if tag.name in ["h1", "h2", "h3", "h4", "h5", "h6"]:
-            self.handle_header(tag, doc)
-        elif tag.name in ["p", "address", "summary"]:
-            self.handle_paragraph(tag, doc)
-        elif tag.name in ["pre", "code"]:
-            self.handle_code(tag, doc)
-        elif tag.name in ["ul", "ol"]:
-            self.handle_list(tag, doc)
-        elif tag.name in ["li"]:
-            self.handle_list_item(tag, doc)
-        elif tag.name == "table":
-            self.handle_table(tag, doc)
-        elif tag.name == "figure":
-            self.handle_figure(tag, doc)
-        elif tag.name == "img":
-            self.handle_image(tag, doc)
-        elif tag.name == "details":
-            self.handle_details(tag, doc)
-        else:
-            self.walk(tag, doc)
-
-    def get_text(self, item: PageElement) -> str:
-        """Get the text content of a tag."""
-        parts: list[str] = self.extract_text_recursively(item)
-
-        return "".join(parts) + " "
-
-    # Function to recursively extract text from all child nodes
-    def extract_text_recursively(self, item: PageElement) -> list[str]:
-        result: list[str] = []
+        assert self.soup is not None
+        # set the title as furniture, since it is part of the document metadata
+        title = self.soup.title
+        if title:
+            doc.add_title(
+                text=title.get_text(separator=" ", strip=True),
+                content_layer=ContentLayer.FURNITURE,
+            )
+        # remove scripts/styles
+        for tag in self.soup(["script", "style"]):
+            tag.decompose()
+        content = self.soup.body or self.soup
+        # normalize <br> tags
+        for br in content("br"):
+            br.replace_with(NavigableString("\n"))
+        # set default content layer
+        headers = content.find(["h1", "h2", "h3", "h4", "h5", "h6"])
+        self.content_layer = (
+            ContentLayer.BODY if headers is None else ContentLayer.FURNITURE
+        )
+        # reset context
+        self.ctx = _Context()
 
-        if isinstance(item, NavigableString):
-            return [item]
+        try:
+            self._walk(content, doc)
+        except Exception:
+            print(traceback.format_exc())
 
-        tag = cast(Tag, item)
-        if tag.name not in ["ul", "ol"]:
-            for child in tag:
-                # Recursively get the child's text content
-                result.extend(self.extract_text_recursively(child))
+        return doc
 
-        return ["".join(result) + " "]
+    def _walk(self, element: Tag, doc: DoclingDocument) -> None:
+        """Parse an XML tag by recursively walking its content.
 
-    def handle_details(self, element: Tag, doc: DoclingDocument) -> None:
-        """Handle details tag (details) and its content."""
+        While walking, the method buffers inline text across tags like <b> or <span>,
+        emitting text nodes only at block boundaries.
 
-        self.parents[self.level + 1] = doc.add_group(
-            name="details",
-            label=GroupLabel.SECTION,
-            parent=self.parents[self.level],
-            content_layer=self.content_layer,
-        )
+        Args:
+            element: The XML tag to parse.
+            doc: The Docling document to be updated with the parsed content.
+        """
+        buffer: list[str] = []
+
+        def flush_buffer():
+            if not buffer:
+                return
+            text = "".join(buffer).strip()
+            buffer.clear()
+            if not text:
+                return
+            for part in text.split("\n"):
+                seg = part.strip()
+                if seg:
+                    doc.add_text(
+                        DocItemLabel.TEXT,
+                        seg,
+                        parent=self.parents[self.level],
+                        content_layer=self.content_layer,
+                    )
 
-        self.level += 1
-        self.walk(element, doc)
-        self.parents[self.level + 1] = None
-        self.level -= 1
+        for node in element.contents:
+            if isinstance(node, Tag):
+                name = node.name.lower()
+                if name == "img":
+                    flush_buffer()
+                    self._emit_image(node, doc)
+                elif name in _BLOCK_TAGS:
+                    flush_buffer()
+                    self._handle_block(node, doc)
+                elif node.find(_BLOCK_TAGS):
+                    flush_buffer()
+                    self._walk(node, doc)
+                else:
+                    buffer.append(node.text)
+            elif isinstance(node, NavigableString) and not isinstance(
+                node, PreformattedString
+            ):
+                buffer.append(str(node))
 
-    def handle_header(self, element: Tag, doc: DoclingDocument) -> None:
-        """Handles header tags (h1, h2, etc.)."""
-        hlevel = int(element.name.replace("h", ""))
-        text = element.text.strip()
+        flush_buffer()
 
+    def _handle_heading(self, tag: Tag, doc: DoclingDocument) -> None:
+        tag_name = tag.name.lower()
+        # set default content layer to BODY as soon as we encounter a heading
         self.content_layer = ContentLayer.BODY
-
-        if hlevel == 1:
+        level = int(tag_name[1])
+        text = tag.get_text(strip=True, separator=" ")
+        # the first level is for the title item
+        if level == 1:
             for key in self.parents.keys():
                 self.parents[key] = None
-
-            self.level = 1
-            self.parents[self.level] = doc.add_text(
-                parent=self.parents[0],
-                label=DocItemLabel.TITLE,
-                text=text,
-                content_layer=self.content_layer,
+            self.level = 0
+            self.parents[self.level + 1] = doc.add_title(
+                text, content_layer=self.content_layer
             )
+        # the other levels need to be lowered by 1 if a title was set
         else:
-            if hlevel > self.level:
+            level -= 1
+            if level > self.level:
                 # add invisible group
-                for i in range(self.level + 1, hlevel):
-                    self.parents[i] = doc.add_group(
-                        name=f"header-{i}",
+                for i in range(self.level, level):
+                    _log.debug(f"Adding invisible group to level {i}")
+                    self.parents[i + 1] = doc.add_group(
+                        name=f"header-{i + 1}",
                         label=GroupLabel.SECTION,
-                        parent=self.parents[i - 1],
+                        parent=self.parents[i],
                         content_layer=self.content_layer,
                     )
-                self.level = hlevel
-
-            elif hlevel < self.level:
+                self.level = level
+            elif level < self.level:
                 # remove the tail
                 for key in self.parents.keys():
-                    if key > hlevel:
+                    if key > level + 1:
+                        _log.debug(f"Remove the tail of level {key}")
                         self.parents[key] = None
-                self.level = hlevel
-
-            self.parents[hlevel] = doc.add_heading(
-                parent=self.parents[hlevel - 1],
-                text=text,
-                level=hlevel - 1,
-                content_layer=self.content_layer,
-            )
-
-    def handle_code(self, element: Tag, doc: DoclingDocument) -> None:
-        """Handles monospace code snippets (pre)."""
-        if element.text is None:
-            return
-        text = element.text.strip()
-        if text:
-            doc.add_code(
+                self.level = level
+            self.parents[self.level + 1] = doc.add_heading(
                 parent=self.parents[self.level],
                 text=text,
+                level=self.level,
                 content_layer=self.content_layer,
             )
+        self.level += 1
+        for img_tag in tag("img"):
+            if isinstance(img_tag, Tag):
+                self._emit_image(img_tag, doc)
 
-    def handle_paragraph(self, element: Tag, doc: DoclingDocument) -> None:
-        """Handles paragraph tags (p) or equivalent ones."""
-        if element.text is None:
-            return
-        text = element.text.strip()
-        if text:
-            doc.add_text(
-                parent=self.parents[self.level],
-                label=DocItemLabel.TEXT,
-                text=text,
-                content_layer=self.content_layer,
-            )
-
-    def handle_list(self, element: Tag, doc: DoclingDocument) -> None:
-        """Handles list tags (ul, ol) and their list items."""
-
+    def _handle_list(self, tag: Tag, doc: DoclingDocument) -> None:
+        tag_name = tag.name.lower()
         start: Optional[int] = None
-        if is_ordered := element.name == "ol":
-            start_attr = element.get("start")
+        name: str = ""
+        is_ordered = tag_name == "ol"
+        if is_ordered:
+            start_attr = tag.get("start")
             if isinstance(start_attr, str) and start_attr.isnumeric():
                 start = int(start_attr)
             name = "ordered list" + (f" start {start}" if start is not None else "")
         else:
             name = "list"
-        # create a list group
+        # Create the list container
         list_group = doc.add_list_group(
             name=name,
             parent=self.parents[self.level],
@@ -320,64 +270,182 @@ class HTMLDocumentBackend(DeclarativeDocumentBackend):
         self.ctx.list_ordered_flag_by_ref[list_group.self_ref] = is_ordered
         if is_ordered and start is not None:
             self.ctx.list_start_by_ref[list_group.self_ref] = start
-
         self.level += 1
 
-        self.walk(element, doc)
+        # For each top-level <li> in this list
+        for li in tag.find_all({"li", "ul", "ol"}, recursive=False):
+            if not isinstance(li, Tag):
+                continue
+
+            # sub-list items should be indented under main list items, but temporarily
+            # addressing invalid HTML (docling-core/issues/357)
+            if li.name in {"ul", "ol"}:
+                self._handle_block(li, doc)
+
+            else:
+                # 1) determine the marker
+                if is_ordered and start is not None:
+                    marker = f"{start + len(list_group.children)}."
+                else:
+                    marker = ""
+
+                # 2) extract only the "direct" text from this <li>
+                parts: list[str] = []
+                for child in li.contents:
+                    if isinstance(child, NavigableString) and not isinstance(
+                        child, PreformattedString
+                    ):
+                        parts.append(child)
+                    elif isinstance(child, Tag) and child.name not in ("ul", "ol"):
+                        text_part = HTMLDocumentBackend.get_text(child)
+                        if text_part:
+                            parts.append(text_part)
+                li_text = re.sub(r"\s+|\n+", " ", "".join(parts)).strip()
+
+                # 3) add the list item
+                if li_text:
+                    self.parents[self.level + 1] = doc.add_list_item(
+                        text=li_text,
+                        enumerated=is_ordered,
+                        marker=marker,
+                        parent=list_group,
+                        content_layer=self.content_layer,
+                    )
+
+                    # 4) recurse into any nested lists, attaching them to this <li> item
+                    for sublist in li({"ul", "ol"}, recursive=False):
+                        if isinstance(sublist, Tag):
+                            self.level += 1
+                            self._handle_block(sublist, doc)
+                            self.parents[self.level + 1] = None
+                            self.level -= 1
+                else:
+                    for sublist in li({"ul", "ol"}, recursive=False):
+                        if isinstance(sublist, Tag):
+                            self._handle_block(sublist, doc)
+
+                # 5) extract any images under this <li>
+                for img_tag in li("img"):
+                    if isinstance(img_tag, Tag):
+                        self._emit_image(img_tag, doc)
 
         self.parents[self.level + 1] = None
         self.level -= 1
 
-    def handle_list_item(self, element: Tag, doc: DoclingDocument) -> None:
-        """Handles list item tags (li)."""
-        nested_list = element.find(["ul", "ol"])
-
-        parent = self.parents[self.level]
-        if parent is None:
-            _log.debug(f"list-item has no parent in DoclingDocument: {element}")
-            return
-        enumerated = self.ctx.list_ordered_flag_by_ref.get(parent.self_ref, False)
-        if enumerated and (start := self.ctx.list_start_by_ref.get(parent.self_ref)):
-            marker = f"{start + len(parent.children)}."
-        else:
-            marker = ""
-
-        if nested_list:
-            # Text in list item can be hidden within hierarchy, hence
-            # we need to extract it recursively
-            text: str = self.get_text(element)
-            # Flatten text, remove break lines:
-            text = text.replace("\n", "").replace("\r", "")
-            text = " ".join(text.split()).strip()
-
-            if len(text) > 0:
-                # create a list-item
-                self.parents[self.level + 1] = doc.add_list_item(
-                    text=text,
-                    enumerated=enumerated,
-                    marker=marker,
-                    parent=parent,
+    def _handle_block(self, tag: Tag, doc: DoclingDocument) -> None:
+        tag_name = tag.name.lower()
+
+        if tag_name == "figure":
+            img_tag = tag.find("img")
+            if isinstance(img_tag, Tag):
+                self._emit_image(img_tag, doc)
+
+        elif tag_name in {"h1", "h2", "h3", "h4", "h5", "h6"}:
+            self._handle_heading(tag, doc)
+
+        elif tag_name in {"ul", "ol"}:
+            self._handle_list(tag, doc)
+
+        elif tag_name in {"p", "address", "summary"}:
+            for part in tag.text.split("\n"):
+                seg = part.strip()
+                if seg:
+                    doc.add_text(
+                        parent=self.parents[self.level],
+                        label=DocItemLabel.TEXT,
+                        text=seg,
+                        content_layer=self.content_layer,
+                    )
+            for img_tag in tag("img"):
+                if isinstance(img_tag, Tag):
+                    self._emit_image(img_tag, doc)
+
+        elif tag_name == "table":
+            data = HTMLDocumentBackend.parse_table_data(tag)
+            for img_tag in tag("img"):
+                if isinstance(img_tag, Tag):
+                    self._emit_image(tag, doc)
+            if data is not None:
+                doc.add_table(
+                    data=data,
+                    parent=self.parents[self.level],
                     content_layer=self.content_layer,
                 )
-                self.level += 1
-                self.walk(element, doc)
-                self.parents[self.level + 1] = None
-                self.level -= 1
-            else:
-                self.walk(element, doc)
 
-        elif element.text.strip():
-            text = element.text.strip()
+        elif tag_name in {"pre", "code"}:
+            # handle monospace code snippets (pre).
+            text = tag.get_text(strip=True)
+            if text:
+                doc.add_code(
+                    parent=self.parents[self.level],
+                    text=text,
+                    content_layer=self.content_layer,
+                )
 
-            doc.add_list_item(
-                text=text,
-                enumerated=enumerated,
-                marker=marker,
-                parent=parent,
+        elif tag_name == "details":
+            # handle details and its content.
+            self.parents[self.level + 1] = doc.add_group(
+                name="details",
+                label=GroupLabel.SECTION,
+                parent=self.parents[self.level],
                 content_layer=self.content_layer,
             )
-        else:
-            _log.debug(f"list-item has no text: {element}")
+            self.level += 1
+            self._walk(tag, doc)
+            self.parents[self.level + 1] = None
+            self.level -= 1
+
+    def _emit_image(self, img_tag: Tag, doc: DoclingDocument) -> None:
+        figure = img_tag.find_parent("figure")
+        caption: str = ""
+        if isinstance(figure, Tag):
+            caption_tag = figure.find("figcaption", recursive=False)
+            if isinstance(caption_tag, Tag):
+                caption = caption_tag.get_text()
+        if not caption:
+            caption = str(img_tag.get("alt", "")).strip()
+
+        caption_item: Optional[TextItem] = None
+        if caption:
+            caption_item = doc.add_text(
+                DocItemLabel.CAPTION, text=caption, content_layer=self.content_layer
+            )
+
+        doc.add_picture(
+            caption=caption_item,
+            parent=self.parents[self.level],
+            content_layer=self.content_layer,
+        )
+
+    @staticmethod
+    def get_text(item: PageElement) -> str:
+        """Concatenate all child strings of a PageElement.
+
+        This method is equivalent to `PageElement.get_text()` but also considers
+        certain tags. When called on a <p> or <li> tags, it returns the text with a
+        trailing space, otherwise the text is concatenated without separators.
+        """
+
+        def _extract_text_recursively(item: PageElement) -> list[str]:
+            """Recursively extract text from all child nodes."""
+            result: list[str] = []
+
+            if isinstance(item, NavigableString):
+                result = [item]
+            elif isinstance(item, Tag):
+                tag = cast(Tag, item)
+                parts: list[str] = []
+                for child in tag:
+                    parts.extend(_extract_text_recursively(child))
+                result.append(
+                    "".join(parts) + " " if tag.name in {"p", "li"} else "".join(parts)
+                )
+
+            return result
+
+        parts: list[str] = _extract_text_recursively(item)
+
+        return "".join(parts)
 
     @staticmethod
     def _get_cell_spans(cell: Tag) -> tuple[int, int]:
@@ -472,9 +540,7 @@ class HTMLDocumentBackend(DeclarativeDocumentBackend):
                         formula.replace_with(NavigableString(math_formula))
 
                 # TODO: extract content correctly from table-cells with lists
-                text = html_cell.text
-
-                # label = html_cell.name
+                text = HTMLDocumentBackend.get_text(html_cell).strip()
                 col_span, row_span = HTMLDocumentBackend._get_cell_spans(html_cell)
                 if row_header:
                     row_span -= 1
@@ -502,84 +568,3 @@ class HTMLDocumentBackend(DeclarativeDocumentBackend):
                 data.table_cells.append(table_cell)
 
         return data
-
-    def handle_table(self, element: Tag, doc: DoclingDocument) -> None:
-        """Handles table tags."""
-
-        table_data = HTMLDocumentBackend.parse_table_data(element)
-
-        if table_data is not None:
-            doc.add_table(
-                data=table_data,
-                parent=self.parents[self.level],
-                content_layer=self.content_layer,
-            )
-
-    def get_list_text(self, list_element: Tag, level: int = 0) -> list[str]:
-        """Recursively extract text from <ul> or <ol> with proper indentation."""
-        result = []
-        bullet_char = "*"  # Default bullet character for unordered lists
-
-        if list_element.name == "ol":  # For ordered lists, use numbers
-            for i, li in enumerate(list_element("li", recursive=False), 1):
-                if not isinstance(li, Tag):
-                    continue
-                # Add numbering for ordered lists
-                result.append(f"{'    ' * level}{i}. {li.get_text(strip=True)}")
-                # Handle nested lists
-                nested_list = li.find(["ul", "ol"])
-                if isinstance(nested_list, Tag):
-                    result.extend(self.get_list_text(nested_list, level + 1))
-        elif list_element.name == "ul":  # For unordered lists, use bullet points
-            for li in list_element("li", recursive=False):
-                if not isinstance(li, Tag):
-                    continue
-                # Add bullet points for unordered lists
-                result.append(
-                    f"{'    ' * level}{bullet_char} {li.get_text(strip=True)}"
-                )
-                # Handle nested lists
-                nested_list = li.find(["ul", "ol"])
-                if isinstance(nested_list, Tag):
-                    result.extend(self.get_list_text(nested_list, level + 1))
-
-        return result
-
-    def handle_figure(self, element: Tag, doc: DoclingDocument) -> None:
-        """Handles image tags (img)."""
-
-        # Extract the image URI from the <img> tag
-        # image_uri = root.xpath('//figure//img/@src')[0]
-
-        contains_captions = element.find(["figcaption"])
-        if not isinstance(contains_captions, Tag):
-            doc.add_picture(
-                parent=self.parents[self.level],
-                caption=None,
-                content_layer=self.content_layer,
-            )
-        else:
-            texts = []
-            for item in contains_captions:
-                texts.append(item.text)
-
-            fig_caption = doc.add_text(
-                label=DocItemLabel.CAPTION,
-                text=("".join(texts)).strip(),
-                content_layer=self.content_layer,
-            )
-            doc.add_picture(
-                parent=self.parents[self.level],
-                caption=fig_caption,
-                content_layer=self.content_layer,
-            )
-
-    def handle_image(self, element: Tag, doc: DoclingDocument) -> None:
-        """Handles image tags (img)."""
-        _log.debug(f"ignoring <img> tags at the moment: {element}")
-
-        doc.add_picture(
-            parent=self.parents[self.level],
-            caption=None,
-            content_layer=self.content_layer,
-        )

docling/backend/msword_backend.py

@@ -1104,8 +1104,17 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
                     )
                 _log.debug(f"  spanned before row {spanned_idx}")
 
+                # Detect equations in cell text
+                text, equations = self._handle_equations_in_text(
+                    element=cell._element, text=cell.text
+                )
+                if len(equations) == 0:
+                    text = cell.text
+                else:
+                    text = text.replace("<eq>", "$").replace("</eq>", "$")
+
                 table_cell = TableCell(
-                    text=cell.text,
+                    text=text,
                     row_span=spanned_idx - row_idx,
                     col_span=cell.grid_span,
                     start_row_offset_idx=row.grid_cols_before + row_idx,

docling/backend/pdf_backend.py

@@ -57,7 +57,31 @@ class PdfDocumentBackend(PaginatedDocumentBackend):
             if self.input_format is InputFormat.IMAGE:
                 buf = BytesIO()
                 img = Image.open(self.path_or_stream)
-                img.save(buf, "PDF")
+
+                # Handle multi-page TIFF images
+                if hasattr(img, "n_frames") and img.n_frames > 1:
+                    # Extract all frames from multi-page image
+                    frames = []
+                    try:
+                        for i in range(img.n_frames):
+                            img.seek(i)
+                            frame = img.copy().convert("RGB")
+                            frames.append(frame)
+                    except EOFError:
+                        pass
+
+                    # Save as multi-page PDF
+                    if frames:
+                        frames[0].save(
+                            buf, "PDF", save_all=True, append_images=frames[1:]
+                        )
+                    else:
+                        # Fallback to single page if frame extraction fails
+                        img.convert("RGB").save(buf, "PDF")
+                else:
+                    # Single page image - convert to RGB and save
+                    img.convert("RGB").save(buf, "PDF")
+
                 buf.seek(0)
                 self.path_or_stream = buf
             else:

docling/pipeline/base_pipeline.py

@@ -217,7 +217,13 @@ class PaginatedPipeline(BasePipeline):  # TODO this is a bad name.
         return conv_res
 
     def _determine_status(self, conv_res: ConversionResult) -> ConversionStatus:
-        status = ConversionStatus.SUCCESS
+        status = conv_res.status
+        if status in [
+            ConversionStatus.PENDING,
+            ConversionStatus.STARTED,
+        ]:  # preserves ConversionStatus.PARTIAL_SUCCESS
+            status = ConversionStatus.SUCCESS
+
         for page in conv_res.pages:
             if page._backend is None or not page._backend.is_valid():
                 conv_res.errors.append(

docling/utils/layout_postprocessor.py

@@ -267,9 +267,14 @@ class LayoutPostprocessor:
         # Initial cell assignment
         clusters = self._assign_cells_to_clusters(clusters)
 
-        # Remove clusters with no cells (if keep_empty_clusters is False)
+        # Remove clusters with no cells (if keep_empty_clusters is False),
+        # but always keep clusters with label DocItemLabel.FORMULA
         if not self.options.keep_empty_clusters:
-            clusters = [cluster for cluster in clusters if cluster.cells]
+            clusters = [
+                cluster
+                for cluster in clusters
+                if cluster.cells or cluster.label == DocItemLabel.FORMULA
+            ]
 
         # Handle orphaned cells
         unassigned = self._find_unassigned_cells(clusters)

{docling-2.42.0.dist-info → docling-2.42.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling
-Version: 2.42.0
+Version: 2.42.2
 Summary: SDK and CLI for parsing PDF, DOCX, HTML, and more, to a unified document representation for powering downstream workflows such as gen AI applications.
 Author-email: Christoph Auer <cau@zurich.ibm.com>, Michele Dolfi <dol@zurich.ibm.com>, Maxim Lysak <mly@zurich.ibm.com>, Nikos Livathinos <nli@zurich.ibm.com>, Ahmed Nassar <ahn@zurich.ibm.com>, Panos Vagenas <pva@zurich.ibm.com>, Peter Staar <taa@zurich.ibm.com>
 License-Expression: MIT
@@ -89,6 +89,7 @@ Dynamic: license-file
 [![License MIT](https://img.shields.io/github/license/docling-project/docling)](https://opensource.org/licenses/MIT)
 [![PyPI Downloads](https://static.pepy.tech/badge/docling/month)](https://pepy.tech/projects/docling)
 [![Docling Actor](https://apify.com/actor-badge?actor=vancura/docling?fpr=docling)](https://apify.com/vancura/docling)
+[![Chat with Dosu](https://dosu.dev/dosu-chat-badge.svg)](https://app.dosu.dev/097760a8-135e-4789-8234-90c8837d7f1c/ask?utm_source=github)
 [![OpenSSF Best Practices](https://www.bestpractices.dev/projects/10101/badge)](https://www.bestpractices.dev/projects/10101)
 [![LF AI & Data](https://img.shields.io/badge/LF%20AI%20%26%20Data-003778?logo=linuxfoundation&logoColor=fff&color=0094ff&labelColor=003778)](https://lfaidata.foundation/projects/)
 

{docling-2.42.0.dist-info → docling-2.42.2.dist-info}/RECORD

@@ -9,13 +9,13 @@ docling/backend/csv_backend.py,sha256=2g9famYG2W-ID9jEdZPxc6O8QGv1vWQfjN8pL-QMBE
 docling/backend/docling_parse_backend.py,sha256=9rUo1vPxX6QLzGqF-2B2iEYglZg6YQ3Uea00XrLluTg,7918
 docling/backend/docling_parse_v2_backend.py,sha256=3ckTfke8IICjaImlIzc3TRhG7KDuxDDba0AuCEcjA-M,9500
 docling/backend/docling_parse_v4_backend.py,sha256=qR_WRVq9JGtRioWCw6MnLWgbvXbC6Y1yds7Ol1-E6UQ,6550
-docling/backend/html_backend.py,sha256=xyCbCGR3vYNl-wSP2YJRgSCy9kIIMKKu28AUylPEUq8,20959
+docling/backend/html_backend.py,sha256=1Sohqc1xQETx6qPw27nT0QR4EdpDQg5DlrsK3rrgv7A,20413
 docling/backend/md_backend.py,sha256=mfwGj8g2hGC-Q_HREtl_Web65uMVXD-Ie1nRqWTXzF0,21013
 docling/backend/msexcel_backend.py,sha256=cq8MQ2RSh6pqCiVrldjOerSww7dOPTWmCQoCBI57i6w,18579
 docling/backend/mspowerpoint_backend.py,sha256=wJgB2JStEPfD7MPpWQlpPN7bffPxaHFUnKD4wj8SLxU,15114
-docling/backend/msword_backend.py,sha256=7mzPCF4bGWZPst5ntoV3aSxH5WUu2nBP-l8lgQT3tdw,44544
+docling/backend/msword_backend.py,sha256=DxMgPcq-Ao1vq7X2v8qqWeMs9MryPw_Jw3YRAAdXBtM,44904
 docling/backend/noop_backend.py,sha256=EOPbD86FzZPX-K_DpNrJh0_lC0bZz--4DpG-OagDNGY,1688
-docling/backend/pdf_backend.py,sha256=KE9TMuFO5WX-o5A_DAd4tEaLi4HMZ4XjKdpllItVkWM,2238
+docling/backend/pdf_backend.py,sha256=sUBrCz1zvt6E7sVl4xHtrkpTBClOK0vBV2lLi_TRHNg,3237
 docling/backend/pypdfium2_backend.py,sha256=8dVniLHgiTdJuDbYr66kPp6Ccv5ZDlqDMEbA2xIfS7U,13370
 docling/backend/docx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 docling/backend/docx/latex/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -74,7 +74,7 @@ docling/models/vlm_models_inline/hf_transformers_model.py,sha256=LAnWFIHGblWln6D
 docling/models/vlm_models_inline/mlx_model.py,sha256=p-H6wG31iVRoOjsqYaCVa4pEzxMP3vzLcsUatMjDJDQ,5948
 docling/pipeline/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 docling/pipeline/asr_pipeline.py,sha256=tQkhu9fXdkSuYIL22xzV2YRUlQh-9qktHBbs2qeXhJI,9070
-docling/pipeline/base_pipeline.py,sha256=14yQrDjsojl4RgbBjKFSEfVBYR_sULZfBI1uDzFLi8Y,9331
+docling/pipeline/base_pipeline.py,sha256=iwUqmttXF9D2myXyCAaIqFuGjBFhPkjAybcSAGpww-Q,9525
 docling/pipeline/simple_pipeline.py,sha256=TXZOwR7hZRji462ZTIpte0VJjzbxvNVE8dbLFANDhSU,2253
 docling/pipeline/standard_pdf_pipeline.py,sha256=yFishq4Cu01BiBGHk3Irr7ogcTQKeSC0QZImQVAhIaY,12740
 docling/pipeline/vlm_pipeline.py,sha256=0lj8tbXNpYF8OLBoLqP2BZfFpTHi40RoHVfvO_Nah4Q,15349
@@ -83,7 +83,7 @@ docling/utils/accelerator_utils.py,sha256=DSajLxVx1JEVT0zt5de26llciLNlVfIDfSa2zY
 docling/utils/api_image_request.py,sha256=_CgdzmPqdsyXmyYUFGLZcXcoH586qC6A1p5vsNbj1Q0,1416
 docling/utils/export.py,sha256=VwVUnYDk3mhGmISDbVm306fwpGNnoojouStBD4UajXI,4673
 docling/utils/glm_utils.py,sha256=TKOWQqWAHsX_w4fvoAA7_2xCi_urhnp1DsmjY8_sk5w,12274
-docling/utils/layout_postprocessor.py,sha256=m92UKjL-cIrOmOBi5Nuiby9FQWFyudcHigJKzud69-Q,24486
+docling/utils/layout_postprocessor.py,sha256=LFLbBE-o3kWu79d8ZcyHlZPIqzQfCabZCIPTJ51lZsY,24657
 docling/utils/locks.py,sha256=RzqQtD5UispgV71pGN_nU6GYfeN11BN0Sh_Dq9ycqGo,52
 docling/utils/model_downloader.py,sha256=3vijCsAIVwWqehGBDRxRq7mJ3yRb9-zBsG00iqjqegU,4076
 docling/utils/ocr_utils.py,sha256=nmresYyfin0raanpQc_GGeU3WoLsfExf6SEXNIQ7Djg,2325
@@ -91,9 +91,9 @@ docling/utils/orientation.py,sha256=jTyLxyT31FlOodZoBMlADHNQK2lAWKYVs5z7pXd_6Cg,
 docling/utils/profiling.py,sha256=YaMGoB9MMZpagF9mb5ndoHj8Lpb9aIdb7El-Pl7IcFs,1753
 docling/utils/utils.py,sha256=kJtIYuzXeOyJHYlxmLAo7dGM5rEsDa1i84qEsUj1nio,1908
 docling/utils/visualization.py,sha256=tY2ylE2aiQKkmzlSLnFW-HTfFyqUUMguW18ldd1PLfo,2868
-docling-2.42.0.dist-info/licenses/LICENSE,sha256=mBb7ErEcM8VS9OhiGHnQ2kk75HwPhr54W1Oiz3965MY,1088
-docling-2.42.0.dist-info/METADATA,sha256=jOwKrV5DDscuvMqHevJKC7-VA_hPOpDNz2lfJA6RAVE,10310
-docling-2.42.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-docling-2.42.0.dist-info/entry_points.txt,sha256=hzVlbeE0aMSTQ9S0-NTYN0Hmgsn6qL_EA2qX4UbkAuY,149
-docling-2.42.0.dist-info/top_level.txt,sha256=vkIywP-USjFyYo1AIRQbWQQaL3xB5jf8vkCYdTIfNic,8
-docling-2.42.0.dist-info/RECORD,,
+docling-2.42.2.dist-info/licenses/LICENSE,sha256=mBb7ErEcM8VS9OhiGHnQ2kk75HwPhr54W1Oiz3965MY,1088
+docling-2.42.2.dist-info/METADATA,sha256=1u5N4PTeuTbyxNgK9QK5DuqVf4cmSHOMcHlCeV7j5Do,10449
+docling-2.42.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+docling-2.42.2.dist-info/entry_points.txt,sha256=hzVlbeE0aMSTQ9S0-NTYN0Hmgsn6qL_EA2qX4UbkAuY,149
+docling-2.42.2.dist-info/top_level.txt,sha256=vkIywP-USjFyYo1AIRQbWQQaL3xB5jf8vkCYdTIfNic,8
+docling-2.42.2.dist-info/RECORD,,