docling 2.7.1__tar.gz → 2.8.0__tar.gz

{docling-2.7.1 → docling-2.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: docling
-Version: 2.7.1
+Version: 2.8.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/DS4SD/docling
 License: MIT
@@ -21,11 +21,12 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Provides-Extra: ocrmac
+Provides-Extra: rapidocr
 Provides-Extra: tesserocr
 Requires-Dist: beautifulsoup4 (>=4.12.3,<5.0.0)
 Requires-Dist: certifi (>=2024.7.4)
 Requires-Dist: deepsearch-glm (>=0.26.1,<0.27.0)
-Requires-Dist: docling-core (>=2.4.0,<3.0.0)
+Requires-Dist: docling-core (>=2.5.1,<3.0.0)
 Requires-Dist: docling-ibm-models (>=2.0.6,<3.0.0)
 Requires-Dist: docling-parse (>=2.0.5,<3.0.0)
 Requires-Dist: easyocr (>=1.7,<2.0)
@@ -34,6 +35,8 @@ Requires-Dist: huggingface_hub (>=0.23,<1)
 Requires-Dist: lxml (>=4.0.0,<6.0.0)
 Requires-Dist: marko (>=2.1.2,<3.0.0)
 Requires-Dist: ocrmac (>=1.0.0,<2.0.0) ; (sys_platform == "darwin") and (extra == "ocrmac")
+Requires-Dist: onnxruntime (>=1.7.0,<1.20.0) ; (python_version < "3.10") and (extra == "rapidocr")
+Requires-Dist: onnxruntime (>=1.7.0,<2.0.0) ; (python_version >= "3.10") and (extra == "rapidocr")
 Requires-Dist: openpyxl (>=3.1.5,<4.0.0)
 Requires-Dist: pandas (>=2.1.4,<3.0.0)
 Requires-Dist: pyarrow (>=16.1.0,<17.0.0)
@@ -42,6 +45,7 @@ Requires-Dist: pydantic-settings (>=2.3.0,<3.0.0)
 Requires-Dist: pypdfium2 (>=4.30.0,<5.0.0)
 Requires-Dist: python-docx (>=1.1.2,<2.0.0)
 Requires-Dist: python-pptx (>=1.0.2,<2.0.0)
+Requires-Dist: rapidocr-onnxruntime (>=1.4.0,<2.0.0) ; (python_version < "3.13") and (extra == "rapidocr")
 Requires-Dist: requests (>=2.32.3,<3.0.0)
 Requires-Dist: rtree (>=1.3.0,<2.0.0)
 Requires-Dist: scipy (>=1.6.0,<2.0.0)

{docling-2.7.1 → docling-2.8.0}/docling/backend/msword_backend.py

@@ -507,18 +507,19 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
 
         image_data = get_docx_image(element, drawing_blip)
         image_bytes = BytesIO(image_data)
+        level = self.get_level()
         # Open the BytesIO object with PIL to create an Image
         try:
             pil_image = Image.open(image_bytes)
             doc.add_picture(
-                parent=self.parents[self.level],
+                parent=self.parents[level - 1],
                 image=ImageRef.from_pil(image=pil_image, dpi=72),
                 caption=None,
             )
         except (UnidentifiedImageError, OSError) as e:
             _log.warning("Warning: image cannot be loaded by Pillow")
             doc.add_picture(
-                parent=self.parents[self.level],
+                parent=self.parents[level - 1],
                 caption=None,
             )
         return

{docling-2.7.1 → docling-2.8.0}/docling/cli/main.py

@@ -27,6 +27,7 @@ from docling.datamodel.pipeline_options import (
     OcrMacOptions,
     OcrOptions,
     PdfPipelineOptions,
+    RapidOcrOptions,
     TableFormerMode,
     TesseractCliOcrOptions,
     TesseractOcrOptions,
@@ -76,6 +77,7 @@ class OcrEngine(str, Enum):
     TESSERACT_CLI = "tesseract_cli"
     TESSERACT = "tesseract"
     OCRMAC = "ocrmac"
+    RAPIDOCR = "rapidocr"
 
 
 def export_documents(
@@ -262,6 +264,8 @@ def convert(
         ocr_options = TesseractOcrOptions(force_full_page_ocr=force_ocr)
     elif ocr_engine == OcrEngine.OCRMAC:
         ocr_options = OcrMacOptions(force_full_page_ocr=force_ocr)
+    elif ocr_engine == OcrEngine.RAPIDOCR:
+        ocr_options = RapidOcrOptions(force_full_page_ocr=force_ocr)
     else:
         raise RuntimeError(f"Unexpected OCR engine type {ocr_engine}")
 

{docling-2.7.1 → docling-2.8.0}/docling/datamodel/pipeline_options.py

@@ -29,6 +29,42 @@ class OcrOptions(BaseModel):
     )
 
 
+class RapidOcrOptions(OcrOptions):
+    kind: Literal["rapidocr"] = "rapidocr"
+
+    # English and chinese are the most commly used models and have been tested with RapidOCR.
+    lang: List[str] = [
+        "english",
+        "chinese",
+    ]  # However, language as a parameter is not supported by rapidocr yet and hence changing this options doesn't affect anything.
+    # For more details on supported languages by RapidOCR visit https://rapidai.github.io/RapidOCRDocs/blog/2022/09/28/%E6%94%AF%E6%8C%81%E8%AF%86%E5%88%AB%E8%AF%AD%E8%A8%80/
+
+    # For more details on the following options visit https://rapidai.github.io/RapidOCRDocs/install_usage/api/RapidOCR/
+    text_score: float = 0.5  # same default as rapidocr
+
+    use_det: Optional[bool] = None  # same default as rapidocr
+    use_cls: Optional[bool] = None  # same default as rapidocr
+    use_rec: Optional[bool] = None  # same default as rapidocr
+
+    # class Device(Enum):
+    #     CPU = "CPU"
+    #     CUDA = "CUDA"
+    #     DIRECTML = "DIRECTML"
+    #     AUTO = "AUTO"
+
+    # device: Device = Device.AUTO  # Default value is AUTO
+
+    print_verbose: bool = False  # same default as rapidocr
+
+    det_model_path: Optional[str] = None  # same default as rapidocr
+    cls_model_path: Optional[str] = None  # same default as rapidocr
+    rec_model_path: Optional[str] = None  # same default as rapidocr
+
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+
+
 class EasyOcrOptions(OcrOptions):
     kind: Literal["easyocr"] = "easyocr"
     lang: List[str] = ["fr", "de", "es", "en"]

docling-2.8.0/docling/models/rapid_ocr_model.py

@@ -0,0 +1,147 @@
+import logging
+from typing import Iterable
+
+import numpy
+from docling_core.types.doc import BoundingBox, CoordOrigin
+
+from docling.datamodel.base_models import OcrCell, Page
+from docling.datamodel.document import ConversionResult
+from docling.datamodel.pipeline_options import RapidOcrOptions
+from docling.datamodel.settings import settings
+from docling.models.base_ocr_model import BaseOcrModel
+from docling.utils.profiling import TimeRecorder
+
+_log = logging.getLogger(__name__)
+
+
+class RapidOcrModel(BaseOcrModel):
+    def __init__(self, enabled: bool, options: RapidOcrOptions):
+        super().__init__(enabled=enabled, options=options)
+        self.options: RapidOcrOptions
+
+        self.scale = 3  # multiplier for 72 dpi == 216 dpi.
+
+        if self.enabled:
+            try:
+                from rapidocr_onnxruntime import RapidOCR  # type: ignore
+            except ImportError:
+                raise ImportError(
+                    "RapidOCR is not installed. Please install it via `pip install rapidocr_onnxruntime` to use this OCR engine. "
+                    "Alternatively, Docling has support for other OCR engines. See the documentation."
+                )
+
+            # This configuration option will be revamped while introducing device settings for all models.
+            # For the moment we will default to auto and let onnx-runtime pick the best.
+            cls_use_cuda = True
+            rec_use_cuda = True
+            det_use_cuda = True
+            det_use_dml = True
+            cls_use_dml = True
+            rec_use_dml = True
+
+            # # Same as Defaults in RapidOCR
+            # cls_use_cuda = False
+            # rec_use_cuda = False
+            # det_use_cuda = False
+            # det_use_dml = False
+            # cls_use_dml = False
+            # rec_use_dml = False
+
+            # # If we set everything to true onnx-runtime would automatically choose the fastest accelerator
+            # if self.options.device == self.options.Device.AUTO:
+            #     cls_use_cuda = True
+            #     rec_use_cuda = True
+            #     det_use_cuda = True
+            #     det_use_dml = True
+            #     cls_use_dml = True
+            #     rec_use_dml = True
+
+            # # If we set use_cuda to true onnx would use the cuda device available in runtime if no cuda device is available it would run on CPU.
+            # elif self.options.device == self.options.Device.CUDA:
+            #     cls_use_cuda = True
+            #     rec_use_cuda = True
+            #     det_use_cuda = True
+
+            # # If we set use_dml to true onnx would use the dml device available in runtime if no dml device is available it would work on CPU.
+            # elif self.options.device == self.options.Device.DIRECTML:
+            #     det_use_dml = True
+            #     cls_use_dml = True
+            #     rec_use_dml = True
+
+            self.reader = RapidOCR(
+                text_score=self.options.text_score,
+                cls_use_cuda=cls_use_cuda,
+                rec_use_cuda=rec_use_cuda,
+                det_use_cuda=det_use_cuda,
+                det_use_dml=det_use_dml,
+                cls_use_dml=cls_use_dml,
+                rec_use_dml=rec_use_dml,
+                print_verbose=self.options.print_verbose,
+                det_model_path=self.options.det_model_path,
+                cls_model_path=self.options.cls_model_path,
+                rec_model_path=self.options.rec_model_path,
+            )
+
+    def __call__(
+        self, conv_res: ConversionResult, page_batch: Iterable[Page]
+    ) -> Iterable[Page]:
+
+        if not self.enabled:
+            yield from page_batch
+            return
+
+        for page in page_batch:
+
+            assert page._backend is not None
+            if not page._backend.is_valid():
+                yield page
+            else:
+                with TimeRecorder(conv_res, "ocr"):
+                    ocr_rects = self.get_ocr_rects(page)
+
+                    all_ocr_cells = []
+                    for ocr_rect in ocr_rects:
+                        # Skip zero area boxes
+                        if ocr_rect.area() == 0:
+                            continue
+                        high_res_image = page._backend.get_page_image(
+                            scale=self.scale, cropbox=ocr_rect
+                        )
+                        im = numpy.array(high_res_image)
+                        result, _ = self.reader(
+                            im,
+                            use_det=self.options.use_det,
+                            use_cls=self.options.use_cls,
+                            use_rec=self.options.use_rec,
+                        )
+
+                        del high_res_image
+                        del im
+
+                        cells = [
+                            OcrCell(
+                                id=ix,
+                                text=line[1],
+                                confidence=line[2],
+                                bbox=BoundingBox.from_tuple(
+                                    coord=(
+                                        (line[0][0][0] / self.scale) + ocr_rect.l,
+                                        (line[0][0][1] / self.scale) + ocr_rect.t,
+                                        (line[0][2][0] / self.scale) + ocr_rect.l,
+                                        (line[0][2][1] / self.scale) + ocr_rect.t,
+                                    ),
+                                    origin=CoordOrigin.TOPLEFT,
+                                ),
+                            )
+                            for ix, line in enumerate(result)
+                        ]
+                        all_ocr_cells.extend(cells)
+
+                    # Post-process the cells
+                    page.cells = self.post_process_cells(all_ocr_cells, page.cells)
+
+                # DEBUG code:
+                if settings.debug.visualize_ocr:
+                    self.draw_ocr_rects_and_cells(conv_res, page, ocr_rects)
+
+                yield page

{docling-2.7.1 → docling-2.8.0}/docling/pipeline/standard_pdf_pipeline.py

@@ -13,6 +13,7 @@ from docling.datamodel.pipeline_options import (
     EasyOcrOptions,
     OcrMacOptions,
     PdfPipelineOptions,
+    RapidOcrOptions,
     TesseractCliOcrOptions,
     TesseractOcrOptions,
 )
@@ -26,6 +27,7 @@ from docling.models.page_preprocessing_model import (
     PagePreprocessingModel,
     PagePreprocessingOptions,
 )
+from docling.models.rapid_ocr_model import RapidOcrModel
 from docling.models.table_structure_model import TableStructureModel
 from docling.models.tesseract_ocr_cli_model import TesseractOcrCliModel
 from docling.models.tesseract_ocr_model import TesseractOcrModel
@@ -121,6 +123,11 @@ class StandardPdfPipeline(PaginatedPipeline):
                 enabled=self.pipeline_options.do_ocr,
                 options=self.pipeline_options.ocr_options,
             )
+        elif isinstance(self.pipeline_options.ocr_options, RapidOcrOptions):
+            return RapidOcrModel(
+                enabled=self.pipeline_options.do_ocr,
+                options=self.pipeline_options.ocr_options,
+            )
         elif isinstance(self.pipeline_options.ocr_options, OcrMacOptions):
             if "darwin" != sys.platform:
                 raise RuntimeError(

{docling-2.7.1 → docling-2.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "docling"
-version = "2.7.1"  # DO NOT EDIT, updated automatically
+version = "2.8.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>", "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 = "MIT"
@@ -26,7 +26,7 @@ packages = [{include = "docling"}]
 ######################
 python = "^3.9"
 pydantic = ">=2.0.0,<2.10"
-docling-core = "^2.4.0"
+docling-core = "^2.5.1"
 docling-ibm-models = "^2.0.6"
 deepsearch-glm = "^0.26.1"
 filetype = "^1.2.0"
@@ -50,6 +50,13 @@ marko = "^2.1.2"
 openpyxl = "^3.1.5"
 lxml = ">=4.0.0,<6.0.0"
 ocrmac = { version = "^1.0.0", markers = "sys_platform == 'darwin'", optional = true }
+rapidocr-onnxruntime = { version = "^1.4.0", optional = true, markers = "python_version < '3.13'" }
+onnxruntime = [
+  # 1.19.2 is the last version with python3.9 support,
+  # see https://github.com/microsoft/onnxruntime/releases/tag/v1.20.0
+  { version = ">=1.7.0,<1.20.0", optional = true, markers = "python_version < '3.10'" },
+  { version = "^1.7.0", optional = true, markers = "python_version >= '3.10'" }
+]
 
 [tool.poetry.group.dev.dependencies]
 black = {extras = ["jupyter"], version = "^24.4.2"}
@@ -104,6 +111,7 @@ torchvision = [
 [tool.poetry.extras]
 tesserocr = ["tesserocr"]
 ocrmac = ["ocrmac"]
+rapidocr = ["rapidocr-onnxruntime", "onnxruntime"]
 
 [tool.poetry.scripts]
 docling = "docling.cli.main:app"