docling 2.64.1__tar.gz → 2.66.0__tar.gz

{docling-2.64.1 → docling-2.66.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling
-Version: 2.64.1
+Version: 2.66.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.64.1 → docling-2.66.0}/docling/backend/html_backend.py

@@ -236,6 +236,7 @@ class HTMLDocumentBackend(DeclarativeDocumentBackend):
         options: HTMLBackendOptions = HTMLBackendOptions(),
     ):
         super().__init__(in_doc, path_or_stream, options)
+        self.options: HTMLBackendOptions
         self.soup: Optional[BeautifulSoup] = None
         self.path_or_stream: Union[BytesIO, Path] = path_or_stream
         self.base_path: Optional[str] = str(options.source_uri)
@@ -299,7 +300,7 @@ class HTMLDocumentBackend(DeclarativeDocumentBackend):
         assert self.soup is not None
         # set the title as furniture, since it is part of the document metadata
         title = self.soup.title
-        if title:
+        if title and self.options.add_title:
             title_text = title.get_text(separator=" ", strip=True)
             title_clean = HTMLDocumentBackend._clean_unicode(title_text)
             doc.add_title(
@@ -333,7 +334,9 @@ class HTMLDocumentBackend(DeclarativeDocumentBackend):
             header = clean_headers[0]
         # Set starting content layer
         self.content_layer = (
-            ContentLayer.BODY if header is None else ContentLayer.FURNITURE
+            ContentLayer.BODY
+            if (not self.options.infer_furniture) or (header is None)
+            else ContentLayer.FURNITURE
         )
         # reset context
         self.ctx = _Context()

{docling-2.64.1 → docling-2.66.0}/docling/backend/md_backend.py

@@ -12,6 +12,8 @@ import marko
 import marko.element
 import marko.inline
 from docling_core.types.doc import (
+    ContentLayer,
+    DocItem,
     DocItemLabel,
     DoclingDocument,
     DocumentOrigin,
@@ -593,6 +595,8 @@ class MarkdownDocumentBackend(DeclarativeDocumentBackend):
                     enable_remote_fetch=md_options.enable_remote_fetch,
                     fetch_images=md_options.fetch_images,
                     source_uri=md_options.source_uri,
+                    infer_furniture=False,
+                    add_title=False,
                 )
                 in_doc = InputDocument(
                     path_or_stream=stream,

{docling-2.64.1 → docling-2.66.0}/docling/backend/msword_backend.py

@@ -25,6 +25,7 @@ from docx import Document
 from docx.document import Document as DocxDocument
 from docx.oxml.table import CT_Tc
 from docx.oxml.xmlchemy import BaseOxmlElement
+from docx.styles.style import ParagraphStyle
 from docx.table import Table, _Cell
 from docx.text.hyperlink import Hyperlink
 from docx.text.paragraph import Paragraph
@@ -511,15 +512,17 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
         if paragraph.style is None:
             return "Normal", None
 
-        label = paragraph.style.style_id
-        name = paragraph.style.name
-        base_style_label = None
-        base_style_name = None
-        if base_style := getattr(paragraph.style, "base_style", None):
+        label: str = paragraph.style.style_id
+        name: str = paragraph.style.name or ""
+        base_style_label: Optional[str] = None
+        base_style_name: Optional[str] = None
+        if isinstance(
+            base_style := getattr(paragraph.style, "base_style", None), ParagraphStyle
+        ):
             base_style_label = base_style.style_id
             base_style_name = base_style.name
 
-        if label is None:
+        if not label:
             return "Normal", None
 
         if ":" in label:
@@ -1348,6 +1351,9 @@ class MsWordDocumentBackend(DeclarativeDocumentBackend):
             _log.debug(f"Row index {row_idx} with {len(row.cells)} populated cells")
             col_idx = 0
             while col_idx < num_cols:
+                # Handle merged cells: row may have fewer cells than num_cols
+                if col_idx >= len(row.cells):
+                    break
                 cell: _Cell = row.cells[col_idx]
                 _log.debug(
                     f" col {col_idx} grid_span {cell.grid_span} grid_cols_before {row.grid_cols_before}"

{docling-2.64.1 → docling-2.66.0}/docling/cli/main.py

@@ -201,6 +201,7 @@ def export_documents(
     conv_results: Iterable[ConversionResult],
     output_dir: Path,
     export_json: bool,
+    export_yaml: bool,
     export_html: bool,
     export_html_split_page: bool,
     show_layout: bool,
@@ -225,6 +226,14 @@ def export_documents(
                     filename=fname, image_mode=image_export_mode
                 )
 
+            # Export YAML format:
+            if export_yaml:
+                fname = output_dir / f"{doc_filename}.yaml"
+                _log.info(f"writing YAML output to {fname}")
+                conv_res.document.save_as_yaml(
+                    filename=fname, image_mode=image_export_mode
+                )
+
             # Export HTML format:
             if export_html:
                 fname = output_dir / f"{doc_filename}.html"
@@ -602,6 +611,7 @@ def convert(  # noqa: C901
             to_formats = [OutputFormat.MARKDOWN]
 
         export_json = OutputFormat.JSON in to_formats
+        export_yaml = OutputFormat.YAML in to_formats
         export_html = OutputFormat.HTML in to_formats
         export_html_split_page = OutputFormat.HTML_SPLIT_PAGE in to_formats
         export_md = OutputFormat.MARKDOWN in to_formats
@@ -873,6 +883,7 @@ def convert(  # noqa: C901
             conv_results,
             output_dir=output,
             export_json=export_json,
+            export_yaml=export_yaml,
             export_html=export_html,
             export_html_split_page=export_html_split_page,
             show_layout=show_layout,

{docling-2.64.1 → docling-2.66.0}/docling/datamodel/backend_options.py

@@ -42,6 +42,12 @@ class HTMLBackendOptions(BaseBackendOptions):
             "will use it to resolve relative paths in the HTML document."
         ),
     )
+    add_title: bool = Field(
+        True, description="Add the HTML title tag as furniture in the DoclingDocument."
+    )
+    infer_furniture: bool = Field(
+        True, description="Infer all the content before the first header as furniture."
+    )
 
 
 class MarkdownBackendOptions(BaseBackendOptions):

{docling-2.64.1 → docling-2.66.0}/docling/datamodel/base_models.py

@@ -75,6 +75,7 @@ class InputFormat(str, Enum):
 class OutputFormat(str, Enum):
     MARKDOWN = "md"
     JSON = "json"
+    YAML = "yaml"
     HTML = "html"
     HTML_SPLIT_PAGE = "html_split_page"
     TEXT = "text"

{docling-2.64.1 → docling-2.66.0}/docling/datamodel/pipeline_options.py

@@ -2,7 +2,7 @@ import logging
 from datetime import datetime
 from enum import Enum
 from pathlib import Path
-from typing import Any, ClassVar, Dict, List, Literal, Optional, Union
+from typing import Annotated, Any, ClassVar, Dict, List, Literal, Optional, Union
 
 from pydantic import (
     AnyUrl,
@@ -79,18 +79,41 @@ class TableStructureOptions(BaseTableStructureOptions):
 class OcrOptions(BaseOptions):
     """OCR options."""
 
-    lang: List[str]
-    force_full_page_ocr: bool = False  # If enabled a full page OCR is always applied
-    bitmap_area_threshold: float = (
-        0.05  # percentage of the area for a bitmap to processed with OCR
-    )
+    lang: Annotated[
+        List[str],
+        Field(
+            description="List of OCR languages to use. The format must match the values of the OCR engine of choice.",
+            examples=[["deu", "eng"]],
+        ),
+    ]
+
+    force_full_page_ocr: Annotated[
+        bool,
+        Field(
+            description="If enabled, a full-page OCR is always applied.",
+            examples=[False],
+        ),
+    ] = False
+
+    bitmap_area_threshold: Annotated[
+        float,
+        Field(
+            description="Percentage of the page area for a bitmap to be processed with OCR.",
+            examples=[0.05, 0.1],
+        ),
+    ] = 0.05
 
 
 class OcrAutoOptions(OcrOptions):
     """Options for pick OCR engine automatically."""
 
     kind: ClassVar[Literal["auto"]] = "auto"
-    lang: List[str] = []
+    lang: Annotated[
+        List[str],
+        Field(
+            description="The automatic OCR engine will use the default values of the engine. Please specify the engine explicitly to change the language selection.",
+        ),
+    ] = []
 
 
 class RapidOcrOptions(OcrOptions):
@@ -278,11 +301,44 @@ class OcrEngine(str, Enum):
 class PipelineOptions(BaseOptions):
     """Base pipeline options."""
 
-    document_timeout: Optional[float] = None
-    accelerator_options: AcceleratorOptions = AcceleratorOptions()
-    enable_remote_services: bool = False
-    allow_external_plugins: bool = False
-    artifacts_path: Optional[Union[Path, str]] = None
+    document_timeout: Annotated[
+        Optional[float],
+        Field(
+            description="Maximum allowed processing time for a document before timing out. If None, no timeout is enforced.",
+            examples=[10.0, 20.0],
+        ),
+    ] = None
+
+    accelerator_options: Annotated[
+        AcceleratorOptions,
+        Field(
+            description="Configuration options for hardware acceleration (e.g., GPU or optimized execution settings).",
+        ),
+    ] = AcceleratorOptions()
+
+    enable_remote_services: Annotated[
+        bool,
+        Field(
+            description="Enable calling external APIs or cloud services during pipeline execution.",
+            examples=[False],
+        ),
+    ] = False
+
+    allow_external_plugins: Annotated[
+        bool,
+        Field(
+            description="Allow loading external third-party plugins or modules. Disabled by default for safety.",
+            examples=[False],
+        ),
+    ] = False
+
+    artifacts_path: Annotated[
+        Optional[Union[Path, str]],
+        Field(
+            description="Filesystem path where pipeline artifacts should be stored. If None, artifacts will be fetched. You can use the utility `docling-tools models download` to pre-fetch the model artifacts.",
+            examples=["./artifacts", "/tmp/docling_outputs"],
+        ),
+    ] = None
 
 
 class ConvertPipelineOptions(PipelineOptions):

{docling-2.64.1 → docling-2.66.0}/docling/datamodel/vlm_model_specs.py

@@ -38,10 +38,6 @@ GRANITEDOCLING_TRANSFORMERS = InlineVlmOptions(
 
 GRANITEDOCLING_VLLM = GRANITEDOCLING_TRANSFORMERS.model_copy()
 GRANITEDOCLING_VLLM.inference_framework = InferenceFramework.VLLM
-GRANITEDOCLING_VLLM.revision = (
-    "untied"  # change back to "main" with next vllm relase after 0.10.2
-)
-
 
 GRANITEDOCLING_MLX = InlineVlmOptions(
     repo_id="ibm-granite/granite-docling-258M-mlx",
@@ -55,6 +51,26 @@ GRANITEDOCLING_MLX = InlineVlmOptions(
     stop_strings=["</doctag>", "<|end_of_text|>"],
 )
 
+GRANITEDOCLING_VLLM_API = ApiVlmOptions(
+    url="http://localhost:8000/v1/chat/completions",  # LM studio defaults to port 1234, VLLM to 8000
+    params=dict(
+        model=GRANITEDOCLING_TRANSFORMERS.repo_id,
+        max_tokens=4096,
+        skip_special_tokens=True,
+    ),
+    prompt=GRANITEDOCLING_TRANSFORMERS.prompt,
+    timeout=90,
+    scale=2.0,
+    temperature=0.0,
+    concurrency=4,
+    stop_strings=["</doctag>", "<|end_of_text|>"],
+    response_format=ResponseFormat.DOCTAGS,
+)
+
+GRANITEDOCLING_OLLAMA = GRANITEDOCLING_VLLM_API.model_copy()
+GRANITEDOCLING_OLLAMA.url = AnyUrl("http://localhost:11434/v1/chat/completions")
+GRANITEDOCLING_OLLAMA.params["model"] = "ibm/granite-docling:258m"
+
 # SmolDocling
 SMOLDOCLING_MLX = InlineVlmOptions(
     repo_id="docling-project/SmolDocling-256M-preview-mlx-bf16",

{docling-2.64.1 → docling-2.66.0}/docling/document_converter.py

@@ -176,14 +176,38 @@ def _get_default_option(format: InputFormat) -> FormatOption:
 
 
 class DocumentConverter:
+    """Convert documents of various input formats to Docling documents.
+
+    `DocumentConverter` is the main entry point for converting documents in Docling.
+    It handles various input formats (PDF, DOCX, PPTX, images, HTML, Markdown, etc.)
+    and provides both single-document and batch conversion capabilities.
+
+    The conversion methods return a `ConversionResult` instance for each document,
+    which wraps a `DoclingDocument` object if the conversion was successful, along
+    with metadata about the conversion process.
+
+    Attributes:
+        allowed_formats: Allowed input formats.
+        format_to_options: Mapping of formats to their options.
+        initialized_pipelines: Cache of initialized pipelines keyed by
+            (pipeline class, options hash).
+    """
+
     _default_download_filename = "file"
 
     def __init__(
         self,
         allowed_formats: Optional[list[InputFormat]] = None,
         format_options: Optional[dict[InputFormat, FormatOption]] = None,
-    ):
-        self.allowed_formats = (
+    ) -> None:
+        """Initialize the converter based on format preferences.
+
+        Args:
+            allowed_formats: List of allowed input formats. By default, any
+                format supported by Docling is allowed.
+            format_options: Dictionary of format-specific options.
+        """
+        self.allowed_formats: list[InputFormat] = (
             allowed_formats if allowed_formats is not None else list(InputFormat)
         )
 
@@ -237,7 +261,19 @@ class DocumentConverter:
         ).hexdigest()
 
     def initialize_pipeline(self, format: InputFormat):
-        """Initialize the conversion pipeline for the selected format."""
+        """Initialize the conversion pipeline for the selected format.
+
+        Args:
+            format: The input format for which to initialize the pipeline.
+
+        Raises:
+            ConversionError: If no pipeline could be initialized for the
+                given format.
+            RuntimeError: If `artifacts_path` is set in
+                `docling.datamodel.settings.settings` when required by
+                the pipeline, but points to a non-directory file.
+            FileNotFoundError: If local model files are not found.
+        """
         pipeline = self._get_pipeline(doc_format=format)
         if pipeline is None:
             raise ConversionError(
@@ -254,6 +290,30 @@ class DocumentConverter:
         max_file_size: int = sys.maxsize,
         page_range: PageRange = DEFAULT_PAGE_RANGE,
     ) -> ConversionResult:
+        """Convert one document fetched from a file path, URL, or DocumentStream.
+
+        Note: If the document content is given as a string (Markdown or HTML
+        content), use the `convert_string` method.
+
+        Args:
+            source: Source of input document given as file path, URL, or
+                DocumentStream.
+            headers: Optional headers given as a dictionary of string key-value pairs,
+                in case of URL input source.
+            raises_on_error: Whether to raise an error on the first conversion failure.
+                If False, errors are captured in the ConversionResult objects.
+            max_num_pages: Maximum number of pages accepted per document.
+                Documents exceeding this number will not be converted.
+            max_file_size: Maximum file size to convert.
+            page_range: Range of pages to convert.
+
+        Returns:
+            The conversion result, which contains a `DoclingDocument` in the `document`
+                attribute, and metadata about the conversion process.
+
+        Raises:
+            ConversionError: An error occurred during conversion.
+        """
         all_res = self.convert_all(
             source=[source],
             raises_on_error=raises_on_error,
@@ -269,11 +329,31 @@ class DocumentConverter:
         self,
         source: Iterable[Union[Path, str, DocumentStream]],  # TODO review naming
         headers: Optional[dict[str, str]] = None,
-        raises_on_error: bool = True,  # True: raises on first conversion error; False: does not raise on conv error
+        raises_on_error: bool = True,
         max_num_pages: int = sys.maxsize,
         max_file_size: int = sys.maxsize,
         page_range: PageRange = DEFAULT_PAGE_RANGE,
     ) -> Iterator[ConversionResult]:
+        """Convert multiple documents from file paths, URLs, or DocumentStreams.
+
+        Args:
+            source: Source of input documents given as an iterable of file paths, URLs,
+                or DocumentStreams.
+            headers: Optional headers given as a (single) dictionary of string
+                key-value pairs, in case of URL input source.
+            raises_on_error: Whether to raise an error on the first conversion failure.
+            max_num_pages: Maximum number of pages to convert.
+            max_file_size: Maximum number of pages accepted per document. Documents
+                exceeding this number will be skipped.
+            page_range: Range of pages to convert in each document.
+
+        Yields:
+            The conversion results, each containing a `DoclingDocument` in the
+                `document` attribute and metadata about the conversion process.
+
+        Raises:
+            ConversionError: An error occurred during conversion.
+        """
         limits = DocumentLimits(
             max_num_pages=max_num_pages,
             max_file_size=max_file_size,
@@ -296,14 +376,16 @@ class DocumentConverter:
                     error_messages = [err.error_message for err in conv_res.errors]
                     error_details = f" Errors: {'; '.join(error_messages)}"
                 raise ConversionError(
-                    f"Conversion failed for: {conv_res.input.file} with status: {conv_res.status}.{error_details}"
+                    f"Conversion failed for: {conv_res.input.file} with status: "
+                    f"{conv_res.status}.{error_details}"
                 )
             else:
                 yield conv_res
 
         if not had_result and raises_on_error:
             raise ConversionError(
-                "Conversion failed because the provided file has no recognizable format or it wasn't in the list of allowed formats."
+                "Conversion failed because the provided file has no recognizable "
+                "format or it wasn't in the list of allowed formats."
             )
 
     @validate_call(config=ConfigDict(strict=True))
@@ -313,6 +395,27 @@ class DocumentConverter:
         format: InputFormat,
         name: Optional[str] = None,
     ) -> ConversionResult:
+        """Convert a document given as a string using the specified format.
+
+        Only Markdown (`InputFormat.MD`) and HTML (`InputFormat.HTML`) formats
+        are supported. The content is wrapped in a `DocumentStream` and passed
+        to the main conversion pipeline.
+
+        Args:
+            content: The document content as a string.
+            format: The format of the input content.
+            name: The filename to associate with the document. If not provided, a
+                timestamp-based name is generated. The appropriate file extension (`md`
+                or `html`) is appended if missing.
+
+        Returns:
+            The conversion result, which contains a `DoclingDocument` in the `document`
+                attribute, and metadata about the conversion process.
+
+        Raises:
+            ValueError: If format is neither `InputFormat.MD` nor `InputFormat.HTML`.
+            ConversionError: An error occurred during conversion.
+        """
         name = name or datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
 
         if format == InputFormat.MD:

{docling-2.64.1 → docling-2.66.0}/docling/models/rapid_ocr_model.py

@@ -196,7 +196,7 @@ class RapidOcrModel(BaseOcrModel):
                 # Recognition model settings
                 "Rec.model_path": rec_model_path,
                 "Rec.font_path": self.options.rec_font_path,
-                "Rec.keys_path": rec_keys_path,
+                "Rec.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,

{docling-2.64.1 → docling-2.66.0}/docling.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling
-Version: 2.64.1
+Version: 2.66.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.64.1 → docling-2.66.0}/pyproject.toml

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