docling 2.59.0__tar.gz → 2.60.0__tar.gz

{docling-2.59.0 → docling-2.60.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling
-Version: 2.59.0
+Version: 2.60.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

{docling-2.59.0 → docling-2.60.0}/docling/backend/pypdfium2_backend.py

@@ -229,10 +229,10 @@ class PyPdfiumPageBackend(PdfPageBackend):
                     b=max(cell.rect.to_bounding_box().b for cell in group),
                 )
 
-                assert self._ppage is not None
-                self.text_page = self._ppage.get_textpage()
+                assert self.text_page is not None
                 bbox = merged_bbox.to_bottom_left_origin(page_size.height)
-                merged_text = self.text_page.get_text_bounded(*bbox.as_tuple())
+                with pypdfium2_lock:
+                    merged_text = self.text_page.get_text_bounded(*bbox.as_tuple())
 
                 return TextCell(
                     index=group[0].index,
@@ -255,9 +255,9 @@ class PyPdfiumPageBackend(PdfPageBackend):
     def get_bitmap_rects(self, scale: float = 1) -> Iterable[BoundingBox]:
         AREA_THRESHOLD = 0  # 32 * 32
         page_size = self.get_size()
-        rotation = self._ppage.get_rotation()
 
         with pypdfium2_lock:
+            rotation = self._ppage.get_rotation()
             for obj in self._ppage.get_objects(filter=[pdfium_c.FPDF_PAGEOBJ_IMAGE]):
                 pos = obj.get_pos()
                 if rotation == 90:

{docling-2.59.0 → docling-2.60.0}/docling/datamodel/pipeline_options.py

@@ -361,15 +361,7 @@ class PdfPipelineOptions(PaginatedPipelineOptions):
 
     generate_parsed_pages: bool = False
 
-
-class ProcessingPipeline(str, Enum):
-    STANDARD = "standard"
-    VLM = "vlm"
-    ASR = "asr"
-
-
-class ThreadedPdfPipelineOptions(PdfPipelineOptions):
-    """Pipeline options for the threaded PDF pipeline with batching and backpressure control"""
+    ### Arguments for threaded PDF pipeline with batching and backpressure control
 
     # Batch sizes for different stages
     ocr_batch_size: int = 4
@@ -377,7 +369,18 @@ class ThreadedPdfPipelineOptions(PdfPipelineOptions):
     table_batch_size: int = 4
 
     # Timing control
-    batch_timeout_seconds: float = 2.0
+    batch_polling_interval_seconds: float = 0.5
 
     # Backpressure and queue control
     queue_max_size: int = 100
+
+
+class ProcessingPipeline(str, Enum):
+    LEGACY = "legacy"
+    STANDARD = "standard"
+    VLM = "vlm"
+    ASR = "asr"
+
+
+class ThreadedPdfPipelineOptions(PdfPipelineOptions):
+    """Pipeline options for the threaded PDF pipeline with batching and backpressure control"""

{docling-2.59.0 → docling-2.60.0}/docling/models/layout_model.py

@@ -167,6 +167,10 @@ class LayoutModel(BasePageModel):
             valid_pages.append(page)
             valid_page_images.append(page_image)
 
+        print(f"{len(pages)=}, {pages[0].page_no}-{pages[-1].page_no}")
+        print(f"{len(valid_pages)=}")
+        print(f"{len(valid_page_images)=}")
+
         # Process all valid pages with batch prediction
         batch_predictions = []
         if valid_page_images:

docling-2.59.0/docling/pipeline/standard_pdf_pipeline.py → docling-2.60.0/docling/pipeline/legacy_standard_pdf_pipeline.py

@@ -31,7 +31,7 @@ from docling.utils.profiling import ProfilingScope, TimeRecorder
 _log = logging.getLogger(__name__)
 
 
-class StandardPdfPipeline(PaginatedPipeline):
+class LegacyStandardPdfPipeline(PaginatedPipeline):
     def __init__(self, pipeline_options: PdfPipelineOptions):
         super().__init__(pipeline_options)
         self.pipeline_options: PdfPipelineOptions
@@ -102,7 +102,7 @@ class StandardPdfPipeline(PaginatedPipeline):
         local_dir: Optional[Path] = None, force: bool = False
     ) -> Path:
         warnings.warn(
-            "The usage of StandardPdfPipeline.download_models_hf() is deprecated "
+            "The usage of LegacyStandardPdfPipeline.download_models_hf() is deprecated "
             "use instead the utility `docling-tools models download`, or "
             "the upstream method docling.utils.models_downloader.download_all()",
             DeprecationWarning,

docling-2.59.0/docling/pipeline/threaded_standard_pdf_pipeline.py → docling-2.60.0/docling/pipeline/standard_pdf_pipeline.py

@@ -1,4 +1,3 @@
-# threaded_standard_pdf_pipeline.py
 """Thread-safe, production-ready PDF pipeline
 ================================================
 A self-contained, thread-safe PDF conversion pipeline exploiting parallelism between pipeline stages and models.
@@ -24,7 +23,7 @@ import warnings
 from collections import defaultdict, deque
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Iterable, List, Optional, Sequence, Tuple, cast
+from typing import Any, Callable, Iterable, List, Optional, Sequence, Tuple, cast
 
 import numpy as np
 from docling_core.types.doc import DocItem, ImageRef, PictureItem, TableItem
@@ -173,6 +172,7 @@ class ThreadedPipelineStage:
         batch_size: int,
         batch_timeout: float,
         queue_max_size: int,
+        postprocess: Optional[Callable[[ThreadedItem], None]] = None,
     ) -> None:
         self.name = name
         self.model = model
@@ -182,6 +182,7 @@ class ThreadedPipelineStage:
         self._outputs: list[ThreadedQueue] = []
         self._thread: Optional[threading.Thread] = None
         self._running = False
+        self._postprocess = postprocess
 
     # ---------------------------------------------------------------- wiring
     def add_output_queue(self, q: ThreadedQueue) -> None:
@@ -274,11 +275,85 @@ class ThreadedPipelineStage:
     # -------------------------------------------------------------- _emit()
     def _emit(self, items: Iterable[ThreadedItem]) -> None:
         for item in items:
+            if self._postprocess is not None:
+                self._postprocess(item)
             for q in self._outputs:
                 if not q.put(item):
                     _log.error("Output queue closed while emitting from %s", self.name)
 
 
+class PreprocessThreadedStage(ThreadedPipelineStage):
+    """Pipeline stage that lazily loads PDF backends just-in-time."""
+
+    def __init__(
+        self,
+        *,
+        batch_timeout: float,
+        queue_max_size: int,
+        model: Any,
+    ) -> None:
+        super().__init__(
+            name="preprocess",
+            model=model,
+            batch_size=1,
+            batch_timeout=batch_timeout,
+            queue_max_size=queue_max_size,
+        )
+
+    def _process_batch(self, batch: Sequence[ThreadedItem]) -> list[ThreadedItem]:
+        groups: dict[int, list[ThreadedItem]] = defaultdict(list)
+        for itm in batch:
+            groups[itm.run_id].append(itm)
+
+        result: list[ThreadedItem] = []
+        for rid, items in groups.items():
+            good = [i for i in items if not i.is_failed]
+            if not good:
+                result.extend(items)
+                continue
+            try:
+                pages_with_payloads: list[tuple[ThreadedItem, Page]] = []
+                for it in good:
+                    page = it.payload
+                    if page is None:
+                        raise RuntimeError("Page payload is None")
+                    if page._backend is None:
+                        backend = it.conv_res.input._backend
+                        assert isinstance(backend, PdfDocumentBackend), (
+                            "Threaded pipeline only supports PdfDocumentBackend."
+                        )
+                        page_backend = backend.load_page(page.page_no)
+                        page._backend = page_backend
+                        if page_backend.is_valid():
+                            page.size = page_backend.get_size()
+                    pages_with_payloads.append((it, page))
+
+                pages = [payload for _, payload in pages_with_payloads]
+                processed_pages = list(
+                    self.model(good[0].conv_res, pages)  # type: ignore[arg-type]
+                )
+                if len(processed_pages) != len(pages):
+                    raise RuntimeError(
+                        "PagePreprocessingModel returned unexpected number of pages"
+                    )
+                for idx, processed_page in enumerate(processed_pages):
+                    result.append(
+                        ThreadedItem(
+                            payload=processed_page,
+                            run_id=rid,
+                            page_no=good[idx].page_no,
+                            conv_res=good[idx].conv_res,
+                        )
+                    )
+            except Exception as exc:
+                _log.error("Stage preprocess failed for run %d: %s", rid, exc)
+                for it in items:
+                    it.is_failed = True
+                    it.error = exc
+                result.extend(items)
+        return result
+
+
 @dataclass
 class RunContext:
     """Wiring for a single *execute* call."""
@@ -293,7 +368,7 @@ class RunContext:
 # ──────────────────────────────────────────────────────────────────────────────
 
 
-class ThreadedStandardPdfPipeline(ConvertPipeline):
+class StandardPdfPipeline(ConvertPipeline):
     """High-performance PDF pipeline with multi-threaded stages."""
 
     def __init__(self, pipeline_options: ThreadedPdfPipelineOptions) -> None:
@@ -372,46 +447,57 @@ class ThreadedStandardPdfPipeline(ConvertPipeline):
             accelerator_options=self.pipeline_options.accelerator_options,
         )
 
+    def _release_page_resources(self, item: ThreadedItem) -> None:
+        page = item.payload
+        if page is None:
+            return
+        if not self.keep_images:
+            page._image_cache = {}
+        if not self.keep_backend and page._backend is not None:
+            page._backend.unload()
+            page._backend = None
+        if not self.pipeline_options.generate_parsed_pages:
+            page.parsed_page = None
+
     # ────────────────────────────────────────────────────────────────────────
     # Build - thread pipeline
     # ────────────────────────────────────────────────────────────────────────
 
     def _create_run_ctx(self) -> RunContext:
         opts = self.pipeline_options
-        preprocess = ThreadedPipelineStage(
-            name="preprocess",
-            model=self.preprocessing_model,
-            batch_size=1,
-            batch_timeout=opts.batch_timeout_seconds,
+        preprocess = PreprocessThreadedStage(
+            batch_timeout=opts.batch_polling_interval_seconds,
             queue_max_size=opts.queue_max_size,
+            model=self.preprocessing_model,
         )
         ocr = ThreadedPipelineStage(
             name="ocr",
             model=self.ocr_model,
             batch_size=opts.ocr_batch_size,
-            batch_timeout=opts.batch_timeout_seconds,
+            batch_timeout=opts.batch_polling_interval_seconds,
             queue_max_size=opts.queue_max_size,
         )
         layout = ThreadedPipelineStage(
             name="layout",
             model=self.layout_model,
             batch_size=opts.layout_batch_size,
-            batch_timeout=opts.batch_timeout_seconds,
+            batch_timeout=opts.batch_polling_interval_seconds,
             queue_max_size=opts.queue_max_size,
         )
         table = ThreadedPipelineStage(
             name="table",
             model=self.table_model,
             batch_size=opts.table_batch_size,
-            batch_timeout=opts.batch_timeout_seconds,
+            batch_timeout=opts.batch_polling_interval_seconds,
             queue_max_size=opts.queue_max_size,
         )
         assemble = ThreadedPipelineStage(
             name="assemble",
             model=self.assemble_model,
             batch_size=1,
-            batch_timeout=opts.batch_timeout_seconds,
+            batch_timeout=opts.batch_polling_interval_seconds,
             queue_max_size=opts.queue_max_size,
+            postprocess=self._release_page_resources,
         )
 
         # wire stages
@@ -430,19 +516,15 @@ class ThreadedStandardPdfPipeline(ConvertPipeline):
         """Stream-build the document while interleaving producer and consumer work."""
         run_id = next(self._run_seq)
         assert isinstance(conv_res.input._backend, PdfDocumentBackend)
-        backend = conv_res.input._backend
 
-        # preload & initialise pages -------------------------------------------------------------
+        # Collect page placeholders; backends are loaded lazily in preprocess stage
         start_page, end_page = conv_res.input.limits.page_range
         pages: list[Page] = []
         for i in range(conv_res.input.page_count):
             if start_page - 1 <= i <= end_page - 1:
                 page = Page(page_no=i)
-                page._backend = backend.load_page(i)
-                if page._backend and page._backend.is_valid():
-                    page.size = page._backend.get_size()
-                    conv_res.pages.append(page)
-                    pages.append(page)
+                conv_res.pages.append(page)
+                pages.append(page)
 
         if not pages:
             conv_res.status = ConversionStatus.FAILURE

docling-2.60.0/docling/pipeline/threaded_standard_pdf_pipeline.py

@@ -0,0 +1,5 @@
+from docling.pipeline.standard_pdf_pipeline import StandardPdfPipeline
+
+
+class ThreadedStandardPdfPipeline(StandardPdfPipeline):
+    """Backwards compatible import for ThreadedStandardPdfPipeline."""

{docling-2.59.0 → docling-2.60.0}/docling.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling
-Version: 2.59.0
+Version: 2.60.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

{docling-2.59.0 → docling-2.60.0}/docling.egg-info/SOURCES.txt

@@ -96,6 +96,7 @@ docling/pipeline/asr_pipeline.py
 docling/pipeline/base_extraction_pipeline.py
 docling/pipeline/base_pipeline.py
 docling/pipeline/extraction_vlm_pipeline.py
+docling/pipeline/legacy_standard_pdf_pipeline.py
 docling/pipeline/simple_pipeline.py
 docling/pipeline/standard_pdf_pipeline.py
 docling/pipeline/threaded_standard_pdf_pipeline.py

{docling-2.59.0 → docling-2.60.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "docling"
-version = "2.59.0"  # DO NOT EDIT, updated automatically
+version = "2.60.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."
 license = "MIT"
 keywords = [

{docling-2.59.0 → docling-2.60.0}/tests/test_threaded_pipeline.py

@@ -5,6 +5,7 @@ from typing import List
 
 import pytest
 
+from docling.backend.pypdfium2_backend import PyPdfiumDocumentBackend
 from docling.datamodel.base_models import ConversionStatus, InputFormat
 from docling.datamodel.document import ConversionResult
 from docling.datamodel.pipeline_options import (
@@ -41,7 +42,7 @@ def test_threaded_pipeline_multiple_documents():
                         layout_batch_size=1,
                         table_batch_size=1,
                         ocr_batch_size=1,
-                        batch_timeout_seconds=1.0,
+                        batch_polling_interval_seconds=1.0,
                         do_table_structure=do_ts,
                         do_ocr=do_ocr,
                     ),
@@ -171,6 +172,27 @@ def test_pipeline_comparison():
     assert len(sync_doc.texts) == len(threaded_doc.texts)
 
 
+def test_pypdfium_threaded_pipeline():
+    doc_converter = (
+        DocumentConverter(  # all of the below is optional, has internal defaults.
+            format_options={
+                InputFormat.PDF: PdfFormatOption(
+                    pipeline_cls=ThreadedStandardPdfPipeline,
+                    backend=PyPdfiumDocumentBackend,
+                ),
+            },
+        )
+    )
+
+    test_file = "tests/data/pdf/2206.01062.pdf"
+    for i in range(6):
+        print(f"iteration {i=}")
+        conv_result = doc_converter.convert(test_file)
+        assert conv_result.status == ConversionStatus.SUCCESS
+        print(f"[{i=}] Success")
+    print("All done!")
+
+
 if __name__ == "__main__":
     # Run basic performance test
     test_pipeline_comparison()