docling 2.55.0__py3-none-any.whl → 2.56.0__py3-none-any.whl

docling/backend/html_backend.py

@@ -272,9 +272,19 @@ class HTMLDocumentBackend(DeclarativeDocumentBackend):
         for br in content("br"):
             br.replace_with(NavigableString("\n"))
         # set default content layer
-        headers = content.find(["h1", "h2", "h3", "h4", "h5", "h6"])
+
+        # Furniture before the first heading rule, except for headers in tables
+        header = None
+        # Find all headers first
+        all_headers = content.find_all(["h1", "h2", "h3", "h4", "h5", "h6"])
+        # Keep only those that do NOT have a <table> in a parent chain
+        clean_headers = [h for h in all_headers if not h.find_parent("table")]
+        # Pick the first header from the remaining
+        if len(clean_headers):
+            header = clean_headers[0]
+        # Set starting content layer
         self.content_layer = (
-            ContentLayer.BODY if headers is None else ContentLayer.FURNITURE
+            ContentLayer.BODY if header is None else ContentLayer.FURNITURE
         )
         # reset context
         self.ctx = _Context()
@@ -309,9 +319,11 @@ class HTMLDocumentBackend(DeclarativeDocumentBackend):
         group_name: str,
         doc: DoclingDocument,
         docling_table: TableItem,
-    ) -> tuple[bool, RefItem]:
+    ) -> tuple[bool, Union[RefItem, None]]:
         rich_table_cell = False
-        ref_for_rich_cell = provs_in_cell[0]
+        ref_for_rich_cell = None
+        if len(provs_in_cell) > 0:
+            ref_for_rich_cell = provs_in_cell[0]
         if len(provs_in_cell) > 1:
             # Cell has multiple elements, we need to group them
             rich_table_cell = True
@@ -324,7 +336,10 @@ class HTMLDocumentBackend(DeclarativeDocumentBackend):
             if isinstance(pr_item, TextItem):
                 # Cell has only one element and it's just a text
                 rich_table_cell = False
-                doc.delete_items(node_items=[pr_item])
+                try:
+                    doc.delete_items(node_items=[pr_item])
+                except Exception as e:
+                    _log.error(f"Error while making rich table: {e}.")
             else:
                 rich_table_cell = True
                 ref_for_rich_cell = HTMLDocumentBackend.group_cell_elements(
@@ -391,17 +406,19 @@ class HTMLDocumentBackend(DeclarativeDocumentBackend):
 
                 provs_in_cell: list[RefItem] = []
                 # Parse table cell sub-tree for Rich Cells content:
+                table_level = self.level
                 provs_in_cell = self._walk(html_cell, doc)
+                # After walking sub-tree in cell, restore previously set level
+                self.level = table_level
 
                 rich_table_cell = False
                 ref_for_rich_cell = None
-                if len(provs_in_cell) > 0:
-                    group_name = f"rich_cell_group_{len(doc.tables)}_{col_idx}_{start_row_span + row_idx}"
-                    rich_table_cell, ref_for_rich_cell = (
-                        HTMLDocumentBackend.process_rich_table_cells(
-                            provs_in_cell, group_name, doc, docling_table
-                        )
+                group_name = f"rich_cell_group_{len(doc.tables)}_{col_idx}_{start_row_span + row_idx}"
+                rich_table_cell, ref_for_rich_cell = (
+                    HTMLDocumentBackend.process_rich_table_cells(
+                        provs_in_cell, group_name, doc, docling_table
                     )
+                )
 
                 # Extracting text
                 text = self.get_text(html_cell).strip()
@@ -774,13 +791,15 @@ class HTMLDocumentBackend(DeclarativeDocumentBackend):
             for key in self.parents.keys():
                 self.parents[key] = None
             self.level = 0
-            docling_title = self.parents[self.level + 1] = doc.add_title(
+            self.parents[self.level + 1] = doc.add_title(
                 text_clean,
                 content_layer=self.content_layer,
                 formatting=annotated_text.formatting,
                 hyperlink=annotated_text.hyperlink,
             )
-            added_ref = [docling_title.get_ref()]
+            p1 = self.parents[self.level + 1]
+            if p1 is not None:
+                added_ref = [p1.get_ref()]
         # the other levels need to be lowered by 1 if a title was set
         else:
             level -= 1
@@ -802,7 +821,7 @@ class HTMLDocumentBackend(DeclarativeDocumentBackend):
                         _log.debug(f"Remove the tail of level {key}")
                         self.parents[key] = None
                 self.level = level
-            docling_heading = self.parents[self.level + 1] = doc.add_heading(
+            self.parents[self.level + 1] = doc.add_heading(
                 parent=self.parents[self.level],
                 text=text_clean,
                 orig=annotated_text.text,
@@ -811,7 +830,9 @@ class HTMLDocumentBackend(DeclarativeDocumentBackend):
                 formatting=annotated_text.formatting,
                 hyperlink=annotated_text.hyperlink,
             )
-            added_ref = [docling_heading.get_ref()]
+            p2 = self.parents[self.level + 1]
+            if p2 is not None:
+                added_ref = [p2.get_ref()]
         self.level += 1
         for img_tag in tag("img"):
             if isinstance(img_tag, Tag):

docling/backend/md_backend.py

@@ -249,7 +249,10 @@ class MarkdownDocumentBackend(DeclarativeDocumentBackend):
 
         # Iterates over all elements in the AST
         # Check for different element types and process relevant details
-        if isinstance(element, marko.block.Heading) and len(element.children) > 0:
+        if (
+            isinstance(element, marko.block.Heading)
+            or isinstance(element, marko.block.SetextHeading)
+        ) and len(element.children) > 0:
             self._close_table(doc)
             _log.debug(
                 f" - Heading level {element.level}, content: {element.children[0].children}"  # type: ignore

docling/backend/msexcel_backend.py

@@ -18,6 +18,7 @@ from docling_core.types.doc import (
     TableData,
 )
 from openpyxl import load_workbook
+from openpyxl.chartsheet.chartsheet import Chartsheet
 from openpyxl.drawing.image import Image
 from openpyxl.drawing.spreadsheet_drawing import TwoCellAnchor
 from openpyxl.worksheet.worksheet import Worksheet
@@ -186,18 +187,18 @@ class MsExcelDocumentBackend(DeclarativeDocumentBackend, PaginatedDocumentBacken
 
         if self.workbook is not None:
             # Iterate over all sheets
-            for sheet_name in self.workbook.sheetnames:
-                _log.info(f"Processing sheet: {sheet_name}")
+            for idx, name in enumerate(self.workbook.sheetnames):
+                _log.info(f"Processing sheet {idx}: {name}")
 
-                sheet = self.workbook[sheet_name]
-                page_no = self.workbook.index(sheet) + 1
+                sheet = self.workbook[name]
+                page_no = idx + 1
                 # do not rely on sheet.max_column, sheet.max_row if there are images
                 page = doc.add_page(page_no=page_no, size=Size(width=0, height=0))
 
                 self.parents[0] = doc.add_group(
                     parent=None,
                     label=GroupLabel.SECTION,
-                    name=f"sheet: {sheet_name}",
+                    name=f"sheet: {name}",
                     content_layer=self._get_sheet_content_layer(sheet),
                 )
                 doc = self._convert_sheet(doc, sheet)
@@ -208,7 +209,9 @@ class MsExcelDocumentBackend(DeclarativeDocumentBackend, PaginatedDocumentBacken
 
         return doc
 
-    def _convert_sheet(self, doc: DoclingDocument, sheet: Worksheet) -> DoclingDocument:
+    def _convert_sheet(
+        self, doc: DoclingDocument, sheet: Union[Worksheet, Chartsheet]
+    ) -> DoclingDocument:
         """Parse an Excel worksheet and attach its structure to a DoclingDocument
 
         Args:
@@ -218,10 +221,11 @@ class MsExcelDocumentBackend(DeclarativeDocumentBackend, PaginatedDocumentBacken
         Returns:
             The updated DoclingDocument.
         """
+        if isinstance(sheet, Worksheet):
+            doc = self._find_tables_in_sheet(doc, sheet)
+            doc = self._find_images_in_sheet(doc, sheet)
 
-        doc = self._find_tables_in_sheet(doc, sheet)
-
-        doc = self._find_images_in_sheet(doc, sheet)
+        # TODO: parse charts in sheet
 
         return doc
 

docling/cli/main.py

@@ -49,7 +49,7 @@ from docling.datamodel.document import ConversionResult
 from docling.datamodel.pipeline_options import (
     AsrPipelineOptions,
     ConvertPipelineOptions,
-    EasyOcrOptions,
+    OcrAutoOptions,
     OcrOptions,
     PaginatedPipelineOptions,
     PdfBackend,
@@ -57,6 +57,8 @@ from docling.datamodel.pipeline_options import (
     PipelineOptions,
     ProcessingPipeline,
     TableFormerMode,
+    TesseractCliOcrOptions,
+    TesseractOcrOptions,
     VlmPipelineOptions,
 )
 from docling.datamodel.settings import settings
@@ -355,6 +357,13 @@ def convert(  # noqa: C901
             help="Replace any existing text with OCR generated text over the full content.",
         ),
     ] = False,
+    tables: Annotated[
+        bool,
+        typer.Option(
+            ...,
+            help="If enabled, the table structure model will be used to extract table information.",
+        ),
+    ] = True,
     ocr_engine: Annotated[
         str,
         typer.Option(
@@ -365,7 +374,7 @@ def convert(  # noqa: C901
                 f"Use the option --show-external-plugins to see the options allowed with external plugins."
             ),
         ),
-    ] = EasyOcrOptions.kind,
+    ] = OcrAutoOptions.kind,
     ocr_lang: Annotated[
         Optional[str],
         typer.Option(
@@ -373,6 +382,13 @@ def convert(  # noqa: C901
             help="Provide a comma-separated list of languages used by the OCR engine. Note that each OCR engine has different values for the language names.",
         ),
     ] = None,
+    psm: Annotated[
+        Optional[int],
+        typer.Option(
+            ...,
+            help="Page Segmentation Mode for the OCR engine (0-13).",
+        ),
+    ] = None,
     pdf_backend: Annotated[
         PdfBackend, typer.Option(..., help="The PDF backend to use.")
     ] = PdfBackend.DLPARSE_V2,
@@ -540,13 +556,25 @@ def convert(  # noqa: C901
                     if local_path.exists() and local_path.is_dir():
                         for fmt in from_formats:
                             for ext in FormatToExtensions[fmt]:
-                                input_doc_paths.extend(
-                                    list(local_path.glob(f"**/*.{ext}"))
-                                )
-                                input_doc_paths.extend(
-                                    list(local_path.glob(f"**/*.{ext.upper()}"))
-                                )
+                                for path in local_path.glob(f"**/*.{ext}"):
+                                    if path.name.startswith("~$") and ext == "docx":
+                                        _log.info(
+                                            f"Ignoring temporary Word file: {path}"
+                                        )
+                                        continue
+                                    input_doc_paths.append(path)
+
+                                for path in local_path.glob(f"**/*.{ext.upper()}"):
+                                    if path.name.startswith("~$") and ext == "docx":
+                                        _log.info(
+                                            f"Ignoring temporary Word file: {path}"
+                                        )
+                                        continue
+                                    input_doc_paths.append(path)
                     elif local_path.exists():
+                        if not local_path.name.startswith("~$") and ext == "docx":
+                            _log.info(f"Ignoring temporary Word file: {path}")
+                            continue
                         input_doc_paths.append(local_path)
                     else:
                         err_console.print(
@@ -577,6 +605,10 @@ def convert(  # noqa: C901
         ocr_lang_list = _split_list(ocr_lang)
         if ocr_lang_list is not None:
             ocr_options.lang = ocr_lang_list
+        if psm is not None and isinstance(
+            ocr_options, (TesseractOcrOptions, TesseractCliOcrOptions)
+        ):
+            ocr_options.psm = psm
 
         accelerator_options = AcceleratorOptions(num_threads=num_threads, device=device)
         # pipeline_options: PaginatedPipelineOptions
@@ -591,7 +623,7 @@ def convert(  # noqa: C901
                 accelerator_options=accelerator_options,
                 do_ocr=ocr,
                 ocr_options=ocr_options,
-                do_table_structure=True,
+                do_table_structure=tables,
                 do_code_enrichment=enrich_code,
                 do_formula_enrichment=enrich_formula,
                 do_picture_description=enrich_picture_description,

docling/cli/models.py

@@ -38,6 +38,7 @@ class _AvailableModels(str, Enum):
     SMOLDOCLING = "smoldocling"
     SMOLDOCLING_MLX = "smoldocling_mlx"
     GRANITE_VISION = "granite_vision"
+    RAPIDOCR = "rapidocr"
     EASYOCR = "easyocr"
 
 
@@ -46,7 +47,7 @@ _default_models = [
     _AvailableModels.TABLEFORMER,
     _AvailableModels.CODE_FORMULA,
     _AvailableModels.PICTURE_CLASSIFIER,
-    _AvailableModels.EASYOCR,
+    _AvailableModels.RAPIDOCR,
 ]
 
 
@@ -115,6 +116,7 @@ def download(
         with_smoldocling=_AvailableModels.SMOLDOCLING in to_download,
         with_smoldocling_mlx=_AvailableModels.SMOLDOCLING_MLX in to_download,
         with_granite_vision=_AvailableModels.GRANITE_VISION in to_download,
+        with_rapidocr=_AvailableModels.RAPIDOCR in to_download,
         with_easyocr=_AvailableModels.EASYOCR in to_download,
     )
 

docling/datamodel/pipeline_options.py

@@ -81,6 +81,13 @@ class OcrOptions(BaseOptions):
     )
 
 
+class OcrAutoOptions(OcrOptions):
+    """Options for pick OCR engine automatically."""
+
+    kind: ClassVar[Literal["auto"]] = "auto"
+    lang: List[str] = []
+
+
 class RapidOcrOptions(OcrOptions):
     """Options for the RapidOCR engine."""
 
@@ -154,6 +161,9 @@ class TesseractCliOcrOptions(OcrOptions):
     lang: List[str] = ["fra", "deu", "spa", "eng"]
     tesseract_cmd: str = "tesseract"
     path: Optional[str] = None
+    psm: Optional[int] = (
+        None  # Page Segmentation Mode (0-13), defaults to tesseract's default
+    )
 
     model_config = ConfigDict(
         extra="forbid",
@@ -166,6 +176,9 @@ class TesseractOcrOptions(OcrOptions):
     kind: ClassVar[Literal["tesserocr"]] = "tesserocr"
     lang: List[str] = ["fra", "deu", "spa", "eng"]
     path: Optional[str] = None
+    psm: Optional[int] = (
+        None  # Page Segmentation Mode (0-13), defaults to tesseract's default
+    )
 
     model_config = ConfigDict(
         extra="forbid",
@@ -249,6 +262,7 @@ class PdfBackend(str, Enum):
 class OcrEngine(str, Enum):
     """Enum of valid OCR engines."""
 
+    AUTO = "auto"
     EASYOCR = "easyocr"
     TESSERACT_CLI = "tesseract_cli"
     TESSERACT = "tesseract"
@@ -330,7 +344,7 @@ class PdfPipelineOptions(PaginatedPipelineOptions):
     # If True, text from backend will be used instead of generated text
 
     table_structure_options: TableStructureOptions = TableStructureOptions()
-    ocr_options: OcrOptions = EasyOcrOptions()
+    ocr_options: OcrOptions = OcrAutoOptions()
     layout_options: LayoutOptions = LayoutOptions()
 
     images_scale: float = 1.0

docling/models/auto_ocr_model.py

@@ -0,0 +1,132 @@
+import logging
+import sys
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Optional, Type
+
+from docling.datamodel.accelerator_options import AcceleratorOptions
+from docling.datamodel.base_models import Page
+from docling.datamodel.document import ConversionResult
+from docling.datamodel.pipeline_options import (
+    EasyOcrOptions,
+    OcrAutoOptions,
+    OcrMacOptions,
+    OcrOptions,
+    RapidOcrOptions,
+)
+from docling.models.base_ocr_model import BaseOcrModel
+from docling.models.easyocr_model import EasyOcrModel
+from docling.models.ocr_mac_model import OcrMacModel
+from docling.models.rapid_ocr_model import RapidOcrModel
+
+_log = logging.getLogger(__name__)
+
+
+class OcrAutoModel(BaseOcrModel):
+    def __init__(
+        self,
+        enabled: bool,
+        artifacts_path: Optional[Path],
+        options: OcrAutoOptions,
+        accelerator_options: AcceleratorOptions,
+    ):
+        super().__init__(
+            enabled=enabled,
+            artifacts_path=artifacts_path,
+            options=options,
+            accelerator_options=accelerator_options,
+        )
+        self.options: OcrAutoOptions
+
+        self._engine: Optional[BaseOcrModel] = None
+        if self.enabled:
+            if "darwin" == sys.platform:
+                try:
+                    from ocrmac import ocrmac
+
+                    self._engine = OcrMacModel(
+                        enabled=self.enabled,
+                        artifacts_path=artifacts_path,
+                        options=OcrMacOptions(
+                            bitmap_area_threshold=self.options.bitmap_area_threshold,
+                            force_full_page_ocr=self.options.force_full_page_ocr,
+                        ),
+                        accelerator_options=accelerator_options,
+                    )
+                    _log.info("Auto OCR model selected ocrmac.")
+                except ImportError:
+                    _log.info("ocrmac cannot be used because ocrmac is not installed.")
+
+            if self._engine is None:
+                try:
+                    import onnxruntime
+                    from rapidocr import EngineType, RapidOCR  # type: ignore
+
+                    self._engine = RapidOcrModel(
+                        enabled=self.enabled,
+                        artifacts_path=artifacts_path,
+                        options=RapidOcrOptions(
+                            backend="onnxruntime",
+                            bitmap_area_threshold=self.options.bitmap_area_threshold,
+                            force_full_page_ocr=self.options.force_full_page_ocr,
+                        ),
+                        accelerator_options=accelerator_options,
+                    )
+                    _log.info("Auto OCR model selected rapidocr with onnxruntime.")
+                except ImportError:
+                    _log.info(
+                        "rapidocr cannot be used because onnxruntime is not installed."
+                    )
+
+            if self._engine is None:
+                try:
+                    import easyocr
+
+                    self._engine = EasyOcrModel(
+                        enabled=self.enabled,
+                        artifacts_path=artifacts_path,
+                        options=EasyOcrOptions(
+                            bitmap_area_threshold=self.options.bitmap_area_threshold,
+                            force_full_page_ocr=self.options.force_full_page_ocr,
+                        ),
+                        accelerator_options=accelerator_options,
+                    )
+                    _log.info("Auto OCR model selected easyocr.")
+                except ImportError:
+                    _log.info("easyocr cannot be used because it is not installed.")
+
+            if self._engine is None:
+                try:
+                    import torch
+                    from rapidocr import EngineType, RapidOCR  # type: ignore
+
+                    self._engine = RapidOcrModel(
+                        enabled=self.enabled,
+                        artifacts_path=artifacts_path,
+                        options=RapidOcrOptions(
+                            backend="torch",
+                            bitmap_area_threshold=self.options.bitmap_area_threshold,
+                            force_full_page_ocr=self.options.force_full_page_ocr,
+                        ),
+                        accelerator_options=accelerator_options,
+                    )
+                    _log.info("Auto OCR model selected rapidocr with torch.")
+                except ImportError:
+                    _log.info(
+                        "rapidocr cannot be used because rapidocr or torch is not installed."
+                    )
+
+            if self._engine is None:
+                _log.warning("No OCR engine found. Please review the install details.")
+
+    def __call__(
+        self, conv_res: ConversionResult, page_batch: Iterable[Page]
+    ) -> Iterable[Page]:
+        if not self.enabled or self._engine is None:
+            yield from page_batch
+            return
+        yield from self._engine(conv_res, page_batch)
+
+    @classmethod
+    def get_options_type(cls) -> Type[OcrOptions]:
+        return OcrAutoOptions

docling/models/base_model.py

@@ -173,11 +173,11 @@ class BaseItemAndImageEnrichmentModel(
         assert isinstance(element, DocItem)
 
         # Allow the case of documents without page images but embedded images (e.g. Word and HTML docs)
-        if len(element.prov) == 0 and isinstance(element, PictureItem):
+        if isinstance(element, PictureItem):
             embedded_im = element.get_image(conv_res.document)
             if embedded_im is not None:
                 return ItemAndImageEnrichmentElement(item=element, image=embedded_im)
-            else:
+            elif len(element.prov) == 0:
                 return None
 
         # Crop the image form the page

docling/models/plugins/defaults.py

@@ -1,4 +1,5 @@
 def ocr_engines():
+    from docling.models.auto_ocr_model import OcrAutoModel
     from docling.models.easyocr_model import EasyOcrModel
     from docling.models.ocr_mac_model import OcrMacModel
     from docling.models.rapid_ocr_model import RapidOcrModel
@@ -7,6 +8,7 @@ def ocr_engines():
 
     return {
         "ocr_engines": [
+            OcrAutoModel,
             EasyOcrModel,
             OcrMacModel,
             RapidOcrModel,

docling/models/rapid_ocr_model.py

@@ -1,7 +1,7 @@
 import logging
 from collections.abc import Iterable
 from pathlib import Path
-from typing import Optional, Type
+from typing import Literal, Optional, Type, TypedDict
 
 import numpy
 from docling_core.types.doc import BoundingBox, CoordOrigin
@@ -18,11 +18,67 @@ from docling.datamodel.settings import settings
 from docling.models.base_ocr_model import BaseOcrModel
 from docling.utils.accelerator_utils import decide_device
 from docling.utils.profiling import TimeRecorder
+from docling.utils.utils import download_url_with_progress
 
 _log = logging.getLogger(__name__)
 
+_ModelPathEngines = Literal["onnxruntime", "torch"]
+_ModelPathTypes = Literal[
+    "det_model_path", "cls_model_path", "rec_model_path", "rec_keys_path"
+]
+
+
+class _ModelPathDetail(TypedDict):
+    url: str
+    path: str
+
 
 class RapidOcrModel(BaseOcrModel):
+    _model_repo_folder = "RapidOcr"
+    # from https://github.com/RapidAI/RapidOCR/blob/main/python/rapidocr/default_models.yaml
+    # matching the default config in https://github.com/RapidAI/RapidOCR/blob/main/python/rapidocr/config.yaml
+    # and naming f"{file_info.engine_type.value}.{file_info.ocr_version.value}.{file_info.task_type.value}"
+    _default_models: dict[
+        _ModelPathEngines, dict[_ModelPathTypes, _ModelPathDetail]
+    ] = {
+        "onnxruntime": {
+            "det_model_path": {
+                "url": "https://www.modelscope.cn/models/RapidAI/RapidOCR/resolve/v3.4.0/onnx/PP-OCRv4/det/ch_PP-OCRv4_det_infer.onnx",
+                "path": "onnx/PP-OCRv4/det/ch_PP-OCRv4_det_infer.onnx",
+            },
+            "cls_model_path": {
+                "url": "https://www.modelscope.cn/models/RapidAI/RapidOCR/resolve/v3.4.0/onnx/PP-OCRv4/cls/ch_ppocr_mobile_v2.0_cls_infer.onnx",
+                "path": "onnx/PP-OCRv4/cls/ch_ppocr_mobile_v2.0_cls_infer.onnx",
+            },
+            "rec_model_path": {
+                "url": "https://www.modelscope.cn/models/RapidAI/RapidOCR/resolve/v3.4.0/onnx/PP-OCRv4/rec/ch_PP-OCRv4_rec_infer.onnx",
+                "path": "onnx/PP-OCRv4/rec/ch_PP-OCRv4_rec_infer.onnx",
+            },
+            "rec_keys_path": {
+                "url": "https://www.modelscope.cn/models/RapidAI/RapidOCR/resolve/v2.0.7/paddle/PP-OCRv4/rec/ch_PP-OCRv4_rec_infer/ppocr_keys_v1.txt",
+                "path": "paddle/PP-OCRv4/rec/ch_PP-OCRv4_rec_infer/ppocr_keys_v1.txt",
+            },
+        },
+        "torch": {
+            "det_model_path": {
+                "url": "https://www.modelscope.cn/models/RapidAI/RapidOCR/resolve/v3.4.0/torch/PP-OCRv4/det/ch_PP-OCRv4_det_infer.pth",
+                "path": "torch/PP-OCRv4/det/ch_PP-OCRv4_det_infer.pth",
+            },
+            "cls_model_path": {
+                "url": "https://www.modelscope.cn/models/RapidAI/RapidOCR/resolve/v3.4.0/torch/PP-OCRv4/cls/ch_ptocr_mobile_v2.0_cls_infer.pth",
+                "path": "torch/PP-OCRv4/cls/ch_ptocr_mobile_v2.0_cls_infer.pth",
+            },
+            "rec_model_path": {
+                "url": "https://www.modelscope.cn/models/RapidAI/RapidOCR/resolve/v3.4.0/torch/PP-OCRv4/rec/ch_PP-OCRv4_rec_infer.pth",
+                "path": "torch/PP-OCRv4/rec/ch_PP-OCRv4_rec_infer.pth",
+            },
+            "rec_keys_path": {
+                "url": "https://www.modelscope.cn/models/RapidAI/RapidOCR/resolve/v3.4.0/paddle/PP-OCRv4/rec/ch_PP-OCRv4_rec_infer/ppocr_keys_v1.txt",
+                "path": "paddle/PP-OCRv4/rec/ch_PP-OCRv4_rec_infer/ppocr_keys_v1.txt",
+            },
+        },
+    }
+
     def __init__(
         self,
         enabled: bool,
@@ -62,25 +118,66 @@ class RapidOcrModel(BaseOcrModel):
             }
             backend_enum = _ALIASES.get(self.options.backend, EngineType.ONNXRUNTIME)
 
+            det_model_path = self.options.det_model_path
+            cls_model_path = self.options.cls_model_path
+            rec_model_path = self.options.rec_model_path
+            rec_keys_path = self.options.rec_keys_path
+            if artifacts_path is not None:
+                det_model_path = (
+                    det_model_path
+                    or artifacts_path
+                    / self._model_repo_folder
+                    / self._default_models[backend_enum.value]["det_model_path"]["path"]
+                )
+                cls_model_path = (
+                    cls_model_path
+                    or artifacts_path
+                    / self._model_repo_folder
+                    / self._default_models[backend_enum.value]["cls_model_path"]["path"]
+                )
+                rec_model_path = (
+                    rec_model_path
+                    or artifacts_path
+                    / self._model_repo_folder
+                    / self._default_models[backend_enum.value]["rec_model_path"]["path"]
+                )
+                rec_keys_path = (
+                    rec_keys_path
+                    or artifacts_path
+                    / self._model_repo_folder
+                    / self._default_models[backend_enum.value]["rec_keys_path"]["path"]
+                )
+
+            for model_path in (
+                rec_keys_path,
+                cls_model_path,
+                rec_model_path,
+                rec_keys_path,
+            ):
+                if model_path is None:
+                    continue
+                if not Path(model_path).exists():
+                    _log.warning(f"The provided model path {model_path} is not found.")
+
             params = {
                 # Global settings (these are still correct)
                 "Global.text_score": self.options.text_score,
                 "Global.font_path": self.options.font_path,
                 # "Global.verbose": self.options.print_verbose,
                 # Detection model settings
-                "Det.model_path": self.options.det_model_path,
+                "Det.model_path": det_model_path,
                 "Det.use_cuda": use_cuda,
                 "Det.use_dml": use_dml,
                 "Det.intra_op_num_threads": intra_op_num_threads,
                 # Classification model settings
-                "Cls.model_path": self.options.cls_model_path,
+                "Cls.model_path": cls_model_path,
                 "Cls.use_cuda": use_cuda,
                 "Cls.use_dml": use_dml,
                 "Cls.intra_op_num_threads": intra_op_num_threads,
                 # Recognition model settings
-                "Rec.model_path": self.options.rec_model_path,
+                "Rec.model_path": rec_model_path,
                 "Rec.font_path": self.options.rec_font_path,
-                "Rec.keys_path": self.options.rec_keys_path,
+                "Rec.keys_path": rec_keys_path,
                 "Rec.use_cuda": use_cuda,
                 "Rec.use_dml": use_dml,
                 "Rec.intra_op_num_threads": intra_op_num_threads,
@@ -102,6 +199,30 @@ class RapidOcrModel(BaseOcrModel):
                 params=params,
             )
 
+    @staticmethod
+    def download_models(
+        backend: _ModelPathEngines,
+        local_dir: Optional[Path] = None,
+        force: bool = False,
+        progress: bool = False,
+    ) -> Path:
+        if local_dir is None:
+            local_dir = settings.cache_dir / "models" / RapidOcrModel._model_repo_folder
+
+        local_dir.mkdir(parents=True, exist_ok=True)
+
+        # Download models
+        for model_type, model_details in RapidOcrModel._default_models[backend].items():
+            output_path = local_dir / model_details["path"]
+            if output_path.exists() and not force:
+                continue
+            output_path.parent.mkdir(exist_ok=True, parents=True)
+            buf = download_url_with_progress(model_details["url"], progress=progress)
+            with output_path.open("wb") as fw:
+                fw.write(buf.read())
+
+        return local_dir
+
     def __call__(
         self, conv_res: ConversionResult, page_batch: Iterable[Page]
     ) -> Iterable[Page]:

docling/models/readingorder_model.py

@@ -9,6 +9,7 @@ from docling_core.types.doc import (
     NodeItem,
     ProvenanceItem,
     RefItem,
+    RichTableCell,
     TableData,
 )
 from docling_core.types.doc.document import ContentLayer
@@ -103,6 +104,22 @@ class ReadingOrderModel:
             else:
                 doc.add_text(parent=doc_item, label=c_label, text=c_text, prov=c_prov)
 
+    def _create_rich_cell_group(
+        self, element: BasePageElement, doc: DoclingDocument, table_item: NodeItem
+    ) -> RefItem:
+        """Create a group containing all child elements for a rich table cell."""
+        group_name = f"rich_cell_group_{len(doc.tables)}_0_0"
+        group_element = doc.add_group(
+            label=GroupLabel.UNSPECIFIED,
+            name=group_name,
+            parent=table_item,
+        )
+
+        # Add all child elements to the group
+        self._add_child_elements(element, group_element, doc)
+
+        return group_element.get_ref()
+
     def _readingorder_elements_to_docling_doc(
         self,
         conv_res: ConversionResult,
@@ -197,11 +214,21 @@ class ReadingOrderModel:
                             )
 
             elif isinstance(element, Table):
-                tbl_data = TableData(
-                    num_rows=element.num_rows,
-                    num_cols=element.num_cols,
-                    table_cells=element.table_cells,
-                )
+                # Check if table has no structure prediction
+                if element.num_rows == 0 and element.num_cols == 0:
+                    # Only create 1x1 table if there are children to put in it
+                    if element.cluster.children:
+                        # Create minimal 1x1 table with rich cell containing all children
+                        tbl_data = TableData(num_rows=1, num_cols=1, table_cells=[])
+                    else:
+                        # Create empty table with no structure
+                        tbl_data = TableData(num_rows=0, num_cols=0, table_cells=[])
+                else:
+                    tbl_data = TableData(
+                        num_rows=element.num_rows,
+                        num_cols=element.num_cols,
+                        table_cells=element.table_cells,
+                    )
 
                 prov = ProvenanceItem(
                     page_no=element.page_no + 1,
@@ -231,6 +258,30 @@ class ReadingOrderModel:
 
                         tbl.footnotes.append(new_footnote_item.get_ref())
 
+                # Handle case where table has no structure prediction but has children
+                if (
+                    element.num_rows == 0
+                    and element.num_cols == 0
+                    and element.cluster.children
+                ):
+                    # Create rich cell containing all child elements
+                    rich_cell_ref = self._create_rich_cell_group(element, out_doc, tbl)
+
+                    # Create rich table cell spanning the entire 1x1 table
+                    rich_cell = RichTableCell(
+                        text="",  # Empty text since content is in the group
+                        row_span=1,
+                        col_span=1,
+                        start_row_offset_idx=0,
+                        end_row_offset_idx=1,
+                        start_col_offset_idx=0,
+                        end_col_offset_idx=1,
+                        column_header=False,
+                        row_header=False,
+                        ref=rich_cell_ref,
+                    )
+                    out_doc.add_table_cell(table_item=tbl, cell=rich_cell)
+
                 # TODO: Consider adding children of Table.
 
             elif isinstance(element, FigureElement):

docling/models/tesseract_ocr_cli_model.py

@@ -117,6 +117,10 @@ class TesseractOcrCliModel(BaseOcrModel):
             cmd.append("--tessdata-dir")
             cmd.append(self.options.path)
 
+        # Add PSM option if specified in the configuration
+        if self.options.psm is not None:
+            cmd.extend(["--psm", str(self.options.psm)])
+
         cmd += [ifilename, "stdout", "tsv"]
         _log.info("command: {}".format(" ".join(cmd)))
 

docling/models/tesseract_ocr_model.py

@@ -86,7 +86,6 @@ class TesseractOcrModel(BaseOcrModel):
                 self.script_prefix = ""
 
             tesserocr_kwargs = {
-                "psm": tesserocr.PSM.AUTO,
                 "init": True,
                 "oem": tesserocr.OEM.DEFAULT,
             }
@@ -96,14 +95,23 @@ class TesseractOcrModel(BaseOcrModel):
             if self.options.path is not None:
                 tesserocr_kwargs["path"] = self.options.path
 
+            # Set main OCR reader with configurable PSM
+            main_psm = (
+                tesserocr.PSM(self.options.psm)
+                if self.options.psm is not None
+                else tesserocr.PSM.AUTO
+            )
             if lang == "auto":
-                self.reader = tesserocr.PyTessBaseAPI(**tesserocr_kwargs)
+                self.reader = tesserocr.PyTessBaseAPI(psm=main_psm, **tesserocr_kwargs)
             else:
                 self.reader = tesserocr.PyTessBaseAPI(
-                    **{"lang": lang} | tesserocr_kwargs,
+                    lang=lang,
+                    psm=main_psm,
+                    **tesserocr_kwargs,
                 )
+            # OSD reader must use PSM.OSD_ONLY for orientation detection
             self.osd_reader = tesserocr.PyTessBaseAPI(
-                **{"lang": "osd", "psm": tesserocr.PSM.OSD_ONLY} | tesserocr_kwargs
+                lang="osd", psm=tesserocr.PSM.OSD_ONLY, **tesserocr_kwargs
             )
             self.reader_RIL = tesserocr.RIL
 
@@ -187,7 +195,9 @@ class TesseractOcrModel(BaseOcrModel):
                                         tesserocr.PyTessBaseAPI(
                                             path=self.reader.GetDatapath(),
                                             lang=lang,
-                                            psm=tesserocr.PSM.AUTO,
+                                            psm=tesserocr.PSM(self.options.psm)
+                                            if self.options.psm is not None
+                                            else tesserocr.PSM.AUTO,
                                             init=True,
                                             oem=tesserocr.OEM.DEFAULT,
                                         )

docling/pipeline/asr_pipeline.py

@@ -1,6 +1,7 @@
 import logging
 import os
 import re
+import tempfile
 from io import BytesIO
 from pathlib import Path
 from typing import List, Optional, Union, cast
@@ -147,7 +148,25 @@ class _NativeWhisperModel:
             self.word_timestamps = asr_options.word_timestamps
 
     def run(self, conv_res: ConversionResult) -> ConversionResult:
-        audio_path: Path = Path(conv_res.input.file).resolve()
+        # Access the file path from the backend, similar to how other pipelines handle it
+        path_or_stream = conv_res.input._backend.path_or_stream
+
+        # Handle both Path and BytesIO inputs
+        temp_file_path: Optional[Path] = None
+
+        if isinstance(path_or_stream, BytesIO):
+            # For BytesIO, write to a temporary file since whisper requires a file path
+            suffix = Path(conv_res.input.file.name).suffix or ".wav"
+            with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp_file:
+                tmp_file.write(path_or_stream.getvalue())
+                temp_file_path = Path(tmp_file.name)
+            audio_path = temp_file_path
+        elif isinstance(path_or_stream, Path):
+            audio_path = path_or_stream
+        else:
+            raise RuntimeError(
+                f"ASR pipeline requires a file path or BytesIO stream, but got {type(path_or_stream)}"
+            )
 
         try:
             conversation = self.transcribe(audio_path)
@@ -167,14 +186,22 @@ class _NativeWhisperModel:
                     label=DocItemLabel.TEXT, text=citem.to_string()
                 )
 
-            conv_res.status = ConversionStatus.SUCCESS
             return conv_res
 
         except Exception as exc:
             _log.error(f"Audio tranciption has an error: {exc}")
+            conv_res.status = ConversionStatus.FAILURE
+            return conv_res
 
-        conv_res.status = ConversionStatus.FAILURE
-        return conv_res
+        finally:
+            # Clean up temporary file if created
+            if temp_file_path is not None and temp_file_path.exists():
+                try:
+                    temp_file_path.unlink()
+                except Exception as e:
+                    _log.warning(
+                        f"Failed to delete temporary file {temp_file_path}: {e}"
+                    )
 
     def transcribe(self, fpath: Path) -> list[_ConversationItem]:
         result = self.model.transcribe(
@@ -221,9 +248,29 @@ class AsrPipeline(BasePipeline):
         else:
             _log.error(f"No model support for {self.pipeline_options.asr_options}")
 
+    def _has_text(self, document: "DoclingDocument") -> bool:
+        """
+        Helper method to check if the document contains any transcribed text.
+        A transcription is considered non-empty if the .texts list contains items with actual, non whitespace content.
+        """
+        if not document or not document.texts:
+            return False
+        for item in document.texts:
+            if item.text and item.text.strip():
+                return True
+        return False
+
     def _determine_status(self, conv_res: ConversionResult) -> ConversionStatus:
-        status = ConversionStatus.SUCCESS
-        return status
+        """Determines the final status of ASR Conversion based on its result."""
+        if conv_res.status == ConversionStatus.FAILURE or conv_res.errors:
+            return ConversionStatus.FAILURE
+        if not self._has_text(conv_res.document):
+            _log.warning(
+                "ASR conversion resulted in an empty document."
+                f"File: {conv_res.input.file.name}"
+            )
+            return ConversionStatus.PARTIAL_SUCCESS
+        return ConversionStatus.SUCCESS
 
     @classmethod
     def get_default_options(cls) -> AsrPipelineOptions:

docling/utils/model_downloader.py

@@ -20,6 +20,7 @@ from docling.models.document_picture_classifier import DocumentPictureClassifier
 from docling.models.easyocr_model import EasyOcrModel
 from docling.models.layout_model import LayoutModel
 from docling.models.picture_description_vlm_model import PictureDescriptionVlmModel
+from docling.models.rapid_ocr_model import RapidOcrModel
 from docling.models.table_structure_model import TableStructureModel
 from docling.models.utils.hf_model_download import download_hf_model
 
@@ -41,6 +42,7 @@ def download_models(
     with_smoldocling: bool = False,
     with_smoldocling_mlx: bool = False,
     with_granite_vision: bool = False,
+    with_rapidocr: bool = True,
     with_easyocr: bool = True,
 ):
     if output_dir is None:
@@ -135,6 +137,16 @@ def download_models(
             progress=progress,
         )
 
+    if with_rapidocr:
+        for backend in ("torch", "onnxruntime"):
+            _log.info(f"Downloading rapidocr {backend} models...")
+            RapidOcrModel.download_models(
+                backend=backend,
+                local_dir=output_dir / RapidOcrModel._model_repo_folder,
+                force=force,
+                progress=progress,
+            )
+
     if with_easyocr:
         _log.info("Downloading easyocr models...")
         EasyOcrModel.download_models(

{docling-2.55.0.dist-info → docling-2.56.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling
-Version: 2.55.0
+Version: 2.56.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.
 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
@@ -34,7 +34,8 @@ Requires-Dist: pypdfium2!=4.30.1,<5.0.0,>=4.30.0
 Requires-Dist: pydantic-settings<3.0.0,>=2.3.0
 Requires-Dist: huggingface_hub<1,>=0.23
 Requires-Dist: requests<3.0.0,>=2.32.2
-Requires-Dist: easyocr<2.0,>=1.7
+Requires-Dist: ocrmac<2.0.0,>=1.0.0; sys_platform == "darwin"
+Requires-Dist: rapidocr<4.0.0,>=3.3; python_version < "3.14"
 Requires-Dist: certifi>=2024.7.4
 Requires-Dist: rtree<2.0.0,>=1.3.0
 Requires-Dist: typer<0.20.0,>=0.12.5
@@ -52,6 +53,8 @@ Requires-Dist: pylatexenc<3.0,>=2.10
 Requires-Dist: scipy<2.0.0,>=1.6.0
 Requires-Dist: accelerate<2,>=1.0.0
 Requires-Dist: polyfactory>=2.22.2
+Provides-Extra: easyocr
+Requires-Dist: easyocr<2.0,>=1.7; extra == "easyocr"
 Provides-Extra: tesserocr
 Requires-Dist: tesserocr<3.0.0,>=2.7.1; extra == "tesserocr"
 Provides-Extra: ocrmac
@@ -65,7 +68,6 @@ Requires-Dist: qwen-vl-utils>=0.0.11; extra == "vlm"
 Provides-Extra: rapidocr
 Requires-Dist: rapidocr<4.0.0,>=3.3; python_version < "3.14" and extra == "rapidocr"
 Requires-Dist: onnxruntime<2.0.0,>=1.7.0; extra == "rapidocr"
-Requires-Dist: modelscope>=1.29.0; extra == "rapidocr"
 Provides-Extra: asr
 Requires-Dist: openai-whisper>=20250625; extra == "asr"
 Dynamic: license-file

{docling-2.55.0.dist-info → docling-2.56.0.dist-info}/RECORD

@@ -10,10 +10,10 @@ 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=xCBbaaXjNNrOaod9tmBuCbe5mL_ipmTNG2XOxVbGG3w,7891
-docling/backend/html_backend.py,sha256=r2m3aIKwwr8Vv2Fxri1FaZFvd4EWvTQlmSPwXeD79zg,47796
-docling/backend/md_backend.py,sha256=zrOUYoIYudUfigwnXRQocb_M4G_ptYfblNgr6BNTYQw,22678
+docling/backend/html_backend.py,sha256=iuRyYztUduyP214X0SyDvl1dP_h0eccp5RkuM72rV8o,48664
+docling/backend/md_backend.py,sha256=TWboEPHl93pqI_Go1a3XpP-KpzI3d17xo5ZW42Ul0kY,22764
 docling/backend/mets_gbs_backend.py,sha256=EA8sY6tbmGiysKGYPPZiNlK-i7Adn8bLTo-7Ym15hTU,12774
-docling/backend/msexcel_backend.py,sha256=5JRbPwOjR1r45AMeIts1rj6InbOgLBf_CtAhvNPVmsQ,19157
+docling/backend/msexcel_backend.py,sha256=GOuA-MlShpzFmCmJq3-Z28iquwWUg4k8v-AT4O-aAQI,19305
 docling/backend/mspowerpoint_backend.py,sha256=wJgB2JStEPfD7MPpWQlpPN7bffPxaHFUnKD4wj8SLxU,15114
 docling/backend/msword_backend.py,sha256=Jfd57hzG8iFVAzqsOAHe5jG8LCHAIBXJhQCW0tESnMM,54405
 docling/backend/noop_backend.py,sha256=EOPbD86FzZPX-K_DpNrJh0_lC0bZz--4DpG-OagDNGY,1688
@@ -31,8 +31,8 @@ docling/backend/xml/jats_backend.py,sha256=_BWpQQg3SlsHAOOj0v2qRJoVqaQzL91GqN1tK
 docling/backend/xml/uspto_backend.py,sha256=Tv4CE7V5_QwxTNJPl90CAd_mAbwaLGy8S6s6evh1Xow,70910
 docling/chunking/__init__.py,sha256=h83TDs0AuOV6oEPLAPrn9dpGKiU-2Vg6IRNo4cv6GDA,346
 docling/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-docling/cli/main.py,sha256=UX-5fRGVP_yGxTQez0x1PNnaNKRgWdcXGoPCHy-0uFM,32887
-docling/cli/models.py,sha256=rw_2JfeJ-k_iOLpz3JfgL1QbJY__W9nE23nHdov6VfU,6252
+docling/cli/main.py,sha256=cvDS6CTME2B2Mrm4l9yNynOUDVsZ9ZTlA6mM_jsa5jU,34258
+docling/cli/models.py,sha256=zZBFQJAD7C5sespnYy5M__4qC_GyqAZ-QpfWtgPRDB0,6343
 docling/cli/tools.py,sha256=QhtRxQG0TVrfsMqdv5i7J0_qQy1ZZyWYnHPwJl7b5oY,322
 docling/datamodel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 docling/datamodel/accelerator_options.py,sha256=wv6dOFTVAwr9onkE-0pfUqX_fDb6gX53iPPE6o8nKjI,2511
@@ -41,14 +41,15 @@ docling/datamodel/base_models.py,sha256=CQ6eThPzVeVD2Gq7BNz9Q5RDLwhe4NgMzk7tdLtk
 docling/datamodel/document.py,sha256=HyO3kdJcXIJ3wL95sPoL3zvsO4Rww3-qHH6IkL4I0q4,17483
 docling/datamodel/extraction.py,sha256=7dgvtK5SuvgfB8LHAwS1FwrW1kcMQJuJG0ol8uAQgoQ,1323
 docling/datamodel/layout_model_specs.py,sha256=GSkJ-Z_0PVgwWGi7C7TsxbzRjlrWS9ZrHJjHumv-Z5U,2339
-docling/datamodel/pipeline_options.py,sha256=28opZ3woXA8IKaG2-BHM-lmmi-gyuScCMHGxhlxGOsk,11290
+docling/datamodel/pipeline_options.py,sha256=dklSaA7P6VkjbBB-Pz2OyzO2SQuV9y0I8VVr9XHJusw,11692
 docling/datamodel/pipeline_options_asr_model.py,sha256=7X068xl-qpbyPxC7-TwX7Q6tLyZXGT5h1osZ_xLNLM0,1454
 docling/datamodel/pipeline_options_vlm_model.py,sha256=Szdq5_MhqQ8xBCvOUkdn_LLV29ZMQJcF4xnItYlkmXQ,3090
 docling/datamodel/settings.py,sha256=c0MTw6pO5be_BKxHKYl4SaBJAw_qL-aapxp-g5HHj1A,2084
 docling/datamodel/vlm_model_specs.py,sha256=9TTmihDEFcI-TY1jJ2GTnTcrGa3bLg0e6anN4gPtFgU,10035
 docling/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 docling/models/api_vlm_model.py,sha256=iNQ9LiT031Mch-LHn8O2CskVXYkr4weEetZPxynU_9U,4236
-docling/models/base_model.py,sha256=LSaJWkSaDyLBVB4Fv9fkw6kmJ67QnG0t32iGn_u2WjE,7256
+docling/models/auto_ocr_model.py,sha256=nn_eQfNdGUclXKrB0nodHmCqgMUNUJzG3dLq0lhlNAI,5188
+docling/models/base_model.py,sha256=QEbglxu3kT6aNq3x_5jY8T_KcD_Hhv9zr0-A4Mizhco,7252
 docling/models/base_ocr_model.py,sha256=kT8TylASOpPlY60rIG6VL6_eLVsfg5KvEVnZHzDWtR0,8193
 docling/models/code_formula_model.py,sha256=XRugm4EwifLRc-TrAk-glKlktJP-nAPneKh2EOovkJU,11308
 docling/models/document_picture_classifier.py,sha256=9JvoWeH5uQBC7levjM8zptk7UT-b8EQnD-2EnxTjTT4,6202
@@ -60,17 +61,17 @@ docling/models/page_preprocessing_model.py,sha256=EmusNexws5ZmR93js_saVU0BedqZ_H
 docling/models/picture_description_api_model.py,sha256=o3EkV5aHW_6WzE_fdj_VRnNCrS_btclO_ZCLAUqrfl0,2377
 docling/models/picture_description_base_model.py,sha256=kLthLhdlgwhootQ4_xhhcAk6A-vso5-qcsFJ3TcYfO0,2991
 docling/models/picture_description_vlm_model.py,sha256=Uja_BQSk7F-U1J2hm4yeLguirUzKYv1K8zRyw1IYomY,4150
-docling/models/rapid_ocr_model.py,sha256=anUVUwaj9Wubgu4FnHdYMuOVkQP_hJiLY1qRToelBoc,7700
-docling/models/readingorder_model.py,sha256=_usJdpM4GMWeGGneEwLLxa9grIGQb0XnNMugV72jGbY,14911
+docling/models/rapid_ocr_model.py,sha256=JGeed1aNO64SYFgxlOifdut4fynUJyBuyyQrfuSno-4,13182
+docling/models/readingorder_model.py,sha256=-j-UuvnsYWqZvY0gByKz0bjcBwOhWQTHerCopig_jVs,17266
 docling/models/table_structure_model.py,sha256=7g_mFf1YzfF8PXQfefNu6XYZu7TzJAn86zKb6IEUdCg,12518
-docling/models/tesseract_ocr_cli_model.py,sha256=I3Gn28Y-LD8OfvyCElN9fLiNgpo2sT0uMkVt258253s,12881
-docling/models/tesseract_ocr_model.py,sha256=GdI5Cjfi87qcehVbM3wdKRvKkl_F9A4bwTUbjXZCJYA,10745
+docling/models/tesseract_ocr_cli_model.py,sha256=KuO4rXc-88C2-cAymvcr41TqFi3hNg4gerEzoI3Z6m4,13039
+docling/models/tesseract_ocr_model.py,sha256=W_476USwExjSfhelXG8B9eNIVXXlm_dNFA60TZ5rq7E,11216
 docling/models/factories/__init__.py,sha256=x_EM5dDg_A3HBcBYzOoqwmA2AFLtJ1IzYDPX-R1A-Sg,868
 docling/models/factories/base_factory.py,sha256=MfWIljMETi5aaVR-6qLTelW8u1gwDAQsOwg3fu7O4Qc,4028
 docling/models/factories/ocr_factory.py,sha256=G5RkmkKvkl-ihpo6qSj8WC77VdlVSQ1s0ekwUX2ILts,316
 docling/models/factories/picture_description_factory.py,sha256=Ru3-TnVVEKf5O07C_UpGf2HCOHc7j20AJzfficw3agM,385
 docling/models/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-docling/models/plugins/defaults.py,sha256=OAHWW2tCcUXSyDMFxV_lXVRjSBJ1n6z-Eb3R8cDucU4,886
+docling/models/plugins/defaults.py,sha256=ZJq_hDg_HTmRNvM6siLBqgtHNb-oHzj3dQU_RVAbyYM,971
 docling/models/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 docling/models/utils/generation_utils.py,sha256=0ZfMBMbolHAWjdbMza8FbD4_jQ4VY6ReUa4gqVLwMoU,5365
 docling/models/utils/hf_model_download.py,sha256=VlKna9tLIVOGQkIRQBXfDimPIIyeRV7cFCbuOVmFQiU,1092
@@ -80,7 +81,7 @@ docling/models/vlm_models_inline/mlx_model.py,sha256=ae7hDMgBsMLkqulmbKDamGSSrLJ
 docling/models/vlm_models_inline/nuextract_transformers_model.py,sha256=jLNtlkMDheUyWot7Oqq-GHQIYzJ0fZrbReq5xCnYb9E,10506
 docling/models/vlm_models_inline/vllm_model.py,sha256=vXClayYxPGX1jzQ1Rvf3vvwtW9khgApGvcRz4Qbyu7I,10293
 docling/pipeline/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-docling/pipeline/asr_pipeline.py,sha256=S55VHLoX3Mgauen1YP-PSUlI0LA1bgTgTkU-eC4U-dg,8481
+docling/pipeline/asr_pipeline.py,sha256=oRluG28no3ezjbtL7nJLpDcxxxJuuULNXheq1W-qklM,10629
 docling/pipeline/base_extraction_pipeline.py,sha256=GYrEz83IXv-tdIHjtNWxMBNczFwL8SZyf9vnPJ3STaI,2627
 docling/pipeline/base_pipeline.py,sha256=NPMQDTyis-LgQ4SybY2f5AESZl5PxogF-FRQuCDckXg,12748
 docling/pipeline/extraction_vlm_pipeline.py,sha256=veUOTe8nGdnduZKaGn1RRb-NfU1H6t_EN4QAsb022Zg,8260
@@ -95,15 +96,15 @@ 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=sE9UR3Nv4iOk26uoIsN3bFioE7ScfAjj0orDBDneLXg,25166
 docling/utils/locks.py,sha256=RzqQtD5UispgV71pGN_nU6GYfeN11BN0Sh_Dq9ycqGo,52
-docling/utils/model_downloader.py,sha256=kFIxr5KUQbisQH0h8yP9GZMqsRJD3Xo1uOIiLiB1T78,4869
+docling/utils/model_downloader.py,sha256=NjVn6ZhGcRwuLU93NYblRQpXOD8dB3pb1WC1bLEbF_E,5324
 docling/utils/ocr_utils.py,sha256=nmresYyfin0raanpQc_GGeU3WoLsfExf6SEXNIQ7Djg,2325
 docling/utils/orientation.py,sha256=jTyLxyT31FlOodZoBMlADHNQK2lAWKYVs5z7pXd_6Cg,1842
 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.55.0.dist-info/licenses/LICENSE,sha256=mBb7ErEcM8VS9OhiGHnQ2kk75HwPhr54W1Oiz3965MY,1088
-docling-2.55.0.dist-info/METADATA,sha256=e1RK_bATZ2Q_Ie9kC6uHFCj99D7pkW678jxk_l0CHxk,11252
-docling-2.55.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-docling-2.55.0.dist-info/entry_points.txt,sha256=hzVlbeE0aMSTQ9S0-NTYN0Hmgsn6qL_EA2qX4UbkAuY,149
-docling-2.55.0.dist-info/top_level.txt,sha256=vkIywP-USjFyYo1AIRQbWQQaL3xB5jf8vkCYdTIfNic,8
-docling-2.55.0.dist-info/RECORD,,
+docling-2.56.0.dist-info/licenses/LICENSE,sha256=mBb7ErEcM8VS9OhiGHnQ2kk75HwPhr54W1Oiz3965MY,1088
+docling-2.56.0.dist-info/METADATA,sha256=jNEpaC8pNgpI_qbjYnBaBMHBoDRtBbKeXgMKhBEo_Xk,11364
+docling-2.56.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+docling-2.56.0.dist-info/entry_points.txt,sha256=hzVlbeE0aMSTQ9S0-NTYN0Hmgsn6qL_EA2qX4UbkAuY,149
+docling-2.56.0.dist-info/top_level.txt,sha256=vkIywP-USjFyYo1AIRQbWQQaL3xB5jf8vkCYdTIfNic,8
+docling-2.56.0.dist-info/RECORD,,