docling-parse 7.22.1__tar.gz → 7.22.2__tar.gz

{docling_parse-7.22.1 → docling_parse-7.22.2}/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [v7.22.2](https://github.com/docling-project/docling-parse/releases/tag/v7.22.2) - 2026-10-05
+
+### Fix
+
+* Ignore malformed ToUnicode bfranges instead of reserving ~4G map entries ([#381](https://github.com/docling-project/docling-parse/issues/381)) ([`6d7ccf2`](https://github.com/docling-project/docling-parse/commit/6d7ccf26d09a38a86a08a8fadaf46987766b53e0))
+* Take the pattern name by value in do_pattern_fill ([#382](https://github.com/docling-project/docling-parse/issues/382)) ([`92ee655`](https://github.com/docling-project/docling-parse/commit/92ee6553b102a7984998abbe4ddea646b45db6c8))
+* Read font directory env vars wide on Windows ([#364](https://github.com/docling-project/docling-parse/issues/364)) ([`0c0eff2`](https://github.com/docling-project/docling-parse/commit/0c0eff2def1b7a594bcb536e7b0dc546524ae5d9))
+* Translate widget and hyperlink rects to the page boundary ([#376](https://github.com/docling-project/docling-parse/issues/376)) ([`6b5b6fd`](https://github.com/docling-project/docling-parse/commit/6b5b6fd0c70fbcde43bc35d0dad004047fdee7a2))
+
 ## [v7.22.1](https://github.com/docling-project/docling-parse/releases/tag/v7.22.1) - 2026-09-28
 
 ### Fix

{docling_parse-7.22.1 → docling_parse-7.22.2}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.22.1
+Version: 7.22.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.22.1 → docling_parse-7.22.2}/pyproject.toml

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

{docling_parse-7.22.1 → docling_parse-7.22.2}/src/parse/page_item_sanitators/page_dimension.h

@@ -22,6 +22,12 @@ namespace pdflib
 
     void sanitize(page_item<PAGE_IMAGES>& images, std::string page_boundary);
 
+    // Annotation rectangles (widgets, hyperlinks) are only moved onto the
+    // page boundary, never dropped: a form field outside the crop box is
+    // still part of the form.
+    template<typename annots_type>
+    void translate(annots_type& annots, std::string page_boundary);
+
   private:
 
     std::array<double, 4> get_page_boundary(std::string page_boundary);
@@ -410,6 +416,22 @@ namespace pdflib
     */
   }
 
+  template<typename annots_type>
+  void page_item_sanitator<PAGE_DIMENSION>::translate(annots_type& annots, std::string page_boundary)
+  {
+    LOG_S(INFO) << __FUNCTION__;
+
+    std::array<double, 4> page_bbox = get_page_boundary(page_boundary);
+
+    for(auto& annot : annots)
+      {
+        annot.x0 -= page_bbox[0];
+        annot.y0 -= page_bbox[1];
+        annot.x1 -= page_bbox[0];
+        annot.y1 -= page_bbox[1];
+      }
+  }
+
   void page_item_sanitator<PAGE_DIMENSION>::transform(std::array<double, 2>& v,
 						std::array<double, 2>& r)
   {

{docling_parse-7.22.1 → docling_parse-7.22.2}/src/parse/page_items/page_hyperlink.h

@@ -59,6 +59,10 @@ namespace pdflib
 
     utils::values::translate_inplace(delta, x0, y0);
     utils::values::translate_inplace(delta, x1, y1);
+
+    // the two corners rotate independently: restore bottom-left/top-right
+    if(x1 < x0) { std::swap(x0, x1); }
+    if(y1 < y0) { std::swap(y0, y1); }
   }
 
 }

{docling_parse-7.22.1 → docling_parse-7.22.2}/src/parse/page_items/page_widget.h

@@ -79,6 +79,10 @@ namespace pdflib
 
     utils::values::translate_inplace(delta, x0, y0);
     utils::values::translate_inplace(delta, x1, y1);
+
+    // the two corners rotate independently: restore bottom-left/top-right
+    if(x1 < x0) { std::swap(x0, x1); }
+    if(y1 < y0) { std::swap(y0, y1); }
   }
 
 }

{docling_parse-7.22.1 → docling_parse-7.22.2}/src/parse/pdf_decoders/page.h

@@ -920,6 +920,8 @@ namespace pdflib
       sanitator.sanitize(page_cells, config.page_boundary);
       sanitator.sanitize(page_shapes, config.page_boundary);
       sanitator.sanitize(page_images, config.page_boundary);
+      sanitator.translate(page_widgets, config.page_boundary);
+      sanitator.translate(page_hyperlinks, config.page_boundary);
 
       // the same boundary the sanitator subtracted from the cells, read after
       // rotate_contents() so it is already in the rotated space

{docling_parse-7.22.1 → docling_parse-7.22.2}/src/parse/pdf_decoders/stream.h

@@ -103,7 +103,11 @@ namespace pdflib
     // `scn` naming a tiling pattern: replay the pattern cell across the page
     // box, clipped to the path being filled. `even_odd` is that path's fill
     // rule. Returns false when the pattern cannot be resolved or painted.
-    bool do_pattern_fill(const std::string& pattern_name, bool even_odd);
+    // `pattern_name` is taken by value: callers pass the fill pattern name
+    // held by the current graphics state, and painting the pattern pushes a
+    // new state (`q`), which can reallocate the state stack and leave a
+    // reference dangling.
+    bool do_pattern_fill(std::string pattern_name, bool even_odd);
     bool do_coons_patch_pattern_fill(const std::string& pattern_name,
                                      pdf_resource<PAGE_PATTERN>& pattern,
                                      bool even_odd);
@@ -1256,7 +1260,7 @@ namespace pdflib
   // 8.7.4.5: `sh` paints the named shading over the whole current clip
   // region, taking its colours from the shading's own colour space and
   // function rather than from the current fill colour.
-  bool pdf_decoder<STREAM>::do_pattern_fill(const std::string& pattern_name,
+  bool pdf_decoder<STREAM>::do_pattern_fill(std::string pattern_name,
                                             bool even_odd)
   {
     if(not page_patterns or page_patterns->count(pattern_name) == 0)

{docling_parse-7.22.1 → docling_parse-7.22.2}/src/parse/pdf_resources/page_font/cmap.h

@@ -55,6 +55,14 @@ namespace pdflib
                    const std::string              src_end,
                    const std::vector<std::string> tgt);
 
+    // A bfrange is expanded code by code, so a corrupt bound (srcCode2 below
+    // srcCode1, or a span far wider than any code space) must be rejected
+    // before `end - begin + 1` wraps around and becomes a multi-gigabyte
+    // reservation. Same limit as the cidrange parser in font_cid.h.
+    static constexpr uint32_t max_range_length = 65536;
+
+    static bool is_valid_range(uint32_t begin, uint32_t end);
+
     // Helper to remove trailing null bytes from a string
     static void remove_trailing_nulls(std::string& str);
 
@@ -816,6 +824,19 @@ namespace pdflib
     _map[c] = tgt;
   }
 
+  bool cmap_parser::is_valid_range(uint32_t begin, uint32_t end)
+  {
+    if(begin <= end and (end - begin) < max_range_length)
+      {
+        return true;
+      }
+
+    LOG_S(WARNING) << "ignoring malformed bfrange: begin=" << begin
+                   << ", end=" << end << " (end must be >= begin and the range at most "
+                   << max_range_length << " codes)";
+    return false;
+  }
+
   void cmap_parser::set_range(const std::string src_begin,
                               const std::string src_end,
                               const std::string tgt)
@@ -840,6 +861,11 @@ namespace pdflib
                        << "'" << src_end << "' -> " << end;
       }
 
+    if(not is_valid_range(begin, end))
+      {
+        return;
+      }
+
     //LOG_S(INFO) << __FUNCTION__ << "\t"
     //<< "beg: " << begin << ", "
     //<< "end: " << end << "\t tgt: `" << tgt << "` with size: " << tgt.size();
@@ -896,6 +922,11 @@ namespace pdflib
     auto itr_end = src_end.begin();
     uint32_t end = utf8::next(itr_end, src_end.end());
 
+    if(not is_valid_range(begin, end))
+      {
+        return;
+      }
+
     // Pre-reserve capacity to avoid rehashing during bulk insertions
     _map.reserve(_map.size() + (end - begin + 1));
 

{docling_parse-7.22.1 → docling_parse-7.22.2}/src/render/blend2d_font_resolver.h

@@ -183,7 +183,9 @@ namespace pdflib
     static int stem_weight(const std::string& stem);
     static bool stem_is_italic(const std::string& stem);
 
-    static std::optional<std::string> getenv_string(const char* name);
+    // Read wide on Windows: narrow getenv() yields ANSI-codepage bytes, which
+    // libstdc++ re-decodes as UTF-8 and rejects non-ASCII (docling-parse#354).
+    static std::optional<std::filesystem::path> getenv_path(const char* name);
     static void append_env_path(std::vector<std::filesystem::path>& paths,
                                 const char* env_name,
                                 const std::filesystem::path& suffix = {});
@@ -616,11 +618,19 @@ namespace pdflib
     return static_cast<int>(std::lround(cutoff * 10000.0f));
   }
 
-  inline std::optional<std::string> blend2d_font_resolver::getenv_string(const char* name)
+  inline std::optional<std::filesystem::path> blend2d_font_resolver::getenv_path(const char* name)
   {
+#if defined(_WIN32)
+    // Variable names are ASCII; widen them without a codepage conversion.
+    const std::wstring wide_name(name, name + std::char_traits<char>::length(name));
+    const wchar_t* value = _wgetenv(wide_name.c_str());
+    if (value == nullptr or value[0] == L'\0') { return std::nullopt; }
+    return std::filesystem::path(value);
+#else
     const char* value = std::getenv(name);
     if (value == nullptr or value[0] == '\0') { return std::nullopt; }
-    return std::string(value);
+    return std::filesystem::path(value);
+#endif
   }
 
   inline void blend2d_font_resolver::append_env_path(
@@ -628,11 +638,10 @@ namespace pdflib
                                                      const char* env_name,
                                                      const std::filesystem::path& suffix)
   {
-    auto value = getenv_string(env_name);
-    if (not value.has_value()) { return; }
-    std::filesystem::path path(*value);
-    if (not suffix.empty()) { path /= suffix; }
-    paths.push_back(path);
+    auto path = getenv_path(env_name);
+    if (not path.has_value()) { return; }
+    if (not suffix.empty()) { *path /= suffix; }
+    paths.push_back(*path);
   }
 
   inline std::vector<std::filesystem::path> blend2d_font_resolver::system_font_directories()
@@ -677,9 +686,9 @@ namespace pdflib
     namespace fs = std::filesystem;
     std::vector<fs::path> paths;
 
-    if (auto override_path = getenv_string("DOCLING_PARSE_FALLBACK_FONT"))
+    if (auto override_path = getenv_path("DOCLING_PARSE_FALLBACK_FONT"))
       {
-        paths.emplace_back(*override_path);
+        paths.push_back(*override_path);
       }
 
     // Bundled fonts: sans before serif before mono (not alphabetical), so a
@@ -793,9 +802,9 @@ namespace pdflib
     namespace fs = std::filesystem;
     std::vector<fs::path> paths;
 
-    if (auto override_path = getenv_string("DOCLING_PARSE_ARABIC_FALLBACK_FONT"))
+    if (auto override_path = getenv_path("DOCLING_PARSE_ARABIC_FALLBACK_FONT"))
       {
-        paths.emplace_back(*override_path);
+        paths.push_back(*override_path);
       }
 
     // Filename stems of faces that carry Arabic, best first. The generic
@@ -1156,9 +1165,9 @@ namespace pdflib
     namespace fs = std::filesystem;
     std::vector<fs::path> paths;
 
-    if (auto override_path = getenv_string("DOCLING_PARSE_CJK_FALLBACK_FONT"))
+    if (auto override_path = getenv_path("DOCLING_PARSE_CJK_FALLBACK_FONT"))
       {
-        paths.emplace_back(*override_path);
+        paths.push_back(*override_path);
       }
 
     // Faces with CJK coverage, best first. Each entry is matched against both

{docling_parse-7.22.1 → docling_parse-7.22.2}/tests/README.md

@@ -131,10 +131,10 @@ helpers rather than `open()` when touching groundtruth:
 
 ```python
 from tests.groundtruth_io import (
-    groundtruth_exists,      # true for either encoding
-    load_groundtruth_json,   # read, auto-detecting encoding
-    dump_groundtruth_json,   # write, following DOCLING_PARSE_GT_FORMAT
-    load_segmented_page,     # SegmentedPdfPage from either encoding
+    groundtruth_exists,  # true for either encoding
+    load_groundtruth_json,  # read, auto-detecting encoding
+    dump_groundtruth_json,  # write, following DOCLING_PARSE_GT_FORMAT
+    load_segmented_page,  # SegmentedPdfPage from either encoding
     read_groundtruth_text,
     write_groundtruth_text,
     resolve_groundtruth_path,  # the path actually on disk, for error messages

{docling_parse-7.22.1 → docling_parse-7.22.2}/tests/test_unit_acroform_widgets.py

@@ -3,7 +3,8 @@
 
 from io import BytesIO
 
-from docling_core.types.doc.page import PdfWidget
+import pytest
+from docling_core.types.doc.page import PdfPageBoundaryType, PdfWidget
 
 from docling_parse.pdf_parser import (
     DecodeConfig,
@@ -118,3 +119,50 @@ def test_acroform_widget_contract_matches_threaded_parser():
 
     assert [_widget_data(widget) for widget in sequential] == expected
     assert [_widget_data(widget) for widget in threaded] == expected
+
+
+def _shifted_crop_box_pdf(rotate: int) -> bytes:
+    # Media box at the origin, crop box at (50, 40). The widget and the link
+    # both frame the word ``Hello`` drawn at user-space (100, 120).
+    return build_pdf(
+        [
+            "<< /Type /Catalog /Pages 2 0 R /AcroForm << /Fields [6 0 R] >> >>",
+            "<< /Type /Pages /Kids [3 0 R] /Count 1 >>",
+            "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 400 300] "
+            f"/CropBox [50 40 350 240] /Rotate {rotate} "
+            "/Resources << /Font << /F1 5 0 R >> >> "
+            "/Contents 4 0 R /Annots [6 0 R 7 0 R] >>",
+            content_stream("BT /F1 12 Tf 100 120 Td (Hello) Tj ET\n"),
+            "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>",
+            "<< /Type /Annot /Subtype /Widget /FT /Tx /T (name) "
+            "/Rect [95 110 145 140] >>",
+            "<< /Type /Annot /Subtype /Link /Rect [95 110 145 140] "
+            "/A << /S /URI /URI (https://example.com) >> >>",
+        ]
+    )
+
+
+@pytest.mark.parametrize("rotate", [0, 90, 180, 270])
+@pytest.mark.parametrize(
+    "boundary_type", [PdfPageBoundaryType.CROP_BOX, PdfPageBoundaryType.MEDIA_BOX]
+)
+def test_widgets_and_hyperlinks_share_the_text_cells_boundary_frame(
+    rotate: int, boundary_type: PdfPageBoundaryType
+):
+    document = DoclingPdfParser(loglevel="fatal").load(
+        BytesIO(_shifted_crop_box_pdf(rotate)),
+        boundary_type=boundary_type,
+        decode_config=DecodeConfig(keep_qpdf_warnings=False),
+    )
+    page = document.get_page(1)
+
+    word = next(c for c in page.word_cells if c.text == "Hello").rect.to_bounding_box()
+    (widget,) = page.widgets
+    (hyperlink,) = page.hyperlinks
+
+    for annot in (widget, hyperlink):
+        box = annot.rect.to_bounding_box()
+        assert (annot.rect.r_x0, annot.rect.r_y0) == pytest.approx((box.l, box.b))
+        assert sorted((box.width, box.height)) == pytest.approx([30.0, 50.0])
+        assert box.l <= word.l and word.r <= box.r
+        assert box.b <= min(word.b, word.t) and max(word.b, word.t) <= box.t

{docling_parse-7.22.1 → docling_parse-7.22.2}/tests/test_unit_cmap_encoding.py

@@ -47,6 +47,7 @@ def _identity_h_pdf(
     text_bytes: str,
     to_unicode: bool,
     default_width: str = "",
+    to_unicode_cmap: str = TO_UNICODE_AB,
 ) -> bytes:
     """A page setting two-byte codes in a non-embedded Identity-H font."""
     content = f"BT\n/F1 {FONT_SIZE} Tf\n20 100 Td\n<{text_bytes}> Tj\nET\n"
@@ -63,7 +64,7 @@ def _identity_h_pdf(
         "<< /Type /Font /Subtype /CIDFontType2 /BaseFont /Test-Identity "
         "/CIDSystemInfo << /Registry (Adobe) /Ordering (Identity) /Supplement 0 >> "
         f"/FontDescriptor 8 0 R{default_width} >>",
-        stream_object("", TO_UNICODE_AB.encode("latin-1")),
+        stream_object("", to_unicode_cmap.encode("latin-1")),
         "<< /Type /FontDescriptor /FontName /Test-Identity /Flags 4 "
         "/FontBBox [0 -200 1000 800] /ItalicAngle 0 /Ascent 800 /Descent -200 "
         "/CapHeight 700 /StemV 80 >>",
@@ -146,3 +147,42 @@ def test_explicit_dw_is_honoured():
     assert width == pytest.approx(FONT_SIZE, rel=0.2), (
         f"two glyphs at /DW 500 measured {width:.1f}pt, expected about {FONT_SIZE}pt"
     )
+
+
+TO_UNICODE_REVERSED_RANGE = """/CIDInit /ProcSet findresource begin
+12 dict begin
+begincmap
+/CMapName /Test-UCS2 def
+/CMapType 2 def
+1 begincodespacerange
+<0000> <FFFF>
+endcodespacerange
+2 beginbfrange
+<FFFF> <00FF> <0058>
+<0001> <0002> <0041>
+endbfrange
+endcmap
+CMapName currentdict /CMap defineresource pop
+end
+end"""
+
+
+def test_reversed_bfrange_is_ignored():
+    """A bfrange whose end lies below its start is skipped, not expanded.
+
+    Its size, `end - begin + 1`, wrapped around in unsigned arithmetic to about
+    four billion codes; reserving a map that large threw std::bad_alloc, or,
+    with no memory limit, used all the memory the machine had. Such ranges
+    occur in real subset fonts (seen: `<ffff> <00ff>` in a ToUnicode CMap
+    written by an optimiser). The well-formed range next to it must still map.
+    """
+    text = _text(
+        _identity_h_pdf(
+            text_bytes="00010002",
+            to_unicode=True,
+            to_unicode_cmap=TO_UNICODE_REVERSED_RANGE,
+        )
+    )
+    assert text == "AB", (
+        f"expected the valid bfrange to map the codes to 'AB', got {text!r}"
+    )

{docling_parse-7.22.1 → docling_parse-7.22.2}/tests/test_unit_patterns.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 
 import pytest
 
-from tests.pdf_builder import render_page, simple_page_pdf, stream_object
+from tests.pdf_builder import parse_page, render_page, simple_page_pdf, stream_object
 from tests.rendering_regression import (
     assert_color_near,
     center_color,
@@ -393,3 +393,44 @@ def test_unresolved_pattern_keeps_the_stroke():
     assert 0.0 < coverage < 0.3, (
         f"expected only the outline to paint, got {coverage:.3f} coverage"
     )
+
+
+# longer than the small-string buffer, so the name lives on the heap
+SHADING_PATTERN_NAME = "AxialShadingPatternWithALongName"
+
+
+def _shading_pattern_page(depth: int) -> bytes:
+    """An axial shading-pattern fill inside `depth` nested `q` ... `Q`."""
+    content = (
+        "q\n" * depth
+        + f"/Pattern cs /{SHADING_PATTERN_NAME} scn\n"
+        + f"{FILL_BOX[0]} {FILL_BOX[0]} "
+        + f"{FILL_BOX[2] - FILL_BOX[0]} {FILL_BOX[3] - FILL_BOX[1]} re f\n"
+        + "Q\n" * depth
+    )
+    pattern = (
+        "<< /Type /Pattern /PatternType 2 /Shading << /ShadingType 2 "
+        "/ColorSpace /DeviceRGB /Coords [20 0 180 0] "
+        "/Function << /FunctionType 2 /Domain [0 1] /C0 [1 0 0] /C1 [0 0 1] /N 1 >> "
+        ">> >>"
+    )
+    return simple_page_pdf(
+        content,
+        resources=f"/Pattern << /{SHADING_PATTERN_NAME} 5 0 R >>",
+        extra_objects=[pattern],
+    )
+
+
+@pytest.mark.parametrize("depth", range(18))
+def test_shading_pattern_fill_survives_graphics_state_growth(depth):
+    """A shading-pattern fill parses at any `q` nesting depth.
+
+    The pattern name was passed by reference into the current graphics state,
+    and painting the pattern pushes a new state. When that push reallocated the
+    state stack, the name dangled, and copying it read freed memory: a garbage
+    length that threw std::bad_alloc ("Page N failed to parse"), or corrupted
+    the heap. Which depths reallocate depends on the stack's growth, so every
+    depth up to a few doublings is tried.
+    """
+    page = parse_page(_shading_pattern_page(depth))
+    assert page is not None

docling_parse-7.22.2/tests/test_unit_unicode_paths.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python
+"""Paths that contain non-ASCII characters.
+
+Two routes carry such paths into the native code, and on Windows both go wrong
+in the ANSI codepage while POSIX passes the bytes through unchanged -- so these
+tests guard intent everywhere but only bite on Windows runners.
+
+The filename travels UTF-8 encoded from Python into the native parser, which
+must open it with UTF-8 semantics on every platform. A narrow byte-path open
+goes through the ANSI codepage instead, so any path with characters outside it
+fails to load (docling-parse#324).
+
+The renderer's font resolver takes its scan directories from the environment
+(LOCALAPPDATA, DOCLING_PARSE_*_FALLBACK_FONT); a narrow getenv() there broke
+every threaded render under a non-ASCII user profile (docling-parse#354).
+"""
+
+import os
+import subprocess
+import sys
+import textwrap
+from io import BytesIO
+from pathlib import Path
+
+import pytest
+
+import docling_parse
+from docling_parse.pdf_parser import DoclingPdfParser
+from tests.pdf_builder import build_pdf
+
+CONTENT = "BT /F1 12 Tf 72 720 Td (Title Case Workers) Tj ET"
+
+# Latin-1, Hangul and Cyrillic together: every common ANSI codepage turns at
+# least one of them into bytes that are not valid UTF-8. Hangul alone becomes
+# '?' under cp1252, the codepage of GitHub's Windows runners, and would pass.
+NON_ASCII_DIR_NAME = "docling_é_한글_Привет"
+
+_RENDER_ONE_PAGE = textwrap.dedent(
+    """
+    import sys
+    from io import BytesIO
+
+    from docling_parse.pdf_parser import (
+        DoclingThreadedPdfParser,
+        RenderConfig,
+        ThreadedPdfParserConfig,
+    )
+
+    parser = DoclingThreadedPdfParser(
+        parser_config=ThreadedPdfParserConfig(
+            loglevel="fatal", threads=1, render_config=RenderConfig()
+        )
+    )
+    parser.load(BytesIO(sys.stdin.buffer.read()))
+    for result in parser.iterate_results():
+        assert result.success, result.error_message
+        assert result.get_image().width > 0
+    parser.unload_all()
+    """
+)
+
+
+def _tiny_pdf() -> bytes:
+    return build_pdf(
+        [
+            "<< /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",
+        ]
+    )
+
+
+def test_load_from_non_ascii_path(tmp_path):
+    """A path with CJK directory and filename components loads like any other."""
+    cjk_dir = tmp_path / "导出的条目"
+    cjk_dir.mkdir()
+    pdf_path = cjk_dir / "2005 - Chiou 等 - test.pdf"
+    pdf_path.write_bytes(_tiny_pdf())
+
+    parser = DoclingPdfParser(loglevel="fatal")
+    doc = parser.load(path_or_stream=str(pdf_path))
+
+    assert doc.number_of_pages() == 1
+
+
+def test_load_from_bytesio_is_path_independent():
+    """The BytesIO route never touches the filesystem and must always work."""
+    parser = DoclingPdfParser(loglevel="fatal")
+    doc = parser.load(path_or_stream=BytesIO(_tiny_pdf()))
+
+    assert doc.number_of_pages() == 1
+
+
+def _render_in_fresh_process(
+    cwd: Path, **env_overrides: str
+) -> subprocess.CompletedProcess:
+    package_root = Path(docling_parse.__file__).resolve().parent.parent
+    env = {**os.environ, **env_overrides}
+    env["PYTHONPATH"] = os.pathsep.join(
+        filter(None, [str(package_root), env.get("PYTHONPATH")])
+    )
+    return subprocess.run(
+        [sys.executable, "-c", _RENDER_ONE_PAGE],
+        input=_tiny_pdf(),
+        env=env,
+        cwd=cwd,
+        capture_output=True,
+        timeout=300,
+    )
+
+
+@pytest.mark.parametrize("dir_name", ["ascii_profile", NON_ASCII_DIR_NAME])
+def test_renderer_starts_under_non_ascii_font_directory_env(tmp_path, dir_name):
+    """The user font directory may sit under a non-ASCII profile path."""
+    profile_dir = tmp_path / dir_name
+    (profile_dir / "Microsoft" / "Windows" / "Fonts").mkdir(parents=True)
+
+    proc = _render_in_fresh_process(
+        tmp_path,
+        LOCALAPPDATA=str(profile_dir),
+        XDG_DATA_HOME=str(profile_dir),
+    )
+
+    assert proc.returncode == 0, proc.stderr.decode("utf-8", "replace")
+
+
+def test_renderer_starts_with_non_ascii_fallback_font_override(tmp_path):
+    """An override that names a non-ASCII path is skipped, not fatal."""
+    font_dir = tmp_path / NON_ASCII_DIR_NAME
+    font_dir.mkdir()
+
+    proc = _render_in_fresh_process(
+        tmp_path, DOCLING_PARSE_FALLBACK_FONT=str(font_dir / "missing.ttf")
+    )
+
+    assert proc.returncode == 0, proc.stderr.decode("utf-8", "replace")

{docling_parse-7.22.1 → docling_parse-7.22.2}/uv.lock

@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 resolution-markers = [
     "python_full_version >= '3.12' and sys_platform != 'win32'",
@@ -730,8 +730,9 @@ wheels = [
 
 [[package]]
 name = "docling-parse"
-version = "7.22.1"
+version = "7.22.2"
 source = { editable = "." }
+default-groups = "all"
 dependencies = [
     { name = "docling-core" },
     { name = "pillow" },