docling 2.0.0__tar.gz → 2.1.0__tar.gz

{docling-2.0.0 → docling-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: docling
-Version: 2.0.0
+Version: 2.1.0
 Summary: Docling PDF conversion package
 Home-page: https://github.com/DS4SD/docling
 License: MIT
@@ -50,7 +50,7 @@ Description-Content-Type: text/markdown
 
 <p align="center">
   <a href="https://github.com/ds4sd/docling">
-    <img loading="lazy" alt="Docling" src="https://github.com/DS4SD/docling/raw/main/docs/assets/logo.png" width="150" />
+    <img loading="lazy" alt="Docling" src="docs/assets/docling_processing.png" width="100%"/>
   </a>
 </p>
 
@@ -69,6 +69,7 @@ Description-Content-Type: text/markdown
 
 Docling parses documents and exports them to the desired format with ease and speed.
 
+
 ## Features
 
 * 🗂️ Multi-format support for input (PDF, DOCX etc.) & output (Markdown, JSON etc.)
@@ -94,7 +95,7 @@ More [detailed installation instructions](https://ds4sd.github.io/docling/instal
 
 ## Getting started
 
-To convert invidual documents, use `convert()`, for example:
+To convert individual documents, use `convert()`, for example:
 
 ```python
 from docling.document_converter import DocumentConverter
@@ -103,7 +104,6 @@ source = "https://arxiv.org/pdf/2408.09869"  # PDF path or URL
 converter = DocumentConverter()
 result = converter.convert(source)
 print(result.document.export_to_markdown())  # output: "## Docling Technical Report[...]"
-print(result.document.export_to_document_tokens())  # output: "<document><title><page_1><loc_20>..."
 ```
 
 

{docling-2.0.0 → docling-2.1.0}/README.md

@@ -1,6 +1,6 @@
 <p align="center">
   <a href="https://github.com/ds4sd/docling">
-    <img loading="lazy" alt="Docling" src="https://github.com/DS4SD/docling/raw/main/docs/assets/logo.png" width="150" />
+    <img loading="lazy" alt="Docling" src="docs/assets/docling_processing.png" width="100%"/>
   </a>
 </p>
 
@@ -19,6 +19,7 @@
 
 Docling parses documents and exports them to the desired format with ease and speed.
 
+
 ## Features
 
 * 🗂️ Multi-format support for input (PDF, DOCX etc.) & output (Markdown, JSON etc.)
@@ -44,7 +45,7 @@ More [detailed installation instructions](https://ds4sd.github.io/docling/instal
 
 ## Getting started
 
-To convert invidual documents, use `convert()`, for example:
+To convert individual documents, use `convert()`, for example:
 
 ```python
 from docling.document_converter import DocumentConverter
@@ -53,7 +54,6 @@ source = "https://arxiv.org/pdf/2408.09869"  # PDF path or URL
 converter = DocumentConverter()
 result = converter.convert(source)
 print(result.document.export_to_markdown())  # output: "## Docling Technical Report[...]"
-print(result.document.export_to_document_tokens())  # output: "<document><title><page_1><loc_20>..."
 ```
 
 

{docling-2.0.0 → docling-2.1.0}/docling/datamodel/document.py

@@ -6,12 +6,6 @@ from pathlib import Path, PurePath
 from typing import TYPE_CHECKING, Dict, Iterable, List, Optional, Tuple, Type, Union
 
 import filetype
-from docling_core.types import BaseText
-from docling_core.types import Document as DsDocument
-from docling_core.types import DocumentDescription as DsDocumentDescription
-from docling_core.types import FileInfoObject as DsFileInfoObject
-from docling_core.types import PageDimensions, PageReference, Prov, Ref
-from docling_core.types import Table as DsSchemaTable
 from docling_core.types.doc import (
     DocItem,
     DocItemLabel,
@@ -22,7 +16,22 @@ from docling_core.types.doc import (
     TextItem,
 )
 from docling_core.types.doc.document import ListItem
-from docling_core.types.legacy_doc.base import Figure, GlmTableCell, TableCell
+from docling_core.types.legacy_doc.base import (
+    BaseText,
+    Figure,
+    GlmTableCell,
+    PageDimensions,
+    PageReference,
+    Prov,
+    Ref,
+)
+from docling_core.types.legacy_doc.base import Table as DsSchemaTable
+from docling_core.types.legacy_doc.base import TableCell
+from docling_core.types.legacy_doc.document import (
+    CCSDocumentDescription as DsDocumentDescription,
+)
+from docling_core.types.legacy_doc.document import CCSFileInfoObject as DsFileInfoObject
+from docling_core.types.legacy_doc.document import ExportedCCSDocument as DsDocument
 from docling_core.utils.file import resolve_file_source
 from pydantic import BaseModel
 from typing_extensions import deprecated

{docling-2.0.0 → docling-2.1.0}/docling/datamodel/pipeline_options.py

@@ -22,6 +22,9 @@ class TableStructureOptions(BaseModel):
 
 class OcrOptions(BaseModel):
     kind: str
+    bitmap_area_threshold: float = (
+        0.05  # percentage of the area for a bitmap to processed with OCR
+    )
 
 
 class EasyOcrOptions(OcrOptions):

{docling-2.0.0 → docling-2.1.0}/docling/models/base_ocr_model.py

@@ -69,7 +69,7 @@ class BaseOcrModel:
         coverage, ocr_rects = find_ocr_rects(page.size, bitmap_rects)
 
         # return full-page rectangle if sufficiently covered with bitmaps
-        if coverage > BITMAP_COVERAGE_TRESHOLD:
+        if coverage > max(BITMAP_COVERAGE_TRESHOLD, self.options.bitmap_area_threshold):
             return [
                 BoundingBox(
                     l=0,
@@ -81,6 +81,14 @@ class BaseOcrModel:
             ]
         # return individual rectangles if the bitmap coverage is smaller
         else:  # coverage <= BITMAP_COVERAGE_TRESHOLD:
+
+            # skip OCR if the bitmap area on the page is smaller than the options threshold
+            ocr_rects = [
+                rect
+                for rect in ocr_rects
+                if rect.area() / (page.size.width * page.size.height)
+                > self.options.bitmap_area_threshold
+            ]
             return ocr_rects
 
     # Filters OCR cells by dropping any OCR cell that intersects with an existing programmatic cell.

{docling-2.0.0 → docling-2.1.0}/docling/models/ds_glm_model.py

@@ -5,15 +5,23 @@ from typing import List, Union
 from deepsearch_glm.nlp_utils import init_nlp_model
 from deepsearch_glm.utils.doc_utils import to_docling_document
 from deepsearch_glm.utils.load_pretrained_models import load_pretrained_nlp_models
-from docling_core.types import BaseText
-from docling_core.types import Document as DsDocument
-from docling_core.types import DocumentDescription as DsDocumentDescription
-from docling_core.types import FileInfoObject as DsFileInfoObject
-from docling_core.types import PageDimensions, PageReference, Prov, Ref
-from docling_core.types import Table as DsSchemaTable
 from docling_core.types.doc import BoundingBox, CoordOrigin, DoclingDocument
 from docling_core.types.legacy_doc.base import BoundingBox as DsBoundingBox
-from docling_core.types.legacy_doc.base import Figure, TableCell
+from docling_core.types.legacy_doc.base import (
+    Figure,
+    PageDimensions,
+    PageReference,
+    Prov,
+    Ref,
+)
+from docling_core.types.legacy_doc.base import Table as DsSchemaTable
+from docling_core.types.legacy_doc.base import TableCell
+from docling_core.types.legacy_doc.document import BaseText
+from docling_core.types.legacy_doc.document import (
+    CCSDocumentDescription as DsDocumentDescription,
+)
+from docling_core.types.legacy_doc.document import CCSFileInfoObject as DsFileInfoObject
+from docling_core.types.legacy_doc.document import ExportedCCSDocument as DsDocument
 from PIL import ImageDraw
 from pydantic import BaseModel, ConfigDict
 
@@ -202,6 +210,7 @@ class GlmModel:
         page_dimensions = [
             PageDimensions(page=p.page_no + 1, height=p.size.height, width=p.size.width)
             for p in conv_res.pages
+            if p.size is not None
         ]
 
         ds_doc: DsDocument = DsDocument(

docling-2.1.0/docling/models/easyocr_model.py

@@ -0,0 +1,90 @@
+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.pipeline_options import EasyOcrOptions
+from docling.models.base_ocr_model import BaseOcrModel
+
+_log = logging.getLogger(__name__)
+
+
+class EasyOcrModel(BaseOcrModel):
+    def __init__(self, enabled: bool, options: EasyOcrOptions):
+        super().__init__(enabled=enabled, options=options)
+        self.options: EasyOcrOptions
+
+        self.scale = 3  # multiplier for 72 dpi == 216 dpi.
+
+        if self.enabled:
+            try:
+                import easyocr
+            except ImportError:
+                raise ImportError(
+                    "EasyOCR is not installed. Please install it via `pip install easyocr` to use this OCR engine. "
+                    "Alternatively, Docling has support for other OCR engines. See the documentation."
+                )
+
+            self.reader = easyocr.Reader(
+                lang_list=self.options.lang,
+                model_storage_directory=self.options.model_storage_directory,
+                download_enabled=self.options.download_enabled,
+            )
+
+    def __call__(self, 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:
+                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.readtext(im)
+
+                    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)
+
+                ## Remove OCR cells which overlap with programmatic cells.
+                filtered_ocr_cells = self.filter_ocr_cells(all_ocr_cells, page.cells)
+
+                page.cells.extend(filtered_ocr_cells)
+
+                # DEBUG code:
+                # self.draw_ocr_rects_and_cells(page, ocr_rects)
+
+                yield page

{docling-2.0.0 → docling-2.1.0}/docling/models/layout_model.py

@@ -273,68 +273,72 @@ class LayoutModel(BasePageModel):
 
     def __call__(self, page_batch: Iterable[Page]) -> Iterable[Page]:
         for page in page_batch:
-            assert page.size is not None
-
-            clusters = []
-            for ix, pred_item in enumerate(
-                self.layout_predictor.predict(page.get_image(scale=1.0))
-            ):
-                label = DocItemLabel(
-                    pred_item["label"].lower().replace(" ", "_").replace("-", "_")
-                )  # Temporary, until docling-ibm-model uses docling-core types
-                cluster = Cluster(
-                    id=ix,
-                    label=label,
-                    confidence=pred_item["confidence"],
-                    bbox=BoundingBox.model_validate(pred_item),
-                    cells=[],
-                )
-                clusters.append(cluster)
-
-            # Map cells to clusters
-            # TODO: Remove, postprocess should take care of it anyway.
-            for cell in page.cells:
-                for cluster in clusters:
-                    if not cell.bbox.area() > 0:
-                        overlap_frac = 0.0
-                    else:
-                        overlap_frac = (
-                            cell.bbox.intersection_area_with(cluster.bbox)
-                            / cell.bbox.area()
-                        )
-
-                    if overlap_frac > 0.5:
-                        cluster.cells.append(cell)
-
-            # Pre-sort clusters
-            # clusters = self.sort_clusters_by_cell_order(clusters)
-
-            # DEBUG code:
-            def draw_clusters_and_cells():
-                image = copy.deepcopy(page.image)
-                draw = ImageDraw.Draw(image)
-                for c in clusters:
-                    x0, y0, x1, y1 = c.bbox.as_tuple()
-                    draw.rectangle([(x0, y0), (x1, y1)], outline="green")
-
-                    cell_color = (
-                        random.randint(30, 140),
-                        random.randint(30, 140),
-                        random.randint(30, 140),
+            assert page._backend is not None
+            if not page._backend.is_valid():
+                yield page
+            else:
+                assert page.size is not None
+
+                clusters = []
+                for ix, pred_item in enumerate(
+                    self.layout_predictor.predict(page.get_image(scale=1.0))
+                ):
+                    label = DocItemLabel(
+                        pred_item["label"].lower().replace(" ", "_").replace("-", "_")
+                    )  # Temporary, until docling-ibm-model uses docling-core types
+                    cluster = Cluster(
+                        id=ix,
+                        label=label,
+                        confidence=pred_item["confidence"],
+                        bbox=BoundingBox.model_validate(pred_item),
+                        cells=[],
                     )
-                    for tc in c.cells:  # [:1]:
-                        x0, y0, x1, y1 = tc.bbox.as_tuple()
-                        draw.rectangle([(x0, y0), (x1, y1)], outline=cell_color)
-                image.show()
+                    clusters.append(cluster)
+
+                # Map cells to clusters
+                # TODO: Remove, postprocess should take care of it anyway.
+                for cell in page.cells:
+                    for cluster in clusters:
+                        if not cell.bbox.area() > 0:
+                            overlap_frac = 0.0
+                        else:
+                            overlap_frac = (
+                                cell.bbox.intersection_area_with(cluster.bbox)
+                                / cell.bbox.area()
+                            )
+
+                        if overlap_frac > 0.5:
+                            cluster.cells.append(cell)
+
+                # Pre-sort clusters
+                # clusters = self.sort_clusters_by_cell_order(clusters)
+
+                # DEBUG code:
+                def draw_clusters_and_cells():
+                    image = copy.deepcopy(page.image)
+                    draw = ImageDraw.Draw(image)
+                    for c in clusters:
+                        x0, y0, x1, y1 = c.bbox.as_tuple()
+                        draw.rectangle([(x0, y0), (x1, y1)], outline="green")
+
+                        cell_color = (
+                            random.randint(30, 140),
+                            random.randint(30, 140),
+                            random.randint(30, 140),
+                        )
+                        for tc in c.cells:  # [:1]:
+                            x0, y0, x1, y1 = tc.bbox.as_tuple()
+                            draw.rectangle([(x0, y0), (x1, y1)], outline=cell_color)
+                    image.show()
 
-            # draw_clusters_and_cells()
+                # draw_clusters_and_cells()
 
-            clusters, page.cells = self.postprocess(
-                clusters, page.cells, page.size.height
-            )
+                clusters, page.cells = self.postprocess(
+                    clusters, page.cells, page.size.height
+                )
 
-            # draw_clusters_and_cells()
+                # draw_clusters_and_cells()
 
-            page.predictions.layout = LayoutPrediction(clusters=clusters)
+                page.predictions.layout = LayoutPrediction(clusters=clusters)
 
-            yield page
+                yield page

docling-2.1.0/docling/models/page_assemble_model.py

@@ -0,0 +1,172 @@
+import logging
+import re
+from typing import Iterable, List
+
+from pydantic import BaseModel
+
+from docling.datamodel.base_models import (
+    AssembledUnit,
+    FigureElement,
+    Page,
+    PageElement,
+    Table,
+    TextElement,
+)
+from docling.models.base_model import BasePageModel
+from docling.models.layout_model import LayoutModel
+
+_log = logging.getLogger(__name__)
+
+
+class PageAssembleOptions(BaseModel):
+    keep_images: bool = False
+
+
+class PageAssembleModel(BasePageModel):
+    def __init__(self, options: PageAssembleOptions):
+        self.options = options
+
+    def sanitize_text(self, lines):
+        if len(lines) <= 1:
+            return " ".join(lines)
+
+        for ix, line in enumerate(lines[1:]):
+            prev_line = lines[ix]
+
+            if prev_line.endswith("-"):
+                prev_words = re.findall(r"\b[\w]+\b", prev_line)
+                line_words = re.findall(r"\b[\w]+\b", line)
+
+                if (
+                    len(prev_words)
+                    and len(line_words)
+                    and prev_words[-1].isalnum()
+                    and line_words[0].isalnum()
+                ):
+                    lines[ix] = prev_line[:-1]
+            else:
+                lines[ix] += " "
+
+        sanitized_text = "".join(lines)
+
+        return sanitized_text.strip()  # Strip any leading or trailing whitespace
+
+    def __call__(self, page_batch: Iterable[Page]) -> Iterable[Page]:
+        for page in page_batch:
+            assert page._backend is not None
+            if not page._backend.is_valid():
+                yield page
+            else:
+                assert page.predictions.layout is not None
+
+                # assembles some JSON output page by page.
+
+                elements: List[PageElement] = []
+                headers: List[PageElement] = []
+                body: List[PageElement] = []
+
+                for cluster in page.predictions.layout.clusters:
+                    # _log.info("Cluster label seen:", cluster.label)
+                    if cluster.label in LayoutModel.TEXT_ELEM_LABELS:
+
+                        textlines = [
+                            cell.text.replace("\x02", "-").strip()
+                            for cell in cluster.cells
+                            if len(cell.text.strip()) > 0
+                        ]
+                        text = self.sanitize_text(textlines)
+                        text_el = TextElement(
+                            label=cluster.label,
+                            id=cluster.id,
+                            text=text,
+                            page_no=page.page_no,
+                            cluster=cluster,
+                        )
+                        elements.append(text_el)
+
+                        if cluster.label in LayoutModel.PAGE_HEADER_LABELS:
+                            headers.append(text_el)
+                        else:
+                            body.append(text_el)
+                    elif cluster.label == LayoutModel.TABLE_LABEL:
+                        tbl = None
+                        if page.predictions.tablestructure:
+                            tbl = page.predictions.tablestructure.table_map.get(
+                                cluster.id, None
+                            )
+                        if (
+                            not tbl
+                        ):  # fallback: add table without structure, if it isn't present
+                            tbl = Table(
+                                label=cluster.label,
+                                id=cluster.id,
+                                text="",
+                                otsl_seq=[],
+                                table_cells=[],
+                                cluster=cluster,
+                                page_no=page.page_no,
+                            )
+
+                        elements.append(tbl)
+                        body.append(tbl)
+                    elif cluster.label == LayoutModel.FIGURE_LABEL:
+                        fig = None
+                        if page.predictions.figures_classification:
+                            fig = (
+                                page.predictions.figures_classification.figure_map.get(
+                                    cluster.id, None
+                                )
+                            )
+                        if (
+                            not fig
+                        ):  # fallback: add figure without classification, if it isn't present
+                            fig = FigureElement(
+                                label=cluster.label,
+                                id=cluster.id,
+                                text="",
+                                data=None,
+                                cluster=cluster,
+                                page_no=page.page_no,
+                            )
+                        elements.append(fig)
+                        body.append(fig)
+                    elif cluster.label == LayoutModel.FORMULA_LABEL:
+                        equation = None
+                        if page.predictions.equations_prediction:
+                            equation = (
+                                page.predictions.equations_prediction.equation_map.get(
+                                    cluster.id, None
+                                )
+                            )
+                        if (
+                            not equation
+                        ):  # fallback: add empty formula, if it isn't present
+                            text = self.sanitize_text(
+                                [
+                                    cell.text.replace("\x02", "-").strip()
+                                    for cell in cluster.cells
+                                    if len(cell.text.strip()) > 0
+                                ]
+                            )
+                            equation = TextElement(
+                                label=cluster.label,
+                                id=cluster.id,
+                                cluster=cluster,
+                                page_no=page.page_no,
+                                text=text,
+                            )
+                        elements.append(equation)
+                        body.append(equation)
+
+                page.assembled = AssembledUnit(
+                    elements=elements, headers=headers, body=body
+                )
+
+                # Remove page images (can be disabled)
+                if not self.options.keep_images:
+                    page._image_cache = {}
+
+                # Unload backend
+                page._backend.unload()
+
+                yield page

{docling-2.0.0 → docling-2.1.0}/docling/models/page_preprocessing_model.py

@@ -17,9 +17,13 @@ class PagePreprocessingModel(BasePageModel):
 
     def __call__(self, page_batch: Iterable[Page]) -> Iterable[Page]:
         for page in page_batch:
-            page = self._populate_page_images(page)
-            page = self._parse_page_cells(page)
-            yield page
+            assert page._backend is not None
+            if not page._backend.is_valid():
+                yield page
+            else:
+                page = self._populate_page_images(page)
+                page = self._parse_page_cells(page)
+                yield page
 
     # Generate the page image and store it in the page object
     def _populate_page_images(self, page: Page) -> Page: