docling 2.28.4__tar.gz → 2.29.0__tar.gz

{docling-2.28.4 → docling-2.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: docling
-Version: 2.28.4
+Version: 2.29.0
 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.
 Home-page: https://github.com/docling-project/docling
 License: MIT

{docling-2.28.4 → docling-2.29.0}/docling/backend/docx/latex/latex_dict.py

@@ -215,6 +215,9 @@ FUNC = {
     "coth": "\\coth({fe})",
     "sec": "\\sec({fe})",
     "csc": "\\csc({fe})",
+    "mod": "\\mod {fe}",
+    "max": "\\max({fe})",
+    "min": "\\min({fe})",
 }
 
 FUNC_PLACE = "{fe}"

{docling-2.28.4 → docling-2.29.0}/docling/backend/docx/latex/omml.py

@@ -5,6 +5,8 @@ Adapted from https://github.com/xiilei/dwml/blob/master/dwml/omml.py
 On 23/01/2025
 """
 
+import logging
+
 import lxml.etree as ET
 from pylatexenc.latexencode import UnicodeToLatexEncoder
 
@@ -39,6 +41,8 @@ from docling.backend.docx.latex.latex_dict import (
 
 OMML_NS = "{http://schemas.openxmlformats.org/officeDocument/2006/math}"
 
+_log = logging.getLogger(__name__)
+
 
 def load(stream):
     tree = ET.parse(stream)
@@ -281,8 +285,10 @@ class oMath2Latex(Tag2Method):
                 if FUNC.get(t):
                     latex_chars.append(FUNC[t])
                 else:
-                    raise NotSupport("Not support func %s" % t)
-            else:
+                    _log.warning("Function not supported, will default to text: %s", t)
+                    if isinstance(t, str):
+                        latex_chars.append(t)
+            elif isinstance(t, str):
                 latex_chars.append(t)
         t = BLANK.join(latex_chars)
         return t if FUNC_PLACE in t else t + FUNC_PLACE  # do_func will replace this
@@ -382,8 +388,6 @@ class oMath2Latex(Tag2Method):
 
         out_latex_str = self.u.unicode_to_latex(s)
 
-        # print(s, out_latex_str)
-
         if (
             s.startswith("{") is False
             and out_latex_str.startswith("{")
@@ -392,19 +396,13 @@ class oMath2Latex(Tag2Method):
         ):
             out_latex_str = f" {out_latex_str[1:-1]} "
 
-        # print(s, out_latex_str)
-
         if "ensuremath" in out_latex_str:
             out_latex_str = out_latex_str.replace("\\ensuremath{", " ")
             out_latex_str = out_latex_str.replace("}", " ")
 
-        # print(s, out_latex_str)
-
         if out_latex_str.strip().startswith("\\text"):
             out_latex_str = f" \\text{{{out_latex_str}}} "
 
-        # print(s, out_latex_str)
-
         return out_latex_str
 
     def do_r(self, elm):
@@ -415,10 +413,12 @@ class oMath2Latex(Tag2Method):
         """
         _str = []
         _base_str = []
-        for s in elm.findtext("./{0}t".format(OMML_NS)):
-            out_latex_str = self.process_unicode(s)
-            _str.append(out_latex_str)
-            _base_str.append(s)
+        found_text = elm.findtext("./{0}t".format(OMML_NS))
+        if found_text:
+            for s in found_text:
+                out_latex_str = self.process_unicode(s)
+                _str.append(out_latex_str)
+                _base_str.append(s)
 
         proc_str = escape_latex(BLANK.join(_str))
         base_proc_str = BLANK.join(_base_str)

{docling-2.28.4 → docling-2.29.0}/docling/backend/html_backend.py

@@ -34,6 +34,7 @@ TAGS_FOR_NODE_ITEMS: Final = [
     "h6",
     "p",
     "pre",
+    "code",
     "ul",
     "ol",
     "li",
@@ -165,7 +166,7 @@ class HTMLDocumentBackend(DeclarativeDocumentBackend):
             self.handle_header(tag, doc)
         elif tag.name in ["p"]:
             self.handle_paragraph(tag, doc)
-        elif tag.name in ["pre"]:
+        elif tag.name in ["pre", "code"]:
             self.handle_code(tag, doc)
         elif tag.name in ["ul", "ol"]:
             self.handle_list(tag, doc)

{docling-2.28.4 → docling-2.29.0}/docling/backend/mspowerpoint_backend.py

@@ -392,9 +392,10 @@ class MsPowerpointDocumentBackend(DeclarativeDocumentBackend, PaginatedDocumentB
                     self.handle_tables(shape, parent_slide, slide_ind, doc, slide_size)
                 if shape.shape_type == MSO_SHAPE_TYPE.PICTURE:
                     # Handle Pictures
-                    self.handle_pictures(
-                        shape, parent_slide, slide_ind, doc, slide_size
-                    )
+                    if hasattr(shape, "image"):
+                        self.handle_pictures(
+                            shape, parent_slide, slide_ind, doc, slide_size
+                        )
                 # If shape doesn't have any text, move on to the next shape
                 if not hasattr(shape, "text"):
                     return

{docling-2.28.4 → docling-2.29.0}/docling/backend/msword_backend.py

@@ -14,15 +14,19 @@ from docling_core.types.doc import (
     TableCell,
     TableData,
 )
+from docling_core.types.doc.document import Formatting
 from docx import Document
 from docx.document import Document as DocxDocument
 from docx.oxml.table import CT_Tc
 from docx.oxml.xmlchemy import BaseOxmlElement
 from docx.table import Table, _Cell
+from docx.text.hyperlink import Hyperlink
 from docx.text.paragraph import Paragraph
+from docx.text.run import Run
 from lxml import etree
 from lxml.etree import XPath
 from PIL import Image, UnidentifiedImageError
+from pydantic import AnyUrl
 from typing_extensions import override
 
 from docling.backend.abstract_backend import DeclarativeDocumentBackend
@@ -54,6 +58,7 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
         self.level_at_new_list: Optional[int] = None
         self.parents: dict[int, Optional[NodeItem]] = {}
         self.numbered_headers: dict[int, int] = {}
+        self.equation_bookends: str = "<eq>{EQ}</eq>"
         for i in range(-1, self.max_levels):
             self.parents[i] = None
 
@@ -118,14 +123,14 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
         doc = DoclingDocument(name=self.file.stem or "file", origin=origin)
         if self.is_valid():
             assert self.docx_obj is not None
-            doc = self.walk_linear(self.docx_obj.element.body, self.docx_obj, doc)
+            doc = self._walk_linear(self.docx_obj.element.body, self.docx_obj, doc)
             return doc
         else:
             raise RuntimeError(
                 f"Cannot convert doc with {self.document_hash} because the backend failed to init."
             )
 
-    def update_history(
+    def _update_history(
         self,
         name: str,
         level: Optional[int],
@@ -138,26 +143,26 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
         self.history["numids"].append(numid)
         self.history["indents"].append(ilevel)
 
-    def prev_name(self) -> Optional[str]:
+    def _prev_name(self) -> Optional[str]:
         return self.history["names"][-1]
 
-    def prev_level(self) -> Optional[int]:
+    def _prev_level(self) -> Optional[int]:
         return self.history["levels"][-1]
 
-    def prev_numid(self) -> Optional[int]:
+    def _prev_numid(self) -> Optional[int]:
         return self.history["numids"][-1]
 
-    def prev_indent(self) -> Optional[int]:
+    def _prev_indent(self) -> Optional[int]:
         return self.history["indents"][-1]
 
-    def get_level(self) -> int:
+    def _get_level(self) -> int:
         """Return the first None index."""
         for k, v in self.parents.items():
             if k >= 0 and v == None:
                 return k
         return 0
 
-    def walk_linear(
+    def _walk_linear(
         self,
         body: BaseOxmlElement,
         docx_obj: DocxDocument,
@@ -177,12 +182,12 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
             # Check for Tables
             if element.tag.endswith("tbl"):
                 try:
-                    self.handle_tables(element, docx_obj, doc)
+                    self._handle_tables(element, docx_obj, doc)
                 except Exception:
                     _log.debug("could not parse a table, broken docx table")
 
             elif drawing_blip:
-                self.handle_pictures(docx_obj, drawing_blip, doc)
+                self._handle_pictures(docx_obj, drawing_blip, doc)
             # Check for the sdt containers, like table of contents
             elif tag_name in ["sdt"]:
                 sdt_content = element.find(".//w:sdtContent", namespaces=namespaces)
@@ -190,16 +195,18 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
                     # Iterate paragraphs, runs, or text inside <w:sdtContent>.
                     paragraphs = sdt_content.findall(".//w:p", namespaces=namespaces)
                     for p in paragraphs:
-                        self.handle_text_elements(p, docx_obj, doc)
+                        self._handle_text_elements(p, docx_obj, doc)
             # Check for Text
             elif tag_name in ["p"]:
                 # "tcPr", "sectPr"
-                self.handle_text_elements(element, docx_obj, doc)
+                self._handle_text_elements(element, docx_obj, doc)
             else:
                 _log.debug(f"Ignoring element in DOCX with tag: {tag_name}")
         return doc
 
-    def str_to_int(self, s: Optional[str], default: Optional[int] = 0) -> Optional[int]:
+    def _str_to_int(
+        self, s: Optional[str], default: Optional[int] = 0
+    ) -> Optional[int]:
         if s is None:
             return None
         try:
@@ -207,7 +214,7 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
         except ValueError:
             return default
 
-    def split_text_and_number(self, input_string: str) -> list[str]:
+    def _split_text_and_number(self, input_string: str) -> list[str]:
         match = re.match(r"(\D+)(\d+)$|^(\d+)(\D+)", input_string)
         if match:
             parts = list(filter(None, match.groups()))
@@ -215,7 +222,7 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
         else:
             return [input_string]
 
-    def get_numId_and_ilvl(
+    def _get_numId_and_ilvl(
         self, paragraph: Paragraph
     ) -> tuple[Optional[int], Optional[int]]:
         # Access the XML element of the paragraph
@@ -230,60 +237,188 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
             numId = numId_elem.get(self.XML_KEY) if numId_elem is not None else None
             ilvl = ilvl_elem.get(self.XML_KEY) if ilvl_elem is not None else None
 
-            return self.str_to_int(numId, None), self.str_to_int(ilvl, None)
+            return self._str_to_int(numId, None), self._str_to_int(ilvl, None)
 
         return None, None  # If the paragraph is not part of a list
 
-    def get_label_and_level(self, paragraph: Paragraph) -> tuple[str, Optional[int]]:
+    def _get_heading_and_level(self, style_label: str) -> tuple[str, Optional[int]]:
+        parts = self._split_text_and_number(style_label)
+
+        if len(parts) == 2:
+            parts.sort()
+            label_str: str = ""
+            label_level: Optional[int] = 0
+            if parts[0].strip().lower() == "heading":
+                label_str = "Heading"
+                label_level = self._str_to_int(parts[1], None)
+            if parts[1].strip().lower() == "heading":
+                label_str = "Heading"
+                label_level = self._str_to_int(parts[0], None)
+            return label_str, label_level
+
+        return style_label, None
+
+    def _get_label_and_level(self, paragraph: Paragraph) -> tuple[str, Optional[int]]:
         if paragraph.style is None:
             return "Normal", None
+
         label = paragraph.style.style_id
+        name = paragraph.style.name
+        base_style_label = None
+        base_style_name = None
+        if base_style := getattr(paragraph.style, "base_style", None):
+            base_style_label = base_style.style_id
+            base_style_name = base_style.name
+
         if label is None:
             return "Normal", None
+
         if ":" in label:
             parts = label.split(":")
-
             if len(parts) == 2:
-                return parts[0], self.str_to_int(parts[1], None)
+                return parts[0], self._str_to_int(parts[1], None)
 
-        parts = self.split_text_and_number(label)
+        if "heading" in label.lower():
+            return self._get_heading_and_level(label)
+        if "heading" in name.lower():
+            return self._get_heading_and_level(name)
+        if base_style_label and "heading" in base_style_label.lower():
+            return self._get_heading_and_level(base_style_label)
+        if base_style_name and "heading" in base_style_name.lower():
+            return self._get_heading_and_level(base_style_name)
 
-        if "Heading" in label and len(parts) == 2:
-            parts.sort()
-            label_str: str = ""
-            label_level: Optional[int] = 0
-            if parts[0] == "Heading":
-                label_str = parts[0]
-                label_level = self.str_to_int(parts[1], None)
-            if parts[1] == "Heading":
-                label_str = parts[1]
-                label_level = self.str_to_int(parts[0], None)
-            return label_str, label_level
-        else:
-            return label, None
+        return label, None
 
-    def handle_equations_in_text(self, element, text):
+    @classmethod
+    def _get_format_from_run(cls, run: Run) -> Optional[Formatting]:
+        has_any_formatting = run.bold or run.italic or run.underline
+        return (
+            Formatting(
+                bold=run.bold or False,
+                italic=run.italic or False,
+                underline=run.underline or False,
+            )
+            if has_any_formatting
+            else None
+        )
+
+    def _get_paragraph_elements(self, paragraph: Paragraph):
+        """
+        Extract paragraph elements along with their formatting and hyperlink
+        """
+
+        # for now retain empty paragraphs for backwards compatibility:
+        if paragraph.text.strip() == "":
+            return [("", None, None)]
+
+        paragraph_elements: list[
+            tuple[str, Optional[Formatting], Optional[Union[AnyUrl, Path]]]
+        ] = []
+        group_text = ""
+        previous_format = None
+
+        # Iterate over the runs of the paragraph and group them by format
+        for c in paragraph.iter_inner_content():
+            if isinstance(c, Hyperlink):
+                text = c.text
+                hyperlink = Path(c.address)
+                format = self._get_format_from_run(c.runs[0])
+            elif isinstance(c, Run):
+                text = c.text
+                hyperlink = None
+                format = self._get_format_from_run(c)
+            else:
+                continue
+
+            if (len(text.strip()) and format != previous_format) or (
+                hyperlink is not None
+            ):
+                # If the style changes for a non empty text, add the previous group
+                if len(group_text.strip()) > 0:
+                    paragraph_elements.append(
+                        (group_text.strip(), previous_format, None)
+                    )
+                group_text = ""
+
+                # If there is a hyperlink, add it immediately
+                if hyperlink is not None:
+                    paragraph_elements.append((text.strip(), format, hyperlink))
+                    text = ""
+                else:
+                    previous_format = format
+
+            group_text += text
+
+        # Format the last group
+        if len(group_text.strip()) > 0:
+            paragraph_elements.append((group_text.strip(), format, None))
+
+        return paragraph_elements
+
+    def _handle_equations_in_text(self, element, text):
         only_texts = []
         only_equations = []
         texts_and_equations = []
         for subt in element.iter():
             tag_name = etree.QName(subt).localname
             if tag_name == "t" and "math" not in subt.tag:
-                only_texts.append(subt.text)
-                texts_and_equations.append(subt.text)
+                if isinstance(subt.text, str):
+                    only_texts.append(subt.text)
+                    texts_and_equations.append(subt.text)
             elif "oMath" in subt.tag and "oMathPara" not in subt.tag:
-                latex_equation = str(oMath2Latex(subt))
-                only_equations.append(latex_equation)
-                texts_and_equations.append(latex_equation)
+                latex_equation = str(oMath2Latex(subt)).strip()
+                if len(latex_equation) > 0:
+                    only_equations.append(
+                        self.equation_bookends.format(EQ=latex_equation)
+                    )
+                    texts_and_equations.append(
+                        self.equation_bookends.format(EQ=latex_equation)
+                    )
 
-        if "".join(only_texts).strip() != text.strip():
+        if len(only_equations) < 1:
+            return text, []
+
+        if (
+            re.sub(r"\s+", "", "".join(only_texts)).strip()
+            != re.sub(r"\s+", "", text).strip()
+        ):
             # If we are not able to reconstruct the initial raw text
             # do not try to parse equations and return the original
             return text, []
 
-        return "".join(texts_and_equations), only_equations
+        # Insert equations into original text
+        # This is done to preserve white space structure
+        output_text = text[:]
+        init_i = 0
+        for i_substr, substr in enumerate(texts_and_equations):
+            if len(substr) == 0:
+                continue
 
-    def handle_text_elements(
+            if substr in output_text[init_i:]:
+                init_i += output_text[init_i:].find(substr) + len(substr)
+            else:
+                if i_substr > 0:
+                    output_text = output_text[:init_i] + substr + output_text[init_i:]
+                    init_i += len(substr)
+                else:
+                    output_text = substr + output_text
+
+        return output_text, only_equations
+
+    def _create_or_reuse_parent(
+        self,
+        *,
+        doc: DoclingDocument,
+        prev_parent: Optional[NodeItem],
+        paragraph_elements: list,
+    ) -> Optional[NodeItem]:
+        return (
+            doc.add_group(label=GroupLabel.INLINE, parent=prev_parent)
+            if len(paragraph_elements) > 1
+            else prev_parent
+        )
+
+    def _handle_text_elements(
         self,
         element: BaseOxmlElement,
         docx_obj: DocxDocument,
@@ -292,10 +427,11 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
         paragraph = Paragraph(element, docx_obj)
 
         raw_text = paragraph.text
-        text, equations = self.handle_equations_in_text(element=element, text=raw_text)
+        text, equations = self._handle_equations_in_text(element=element, text=raw_text)
 
         if text is None:
             return
+        paragraph_elements = self._get_paragraph_elements(paragraph)
         text = text.strip()
 
         # Common styles for bullet and numbered lists.
@@ -303,8 +439,8 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
         # Identify wether list is a numbered list or not
         # is_numbered = "List Bullet" not in paragraph.style.name
         is_numbered = False
-        p_style_id, p_level = self.get_label_and_level(paragraph)
-        numid, ilevel = self.get_numId_and_ilvl(paragraph)
+        p_style_id, p_level = self._get_label_and_level(paragraph)
+        numid, ilevel = self._get_numId_and_ilvl(paragraph)
 
         if numid == 0:
             numid = None
@@ -315,18 +451,18 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
             and ilevel is not None
             and p_style_id not in ["Title", "Heading"]
         ):
-            self.add_listitem(
-                doc,
-                numid,
-                ilevel,
-                text,
-                is_numbered,
+            self._add_list_item(
+                doc=doc,
+                numid=numid,
+                ilevel=ilevel,
+                elements=paragraph_elements,
+                is_numbered=is_numbered,
             )
-            self.update_history(p_style_id, p_level, numid, ilevel)
+            self._update_history(p_style_id, p_level, numid, ilevel)
             return
         elif (
             numid is None
-            and self.prev_numid() is not None
+            and self._prev_numid() is not None
             and p_style_id not in ["Title", "Heading"]
         ):  # Close list
             if self.level_at_new_list:
@@ -348,26 +484,26 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
             )
         elif "Heading" in p_style_id:
             style_element = getattr(paragraph.style, "element", None)
-            if style_element:
+            if style_element is not None:
                 is_numbered_style = (
                     "<w:numPr>" in style_element.xml or "<w:numPr>" in element.xml
                 )
             else:
                 is_numbered_style = False
-            self.add_header(doc, p_level, text, is_numbered_style)
+            self._add_header(doc, p_level, text, is_numbered_style)
 
         elif len(equations) > 0:
-            if (raw_text is None or len(raw_text) == 0) and len(text) > 0:
+            if (raw_text is None or len(raw_text.strip()) == 0) and len(text) > 0:
                 # Standalone equation
-                level = self.get_level()
+                level = self._get_level()
                 doc.add_text(
                     label=DocItemLabel.FORMULA,
                     parent=self.parents[level - 1],
-                    text=text,
+                    text=text.replace("<eq>", "").replace("</eq>", ""),
                 )
             else:
                 # Inline equation
-                level = self.get_level()
+                level = self._get_level()
                 inline_equation = doc.add_group(
                     label=GroupLabel.INLINE, parent=self.parents[level - 1]
                 )
@@ -376,8 +512,11 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
                     if len(text_tmp) == 0:
                         break
 
-                    pre_eq_text = text_tmp.split(eq, maxsplit=1)[0]
-                    text_tmp = text_tmp.split(eq, maxsplit=1)[1]
+                    split_text_tmp = text_tmp.split(eq.strip(), maxsplit=1)
+
+                    pre_eq_text = split_text_tmp[0]
+                    text_tmp = "" if len(split_text_tmp) == 1 else split_text_tmp[1]
+
                     if len(pre_eq_text) > 0:
                         doc.add_text(
                             label=DocItemLabel.PARAGRAPH,
@@ -387,13 +526,14 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
                     doc.add_text(
                         label=DocItemLabel.FORMULA,
                         parent=inline_equation,
-                        text=eq,
+                        text=eq.replace("<eq>", "").replace("</eq>", ""),
                     )
+
                 if len(text_tmp) > 0:
                     doc.add_text(
                         label=DocItemLabel.PARAGRAPH,
                         parent=inline_equation,
-                        text=text_tmp,
+                        text=text_tmp.strip(),
                     )
 
         elif p_style_id in [
@@ -406,30 +546,50 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
             "ListBullet",
             "Quote",
         ]:
-            level = self.get_level()
-            doc.add_text(
-                label=DocItemLabel.PARAGRAPH, parent=self.parents[level - 1], text=text
+            level = self._get_level()
+            parent = self._create_or_reuse_parent(
+                doc=doc,
+                prev_parent=self.parents.get(level - 1),
+                paragraph_elements=paragraph_elements,
             )
+            for text, format, hyperlink in paragraph_elements:
+                doc.add_text(
+                    label=DocItemLabel.PARAGRAPH,
+                    parent=parent,
+                    text=text,
+                    formatting=format,
+                    hyperlink=hyperlink,
+                )
 
         else:
             # Text style names can, and will have, not only default values but user values too
             # hence we treat all other labels as pure text
-            level = self.get_level()
-            doc.add_text(
-                label=DocItemLabel.PARAGRAPH, parent=self.parents[level - 1], text=text
+            level = self._get_level()
+            parent = self._create_or_reuse_parent(
+                doc=doc,
+                prev_parent=self.parents.get(level - 1),
+                paragraph_elements=paragraph_elements,
             )
+            for text, format, hyperlink in paragraph_elements:
+                doc.add_text(
+                    label=DocItemLabel.PARAGRAPH,
+                    parent=parent,
+                    text=text,
+                    formatting=format,
+                    hyperlink=hyperlink,
+                )
 
-        self.update_history(p_style_id, p_level, numid, ilevel)
+        self._update_history(p_style_id, p_level, numid, ilevel)
         return
 
-    def add_header(
+    def _add_header(
         self,
         doc: DoclingDocument,
         curr_level: Optional[int],
         text: str,
         is_numbered_style: bool = False,
     ) -> None:
-        level = self.get_level()
+        level = self._get_level()
         if isinstance(curr_level, int):
             if curr_level > level:
                 # add invisible group
@@ -485,19 +645,20 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
         )
         return
 
-    def add_listitem(
+    def _add_list_item(
         self,
+        *,
         doc: DoclingDocument,
         numid: int,
         ilevel: int,
-        text: str,
+        elements: list,
         is_numbered: bool = False,
     ) -> None:
         enum_marker = ""
 
-        level = self.get_level()
-        prev_indent = self.prev_indent()
-        if self.prev_numid() is None:  # Open new list
+        level = self._get_level()
+        prev_indent = self._prev_indent()
+        if self._prev_numid() is None:  # Open new list
             self.level_at_new_list = level
 
             self.parents[level] = doc.add_group(
@@ -509,15 +670,23 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
             if is_numbered:
                 enum_marker = str(self.listIter) + "."
                 is_numbered = True
-            doc.add_list_item(
-                marker=enum_marker,
-                enumerated=is_numbered,
-                parent=self.parents[level],
-                text=text,
+            new_parent = self._create_or_reuse_parent(
+                doc=doc,
+                prev_parent=self.parents[level],
+                paragraph_elements=elements,
             )
+            for text, format, hyperlink in elements:
+                doc.add_list_item(
+                    marker=enum_marker,
+                    enumerated=is_numbered,
+                    parent=new_parent,
+                    text=text,
+                    formatting=format,
+                    hyperlink=hyperlink,
+                )
 
         elif (
-            self.prev_numid() == numid
+            self._prev_numid() == numid
             and self.level_at_new_list is not None
             and prev_indent is not None
             and prev_indent < ilevel
@@ -545,15 +714,23 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
             if is_numbered:
                 enum_marker = str(self.listIter) + "."
                 is_numbered = True
-            doc.add_list_item(
-                marker=enum_marker,
-                enumerated=is_numbered,
-                parent=self.parents[self.level_at_new_list + ilevel],
-                text=text,
-            )
 
+            new_parent = self._create_or_reuse_parent(
+                doc=doc,
+                prev_parent=self.parents[self.level_at_new_list + ilevel],
+                paragraph_elements=elements,
+            )
+            for text, format, hyperlink in elements:
+                doc.add_list_item(
+                    marker=enum_marker,
+                    enumerated=is_numbered,
+                    parent=new_parent,
+                    text=text,
+                    formatting=format,
+                    hyperlink=hyperlink,
+                )
         elif (
-            self.prev_numid() == numid
+            self._prev_numid() == numid
             and self.level_at_new_list is not None
             and prev_indent is not None
             and ilevel < prev_indent
@@ -567,29 +744,46 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
             if is_numbered:
                 enum_marker = str(self.listIter) + "."
                 is_numbered = True
-            doc.add_list_item(
-                marker=enum_marker,
-                enumerated=is_numbered,
-                parent=self.parents[self.level_at_new_list + ilevel],
-                text=text,
+            new_parent = self._create_or_reuse_parent(
+                doc=doc,
+                prev_parent=self.parents[self.level_at_new_list + ilevel],
+                paragraph_elements=elements,
             )
+            for text, format, hyperlink in elements:
+                doc.add_list_item(
+                    marker=enum_marker,
+                    enumerated=is_numbered,
+                    parent=new_parent,
+                    text=text,
+                    formatting=format,
+                    hyperlink=hyperlink,
+                )
             self.listIter = 0
 
-        elif self.prev_numid() == numid or prev_indent == ilevel:
+        elif self._prev_numid() == numid or prev_indent == ilevel:
             # TODO: Set marker and enumerated arguments if this is an enumeration element.
             self.listIter += 1
             if is_numbered:
                 enum_marker = str(self.listIter) + "."
                 is_numbered = True
-            doc.add_list_item(
-                marker=enum_marker,
-                enumerated=is_numbered,
-                parent=self.parents[level - 1],
-                text=text,
+            new_parent = self._create_or_reuse_parent(
+                doc=doc,
+                prev_parent=self.parents[level - 1],
+                paragraph_elements=elements,
             )
+            for text, format, hyperlink in elements:
+                # Add the list item to the parent group
+                doc.add_list_item(
+                    marker=enum_marker,
+                    enumerated=is_numbered,
+                    parent=new_parent,
+                    text=text,
+                    formatting=format,
+                    hyperlink=hyperlink,
+                )
         return
 
-    def handle_tables(
+    def _handle_tables(
         self,
         element: BaseOxmlElement,
         docx_obj: DocxDocument,
@@ -604,7 +798,7 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
             cell_element = table.rows[0].cells[0]
             # In case we have a table of only 1 cell, we consider it furniture
             # And proceed processing the content of the cell as though it's in the document body
-            self.walk_linear(cell_element._element, docx_obj, doc)
+            self._walk_linear(cell_element._element, docx_obj, doc)
             return
 
         data = TableData(num_rows=num_rows, num_cols=num_cols)
@@ -649,11 +843,11 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
                 data.table_cells.append(table_cell)
                 col_idx += cell.grid_span
 
-        level = self.get_level()
+        level = self._get_level()
         doc.add_table(data=data, parent=self.parents[level - 1])
         return
 
-    def handle_pictures(
+    def _handle_pictures(
         self, docx_obj: DocxDocument, drawing_blip: Any, doc: DoclingDocument
     ) -> None:
         def get_docx_image(drawing_blip):
@@ -666,7 +860,7 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
                 image_data = image_part.blob  # Get the binary image data
             return image_data
 
-        level = self.get_level()
+        level = self._get_level()
         # Open the BytesIO object with PIL to create an Image
         try:
             image_data = get_docx_image(drawing_blip)

{docling-2.28.4 → docling-2.29.0}/docling/cli/main.py

@@ -60,6 +60,44 @@ err_console = Console(stderr=True)
 ocr_factory_internal = get_ocr_factory(allow_external_plugins=False)
 ocr_engines_enum_internal = ocr_factory_internal.get_enum()
 
+DOCLING_ASCII_ART = r"""
+                             ████ ██████
+                           ███░░██░░░░░██████
+                      ████████░░░░░░░░████████████
+                   ████████░░░░░░░░░░░░░░░░░░████████
+                 ██████░░░░░░░░░░░░░░░░░░░░░░░░░░██████
+              ██████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█████
+            ██████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█████
+          ██████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██████
+         ██████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██████
+        ██████░░░░░░░   ░░░░░░░░░░░░░░░░░░░░░░   ░░░░░░░██████
+       ██████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██████
+      ██████░░░░░░         ░░░░░░░░░░░░░░░          ░░░░░░██████
+      ███▒██░░░░░   ████     ░░░░░░░░░░░░   ████     ░░░░░██▒███
+     ███▒██░░░░░░  ████      ░░░░░░░░░░░░  ████      ░░░░░██▒████
+     ███▒██░░░░░░  ██     ██ ░░░░░░░░░░░░  ██     ██ ░░░░░██▒▒███
+     ███▒███░░░░░        ██  ░░░░████░░░░        ██  ░░░░░██▒▒███
+    ████▒▒██░░░░░░         ░░░███▒▒▒▒███░░░        ░░░░░░░██▒▒████
+    ████▒▒██░░░░░░░░░░░░░░░░░█▒▒▒▒▒▒▒▒▒▒█░░░░░░░░░░░░░░░░███▒▒████
+    ████▒▒▒██░░░░░░░░░░░░█████  ▒▒▒▒▒▒  ██████░░░░░░░░░░░██▒▒▒████
+     ███▒▒▒▒██░░░░░░░░███▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒███░░░░░░░░██▒▒▒▒███
+     ███▒▒▒▒▒███░░░░░░██▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒██░░░░░░███▒▒▒▒▒███
+     ████▒▒▒▒▒████░░░░░░██████████████████████░░░░░░████▒▒▒▒▒████
+      ███▒▒▒▒▒▒▒▒████░░░░░░░░░░░░░░░░░░░░░░░░░░░████▒▒▒▒▒▒▒▒▒███
+      ████▒▒▒▒▒▒▒▒███░░░░░████████████████████████▒▒▒▒▒▒▒▒▒████
+       ████▒▒▒▒▒▒██░░░░░░█                   █░░░░░██▒▒▒▒▒▒████
+        ████▒▒▒▒█░░░░░░░█   D O C L I N G   █░░░░░░░░██▒▒▒████
+         ████▒▒██░░░░░░█                   █░░░░░░░░░░█▒▒████
+          ██████░░░░░░█   D O C L I N G   █░░░░░░░░░░░██████
+            ████░░░░░█                   █░░░░░░░░░░░░████
+             █████░░█   D O C L I N G   █░░░░░░░░░░░█████
+               █████                   █░░░░░░░░████████
+                 ██   D O C L I N G   █░░░░░░░░█████
+                 █                   █░░░████████
+                █████████████████████████████
+"""
+
+
 app = typer.Typer(
     name="Docling",
     no_args_is_help=True,
@@ -68,6 +106,12 @@ app = typer.Typer(
 )
 
 
+def logo_callback(value: bool):
+    if value:
+        print(DOCLING_ASCII_ART)
+        raise typer.Exit()
+
+
 def version_callback(value: bool):
     if value:
         docling_version = importlib.metadata.version("docling")
@@ -356,6 +400,12 @@ def convert(
     device: Annotated[
         AcceleratorDevice, typer.Option(..., help="Accelerator device")
     ] = AcceleratorDevice.AUTO,
+    docling_logo: Annotated[
+        Optional[bool],
+        typer.Option(
+            "--logo", callback=logo_callback, is_eager=True, help="Docling logo"
+        ),
+    ] = None,
 ):
     if verbose == 0:
         logging.basicConfig(level=logging.WARNING)

{docling-2.28.4 → docling-2.29.0}/docling/models/tesseract_ocr_cli_model.py

@@ -247,7 +247,7 @@ class TesseractOcrCliModel(BaseOcrModel):
 
                             cell = TextCell(
                                 index=ix,
-                                text=text,
+                                text=str(text),
                                 orig=text,
                                 from_ocr=True,
                                 confidence=conf / 100.0,

{docling-2.28.4 → docling-2.29.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "docling"
-version = "2.28.4"  # DO NOT EDIT, updated automatically
+version = "2.29.0"  # DO NOT EDIT, updated automatically
 description = "SDK and CLI for parsing PDF, DOCX, HTML, and more, to a unified document representation for powering downstream workflows such as gen AI applications."
 authors = [
   "Christoph Auer <cau@zurich.ibm.com>",