docling-parse 7.0.0__tar.gz → 7.3.0__tar.gz

{docling_parse-7.0.0 → docling_parse-7.3.0}/CHANGELOG.md

@@ -1,3 +1,25 @@
+## [v7.3.0](https://github.com/docling-project/docling-parse/releases/tag/v7.3.0) - 2026-07-01
+
+### Feature
+
+* Caching objects ([#285](https://github.com/docling-project/docling-parse/issues/285)) ([`2bc547e`](https://github.com/docling-project/docling-parse/commit/2bc547ecdecb1e24ebd9c10b22c2c8aca9e0d8a5))
+
+## [v7.2.0](https://github.com/docling-project/docling-parse/releases/tag/v7.2.0) - 2026-06-29
+
+### Feature
+
+* Upgrade bitmap rendering with clipping ([#284](https://github.com/docling-project/docling-parse/issues/284)) ([`b55da56`](https://github.com/docling-project/docling-parse/commit/b55da563b9eda2da30c9dead373d54656fb5f01f))
+
+## [v7.1.0](https://github.com/docling-project/docling-parse/releases/tag/v7.1.0) - 2026-06-26
+
+### Feature
+
+* Refactoring the parsing of XObjects ([#281](https://github.com/docling-project/docling-parse/issues/281)) ([`163f741`](https://github.com/docling-project/docling-parse/commit/163f7419bd6a98d7667cefe7e9c356b38135f9e8))
+
+### Documentation
+
+* Updates for docling-parse v7 usage ([#280](https://github.com/docling-project/docling-parse/issues/280)) ([`a81339e`](https://github.com/docling-project/docling-parse/commit/a81339efade7a904aac0bb64c0f871d9fbf03e1e))
+
 ## [v7.0.0](https://github.com/docling-project/docling-parse/releases/tag/v7.0.0) - 2026-06-22
 
 ### Feature

{docling_parse-7.0.0 → docling_parse-7.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.0.0
+Version: 7.3.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
@@ -25,7 +25,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pillow<13.0.0,>=10.0.0
 Requires-Dist: pydantic>=2.0.0
-Requires-Dist: docling-core>=2.65.2
+Requires-Dist: docling-core<3.0.0,>=2.85.0
 Requires-Dist: pywin32>=305; sys_platform == "win32"
 Dynamic: license-file
 
@@ -87,75 +87,151 @@ uv run python ./docling_parse/visualize.py -i <path-to-pdf-file> -c word --inter
 
 ## Quick start
 
-Install the package from Pypi
+Install the package from PyPI:
 
 ```sh
 pip install docling-parse
 ```
 
-Convert a PDF (look in the [visualize.py](docling_parse/visualize.py) for a more detailed information)
+### Sequential parsing
+
+`docling-parse` v7 split page parsing into two public configs:
+
+- `DecodeConfig`: how to compute pages. This is fixed when a document is opened.
+- `ContentConfig`: what to keep or materialize per page. This can be overridden per page.
 
 ```python
 from docling_core.types.doc.page import TextCellUnit
-from docling_parse.pdf_parser import DoclingPdfParser, PdfDocument
-
-parser = DoclingPdfParser()
+from docling_parse.pdf_parser import (
+    ContentConfig,
+    ContentLevel,
+    DecodeConfig,
+    DoclingPdfParser,
+)
 
-pdf_doc: PdfDocument = parser.load(
-    path_or_stream="<path-to-pdf>"
+parser = DoclingPdfParser(loglevel="fatal")
+
+pdf_doc = parser.load(
+    path_or_stream="<path-to-pdf>",
+    decode_config=DecodeConfig(
+        do_sanitization=True,
+        keep_glyphs=False,
+    ),
+    content_config=ContentConfig(
+        char_cells_content_level=ContentLevel.SKIP,
+        word_cells_content_level=ContentLevel.COMPUTE_AND_MATERIALIZE,
+        line_cells_content_level=ContentLevel.COMPUTE_AND_MATERIALIZE,
+        shapes_content_level=ContentLevel.SKIP,
+        bitmaps_content_level=ContentLevel.SKIP,
+    ),
 )
 
-# PdfDocument.iterate_pages() will automatically populate pages as they are yielded.
-for page_no, pred_page in pdf_doc.iterate_pages():
+for page_no, page in pdf_doc.iterate_pages():
+    print(page_no, len(page.word_cells), len(page.textline_cells))
 
-    # iterate over the word-cells
-    for word in pred_page.iterate_cells(unit_type=TextCellUnit.WORD):
-        print(word.rect, ": ", word.text)
+    for word in page.iterate_cells(unit_type=TextCellUnit.WORD):
+        print(word.rect, word.text)
 
-        # create a PIL image with the char cells
-    img = pred_page.render_as_image(cell_unit=TextCellUnit.CHAR)
-    img.show()
+    image = page.render_as_image(cell_unit=TextCellUnit.WORD)
+    image.show()
 ```
 
+If you open cheaply and later need richer output, request it per page. When the
+new `content_config` needs entities that were previously skipped, that page is
+re-decoded automatically:
+
+```python
+from docling_parse.pdf_parser import ContentConfig, ContentLevel
+
+page = pdf_doc.get_page(
+    1,
+    content_config=ContentConfig(
+        word_cells_content_level=ContentLevel.COMPUTE_AND_MATERIALIZE,
+        line_cells_content_level=ContentLevel.COMPUTE_AND_MATERIALIZE,
+    ),
+)
+```
+
+### v6 -> v7 migration
+
+The main API break in v7 is that the old public `DecodePageConfig` selection
+flags were split into two concerns:
+
+- `DecodeConfig`: compute-time tuning only
+- `ContentConfig`: what to skip, compute, or materialize per page
+
+In practice:
+
+- open-time `decode_config` replaces the old per-page decode tuning
+- per-page content selection now lives in `content_config`
+- `materialize_bitmap_bytes` became `include_bitmap_bytes`
+- threaded `page_materialization_config` became `page_content_config`
+
+Typical migration examples:
+
+- old `DecodePageConfig.keep_char_cells=True` -> `ContentConfig(char_cells_content_level=ContentLevel.COMPUTE_AND_MATERIALIZE)`
+- old `DecodePageConfig.create_word_cells=True` without surfacing them everywhere -> `ContentConfig(word_cells_content_level=ContentLevel.COMPUTE)`
+- old `materialize_bitmap_bytes=False` -> `ContentConfig(include_bitmap_bytes=False)`
+
+One semantic change matters: `decode_config` is now fixed when the document or
+threaded batch is opened. If you want richer page output later, override
+`content_config` on `get_page(...)` instead. On the sequential path this may
+re-decode that page; on the threaded path you can only materialize entities the
+batch already computed.
+
 ### Parallel parsing (multi-threaded)
 
-Parse pages from one or more PDFs in parallel using a thread pool with backpressure:
+Parse one or more PDFs in parallel with backpressure:
 
 ```python
 from docling_parse.pdf_parser import (
+    ContentConfig,
+    ContentLevel,
     DecodeConfig,
     DoclingThreadedPdfParser,
     ThreadedPdfParserConfig,
 )
 
-parser_config = ThreadedPdfParserConfig(
-    loglevel="fatal",
-    threads=4,                # worker threads
-    max_concurrent_results=32 # cap buffered results to limit memory
-)
-decode_config = DecodeConfig()
-
 parser = DoclingThreadedPdfParser(
-    parser_config=parser_config,
-    decode_config=decode_config,
+    parser_config=ThreadedPdfParserConfig(
+        loglevel="fatal",
+        threads=4,
+        max_concurrent_results=32,
+        page_content_config=ContentConfig(
+            word_cells_content_level=ContentLevel.COMPUTE,
+            line_cells_content_level=ContentLevel.COMPUTE_AND_MATERIALIZE,
+        ),
+    ),
+    decode_config=DecodeConfig(),
 )
 
-# load one or more documents
-for source in ["doc_a.pdf", "doc_b.pdf"]:
-    doc_key = parser.load(source)
-    print(doc_key, parser.page_count(doc_key))
+doc_key = parser.load("doc_a.pdf", page_numbers=[1, 3, 5])
+print(doc_key, parser.page_count(doc_key), parser.scheduled_page_count(doc_key))
 
-# consume decoded pages as they become available
 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 {result.doc_key} p{result.page_number}: {result.error_message}")
+    if not result.success:
+        print(result.doc_key, result.page_number, result.error_message)
+        continue
+
+    # Batch decode kept word cells in C++, but did not materialize them by default.
+    page = result.get_page(
+        ContentConfig(
+            word_cells_content_level=ContentLevel.COMPUTE_AND_MATERIALIZE,
+            line_cells_content_level=ContentLevel.COMPUTE_AND_MATERIALIZE,
+        )
+    )
+    print(
+        result.doc_key,
+        result.page_number,
+        len(page.word_cells),
+        result.timings.total_s,
+    )
 ```
 
+For threaded parse-and-render workloads, set
+`ThreadedPdfParserConfig.render_config` and use `result.get_image()`,
+`result.get_image(scale=...)`, or `result.get_image(canvas_size=...)`.
+
 Use the CLI
 
 ```sh
@@ -171,7 +247,11 @@ options:
 
 ## Performance Benchmarks
 
-*Coming soon - benchmarks will be updated for the current parser version.*
+Current perf tooling lives under [`perf/`](./perf/README.md):
+
+- [`perf/run_perf.py`](./perf/run_perf.py): per-page CSV benchmarking across `docling`, `docling-threaded`, `pdfplumber`, `pypdfium2`, and `pymupdf`
+- [`perf/run_scaling.py`](./perf/run_scaling.py): pages/sec and scaling sweeps for threaded parse and render workloads
+- [`docs/performance_code.md`](./docs/performance_code.md): usage notes and interpretation
 
 For historical V1 vs V2 benchmarks, see [legacy_performance_benchmarks.md](./docs/legacy_performance_benchmarks.md).
 

{docling_parse-7.0.0 → docling_parse-7.3.0}/README.md

@@ -56,75 +56,151 @@ uv run python ./docling_parse/visualize.py -i <path-to-pdf-file> -c word --inter
 
 ## Quick start
 
-Install the package from Pypi
+Install the package from PyPI:
 
 ```sh
 pip install docling-parse
 ```
 
-Convert a PDF (look in the [visualize.py](docling_parse/visualize.py) for a more detailed information)
+### Sequential parsing
+
+`docling-parse` v7 split page parsing into two public configs:
+
+- `DecodeConfig`: how to compute pages. This is fixed when a document is opened.
+- `ContentConfig`: what to keep or materialize per page. This can be overridden per page.
 
 ```python
 from docling_core.types.doc.page import TextCellUnit
-from docling_parse.pdf_parser import DoclingPdfParser, PdfDocument
-
-parser = DoclingPdfParser()
+from docling_parse.pdf_parser import (
+    ContentConfig,
+    ContentLevel,
+    DecodeConfig,
+    DoclingPdfParser,
+)
 
-pdf_doc: PdfDocument = parser.load(
-    path_or_stream="<path-to-pdf>"
+parser = DoclingPdfParser(loglevel="fatal")
+
+pdf_doc = parser.load(
+    path_or_stream="<path-to-pdf>",
+    decode_config=DecodeConfig(
+        do_sanitization=True,
+        keep_glyphs=False,
+    ),
+    content_config=ContentConfig(
+        char_cells_content_level=ContentLevel.SKIP,
+        word_cells_content_level=ContentLevel.COMPUTE_AND_MATERIALIZE,
+        line_cells_content_level=ContentLevel.COMPUTE_AND_MATERIALIZE,
+        shapes_content_level=ContentLevel.SKIP,
+        bitmaps_content_level=ContentLevel.SKIP,
+    ),
 )
 
-# PdfDocument.iterate_pages() will automatically populate pages as they are yielded.
-for page_no, pred_page in pdf_doc.iterate_pages():
+for page_no, page in pdf_doc.iterate_pages():
+    print(page_no, len(page.word_cells), len(page.textline_cells))
 
-    # iterate over the word-cells
-    for word in pred_page.iterate_cells(unit_type=TextCellUnit.WORD):
-        print(word.rect, ": ", word.text)
+    for word in page.iterate_cells(unit_type=TextCellUnit.WORD):
+        print(word.rect, word.text)
 
-        # create a PIL image with the char cells
-    img = pred_page.render_as_image(cell_unit=TextCellUnit.CHAR)
-    img.show()
+    image = page.render_as_image(cell_unit=TextCellUnit.WORD)
+    image.show()
 ```
 
+If you open cheaply and later need richer output, request it per page. When the
+new `content_config` needs entities that were previously skipped, that page is
+re-decoded automatically:
+
+```python
+from docling_parse.pdf_parser import ContentConfig, ContentLevel
+
+page = pdf_doc.get_page(
+    1,
+    content_config=ContentConfig(
+        word_cells_content_level=ContentLevel.COMPUTE_AND_MATERIALIZE,
+        line_cells_content_level=ContentLevel.COMPUTE_AND_MATERIALIZE,
+    ),
+)
+```
+
+### v6 -> v7 migration
+
+The main API break in v7 is that the old public `DecodePageConfig` selection
+flags were split into two concerns:
+
+- `DecodeConfig`: compute-time tuning only
+- `ContentConfig`: what to skip, compute, or materialize per page
+
+In practice:
+
+- open-time `decode_config` replaces the old per-page decode tuning
+- per-page content selection now lives in `content_config`
+- `materialize_bitmap_bytes` became `include_bitmap_bytes`
+- threaded `page_materialization_config` became `page_content_config`
+
+Typical migration examples:
+
+- old `DecodePageConfig.keep_char_cells=True` -> `ContentConfig(char_cells_content_level=ContentLevel.COMPUTE_AND_MATERIALIZE)`
+- old `DecodePageConfig.create_word_cells=True` without surfacing them everywhere -> `ContentConfig(word_cells_content_level=ContentLevel.COMPUTE)`
+- old `materialize_bitmap_bytes=False` -> `ContentConfig(include_bitmap_bytes=False)`
+
+One semantic change matters: `decode_config` is now fixed when the document or
+threaded batch is opened. If you want richer page output later, override
+`content_config` on `get_page(...)` instead. On the sequential path this may
+re-decode that page; on the threaded path you can only materialize entities the
+batch already computed.
+
 ### Parallel parsing (multi-threaded)
 
-Parse pages from one or more PDFs in parallel using a thread pool with backpressure:
+Parse one or more PDFs in parallel with backpressure:
 
 ```python
 from docling_parse.pdf_parser import (
+    ContentConfig,
+    ContentLevel,
     DecodeConfig,
     DoclingThreadedPdfParser,
     ThreadedPdfParserConfig,
 )
 
-parser_config = ThreadedPdfParserConfig(
-    loglevel="fatal",
-    threads=4,                # worker threads
-    max_concurrent_results=32 # cap buffered results to limit memory
-)
-decode_config = DecodeConfig()
-
 parser = DoclingThreadedPdfParser(
-    parser_config=parser_config,
-    decode_config=decode_config,
+    parser_config=ThreadedPdfParserConfig(
+        loglevel="fatal",
+        threads=4,
+        max_concurrent_results=32,
+        page_content_config=ContentConfig(
+            word_cells_content_level=ContentLevel.COMPUTE,
+            line_cells_content_level=ContentLevel.COMPUTE_AND_MATERIALIZE,
+        ),
+    ),
+    decode_config=DecodeConfig(),
 )
 
-# load one or more documents
-for source in ["doc_a.pdf", "doc_b.pdf"]:
-    doc_key = parser.load(source)
-    print(doc_key, parser.page_count(doc_key))
+doc_key = parser.load("doc_a.pdf", page_numbers=[1, 3, 5])
+print(doc_key, parser.page_count(doc_key), parser.scheduled_page_count(doc_key))
 
-# consume decoded pages as they become available
 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 {result.doc_key} p{result.page_number}: {result.error_message}")
+    if not result.success:
+        print(result.doc_key, result.page_number, result.error_message)
+        continue
+
+    # Batch decode kept word cells in C++, but did not materialize them by default.
+    page = result.get_page(
+        ContentConfig(
+            word_cells_content_level=ContentLevel.COMPUTE_AND_MATERIALIZE,
+            line_cells_content_level=ContentLevel.COMPUTE_AND_MATERIALIZE,
+        )
+    )
+    print(
+        result.doc_key,
+        result.page_number,
+        len(page.word_cells),
+        result.timings.total_s,
+    )
 ```
 
+For threaded parse-and-render workloads, set
+`ThreadedPdfParserConfig.render_config` and use `result.get_image()`,
+`result.get_image(scale=...)`, or `result.get_image(canvas_size=...)`.
+
 Use the CLI
 
 ```sh
@@ -140,7 +216,11 @@ options:
 
 ## Performance Benchmarks
 
-*Coming soon - benchmarks will be updated for the current parser version.*
+Current perf tooling lives under [`perf/`](./perf/README.md):
+
+- [`perf/run_perf.py`](./perf/run_perf.py): per-page CSV benchmarking across `docling`, `docling-threaded`, `pdfplumber`, `pypdfium2`, and `pymupdf`
+- [`perf/run_scaling.py`](./perf/run_scaling.py): pages/sec and scaling sweeps for threaded parse and render workloads
+- [`docs/performance_code.md`](./docs/performance_code.md): usage notes and interpretation
 
 For historical V1 vs V2 benchmarks, see [legacy_performance_benchmarks.md](./docs/legacy_performance_benchmarks.md).
 

{docling_parse-7.0.0 → docling_parse-7.3.0}/app/parse.cpp

@@ -208,15 +208,9 @@ int main(int argc, char* argv[]) {
       parser.parse(config_file, page_config);
 
       double total_time = timer.get_time();
-      std::cout << "\ntimings:\n";
-      for(const auto& [key, val] : parser.get_timings())
-        {
-          if(pdflib::pdf_timings::is_static_key(key))
-            {
-              std::cout << "  " << std::setw(48) << std::left << key << val << " [sec]\n";
-            }
-        }
-      std::cout << std::setw(48) << std::left << "  total-time" << total_time << " [sec]" << std::endl;
+      std::cout << "\ntimings:\n"
+                << pdflib::pdf_timings::format_tree_table(parser.get_timings(), total_time)
+                << std::endl;
 
       return 0;
     }
@@ -267,15 +261,9 @@ int main(int argc, char* argv[]) {
       parser.parse(config, page_config);
 
       double total_time = timer.get_time();
-      std::cout << "\ntimings:\n";
-      for(const auto& [key, val] : parser.get_timings())
-        {
-          if(pdflib::pdf_timings::is_static_key(key))
-            {
-              std::cout << "  " << std::setw(48) << std::left << key << val << " [sec]\n";
-            }
-        }
-      std::cout << std::setw(48) << std::left << "  total-time" << total_time << " [sec]" << std::endl;
+      std::cout << "\ntimings:\n"
+                << pdflib::pdf_timings::format_tree_table(parser.get_timings(), total_time)
+                << std::endl;
 
       if (result.count("print-cells")) {
         std::string mode = result["print-cells"].as<std::string>();

{docling_parse-7.0.0 → docling_parse-7.3.0}/app/pybind_parse.cpp

@@ -274,6 +274,7 @@ PYBIND11_MODULE(pdf_parsers, m) {
         keep_bitmaps (bool): Keep all the bitmap resources [default=true].
         max_num_lines (int): Maximum number of lines to keep (-1 means no cap) [default=-1].
         max_num_bitmaps (int): Maximum number of bitmaps to keep (-1 means no cap) [default=-1].
+        min_visible_clip_extent (float): Minimum clip width/height treated as a usable image clip [default=1e-3].
         keep_glyphs (bool): If true, keep GLYPH<...> fallback strings in output; if false, replace them with a space [default=false].
         keep_qpdf_warnings (bool): If true, QPDF warnings are emitted; if false, they are suppressed [default=false].
     )")
@@ -285,6 +286,7 @@ PYBIND11_MODULE(pdf_parsers, m) {
     .def_readwrite("keep_bitmaps", &pdflib::decode_config::keep_bitmaps)
     .def_readwrite("max_num_lines", &pdflib::decode_config::max_num_lines)
     .def_readwrite("max_num_bitmaps", &pdflib::decode_config::max_num_bitmaps)
+    .def_readwrite("min_visible_clip_extent", &pdflib::decode_config::min_visible_clip_extent)
     .def_readwrite("create_word_cells", &pdflib::decode_config::create_word_cells)
     .def_readwrite("create_line_cells", &pdflib::decode_config::create_line_cells)
     .def_readwrite("enforce_same_font", &pdflib::decode_config::enforce_same_font)
@@ -367,6 +369,12 @@ PYBIND11_MODULE(pdf_parsers, m) {
     .def_readonly("y0", &pdflib::page_item<pdflib::PAGE_IMAGE>::y0)
     .def_readonly("x1", &pdflib::page_item<pdflib::PAGE_IMAGE>::x1)
     .def_readonly("y1", &pdflib::page_item<pdflib::PAGE_IMAGE>::y1)
+    .def_readonly("is_visible", &pdflib::page_item<pdflib::PAGE_IMAGE>::is_visible)
+    .def_readonly("has_visible_bbox", &pdflib::page_item<pdflib::PAGE_IMAGE>::has_visible_bbox)
+    .def_readonly("visible_x0", &pdflib::page_item<pdflib::PAGE_IMAGE>::visible_x0)
+    .def_readonly("visible_y0", &pdflib::page_item<pdflib::PAGE_IMAGE>::visible_y0)
+    .def_readonly("visible_x1", &pdflib::page_item<pdflib::PAGE_IMAGE>::visible_x1)
+    .def_readonly("visible_y1", &pdflib::page_item<pdflib::PAGE_IMAGE>::visible_y1)
     .def_readonly("image_width", &pdflib::page_item<pdflib::PAGE_IMAGE>::image_width)
     .def_readonly("image_height", &pdflib::page_item<pdflib::PAGE_IMAGE>::image_height)
     .def("get_image_format", &pdflib::page_item<pdflib::PAGE_IMAGE>::get_image_format,
@@ -677,13 +685,15 @@ PYBIND11_MODULE(pdf_parsers, m) {
 	 [](docling::docling_parser &self,
 	    const std::string &key,
 	    const std::string &filename,
-	    std::optional<std::string>& password
+	    std::optional<std::string>& password,
+	    bool keep_qpdf_warnings
 	    ) -> bool {
-	   return self.load_document(key, filename, password);
+	   return self.load_document(key, filename, password, keep_qpdf_warnings);
 	 },
 	 pybind11::arg("key"),
 	 pybind11::arg("filename"),
 	 pybind11::arg("password") = pybind11::none(),
+	 pybind11::arg("keep_qpdf_warnings") = false,
 	 R"(
     Load a document by key and filename.
 
@@ -699,13 +709,18 @@ PYBIND11_MODULE(pdf_parsers, m) {
 	 [](docling::docling_parser &self,
 	    const std::string &key,
 	    pybind11::object bytes_io,
-	    std::optional<std::string>& password
+	    std::optional<std::string>& password,
+	    bool keep_qpdf_warnings
 	    ) -> bool {
-	   return self.load_document_from_bytesio(key, bytes_io, password);
+	   return self.load_document_from_bytesio(key,
+                                                  bytes_io,
+                                                  password,
+                                                  keep_qpdf_warnings);
 	 },
 	 pybind11::arg("key"),
 	 pybind11::arg("bytes_io"),
-	 pybind11::arg("password") = pybind11::none(),	 
+	 pybind11::arg("password") = pybind11::none(),
+	 pybind11::arg("keep_qpdf_warnings") = false,
 	 R"(
     Load a document by key from a BytesIO-like object.
 

{docling_parse-7.0.0 → docling_parse-7.3.0}/app/run_scaling.cpp

@@ -636,7 +636,9 @@ namespace
               auto total_start = clock_type::now();
 
               auto stage_start = clock_type::now();
-              auto page_decoder = docs_[task.doc_index]->make_thread_safe_page_decoder(task.page_number);
+              auto page_decoder = docs_[task.doc_index]->make_thread_safe_page_decoder(
+                task.page_number,
+                decode_config_.keep_qpdf_warnings);
               result.timings.make_page_decoder_s =
                 std::chrono::duration<double>(clock_type::now() - stage_start).count();