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

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

@@ -1,3 +1,19 @@
+## [v6.2.0](https://github.com/docling-project/docling-parse/releases/tag/v6.2.0) - 2026-05-28
+
+### Feature
+
+* Add materialize_bitmap_bytes flag to skip bitmap byte extraction ([#277](https://github.com/docling-project/docling-parse/issues/277)) ([`918d7b9`](https://github.com/docling-project/docling-parse/commit/918d7b90911403fd2e9fec3eb5550ebaf4590e89))
+
+## [v6.1.0](https://github.com/docling-project/docling-parse/releases/tag/v6.1.0) - 2026-05-26
+
+### Feature
+
+* Release unused python memory ([#274](https://github.com/docling-project/docling-parse/issues/274)) ([`537461a`](https://github.com/docling-project/docling-parse/commit/537461a5da1f32db649cc29cf7569ee04f7379cb))
+
+### Performance
+
+* Update perf scripts ([#271](https://github.com/docling-project/docling-parse/issues/271)) ([`f53ab21`](https://github.com/docling-project/docling-parse/commit/f53ab215586570df4cafb892a5845b8bd1297eca))
+
 ## [v6.0.0](https://github.com/docling-project/docling-parse/releases/tag/v6.0.0) - 2026-05-11
 
 ### Feature

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 6.0.0
+Version: 6.2.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

{docling_parse-6.0.0 → docling_parse-6.2.0}/app/parse.cpp

@@ -2,6 +2,8 @@
 
 #include "parse.h"
 
+#include <sstream>
+
 void set_loglevel(std::string level)
 {
   if(level=="info")
@@ -26,9 +28,52 @@ void set_loglevel(std::string level)
     }
 }
 
+std::optional<std::vector<int>> parse_page_selection(const cxxopts::ParseResult& result)
+{
+  const bool has_page = result.count("page") && result["page"].as<int>() != -1;
+  const bool has_page_range = result.count("page-range");
+
+  if(has_page && has_page_range)
+    {
+      throw std::runtime_error("Use either --page or --page-range, not both");
+    }
+
+  if(has_page)
+    {
+      return std::vector<int>{result["page"].as<int>()};
+    }
+
+  if(!has_page_range)
+    {
+      return std::nullopt;
+    }
+
+  std::string raw = result["page-range"].as<std::string>();
+  size_t dash = raw.find('-');
+  if(dash == std::string::npos)
+    {
+      throw std::runtime_error("Page range must have form start-end");
+    }
+
+  int start = std::stoi(raw.substr(0, dash));
+  int end = std::stoi(raw.substr(dash + 1));
+  if(end < start)
+    {
+      throw std::runtime_error("Page range end must be >= start");
+    }
+
+  std::vector<int> pages;
+  pages.reserve(static_cast<size_t>(end - start + 1));
+  for(int page = start; page <= end; ++page)
+    {
+      pages.push_back(page);
+    }
+  return pages;
+}
+
 nlohmann::json create_config(std::filesystem::path ifile,
                              std::filesystem::path ofile,
-                             int page=-1,
+                             std::optional<std::vector<int>> pages=std::nullopt,
                              std::filesystem::path pdf_resource_dir="../docling_parse/pdf_resources/")
 {
   nlohmann::json config = nlohmann::json::object({});
@@ -46,10 +91,9 @@ nlohmann::json create_config(std::filesystem::path ifile,
         task["output"] = ofile;
       }
 
-    if(page!=-1)
+    if(pages.has_value())
       {
-        std::vector<int> pages = {page};
-        task["page-numbers"] = pages;
+        task["page-numbers"] = *pages;
       }
 
     tasks.push_back(task);
@@ -76,6 +120,7 @@ int main(int argc, char* argv[]) {
       ("c,config",       "Config file",                                                           cxxopts::value<std::string>())
       ("create-config",  "Create config file",                                                    cxxopts::value<std::string>())
       ("p,page",         "Pages to process (default: -1 for all)",                               cxxopts::value<int>()->default_value("-1"))
+      ("page-range",     "Inclusive page range to process, e.g. 10-20",                          cxxopts::value<std::string>())
       ("password",       "Password for accessing encrypted, password-protected files",            cxxopts::value<std::string>())
       ("o,output",       "Output file",                                                           cxxopts::value<std::string>())
       ("export-images",  "Export images to directory",                                            cxxopts::value<std::string>())
@@ -181,15 +226,14 @@ int main(int argc, char* argv[]) {
       std::string ifile = result["input"].as<std::string>();
       std::string ofile = "";
 
-      int page = result["page"].as<int>();
-      LOG_F(INFO, "Page to process: %d", page);
+      auto pages = parse_page_selection(result);
 
       if (result.count("output")) {
         ofile = result["output"].as<std::string>();
         LOG_F(INFO, "Output file: %s", ofile.c_str());
       }
 
-      auto config = create_config(ifile, ofile, page);
+      auto config = create_config(ifile, ofile, pages);
       LOG_S(INFO) << "config: \n" << config.dump(2);
     }
 
@@ -199,8 +243,7 @@ int main(int argc, char* argv[]) {
       std::string ifile = result["input"].as<std::string>();
       std::string ofile = ifile+".json";
 
-      int page = result["page"].as<int>();
-      LOG_F(INFO, "Page to process: %d", page);
+      auto pages = parse_page_selection(result);
 
       if (result.count("output")) {
         ofile = result["output"].as<std::string>();
@@ -210,7 +253,7 @@ int main(int argc, char* argv[]) {
         LOG_F(INFO, "No output file found, defaulting to %s", ofile.c_str());
       }
 
-      auto config = create_config(ifile, ofile, page);
+      auto config = create_config(ifile, ofile, pages);
       LOG_S(INFO) << "config: \n" << config.dump(2);
       if (result.count("password")) {
         config["password"] = result["password"].as<std::string>();
@@ -241,7 +284,7 @@ int main(int argc, char* argv[]) {
 
       if (result.count("export-images")) {
         std::string images_dir = result["export-images"].as<std::string>();
-        parser.export_images(images_dir, page);
+        parser.export_images(images_dir, result["page"].as<int>());
       }
 
       return 0;

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

@@ -269,13 +269,14 @@ PYBIND11_MODULE(pdf_parsers, m) {
     Attributes:
         page_boundary (str): The page boundary specification [choices: crop_box, media_box].
         do_sanitization (bool): Sanitize the chars into lines [default=true].
-        keep_char_cells (bool): Keep all the individual char cells [default=true].
+        keep_char_cells (bool): Expose individual char cells in the decoded output. Internal base text cells are still built when words or lines are requested [default=true].
         keep_shapes (bool): Keep all the graphic shapes [default=true].
         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].
         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].
+        materialize_bitmap_bytes (bool): If true (default), bitmap byte data is extracted and embedded in BitmapResource objects. If false, only bitmap geometry (rectangles) is preserved and image bytes are skipped. Consumed by the Python layer only; has no effect in C++ [default=true].
     )")
     .def(pybind11::init<>())
     .def_readwrite("page_boundary", &pdflib::decode_config::page_boundary)
@@ -293,8 +294,12 @@ PYBIND11_MODULE(pdf_parsers, m) {
     .def_readwrite("line_space_width_factor_for_merge", &pdflib::decode_config::line_space_width_factor_for_merge)
     .def_readwrite("line_space_width_factor_for_merge_with_space", &pdflib::decode_config::line_space_width_factor_for_merge_with_space)
     .def_readwrite("do_thread_safe", &pdflib::decode_config::do_thread_safe)
+    .def_readwrite("release_native_memory_every_n_pages", &pdflib::decode_config::release_native_memory_every_n_pages)
     .def_readwrite("keep_glyphs", &pdflib::decode_config::keep_glyphs)
-    .def_readwrite("keep_qpdf_warnings", &pdflib::decode_config::keep_qpdf_warnings);
+    .def_readwrite("keep_qpdf_warnings", &pdflib::decode_config::keep_qpdf_warnings)
+    .def_readwrite("materialize_bitmap_bytes", &pdflib::decode_config::materialize_bitmap_bytes)
+    .def("__copy__", [](const pdflib::decode_config& self) { return self; })
+    .def("__deepcopy__", [](const pdflib::decode_config& self, pybind11::dict) { return self; });
 
   // ============= Typed Resource Bindings (for zero-copy access) =============
 

{docling_parse-6.0.0 → docling_parse-6.2.0}/docling_parse/pdf_parser.py

@@ -1,5 +1,6 @@
 """Parser for PDF files"""
 
+import copy
 import hashlib
 import logging
 import math
@@ -366,46 +367,52 @@ def _to_hyperlinks_from_decoder(hyperlinks_container) -> List[PdfHyperlink]:
     return result
 
 
-def _to_bitmap_resources_from_decoder(images_container) -> List[BitmapResource]:
+def _to_bitmap_resources_from_decoder(
+    images_container,
+    materialize_bitmap_bytes: bool = True,
+) -> List[BitmapResource]:
     result: List[BitmapResource] = []
 
     for ind, image in enumerate(images_container):
         image_ref = None
         mode = ImageRefMode.PLACEHOLDER
 
-        try:
-            image_bytes = image.get_image_as_bytes()
-
-            if image_bytes and len(image_bytes) > 0:
-                fmt = image.get_image_format()
-                pil_image: PILImage.Image | None = None
-
-                if fmt in ("jpeg", "jp2"):
-                    pil_image = PILImage.open(BytesIO(image_bytes))
-                elif fmt in ("raw", "jbig2"):
-                    pil_mode = image.get_pil_mode()
-                    w = image.image_width
-                    h = image.image_height
-                    if w > 0 and h > 0:
-                        pil_image = PILImage.frombytes(pil_mode, (w, h), image_bytes)
-
-                if pil_image is not None:
-                    if pil_image.mode != "RGBA":
-                        pil_image = pil_image.convert("RGBA")
-
-                    bbox_width = abs(image.x1 - image.x0)
-                    if bbox_width > 0 and image.image_width > 0:
-                        dpi = round(image.image_width * 72.0 / bbox_width)
-                    else:
-                        dpi = 72
-
-                    image_ref = ImageRef.from_pil(pil_image, dpi=dpi)
-                    mode = ImageRefMode.EMBEDDED
-
-        except Exception:
-            _log.debug(
-                "Failed to extract image data for bitmap, falling back to placeholder"
-            )
+        if materialize_bitmap_bytes:
+            try:
+                image_bytes = image.get_image_as_bytes()
+
+                if image_bytes and len(image_bytes) > 0:
+                    fmt = image.get_image_format()
+                    pil_image: PILImage.Image | None = None
+
+                    if fmt in ("jpeg", "jp2"):
+                        pil_image = PILImage.open(BytesIO(image_bytes))
+                    elif fmt in ("raw", "jbig2"):
+                        pil_mode = image.get_pil_mode()
+                        w = image.image_width
+                        h = image.image_height
+                        if w > 0 and h > 0:
+                            pil_image = PILImage.frombytes(
+                                pil_mode, (w, h), image_bytes
+                            )
+
+                    if pil_image is not None:
+                        if pil_image.mode != "RGBA":
+                            pil_image = pil_image.convert("RGBA")
+
+                        bbox_width = abs(image.x1 - image.x0)
+                        if bbox_width > 0 and image.image_width > 0:
+                            dpi = round(image.image_width * 72.0 / bbox_width)
+                        else:
+                            dpi = 72
+
+                        image_ref = ImageRef.from_pil(pil_image, dpi=dpi)
+                        mode = ImageRefMode.EMBEDDED
+
+            except Exception:
+                _log.debug(
+                    "Failed to extract image data for bitmap, falling back to placeholder"
+                )
 
         result.append(
             BitmapResource(
@@ -432,6 +439,7 @@ def _to_bitmap_resources_from_decoder(images_container) -> List[BitmapResource]:
 def segmented_page_from_decoder(
     page_decoder: PdfPageDecoder,
     boundary_type: PdfPageBoundaryType = PdfPageBoundaryType.CROP_BOX,
+    materialize_bitmap_bytes: bool = True,
 ) -> SegmentedPdfPage:
     """Convert a C++ PdfPageDecoder to a SegmentedPdfPage."""
     char_cells = _to_cells_from_decoder(page_decoder.get_char_cells())
@@ -445,7 +453,8 @@ def segmented_page_from_decoder(
         textline_cells=[],
         has_chars=len(char_cells) > 0,
         bitmap_resources=_to_bitmap_resources_from_decoder(
-            page_decoder.get_page_images()
+            page_decoder.get_page_images(),
+            materialize_bitmap_bytes=materialize_bitmap_bytes,
         ),
         shapes=_to_shapes_from_decoder(page_decoder.get_page_shapes()),
         widgets=_to_widgets_from_decoder(page_decoder.get_page_widgets()),
@@ -492,7 +501,7 @@ class PdfDocument:
         self._parser: pdf_parser = parser
         self._key = key
         self._boundary_type = boundary_type
-        self._pages: Dict[int, SegmentedPdfPage] = {}
+        self._pages: Dict[tuple[int, bool], SegmentedPdfPage] = {}
         self._toc: PdfTableOfContents | None = None
         self._meta: PdfMetaData | None = None
         self._annotations: PdfAnnotations | None = None
@@ -520,11 +529,13 @@ class PdfDocument:
             if page_no < 1:
                 _log.error("page_no should always be >=1!")
 
-            if page_no in self._pages:
+            cache_keys = [k for k in self._pages if k[0] == page_no]
+            if cache_keys:
                 # we are using 0 indexing in the C++ docling-parse!
                 page_num = page_no - 1
                 self._parser.unload_document_page(key=self._key, page=page_num)
-                del self._pages[page_no]
+                for k in cache_keys:
+                    del self._pages[k]
 
     def number_of_pages(self) -> int:
         if self.is_loaded():
@@ -702,6 +713,7 @@ class PdfDocument:
 
         segmented_page = self._to_segmented_page_from_decoder(
             page_decoder=page_decoder,
+            materialize_bitmap_bytes=config.materialize_bitmap_bytes,
         )
 
         # Get timings from the page decoder
@@ -740,19 +752,26 @@ class PdfDocument:
         return _to_hyperlinks_from_decoder(hyperlinks_container)
 
     def _to_bitmap_resources_from_decoder(
-        self, images_container
+        self,
+        images_container,
+        materialize_bitmap_bytes: bool = True,
     ) -> List[BitmapResource]:
         """Convert typed PdfImages container to list of BitmapResource objects."""
-        return _to_bitmap_resources_from_decoder(images_container)
+        return _to_bitmap_resources_from_decoder(
+            images_container,
+            materialize_bitmap_bytes=materialize_bitmap_bytes,
+        )
 
     def _to_segmented_page_from_decoder(
         self,
         page_decoder,
+        materialize_bitmap_bytes: bool = True,
     ) -> SegmentedPdfPage:
         """Convert typed PdfPageDecoder to SegmentedPdfPage (zero-copy path)."""
         return segmented_page_from_decoder(
             page_decoder=page_decoder,
             boundary_type=self._boundary_type,
+            materialize_bitmap_bytes=materialize_bitmap_bytes,
         )
 
     def _get_page_typed(
@@ -773,8 +792,9 @@ class PdfDocument:
         Returns:
             SegmentedPdfPage with the parsed page data.
         """
-        if page_no in self._pages.keys():
-            return self._pages[page_no]
+        cache_key = (page_no, config.materialize_bitmap_bytes)
+        if cache_key in self._pages:
+            return self._pages[cache_key]
 
         if 1 <= page_no <= self.number_of_pages():
             page_decoder = self._parser.get_page_decoder(
@@ -786,10 +806,11 @@ class PdfDocument:
             if page_decoder is None:
                 raise ValueError(f"Failed to decode page {page_no}")
 
-            self._pages[page_no] = self._to_segmented_page_from_decoder(
+            self._pages[cache_key] = self._to_segmented_page_from_decoder(
                 page_decoder=page_decoder,
+                materialize_bitmap_bytes=config.materialize_bitmap_bytes,
             )
-            return self._pages[page_no]
+            return self._pages[cache_key]
 
         raise ValueError(
             f"incorrect page_no: {page_no} for key={self._key} (min:1, max:{self.number_of_pages()})"
@@ -923,10 +944,12 @@ class PageParseResult:
         *,
         boundary_type: PdfPageBoundaryType,
         render_config: RenderConfig | None,
+        decode_config: DecodePageConfig,
     ):
         self._raw = raw_result
         self._boundary_type = boundary_type
         self._render_config = render_config
+        self._decode_config = decode_config
         self._page: SegmentedPdfPage | None = None
         self._page_decoder: PdfPageDecoder | None = None
         self._default_image: PILImage.Image | None = None
@@ -972,6 +995,7 @@ class PageParseResult:
             self._page = segmented_page_from_decoder(
                 page_decoder=self._require_page_decoder(),
                 boundary_type=self._boundary_type,
+                materialize_bitmap_bytes=self._decode_config.materialize_bitmap_bytes,
             )
         return self._page
 
@@ -1113,30 +1137,6 @@ class PageParseResult:
         return self._require_page_decoder().export_bitmap_artifacts()
 
 
-def _copy_decode_config(src: DecodePageConfig) -> DecodePageConfig:
-    dst = DecodePageConfig()
-    dst.page_boundary = src.page_boundary
-    dst.do_sanitization = src.do_sanitization
-    dst.keep_char_cells = src.keep_char_cells
-    dst.keep_shapes = src.keep_shapes
-    dst.keep_bitmaps = src.keep_bitmaps
-    dst.max_num_lines = src.max_num_lines
-    dst.max_num_bitmaps = src.max_num_bitmaps
-    dst.create_word_cells = src.create_word_cells
-    dst.create_line_cells = src.create_line_cells
-    dst.enforce_same_font = src.enforce_same_font
-    dst.horizontal_cell_tolerance = src.horizontal_cell_tolerance
-    dst.word_space_width_factor_for_merge = src.word_space_width_factor_for_merge
-    dst.line_space_width_factor_for_merge = src.line_space_width_factor_for_merge
-    dst.line_space_width_factor_for_merge_with_space = (
-        src.line_space_width_factor_for_merge_with_space
-    )
-    dst.do_thread_safe = src.do_thread_safe
-    dst.keep_glyphs = src.keep_glyphs
-    dst.keep_qpdf_warnings = src.keep_qpdf_warnings
-    return dst
-
-
 def _copy_render_config(src: RenderConfig) -> RenderConfig:
     dst = RenderConfig()
     dst.render_text = src.render_text
@@ -1188,7 +1188,7 @@ class DoclingThreadedPdfParser:
                 parser_config.render_config
             )
         self._decode_config = (
-            _copy_decode_config(decode_config)
+            copy.copy(decode_config)
             if decode_config is not None
             else DecodePageConfig()
         )
@@ -1317,4 +1317,5 @@ class DoclingThreadedPdfParser:
             self._parser.get_task(),
             boundary_type=self._parser_config.boundary_type,
             render_config=self._parser_config.render_config,
+            decode_config=self._decode_config,
         )

{docling_parse-6.0.0 → docling_parse-6.2.0}/docling_parse.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 6.0.0
+Version: 6.2.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

{docling_parse-6.0.0 → docling_parse-6.2.0}/docling_parse.egg-info/SOURCES.txt

@@ -540,6 +540,7 @@ src/parse/pdf_states/grph.h
 src/parse/pdf_states/shape.h
 src/parse/pdf_states/text.h
 src/parse/qpdf/annots.h
+src/parse/qpdf/logger.h
 src/parse/qpdf/qpdf_compat.h
 src/parse/qpdf/stream_decoder.h
 src/parse/qpdf/stream_instruction.h
@@ -561,6 +562,7 @@ src/pybind/docling_resources.h
 src/pybind/docling_threaded_base.h
 src/pybind/docling_threaded_parser.h
 src/pybind/docling_threaded_renderer.h
+src/pybind/native_memory.h
 src/pybind/utils/pybind11_json.h
 src/render/blend2d_renderer.h
 src/render/config.h

{docling_parse-6.0.0 → docling_parse-6.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "docling-parse"
-version = "6.0.0"
+version = "6.2.0"
 description = "Simple package to extract text with coordinates from programmatic PDFs"
 license = "MIT"
 keywords = ["docling", "pdf", "parser"]
@@ -63,7 +63,7 @@ build = [
     "cmake>=3.27.0,<4.0.0"
 ]
 dev = [
-    "pytest>=7.4.2,<8.0.0",
+    "pytest>=9.0.3,<10.0.0",
     "ruff>=0.11,<1.0",
     "python-semantic-release>=7.32.2,<8.0.0",
     "pre-commit>=3.7.1,<4.0.0",
@@ -78,6 +78,7 @@ perf-test = [
     "pdfplumber>=0.11.7",
     "pymupdf>=1.26.4",
     "pypdfium2>=4.30.0",
+    "huggingface-hub>=1.11.0",
 ]
 
 

{docling_parse-6.0.0 → docling_parse-6.2.0}/src/parse/config.h

@@ -37,11 +37,15 @@ namespace pdflib
 
     // threading
     bool do_thread_safe = true; // slight compute/memory overhead in single threaded case
+    int release_native_memory_every_n_pages = 0; // 0 disables allocator trimming
 
-    // debug: in production, we dont want to have ugly GLYPH<...> 
+    // debug: in production, we dont want to have ugly GLYPH<...>
     bool keep_glyphs = false;
     bool keep_qpdf_warnings = false;
-    
+
+    // consumed by Python layer only; C++ ignores this field
+    bool materialize_bitmap_bytes = true;
+
     nlohmann::json to_json() const;
     void from_json(const nlohmann::json& j);
 
@@ -78,9 +82,11 @@ namespace pdflib
     j["line_space_width_factor_for_merge_with_space"] = line_space_width_factor_for_merge_with_space;
 
     j["populate_json_objects"] = populate_json_objects;
+    j["release_native_memory_every_n_pages"] = release_native_memory_every_n_pages;
 
     j["keep_glyphs"] = keep_glyphs;
     j["keep_qpdf_warnings"] = keep_qpdf_warnings;
+    j["materialize_bitmap_bytes"] = materialize_bitmap_bytes;
 
     return j;
   }
@@ -110,9 +116,11 @@ namespace pdflib
     if(j.count("line_space_width_factor_for_merge_with_space")) { line_space_width_factor_for_merge_with_space = j["line_space_width_factor_for_merge_with_space"]; }
 
     if(j.count("populate_json_objects")) { populate_json_objects = j["populate_json_objects"]; }
+    if(j.count("release_native_memory_every_n_pages")) { release_native_memory_every_n_pages = j["release_native_memory_every_n_pages"]; }
 
     if(j.count("keep_glyphs")) { keep_glyphs = j["keep_glyphs"]; }
     if(j.count("keep_qpdf_warnings")) { keep_qpdf_warnings = j["keep_qpdf_warnings"]; }
+    if(j.count("materialize_bitmap_bytes")) { materialize_bitmap_bytes = j["materialize_bitmap_bytes"]; }
   }
 
   bool decode_config::load(const std::string& filename)
@@ -164,8 +172,10 @@ namespace pdflib
        << std::setw(48) << "line_space_width_factor_for_merge" << line_space_width_factor_for_merge << "\n"
        << std::setw(48) << "line_space_width_factor_for_merge_with_space" << line_space_width_factor_for_merge_with_space << "\n"
        << std::setw(48) << "populate_json_objects" << (populate_json_objects ? "true" : "false") << "\n"
+       << std::setw(48) << "release_native_memory_every_n_pages" << release_native_memory_every_n_pages << "\n"
        << std::setw(48) << "keep_glyphs" << (keep_glyphs ? "true" : "false") << "\n"
-       << std::setw(48) << "keep_qpdf_warnings" << (keep_qpdf_warnings ? "true" : "false") << "\n";
+       << std::setw(48) << "keep_qpdf_warnings" << (keep_qpdf_warnings ? "true" : "false") << "\n"
+       << std::setw(48) << "materialize_bitmap_bytes" << (materialize_bitmap_bytes ? "true" : "false") << "\n";
 
     return ss.str();
   }