docling-parse 5.10.1__tar.gz → 6.0.0__tar.gz

{docling_parse-5.10.1 → docling_parse-6.0.0}/CHANGELOG.md

@@ -1,3 +1,32 @@
+## [v6.0.0](https://github.com/docling-project/docling-parse/releases/tag/v6.0.0) - 2026-05-11
+
+### Feature
+
+* Public threaded PDF parser and rendering API ([#265](https://github.com/docling-project/docling-parse/issues/265)) ([`b066b26`](https://github.com/docling-project/docling-parse/commit/b066b2621511520087fe8ffc202cb5e015ec7508))
+
+### Fix
+
+* Upgrade packages for vulnerabilities ([#270](https://github.com/docling-project/docling-parse/issues/270)) ([`1515795`](https://github.com/docling-project/docling-parse/commit/15157952d3d033e4802f250cbca74615dcf767d8))
+* Upgraded pillow, requests, pygments, cryptography ([#269](https://github.com/docling-project/docling-parse/issues/269)) ([`a41ef14`](https://github.com/docling-project/docling-parse/commit/a41ef14bb2cfc998301d62e9b388403178fe53fb))
+
+### Breaking
+
+* Public threaded PDF parser and rendering API ([#265](https://github.com/docling-project/docling-parse/issues/265)) ([`b066b26`](https://github.com/docling-project/docling-parse/commit/b066b2621511520087fe8ffc202cb5e015ec7508))
+
+## [v5.11.0](https://github.com/docling-project/docling-parse/releases/tag/v5.11.0) - 2026-05-08
+
+### Feature
+
+* Rendering of math and latex symbols ([#264](https://github.com/docling-project/docling-parse/issues/264)) ([`ac0a361`](https://github.com/docling-project/docling-parse/commit/ac0a361a4ffcb45cb04fc26fb77726f02a7eea5a))
+
+### Fix
+
+* Locale-independent float parsing (fixes docling#1455) ([#243](https://github.com/docling-project/docling-parse/issues/243)) ([`e56632d`](https://github.com/docling-project/docling-parse/commit/e56632d962d456cc7968cc9848b8528b32727e02))
+
+### Documentation
+
+* **security:** Document security processes ([#268](https://github.com/docling-project/docling-parse/issues/268)) ([`f1316fa`](https://github.com/docling-project/docling-parse/commit/f1316fa14bbfe27070f870f64585169df7b6fd6f))
+
 ## [v5.10.1](https://github.com/docling-project/docling-parse/releases/tag/v5.10.1) - 2026-04-24
 
 ### Fix

{docling_parse-5.10.1 → docling_parse-6.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 5.10.1
+Version: 6.0.0
 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
@@ -143,18 +143,18 @@ parser = DoclingThreadedPdfParser(
 
 # load one or more documents
 for source in ["doc_a.pdf", "doc_b.pdf"]:
-    parser.load(source)
+    doc_key = parser.load(source)
+    print(doc_key, parser.page_count(doc_key))
 
 # consume decoded pages as they become available
-while parser.has_tasks():
-    task = parser.get_task()
-
-    if task.success:
-        page_decoder, timings = task.get()
-        print(f"{task.doc_key} p{task.page_number}: "
-              f"{len(list(page_decoder.get_word_cells()))} words")
+for result in parser.iterate_results():
+    if result.success:
+        seg_page = result.get_page()
+        timings = result.get_timings()
+        print(f"{result.doc_key} p{result.page_number}: "
+              f"{len(seg_page.word_cells)} words in {timings.total():.3f}s")
     else:
-        print(f"error on {task.doc_key} p{task.page_number}: {task.error()}")
+        print(f"error on {result.doc_key} p{result.page_number}: {result.error_message}")
 ```
 
 Use the CLI

{docling_parse-5.10.1 → docling_parse-6.0.0}/README.md

@@ -111,18 +111,18 @@ parser = DoclingThreadedPdfParser(
 
 # load one or more documents
 for source in ["doc_a.pdf", "doc_b.pdf"]:
-    parser.load(source)
+    doc_key = parser.load(source)
+    print(doc_key, parser.page_count(doc_key))
 
 # consume decoded pages as they become available
-while parser.has_tasks():
-    task = parser.get_task()
-
-    if task.success:
-        page_decoder, timings = task.get()
-        print(f"{task.doc_key} p{task.page_number}: "
-              f"{len(list(page_decoder.get_word_cells()))} words")
+for result in parser.iterate_results():
+    if result.success:
+        seg_page = result.get_page()
+        timings = result.get_timings()
+        print(f"{result.doc_key} p{result.page_number}: "
+              f"{len(seg_page.word_cells)} words in {timings.total():.3f}s")
     else:
-        print(f"error on {task.doc_key} p{task.page_number}: {task.error()}")
+        print(f"error on {result.doc_key} p{result.page_number}: {result.error_message}")
 ```
 
 Use the CLI

docling_parse-6.0.0/app/parse_fonts.cpp

@@ -0,0 +1,63 @@
+//-*-C++-*-
+
+/*
+example input:
+
+{
+    "data":
+    {
+
+    }
+}
+*/
+
+#include <parse.h>
+
+nlohmann::json read_input(std::string filename)
+{
+  nlohmann::json input;
+
+  std::ifstream ifs(filename);
+  
+  if(ifs)
+    {
+      ifs >> input;
+      
+      LOG_S(INFO) << "input-filename: " << filename;    
+      LOG_S(INFO) << "input: " << input.dump(2);    
+    }
+  else
+    {
+      LOG_S(FATAL) << "input-filename: " << filename << " does not exists";
+    }
+
+  return input;
+}
+
+int main(int argc, char *argv[])
+{
+  std::string glyphs_dir =  "../docling_parse/pdf_resources/glyphs";
+  std::string cids_dir = "../docling_parse/pdf_resources/cmap-resources";
+  std::string encodings_dir = "../docling_parse/pdf_resources/encodings";
+  std::string fonts_dir = "../docling_parse/pdf_resources/fonts";
+  
+  loguru::init(argc, argv);
+
+  pdflib::font_cids cids;
+  cids.initialise(cids_dir);
+  cids.decode_all();
+  
+  pdflib::font_glyphs glyphs;
+  glyphs.initialise(glyphs_dir);
+
+  pdflib::font_encodings encodings;
+  encodings.initialise(encodings_dir, glyphs);
+  
+  pdflib::base_fonts fonts;
+  fonts.initialise(fonts_dir, glyphs);
+
+  fonts.verify_all();
+  glyphs.print_unknown_glyphs();
+
+  return 0;
+}

{docling_parse-5.10.1 → docling_parse-6.0.0}/app/pybind_parse.cpp

@@ -10,6 +10,7 @@
 #include <pybind/docling_parser.h>
 #include <pybind/docling_threaded_parser.h>
 #include <pybind/docling_threaded_renderer.h>
+#include <render/blend2d_renderer.h>
 
 // Include parse headers for typed bindings
 #include <parse.h>
@@ -549,7 +550,29 @@ PYBIND11_MODULE(pdf_parsers, m) {
            self.get_instructions().iterate_over_instructions(visitor);
            return visitor.artifacts;
          },
-         "Export bitmap artifacts as inspectable image bytes plus raw payload bytes");
+         "Export bitmap artifacts as inspectable image bytes plus raw payload bytes")
+    .def("render_image",
+         [](pdflib::pdf_decoder<pdflib::PAGE>& self,
+            const pdflib::render_config& config) -> pybind11::tuple {
+           pdflib::renderer<pdflib::BLEND2D> rnd(config);
+           {
+             pybind11::gil_scoped_release release;
+             self.get_instructions().iterate_over_instructions(rnd);
+           }
+
+           auto canvas = rnd.get_canvas();
+           const auto& shape = rnd.get_shape();
+           pybind11::bytes image_bytes("");
+           if(canvas and not canvas->empty())
+             {
+               image_bytes = pybind11::bytes(
+                   reinterpret_cast<const char*>(canvas->data()),
+                   canvas->size());
+             }
+           return pybind11::make_tuple(image_bytes, shape);
+         },
+         pybind11::arg("config"),
+         "Render the decoded page to RGBA bytes using the provided RenderConfig");
 
   // ============= Timing Keys Constants =============
 
@@ -799,10 +822,10 @@ PYBIND11_MODULE(pdf_parsers, m) {
 
   // ============= Threaded PDF Parser =============
 
-  // PageDecodeResult - result of a threaded page decode task
-  pybind11::class_<docling::page_decode_result>(m, "PageDecodeResult",
+  // _PageDecodeResult - internal result of a threaded page decode task
+  pybind11::class_<docling::page_decode_result>(m, "_PageDecodeResult",
     R"(
-    Result of a threaded page decoding task.
+    Internal result of a threaded page decoding task.
 
     Attributes:
         doc_key (str): The document key this page belongs to.
@@ -839,10 +862,10 @@ PYBIND11_MODULE(pdf_parsers, m) {
     Returns:
         str: The error message.)");
 
-  // threaded_pdf_parser - parallel PDF parser with bounded result queue
-  pybind11::class_<docling::docling_threaded_parser>(m, "threaded_pdf_parser",
+  // _threaded_pdf_parser - internal parallel PDF parser with bounded result queue
+  pybind11::class_<docling::docling_threaded_parser>(m, "_threaded_pdf_parser",
     R"(
-    Threaded PDF parser that processes pages in parallel.
+    Internal threaded PDF parser that processes pages in parallel.
 
     Loads multiple documents and decodes their pages using a thread pool.
     Results are available via a bounded queue to control memory usage.
@@ -865,12 +888,14 @@ PYBIND11_MODULE(pdf_parsers, m) {
          [](docling::docling_threaded_parser& self,
             const std::string& key,
             const std::string& filename,
-            std::optional<std::string>& password) -> bool {
-           return self.load_document(key, filename, password);
+            std::optional<std::string>& password,
+            std::optional<std::vector<int>>& page_numbers) -> bool {
+           return self.load_document(key, filename, password, page_numbers);
          },
          pybind11::arg("key"),
          pybind11::arg("filename"),
          pybind11::arg("password") = pybind11::none(),
+         pybind11::arg("page_numbers") = pybind11::none(),
          R"(
     Load a document by key and filename.
 
@@ -878,6 +903,7 @@ PYBIND11_MODULE(pdf_parsers, m) {
         key (str): The unique key to identify the document.
         filename (str): The path to the document file to load.
         password (str, optional): Optional password for password-protected files.
+        page_numbers (Sequence[int], optional): Selected 1-indexed physical pages to schedule.
 
     Returns:
         bool: True if the document was successfully loaded.)")
@@ -886,12 +912,14 @@ PYBIND11_MODULE(pdf_parsers, m) {
          [](docling::docling_threaded_parser& self,
             const std::string& key,
             pybind11::object bytes_io,
-            std::optional<std::string>& password) -> bool {
-           return self.load_document_from_bytesio(key, bytes_io, password);
+            std::optional<std::string>& password,
+            std::optional<std::vector<int>>& page_numbers) -> bool {
+           return self.load_document_from_bytesio(key, bytes_io, password, page_numbers);
          },
          pybind11::arg("key"),
          pybind11::arg("bytes_io"),
          pybind11::arg("password") = pybind11::none(),
+         pybind11::arg("page_numbers") = pybind11::none(),
          R"(
     Load a document from a BytesIO-like object.
 
@@ -899,10 +927,54 @@ PYBIND11_MODULE(pdf_parsers, m) {
         key (str): The unique key to identify the document.
         bytes_io (Any): A BytesIO-like object containing the document data.
         password (str, optional): Optional password for password-protected files.
+        page_numbers (Sequence[int], optional): Selected 1-indexed physical pages to schedule.
 
     Returns:
         bool: True if the document was successfully loaded.)")
 
+    .def("number_of_pages",
+         [](docling::docling_threaded_parser& self, const std::string& key) -> int {
+           return self.number_of_pages(key);
+         },
+         pybind11::arg("key"),
+         R"(
+    Return the number of pages in a loaded document.
+
+    Parameters:
+        key (str): The unique key identifying the document.
+
+    Returns:
+        int: Number of pages in the loaded document.)")
+    .def("scheduled_number_of_pages",
+         [](docling::docling_threaded_parser& self, const std::string& key) -> int {
+           return self.scheduled_number_of_pages(key);
+         },
+         pybind11::arg("key"),
+         R"(
+    Return the number of scheduled pages in a loaded document.
+
+    Parameters:
+        key (str): The unique key identifying the document.
+
+    Returns:
+        int: Number of pages that will be emitted by the threaded parser.)")
+    .def("unload_document",
+         [](docling::docling_threaded_parser& self, const std::string& key) -> bool {
+           return self.unload_document(key);
+         },
+         pybind11::arg("key"),
+         R"(
+    Unload one document after threaded processing is complete.
+
+    Returns:
+        bool: True when document state existed and was removed.)")
+    .def("unload_all_documents",
+         [](docling::docling_threaded_parser& self) {
+           self.unload_all_documents();
+         },
+         R"(
+    Unload all documents after threaded processing is complete.)")
+
     .def("has_tasks",
          [](docling::docling_threaded_parser& self) -> bool {
            return self.has_tasks();
@@ -926,7 +998,7 @@ PYBIND11_MODULE(pdf_parsers, m) {
     Blocks until a result is available. Releases the GIL while waiting.
 
     Returns:
-        PageDecodeResult: The result of a page decoding task.)");
+        _PageDecodeResult: The result of a page decoding task.)");
 
   // ============= Threaded PDF Renderer =============
 
@@ -938,25 +1010,31 @@ PYBIND11_MODULE(pdf_parsers, m) {
     Attributes:
         render_text (bool): Render glyph outlines for text cells [default=true].
         draw_text_bbox (bool): Draw bounding quad for each text cell [default=false].
+        draw_text_basepoint (bool): Draw the text baseline origin as a small red dot [default=false].
+        fit_glyph_bbox_to_target (bool): Uniformly rescale measured glyph outlines so the rendered bbox fits inside the target glyph bbox, with either width or height matching exactly [default=false].
         resolve_fonts (bool): Resolve PDF font names to system fonts [default=true].
         font_similarity_cutoff (float): Minimum Jaccard similarity for fuzzy font matching; candidates below this threshold fall back to the default font [default=0.25].
+        scale (float): Target render scale in multiples of the PDF page size; -1 disables scale-based sizing [default=-1].
         canvas_width (int): Target canvas width in pixels; -1 means use PDF page size [default=-1].
         canvas_height (int): Target canvas height in pixels; -1 means use PDF page size [default=-1].
     )")
     .def(pybind11::init<>())
     .def_readwrite("render_text",             &pdflib::render_config::render_text)
     .def_readwrite("draw_text_bbox",          &pdflib::render_config::draw_text_bbox)
+    .def_readwrite("draw_text_basepoint",     &pdflib::render_config::draw_text_basepoint)
+    .def_readwrite("fit_glyph_bbox_to_target",&pdflib::render_config::fit_glyph_bbox_to_target)
     .def_readwrite("resolve_fonts",           &pdflib::render_config::resolve_fonts)
     .def_readwrite("font_similarity_cutoff",  &pdflib::render_config::font_similarity_cutoff)
+    .def_readwrite("scale",                   &pdflib::render_config::scale)
     .def_readwrite("canvas_width",            &pdflib::render_config::canvas_width)
     .def_readwrite("canvas_height",           &pdflib::render_config::canvas_height);
 
-  // PageRenderResult - result of a threaded page render task
-  pybind11::class_<docling::page_render_result, docling::page_decode_result>(m, "PageRenderResult",
+  // _PageRenderResult - internal result of a threaded page render task
+  pybind11::class_<docling::page_render_result, docling::page_decode_result>(m, "_PageRenderResult",
     R"(
-    Result of a threaded page rendering task.
+    Internal result of a threaded page rendering task.
 
-    Inherits all attributes of PageDecodeResult and adds rendered image data.
+    Inherits all attributes of _PageDecodeResult and adds rendered image data.
 
     Attributes:
         image_data: Raw RGBA bytes of the rendered page (height x width x 4, row-major).
@@ -984,10 +1062,10 @@ PYBIND11_MODULE(pdf_parsers, m) {
     Returns:
         bytes: Raw RGBA pixel data, or empty bytes on failure.)");
 
-  // threaded_pdf_renderer - parallel PDF renderer with bounded result queue
-  pybind11::class_<docling::docling_threaded_renderer>(m, "threaded_pdf_renderer",
+  // _threaded_pdf_renderer - internal parallel PDF renderer with bounded result queue
+  pybind11::class_<docling::docling_threaded_renderer>(m, "_threaded_pdf_renderer",
     R"(
-    Threaded PDF renderer that decodes and renders pages in parallel.
+    Internal threaded PDF renderer that decodes and renders pages in parallel.
 
     Loads multiple documents and renders their pages using a thread pool.
     Each result contains both the decoded page data and the rendered RGBA image.
@@ -1014,23 +1092,47 @@ PYBIND11_MODULE(pdf_parsers, m) {
          [](docling::docling_threaded_renderer& self,
             const std::string& key,
             const std::string& filename,
-            std::optional<std::string>& password) -> bool {
-           return self.load_document(key, filename, password);
+            std::optional<std::string>& password,
+            std::optional<std::vector<int>>& page_numbers) -> bool {
+           return self.load_document(key, filename, password, page_numbers);
          },
          pybind11::arg("key"),
          pybind11::arg("filename"),
-         pybind11::arg("password") = pybind11::none())
+         pybind11::arg("password") = pybind11::none(),
+         pybind11::arg("page_numbers") = pybind11::none())
 
     .def("load_document_from_bytesio",
          [](docling::docling_threaded_renderer& self,
             const std::string& key,
             pybind11::object bytes_io,
-            std::optional<std::string>& password) -> bool {
-           return self.load_document_from_bytesio(key, bytes_io, password);
+            std::optional<std::string>& password,
+            std::optional<std::vector<int>>& page_numbers) -> bool {
+           return self.load_document_from_bytesio(key, bytes_io, password, page_numbers);
          },
          pybind11::arg("key"),
          pybind11::arg("bytes_io"),
-         pybind11::arg("password") = pybind11::none())
+         pybind11::arg("password") = pybind11::none(),
+         pybind11::arg("page_numbers") = pybind11::none())
+
+    .def("number_of_pages",
+         [](docling::docling_threaded_renderer& self, const std::string& key) -> int {
+           return self.number_of_pages(key);
+         },
+         pybind11::arg("key"))
+    .def("scheduled_number_of_pages",
+         [](docling::docling_threaded_renderer& self, const std::string& key) -> int {
+           return self.scheduled_number_of_pages(key);
+         },
+         pybind11::arg("key"))
+    .def("unload_document",
+         [](docling::docling_threaded_renderer& self, const std::string& key) -> bool {
+           return self.unload_document(key);
+         },
+         pybind11::arg("key"))
+    .def("unload_all_documents",
+         [](docling::docling_threaded_renderer& self) {
+           self.unload_all_documents();
+         })
 
     .def("has_tasks",
          [](docling::docling_threaded_renderer& self) -> bool {
@@ -1048,5 +1150,5 @@ PYBIND11_MODULE(pdf_parsers, m) {
     Blocks until a result is available. Releases the GIL while waiting.
 
     Returns:
-        PageRenderResult: The result of a page rendering task.)");
+        _PageRenderResult: The result of a page rendering task.)");
 }

{docling_parse-5.10.1 → docling_parse-6.0.0}/app/render.cpp

@@ -212,8 +212,13 @@ int main(int argc, char* argv[])
         // ---- render_config ----
         ("render-text",    "Render glyph outlines for text cells (default: true)",          cxxopts::value<bool>()->implicit_value("true"))
         ("draw-text-bbox", "Draw bounding quad around each text cell",                      cxxopts::value<bool>()->implicit_value("true"))
+        ("draw-text-basepoint", "Draw the text base point as a small red dot",              cxxopts::value<bool>()->implicit_value("true"))
+        ("fit-glyph-bbox-to-target",
+         "Uniformly rescale measured glyph outlines so the rendered bbox fits inside the target glyph bbox and matches either its width or height",
+         cxxopts::value<bool>()->implicit_value("true"))
         ("resolve-fonts",           "Resolve PDF font names to system fonts (default: true)",                cxxopts::value<bool>()->implicit_value("true"))
         ("font-similarity-cutoff",  "Minimum Jaccard similarity for fuzzy font matching (default: 0.25)",    cxxopts::value<float>())
+        ("scale",                   "Canvas scale in multiples of the PDF page size (-1 = disabled)",        cxxopts::value<float>())
         ("canvas-width",            "Canvas width in pixels (-1 = use page size)",                           cxxopts::value<int>())
         ("canvas-height",           "Canvas height in pixels (-1 = use page size)",                          cxxopts::value<int>())
 
@@ -309,8 +314,11 @@ int main(int argc, char* argv[])
       pdflib::render_config cfg;
       if (result.count("render-text"))    { cfg.render_text    = result["render-text"].as<bool>(); }
       if (result.count("draw-text-bbox")) { cfg.draw_text_bbox = result["draw-text-bbox"].as<bool>(); }
+      if (result.count("draw-text-basepoint")) { cfg.draw_text_basepoint = result["draw-text-basepoint"].as<bool>(); }
+      if (result.count("fit-glyph-bbox-to-target")) { cfg.fit_glyph_bbox_to_target = result["fit-glyph-bbox-to-target"].as<bool>(); }
       if (result.count("resolve-fonts"))          { cfg.resolve_fonts          = result["resolve-fonts"].as<bool>(); }
       if (result.count("font-similarity-cutoff")) { cfg.font_similarity_cutoff = result["font-similarity-cutoff"].as<float>(); }
+      if (result.count("scale"))                  { cfg.scale                  = result["scale"].as<float>(); }
       if (result.count("canvas-width"))           { cfg.canvas_width           = result["canvas-width"].as<int>(); }
       if (result.count("canvas-height"))          { cfg.canvas_height          = result["canvas-height"].as<int>(); }
 

docling_parse-6.0.0/docling_parse/__init__.py

@@ -0,0 +1,42 @@
+"""docling-parse: Extract text with coordinates from programmatic PDFs."""
+
+import locale as _locale
+import logging as _logging
+
+_log = _logging.getLogger(__name__)
+
+
+def _ensure_safe_numeric_locale() -> None:
+    """Ensure LC_NUMERIC uses a period as decimal separator.
+
+    PDF coordinate parsing (both in QPDF's C library and in this
+    package's C++ layer) relies on '.' as the decimal separator.
+    Locales that use ',' (French, German, Portuguese, etc.) silently
+    corrupt every floating-point value extracted from a PDF.
+
+    This function is called at import time as a defence-in-depth
+    measure.  The primary fix is in the C++ layer (from_chars), but
+    this protects against any locale-sensitive path we may have missed
+    — including QPDF's own atof() calls that we cannot patch.
+
+    See: https://github.com/docling-project/docling/issues/1455
+    """
+    try:
+        current = _locale.getlocale(_locale.LC_NUMERIC)
+        # setlocale returns the *actual* locale string; checking the
+        # decimal point via localeconv is the most reliable test.
+        conv = _locale.localeconv()
+        if conv.get("decimal_point", ".") != ".":
+            _locale.setlocale(_locale.LC_NUMERIC, "C")
+            _log.info(
+                "docling-parse: overrode LC_NUMERIC from %s to 'C' "
+                "to prevent PDF coordinate corruption",
+                current,
+            )
+    except (_locale.Error, ValueError):
+        # If we can't query or set the locale, the C++ from_chars
+        # layer will still protect us.
+        pass
+
+
+_ensure_safe_numeric_locale()