docling-parse 7.24.1__tar.gz → 7.24.2__tar.gz

{docling_parse-7.24.1 → docling_parse-7.24.2}/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [v7.24.2](https://github.com/docling-project/docling-parse/releases/tag/v7.24.2) - 2026-10-29
+
+### Fix
+
+* Bind take_load_error for the threaded renderer ([#432](https://github.com/docling-project/docling-parse/issues/432)) ([`4ebbb8a`](https://github.com/docling-project/docling-parse/commit/4ebbb8afa3516e2aec1f3d37bf67568fb3deb9ed))
+* **render:** Draw images in /CalGray and /CalRGB colour spaces ([#411](https://github.com/docling-project/docling-parse/issues/411)) ([`4df810b`](https://github.com/docling-project/docling-parse/commit/4df810b4878603dbe64ae8ad2b7c13cb47299480))
+
 ## [v7.24.1](https://github.com/docling-project/docling-parse/releases/tag/v7.24.1) - 2026-10-28
 
 ### Fix

{docling_parse-7.24.1 → docling_parse-7.24.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.24.1
+Version: 7.24.2
 Summary: Simple package to extract text with coordinates from programmatic PDFs
 Author-email: Peter Staar <taa@zurich.ibm.com>, Christoph Auer <cau@zurich.ibm.com>, Michele Dolfi <dol@zurich.ibm.com>, Panos Vagenas <pva@zurich.ibm.com>, Maxim Lysak <mly@zurich.ibm.com>
 License-Expression: MIT

{docling_parse-7.24.1 → docling_parse-7.24.2}/app/pybind_parse.cpp

@@ -1421,6 +1421,23 @@ PYBIND11_MODULE(pdf_parsers, m) {
          pybind11::arg("page_numbers") = pybind11::none(),
          pybind11::arg("page_range") = pybind11::none())
 
+    .def("take_load_error",
+         [](docling::docling_threaded_renderer& self, const std::string& key) -> std::map<std::string, std::string> {
+           return self.take_load_error(key);
+         },
+         pybind11::arg("key"),
+         R"(
+    Return and clear why the last load of `key` failed.
+
+    Parameters:
+        key (str): The key passed to the failed load call.
+
+    Returns:
+        dict[str, str]: {"category": ..., "message": ...}, or an empty dict when
+        no failure is recorded for the key. category is one of "password",
+        "damaged", "unsupported", "io" and "unknown"; message is the text of
+        the underlying (qpdf) error.)")
+
     .def("number_of_pages",
          [](docling::docling_threaded_renderer& self, const std::string& key) -> int {
            return self.number_of_pages(key);

{docling_parse-7.24.1 → docling_parse-7.24.2}/docling_parse.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.24.1
+Version: 7.24.2
 Summary: Simple package to extract text with coordinates from programmatic PDFs
 Author-email: Peter Staar <taa@zurich.ibm.com>, Christoph Auer <cau@zurich.ibm.com>, Michele Dolfi <dol@zurich.ibm.com>, Panos Vagenas <pva@zurich.ibm.com>, Maxim Lysak <mly@zurich.ibm.com>
 License-Expression: MIT

{docling_parse-7.24.1 → docling_parse-7.24.2}/docling_parse.egg-info/SOURCES.txt

@@ -738,6 +738,7 @@ tests/conftest.py
 tests/constants.py
 tests/data_utils.py
 tests/groundtruth_io.py
+tests/image_fixtures.py
 tests/outline_fixtures.py
 tests/pdf_builder.py
 tests/regression_page_selection.py
@@ -746,12 +747,14 @@ tests/test_regression_cell_contraction.py
 tests/test_regression_embedded_fonts.py
 tests/test_regression_locale_safety.py
 tests/test_regression_parse.py
+tests/test_regression_pypdfium_cited_pages.py
 tests/test_regression_pypdfium_render.py
 tests/test_regression_threaded_parse.py
 tests/test_regression_threaded_render.py
 tests/test_unit_acroform_widgets.py
 tests/test_unit_actual_text.py
 tests/test_unit_bitmap_artifacts.py
+tests/test_unit_cal_colorspace_images.py
 tests/test_unit_ccitt_images.py
 tests/test_unit_cid_to_gid_map.py
 tests/test_unit_cjk_fonts.py

{docling_parse-7.24.1 → docling_parse-7.24.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "docling-parse"
-version = "7.24.1"
+version = "7.24.2"
 description = "Simple package to extract text with coordinates from programmatic PDFs"
 license = "MIT"
 keywords = ["docling", "pdf", "parser"]

{docling_parse-7.24.1 → docling_parse-7.24.2}/src/parse/pdf_resources/page_xobject_image.h

@@ -19,6 +19,15 @@ namespace pdflib
 
   namespace detail
   {
+    // [/CalGray dict] and [/CalRGB dict] samples read as their device space; the
+    // calibration (WhitePoint, Gamma, Matrix) is not modelled. Other names pass through.
+    inline std::string cal_to_device_space(std::string const& name)
+    {
+      if(name == "/CalGray") return "/DeviceGray";
+      if(name == "/CalRGB")  return "/DeviceRGB";
+      return name;
+    }
+
     inline int icc_signature_to_components(char const* sig)
     {
       if(std::memcmp(sig, "GRAY", 4) == 0) return 1;
@@ -616,7 +625,7 @@ namespace pdflib
                           }
                         else if(base_name.isName())
                           {
-                            indexed_base_cs = base_name.getName();
+                            indexed_base_cs = detail::cal_to_device_space(base_name.getName());
                             LOG_S(INFO) << "Indexed array base color space: " << indexed_base_cs;
                           }
 
@@ -780,6 +789,12 @@ namespace pdflib
                           }
                       }
                   }
+                else if(name_obj.isName()
+                        and (name_obj.getName() == "/CalGray" or name_obj.getName() == "/CalRGB"))
+                  {
+                    color_space = detail::cal_to_device_space(name_obj.getName());
+                    LOG_S(INFO) << "reading " << name_obj.getName() << " samples as " << color_space;
+                  }
               }
           }
       }

{docling_parse-7.24.1 → docling_parse-7.24.2}/tests/constants.py

@@ -1,7 +1,7 @@
 from tests.regression_page_selection import REGRESSION_PAGE_SELECTION
 
 HF_DATASET_REPO_ID = "docling-project/regression-dataset-for-docling-parse"
-HF_DATASET_REVISION = "21374211ec8e84cb58eea3c62f869c2adfcc9a54"
+HF_DATASET_REVISION = "bc46a476692b0b035112d2e47a64843fdfb6337b"
 
 REGRESSION_DIR = "tests/data/regression"
 

docling_parse-7.24.2/tests/image_fixtures.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+"""Image sample data for the unit fixtures.
+
+The codestreams come from a real encoder (Pillow's) rather than from a test's
+own understanding of one, so a renderer that disagrees with them disagrees with
+the encoder, not with this file.
+"""
+
+from __future__ import annotations
+
+import io
+from collections.abc import Sequence
+
+from PIL import Image, TiffImagePlugin
+
+
+def middle_half(extent: int) -> range:
+    return range(extent // 4, 3 * extent // 4)
+
+
+def g4_codes(
+    columns: int, rows: int, ink_columns: Sequence[range], ink_rows: range
+) -> bytes:
+    """Group 4 codes for bands of ink, `columns` pixels to the row.
+
+    Pillow writes a mode-"1" image with photometric=BlackIsZero, which makes
+    its *0* pixels the codestream's white runs. A PDF reads the opposite way
+    round under the default /BlackIs1 false, where a decoded 0 bit is black, so
+    the image handed to Pillow is the inverse of the samples wanted back.
+    """
+    image = Image.new("1", (columns, rows), 0)
+    for y in ink_rows:
+        for band in ink_columns:
+            for x in band:
+                image.putpixel((x, y), 1)
+
+    buffer = io.BytesIO()
+    image.save(buffer, format="TIFF", compression="group4")
+
+    tiff = Image.open(io.BytesIO(buffer.getvalue()))
+    # Only a TIFF carries the strip tags this reads back out.
+    assert isinstance(tiff, TiffImagePlugin.TiffImageFile)
+
+    offsets, counts = tiff.tag_v2[273], tiff.tag_v2[279]
+    assert len(offsets) == 1, "the fixture wants one strip, i.e. one codestream"
+
+    return buffer.getvalue()[offsets[0] : offsets[0] + counts[0]]

docling_parse-7.24.2/tests/test_regression_pypdfium_cited_pages.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python
+"""Enforced comparison against pypdfium2 on the pages that rendering fixes cite.
+
+`test_regression_pypdfium_render.py` reports how the whole corpus compares with
+pypdfium2 but never fails. This file holds the pages a rendering fix was shown
+on: each one must stay within its own tolerance of pypdfium2, so the fix cannot
+regress unnoticed. A fix adds its pages here, with a tolerance that fails on the
+code before the fix.
+"""
+
+from pathlib import Path
+
+import pytest
+
+from tests.rendering_regression import (
+    ImageTolerance,
+    flatten_on_white,
+    image_comparison_failed,
+    measure_image_pair,
+    render_pypdfium_page,
+)
+from tests.test_regression_pypdfium_render import (
+    PYPDFIUM_RENDER_SCALE,
+    _make_pypdfium_render_config,
+)
+from tests.test_regression_threaded_render import _make_parser
+
+REGRESSION_DIR = Path("tests/data/regression")
+
+CITED_PAGES = [
+    # A /CalRGB JPEG image XObject. It was drawn as the semi-transparent yellow
+    # "missing image" placeholder (mean_abs_error 5.10, changed_pixels_ratio
+    # 0.131 before the fix; 0.26 and 0.0045 after it).
+    pytest.param(
+        "dln_23cb379bc6159a37e5488b65bb08ad295ce3ff21d9ddf682064330594ad59db3.pdf",
+        1,
+        ImageTolerance(
+            pixel_threshold=12, mean_abs_error=1.0, changed_pixels_ratio=0.02
+        ),
+        id="calrgb-image",
+    ),
+    # docling#4861: a scanned invoice written as a /CalGray CCITT Group 4 image
+    # by an image-to-PDF converter. It was drawn as the yellow placeholder, so
+    # OCR on the rendered page found nothing (mean_abs_error 38.1, changed_pixels_ratio
+    # 0.111 before the fix; 3.30 and 0.051 after it, the rest being how the 1-bit
+    # scan is anti-aliased when downsampled).
+    pytest.param(
+        "APT002_issue_calibrated_gray_colorspace.pdf",
+        1,
+        ImageTolerance(
+            pixel_threshold=12, mean_abs_error=5.0, changed_pixels_ratio=0.08
+        ),
+        id="calgray-fax-scan",
+    ),
+]
+
+
+@pytest.mark.parametrize(("document", "page", "tolerance"), CITED_PAGES)
+def test_cited_page_matches_pypdfium(
+    document: str, page: int, tolerance: ImageTolerance
+) -> None:
+    pytest.importorskip(
+        "pypdfium2",
+        reason="pypdfium2 is required for the cross-renderer comparison",
+    )
+    pdf_path = REGRESSION_DIR / document
+
+    parser = _make_parser(render_config=_make_pypdfium_render_config())
+    doc_key = parser.load(str(pdf_path), page_numbers=[page])
+    results = list(parser.iterate_results())
+    parser.unload_all()
+
+    assert len(results) == 1
+    result = results[0]
+    assert result.doc_key == doc_key
+    assert result.success, result.error_message
+
+    reference = render_pypdfium_page(pdf_path, page, scale=PYPDFIUM_RENDER_SCALE)
+    comparison = measure_image_pair(
+        document,
+        page,
+        flatten_on_white(result.get_image()),
+        flatten_on_white(reference),
+        tolerance=tolerance,
+    )
+
+    assert not image_comparison_failed(comparison, tolerance=tolerance), (
+        f"{document}@{page}: mean_abs_error={comparison.mean_abs_error:.4f} "
+        f"(limit {tolerance.mean_abs_error}), "
+        f"changed_pixels_ratio={comparison.changed_pixels_ratio:.4f} "
+        f"(limit {tolerance.changed_pixels_ratio}), "
+        f"size_matches={comparison.size_matches}"
+    )

docling_parse-7.24.2/tests/test_unit_cal_colorspace_images.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python
+"""Images in the CIE-based /CalGray and /CalRGB colour spaces.
+
+/CalGray and /CalRGB (ISO 32000-1, 8.6.5.2 and 8.6.5.3) are always written as
+an array, `[/CalGray << ... >>]`, because the dictionary of white point and
+gamma is what makes them calibrated. The image path recognised only the
+ICCBased, Separation, DeviceN and Indexed arrays; a calibrated space was left
+as its JSON dump, reported as unsupported, and the image was dropped for the
+renderer's yellow placeholder. PDF/A image-to-PDF converters write scanned
+bilevel pages as /CalGray, since PDF/A wants device-independent colour, so a
+whole scanned page came out as that placeholder and OCR run on it found
+nothing (docling#4861).
+
+The samples of either space read as those of its device counterpart; the
+calibration only refines how they look, which the renderer does not model.
+"""
+
+from __future__ import annotations
+
+import zlib
+
+import pytest
+
+from tests.image_fixtures import g4_codes, middle_half
+from tests.pdf_builder import render_page, simple_page_pdf, stream_object
+from tests.rendering_regression import assert_color_near, center_color, region_image
+
+WHITE = (255, 255, 255)
+BLACK = (0, 0, 0)
+RED = (255, 0, 0)
+
+# Every fixture draws its image over the middle 100x100 points of a 200x200
+# page and paints the middle half of the image in both directions, so the paint
+# lands on the middle 50x50 points of the page. Boxes are (left, top, right,
+# bottom) in points from the top-left.
+PAINT = (90.0, 90.0, 110.0, 110.0)
+MARGIN = (55.0, 55.0, 70.0, 70.0)
+
+CAL_GRAY = "[/CalGray << /WhitePoint [0.9505 1.0 1.089] /Gamma 2.2 >>]"
+CAL_RGB = (
+    "[/CalRGB << /WhitePoint [0.9505 1.0 1.089] /Gamma [2.2 2.2 2.2] "
+    "/Matrix [0.4124 0.2126 0.0193 0.3576 0.7152 0.1192 0.1805 0.0722 0.9505] >>]"
+)
+
+
+def image_page(dictionary: str, payload: bytes) -> bytes:
+    """A page drawing one image XObject over the middle of a 200x200 page."""
+    image = stream_object(f"/Type /XObject /Subtype /Image {dictionary}", payload)
+    return simple_page_pdf(
+        "q\n100 0 0 100 50 50 cm\n/Im0 Do\nQ\n",
+        resources="/XObject << /Im0 5 0 R >>",
+        extra_objects=[image],
+    )
+
+
+def painted(x: int, y: int, width: int, height: int) -> bool:
+    return x in middle_half(width) and y in middle_half(height)
+
+
+def assert_painted(result, color: tuple[int, int, int], what: str) -> None:
+    """The paint is a block in the middle, with white page around it."""
+    assert_color_near(
+        center_color(region_image(result, PAINT)),
+        color,
+        tolerance=30,
+        what=f"paint of {what}",
+    )
+    assert_color_near(
+        center_color(region_image(result, MARGIN)),
+        WHITE,
+        tolerance=30,
+        what=f"margin of {what}",
+    )
+
+
+@pytest.mark.parametrize(
+    "decode_parms, decode",
+    [
+        ("<< /K -1 /Columns 64 >>", ""),
+        # How image-to-PDF converters tend to write a fax page: the codes'
+        # black runs come out as 1 bits, and /Decode turns them back into ink.
+        ("<< /K -1 /Columns 64 /BlackIs1 true >>", "/Decode [1 0]"),
+    ],
+    ids=["default-decode", "blackis1-with-inverting-decode"],
+)
+def test_calgray_fax_scan_is_drawn(decode_parms: str, decode: str):
+    """The scanned page of docling#4861: a Group 4 image in /CalGray."""
+    width = height = 64
+    codes = g4_codes(width, height, [middle_half(width)], middle_half(height))
+    pdf = image_page(
+        f"/Width {width} /Height {height} /ColorSpace {CAL_GRAY} "
+        f"/BitsPerComponent 1 /Filter /CCITTFaxDecode "
+        f"/DecodeParms {decode_parms} {decode}",
+        codes,
+    )
+    assert_painted(render_page(pdf), BLACK, "a /CalGray fax image")
+
+
+def test_calrgb_samples_are_read_as_rgb():
+    width = height = 16
+    samples = b"".join(
+        bytes(RED if painted(x, y, width, height) else WHITE)
+        for y in range(height)
+        for x in range(width)
+    )
+    pdf = image_page(
+        f"/Width {width} /Height {height} /ColorSpace {CAL_RGB} "
+        f"/BitsPerComponent 8 /Filter /FlateDecode",
+        zlib.compress(samples),
+    )
+    assert_painted(render_page(pdf), RED, "a /CalRGB image")
+
+
+def test_indexed_image_over_a_calrgb_base_is_drawn():
+    width = height = 16
+    palette = bytes(WHITE) + bytes(RED)
+    indices = bytes(
+        1 if painted(x, y, width, height) else 0
+        for y in range(height)
+        for x in range(width)
+    )
+    pdf = image_page(
+        f"/Width {width} /Height {height} "
+        f"/ColorSpace [/Indexed {CAL_RGB} 1 <{palette.hex()}>] "
+        f"/BitsPerComponent 8",
+        indices,
+    )
+    assert_painted(render_page(pdf), RED, "an /Indexed image over a /CalRGB base")

{docling_parse-7.24.1 → docling_parse-7.24.2}/tests/test_unit_ccitt_images.py

@@ -20,14 +20,12 @@ takes that padding for code bits, so the second row is already wrong.
 
 from __future__ import annotations
 
-import io
 import zlib
 from base64 import a85encode
-from collections.abc import Sequence
 
 import pytest
-from PIL import Image, TiffImagePlugin
 
+from tests.image_fixtures import g4_codes, middle_half
 from tests.pdf_builder import render_page, simple_page_pdf, stream_object
 from tests.rendering_regression import assert_color_near, center_color, region_image
 
@@ -46,45 +44,6 @@ MARGIN = (55.0, 55.0, 70.0, 70.0)
 BELOW_INK = (90.0, 130.0, 110.0, 145.0)
 
 
-def middle_half(extent: int) -> range:
-    return range(extent // 4, 3 * extent // 4)
-
-
-# ---------------------------------------------------------------------------
-# Fixtures encoded by Pillow, so the codes under test come from a real fax
-# encoder rather than from this file's understanding of one.
-# ---------------------------------------------------------------------------
-
-
-def g4_codes(
-    columns: int, rows: int, ink_columns: Sequence[range], ink_rows: range
-) -> bytes:
-    """Group 4 codes for bands of ink, `columns` pixels to the row.
-
-    Pillow writes a mode-"1" image with photometric=BlackIsZero, which makes
-    its *0* pixels the codestream's white runs. A PDF reads the opposite way
-    round under the default /BlackIs1 false, where a decoded 0 bit is black, so
-    the image handed to Pillow is the inverse of the samples wanted back.
-    """
-    image = Image.new("1", (columns, rows), 0)
-    for y in ink_rows:
-        for band in ink_columns:
-            for x in band:
-                image.putpixel((x, y), 1)
-
-    buffer = io.BytesIO()
-    image.save(buffer, format="TIFF", compression="group4")
-
-    tiff = Image.open(io.BytesIO(buffer.getvalue()))
-    # Only a TIFF carries the strip tags this reads back out.
-    assert isinstance(tiff, TiffImagePlugin.TiffImageFile)
-
-    offsets, counts = tiff.tag_v2[273], tiff.tag_v2[279]
-    assert len(offsets) == 1, "the fixture wants one strip, i.e. one codestream"
-
-    return buffer.getvalue()[offsets[0] : offsets[0] + counts[0]]
-
-
 # ---------------------------------------------------------------------------
 # A hand-written codestream, for the one parameter no TIFF encoder will
 # produce: TIFF has no /EncodedByteAlign, so the padded rows have to be built

{docling_parse-7.24.1 → docling_parse-7.24.2}/tests/test_unit_load_failure_reason.py

@@ -23,6 +23,8 @@ from docling_parse.pdf_parser import (
     PdfLoadError,
     PdfLoadErrorCategory,
     PdfPasswordError,
+    RenderConfig,
+    ThreadedPdfParserConfig,
 )
 from tests.pdf_builder import simple_page_pdf
 
@@ -62,8 +64,16 @@ def _threaded_parser():
     return DoclingThreadedPdfParser()
 
 
+def _threaded_renderer():
+    return DoclingThreadedPdfParser(
+        parser_config=ThreadedPdfParserConfig(render_config=RenderConfig())
+    )
+
+
 PARSERS = pytest.mark.parametrize(
-    "make_parser", [_plain_parser, _threaded_parser], ids=["plain", "threaded"]
+    "make_parser",
+    [_plain_parser, _threaded_parser, _threaded_renderer],
+    ids=["plain", "threaded", "renderer"],
 )
 
 

{docling_parse-7.24.1 → docling_parse-7.24.2}/uv.lock

@@ -920,7 +920,7 @@ wheels = [
 
 [[package]]
 name = "docling-parse"
-version = "7.24.1"
+version = "7.24.2"
 source = { editable = "." }
 default-groups = "all"
 dependencies = [