docling-parse 7.8.0__tar.gz → 7.8.1__tar.gz

{docling_parse-7.8.0 → docling_parse-7.8.1}/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [v7.8.1](https://github.com/docling-project/docling-parse/releases/tag/v7.8.1) - 2026-07-20
+
+### Fix
+
+* Report document load failures instead of deferring them as -1 page count ([#301](https://github.com/docling-project/docling-parse/issues/301)) ([`77eab80`](https://github.com/docling-project/docling-parse/commit/77eab80a6b37df2231299fc59867abc3158bce97))
+* Resolve core-14 font aliases to their standard metrics ([#294](https://github.com/docling-project/docling-parse/issues/294)) ([`109ce27`](https://github.com/docling-project/docling-parse/commit/109ce278db1def7b835b484453e5a34761314d3e))
+
 ## [v7.8.0](https://github.com/docling-project/docling-parse/releases/tag/v7.8.0) - 2026-07-10
 
 ### Feature

{docling_parse-7.8.0 → docling_parse-7.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.8.0
+Version: 7.8.1
 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.8.0 → docling_parse-7.8.1}/docling_parse.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.8.0
+Version: 7.8.1
 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.8.0 → docling_parse-7.8.1}/docling_parse.egg-info/SOURCES.txt

@@ -666,8 +666,10 @@ tests/constants.py
 tests/data_utils.py
 tests/rendering_regression.py
 tests/test_embedded_fonts.py
+tests/test_load_failure.py
 tests/test_locale_safety.py
 tests/test_parse.py
+tests/test_standard_font_widths.py
 tests/test_threaded_parse.py
 tests/test_threaded_render.py
 tests/update_groundtruth.py

{docling_parse-7.8.0 → docling_parse-7.8.1}/pyproject.toml

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

{docling_parse-7.8.0 → docling_parse-7.8.1}/src/parse/pdf_resources/page_font/base_fonts.h

@@ -42,6 +42,8 @@ namespace pdflib
 
     std::string read_fontname(std::string filename);
 
+    void register_standard_aliases();
+
   private:
 
     bool initialized;
@@ -236,6 +238,8 @@ namespace pdflib
 	  }
       }
 
+    register_standard_aliases();
+
     initialized = true;
   }
 
@@ -289,6 +293,45 @@ namespace pdflib
     return fontname;
   }
 
+  void base_fonts::register_standard_aliases()
+  {
+    // A PDF may name a Core-14 font by a common family alias (Arial for
+    // Helvetica, Times New Roman for Times, Courier New for Courier) and ship it
+    // without a /Widths table. The resolver only matches when the canonical
+    // PostScript name is contained in the font name, which these aliases are
+    // not, so bind them to the Core-14 metrics that viewers substitute.
+    static const std::vector<std::pair<std::string, std::string> > aliases =
+      {
+        {"arial",                    "helvetica"},
+        {"arial-bold",               "helvetica-bold"},
+        {"arial-italic",             "helvetica-oblique"},
+        {"arial-bolditalic",         "helvetica-boldoblique"},
+        {"couriernew",               "courier"},
+        {"couriernew-bold",          "courier-bold"},
+        {"couriernew-italic",        "courier-oblique"},
+        {"couriernew-bolditalic",    "courier-boldoblique"},
+        {"times",                    "times-roman"},
+        {"timesnewroman",            "times-roman"},
+        {"timesnewroman-bold",       "times-bold"},
+        {"timesnewroman-italic",     "times-italic"},
+        {"timesnewroman-bolditalic", "times-bolditalic"},
+      };
+
+    for(auto& alias : aliases)
+      {
+        if(name_to_basefont.count(alias.first)==1 or
+           name_to_basefont.count(alias.second)==0)
+          {
+            continue;
+          }
+
+        base_font bf = name_to_basefont.at(alias.second);
+        name_to_basefont.emplace(alias.first, bf);
+
+        core_14_fonts.insert(alias.first);
+      }
+  }
+
 }
 
 #endif

{docling_parse-7.8.0 → docling_parse-7.8.1}/src/pybind/docling_parser.h

@@ -170,9 +170,17 @@ namespace docling
         remove_page_decoders(key);
 
         doc_decoders[key] = std::make_shared<doc_decoder_type>();
-        doc_decoders.at(key)->process_document_from_file(filename,
-                                                         password,
-                                                         keep_qpdf_warnings);
+        bool success = doc_decoders.at(key)->process_document_from_file(filename,
+                                                                        password,
+                                                                        keep_qpdf_warnings);
+        if(not success)
+          {
+            // do not keep a decoder that never parsed the document: it would
+            // report is_loaded()=true and a number_of_pages of -1
+            doc_decoders.erase(key);
+            LOG_S(ERROR) << "could not process document for key=" << key;
+            return false;
+          }
 
         return true;
       }
@@ -210,16 +218,25 @@ namespace docling
 
         doc_decoders[key] = std::make_shared<doc_decoder_type>();
         std::string description = "parsing of " + key + " from bytesio";
-        doc_decoders.at(key)->process_document_from_bytesio(data_buffer,
-                                                            password,
-                                                            description,
-                                                            keep_qpdf_warnings);
+        bool success = doc_decoders.at(key)->process_document_from_bytesio(data_buffer,
+                                                                           password,
+                                                                           description,
+                                                                           keep_qpdf_warnings);
+        if(not success)
+          {
+            // do not keep a decoder that never parsed the document: it would
+            // report is_loaded()=true and a number_of_pages of -1
+            doc_decoders.erase(key);
+            LOG_S(ERROR) << "could not decode bytesio object for key="<<key;
+            return false;
+          }
 
         return true;
       }
     catch(const std::exception& exc)
       {
-        LOG_S(ERROR) << "could not docode bytesio object for key="<<key;
+        doc_decoders.erase(key);
+        LOG_S(ERROR) << "could not decode bytesio object for key="<<key;
         return false;
       }
 

{docling_parse-7.8.0 → docling_parse-7.8.1}/src/pybind/docling_threaded_base.h

@@ -217,9 +217,17 @@ namespace docling
         try
           {
             key2doc[key] = std::make_shared<doc_decoder_type>();
-            key2doc.at(key)->process_document_from_file(filename,
-                                                        password,
-                                                        config.keep_qpdf_warnings);
+            bool success = key2doc.at(key)->process_document_from_file(filename,
+                                                                       password,
+                                                                       config.keep_qpdf_warnings);
+            if(not success)
+              {
+                // do not keep a decoder that never parsed the document: it
+                // would schedule zero pages and report a page count of -1
+                key2doc.erase(key);
+                LOG_S(ERROR) << "could not decode file object for key=" << key;
+                return false;
+              }
           }
         catch(const std::exception& exc)
           {
@@ -277,10 +285,19 @@ namespace docling
       {
         key2doc[key] = std::make_shared<doc_decoder_type>();
         std::string description = "parsing of " + key + " from bytesio";
-        key2doc.at(key)->process_document_from_bytesio(data_buffer,
-                                                       password,
-                                                       description,
-                                                       config.keep_qpdf_warnings);
+        bool success = key2doc.at(key)->process_document_from_bytesio(data_buffer,
+                                                                      password,
+                                                                      description,
+                                                                      config.keep_qpdf_warnings);
+        if(not success)
+          {
+            // do not keep a decoder that never parsed the document: it would
+            // schedule zero pages and report a page count of -1
+            key2doc.erase(key);
+            key2scheduled_pages.erase(key);
+            LOG_S(ERROR) << "could not decode bytesio object for key=" << key;
+            return false;
+          }
       }
     catch(const std::exception& exc)
       {
@@ -362,6 +379,14 @@ namespace docling
   {
     std::vector<int> scheduled_pages;
 
+    if(num_pages < 0)
+      {
+        // a negative count means the document was never parsed; scheduling
+        // from it would silently produce an empty task list
+        throw std::runtime_error("Invalid page count " + std::to_string(num_pages)
+                                 + " for document key " + key);
+      }
+
     if(not page_numbers.has_value())
       {
         scheduled_pages.reserve(num_pages);

docling_parse-7.8.1/tests/test_load_failure.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python
+"""Load failures must be reported, not deferred as a -1 page count.
+
+When qpdf cannot parse a document, the C++ decoder returns false with its
+number_of_pages still at the -1 sentinel. The pybind loaders used to ignore
+that return value and report success, so the failure only surfaced later as
+number_of_pages() == -1 — which downstream docling propagated as
+"Inconsistent number of pages: N!=-1" and a silently rejected document
+(docling-parse#239, docling#3031).
+
+load() must raise at load time, and the failed key must not linger in the
+parser (is_loaded() reporting true for a document that never parsed).
+"""
+
+from io import BytesIO
+
+import pytest
+
+from docling_parse.pdf_parser import DoclingPdfParser, DoclingThreadedPdfParser
+
+GARBAGE = b"%PDF-1.4\nthis is not a valid pdf at all"
+
+
+def _minimal_pdf() -> bytes:
+    content = "BT /F1 24 Tf 72 700 Td (ok) Tj ET"
+    objects = [
+        "<< /Type /Catalog /Pages 2 0 R >>",
+        "<< /Type /Pages /Kids [3 0 R] /Count 1 >>",
+        "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] "
+        "/Resources << /Font << /F1 4 0 R >> >> /Contents 5 0 R >>",
+        "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>",
+        f"<< /Length {len(content)} >>\nstream\n{content}\nendstream",
+    ]
+
+    out = b"%PDF-1.4\n"
+    offsets = []
+    for index, obj in enumerate(objects, start=1):
+        offsets.append(len(out))
+        out += f"{index} 0 obj\n{obj}\nendobj\n".encode("latin-1")
+
+    startxref = len(out)
+    out += f"xref\n0 {len(objects) + 1}\n".encode("latin-1")
+    out += b"0000000000 65535 f \n"
+    for offset in offsets:
+        out += f"{offset:010d} 00000 n \n".encode("latin-1")
+    out += (
+        f"trailer\n<< /Size {len(objects) + 1} /Root 1 0 R >>\n"
+        f"startxref\n{startxref}\n%%EOF"
+    ).encode("latin-1")
+    return out
+
+
+def test_bytesio_garbage_raises_at_load():
+    parser = DoclingPdfParser(loglevel="fatal")
+    with pytest.raises(RuntimeError, match="Failed to load document"):
+        parser.load(path_or_stream=BytesIO(GARBAGE))
+
+
+def test_file_garbage_raises_at_load(tmp_path):
+    bad = tmp_path / "garbage.pdf"
+    bad.write_bytes(GARBAGE)
+
+    parser = DoclingPdfParser(loglevel="fatal")
+    with pytest.raises(RuntimeError, match="Failed to load document"):
+        parser.load(path_or_stream=str(bad))
+
+
+def test_failed_load_leaves_no_stale_key():
+    parser = DoclingPdfParser(loglevel="fatal")
+    with pytest.raises(RuntimeError):
+        parser.load(path_or_stream=BytesIO(GARBAGE))
+
+    # a decoder that never parsed must not stay registered: it would report
+    # is_loaded()=true and number_of_pages()=-1
+    assert parser.list_loaded_keys() == []
+
+
+def test_valid_document_still_loads():
+    parser = DoclingPdfParser(loglevel="fatal")
+    doc = parser.load(path_or_stream=BytesIO(_minimal_pdf()))
+    assert doc.number_of_pages() == 1
+
+
+def test_threaded_bytesio_garbage_raises_at_load():
+    parser = DoclingThreadedPdfParser()
+    with pytest.raises(RuntimeError, match="Failed to load document"):
+        parser.load(path_or_stream=BytesIO(GARBAGE))
+
+
+def test_threaded_valid_document_still_loads():
+    parser = DoclingThreadedPdfParser()
+    key = parser.load(path_or_stream=BytesIO(_minimal_pdf()))
+    assert parser.page_count(key) == 1

docling_parse-7.8.1/tests/test_standard_font_widths.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python
+"""Character widths for standard Type1 fonts without an explicit /Widths table.
+
+A PDF may reference one of the Core-14 fonts (or a common family alias such as
+Arial or Times New Roman) and rely on the built-in font metrics instead of
+shipping a /Widths array. These tests build such PDFs in memory and check that
+the parser reports the real per-glyph advances rather than a flat fallback.
+"""
+
+from io import BytesIO
+from itertools import pairwise
+from typing import List
+
+from docling_parse.pdf_parser import DoclingPdfParser
+
+
+def _build_pdf(
+    base_font: str, text: str, font_size: int = 10, widths: str = ""
+) -> bytes:
+    content = f"BT\n/F001 {font_size} Tf\n72 720 Td\n({text}) Tj\nET\n"
+    font = (
+        f"<< /Type /Font /Subtype /Type1 /BaseFont /{base_font} /Name /F001"
+        f"{widths} /Encoding /WinAnsiEncoding >>"
+    )
+    objects = [
+        "<< /Type /Catalog /Pages 2 0 R >>",
+        "<< /Type /Pages /Kids [3 0 R] /Count 1 >>",
+        "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 857 792] /Contents 4 0 R "
+        "/Resources << /Font << /F001 5 0 R >> >> >>",
+        f"<< /Length {len(content)} >>\nstream\n{content}\nendstream",
+        font,
+    ]
+
+    out = b"%PDF-1.4\n"
+    offsets = []
+    for index, obj in enumerate(objects, start=1):
+        offsets.append(len(out))
+        out += f"{index} 0 obj\n{obj}\nendobj\n".encode("latin-1")
+
+    startxref = len(out)
+    out += f"xref\n0 {len(objects) + 1}\n".encode("latin-1")
+    out += b"0000000000 65535 f \n"
+    for offset in offsets:
+        out += f"{offset:010d} 00000 n \n".encode("latin-1")
+    out += (
+        f"trailer\n<< /Size {len(objects) + 1} /Root 1 0 R >>\n"
+        f"startxref\n{startxref}\n%%EOF"
+    ).encode("latin-1")
+    return out
+
+
+def _char_advances(base_font: str, text: str, **kwargs) -> List[float]:
+    """Left-edge spacing between consecutive glyphs of the first text line."""
+    parser = DoclingPdfParser(loglevel="fatal")
+    doc = parser.load(path_or_stream=BytesIO(_build_pdf(base_font, text, **kwargs)))
+
+    _, page = next(doc.iterate_pages())
+    cells = list(page.char_cells)
+    assert cells, f"no char cells for {base_font}"
+
+    def left(cell) -> float:
+        rect = cell.rect
+        return min(rect.r_x0, rect.r_x1, rect.r_x2, rect.r_x3)
+
+    lefts = sorted(left(cell) for cell in cells)
+    return [round(b - a, 3) for a, b in pairwise(lefts)]
+
+
+FLAT_FALLBACK_ADVANCE = 5.0  # 500 units/em at 10pt, the pre-fix wrong value
+
+
+def test_courier_char_advance_is_six_points():
+    """Courier is monospace at 600 units/em, so every 10pt glyph advances 6pt."""
+    advances = _char_advances("Courier", "ABC12345 COMPANY")
+    assert advances
+    for advance in advances:
+        assert abs(advance - 6.0) < 0.01
+
+
+def test_helvetica_widths_vary_and_are_not_flat():
+    """A proportional Core-14 font yields real per-glyph widths, not a flat 5pt."""
+    # "imW" exercises a narrow, a wide and an extra-wide glyph.
+    advances = _char_advances("Helvetica", "imW")
+    assert len(advances) >= 2
+    assert len(set(advances)) > 1
+    for advance in advances:
+        assert abs(advance - FLAT_FALLBACK_ADVANCE) > 0.01
+
+
+def test_arial_alias_resolves_to_helvetica_metrics():
+    """Arial has no bundled AFM, so it must fall back to the Helvetica metrics.
+
+    Without the alias it drops to the flat 5pt fallback; with it the advances
+    match Helvetica glyph for glyph.
+    """
+    text = "imWl0"
+    arial = _char_advances("Arial", text)
+    helvetica = _char_advances("Helvetica", text)
+
+    assert arial == helvetica
+    for advance in arial:
+        assert abs(advance - FLAT_FALLBACK_ADVANCE) > 0.01
+
+
+def test_times_aliases_resolve_to_times_roman_metrics():
+    """Both "Times" and "TimesNewRoman" map onto the Times-Roman metrics."""
+    text = "imWl0"
+    times_roman = _char_advances("Times-Roman", text)
+
+    assert _char_advances("Times", text) == times_roman
+    assert _char_advances("TimesNewRoman", text) == times_roman
+    assert times_roman[0] != times_roman[1]
+
+
+def test_explicit_widths_take_precedence_over_base_metrics():
+    """An explicit /Widths table overrides the built-in Core-14 metrics."""
+    widths = " /FirstChar 65 /LastChar 90 /Widths [" + " ".join(["1000"] * 26) + "]"
+    advances = _char_advances("Courier", "AWX", widths=widths)
+
+    assert advances
+    for advance in advances:
+        assert abs(advance - 10.0) < 0.01

{docling_parse-7.8.0 → docling_parse-7.8.1}/uv.lock

@@ -739,7 +739,7 @@ wheels = [
 
 [[package]]
 name = "docling-parse"
-version = "7.8.0"
+version = "7.8.1"
 source = { editable = "." }
 dependencies = [
     { name = "docling-core" },