feat: Support reading password protected PDF (#169)

Signed-off-by: Nimalan <[email protected]>
Signed-off-by: Michele Dolfi <[email protected]>
Co-authored-by: Michele Dolfi <[email protected]>

Author: Mark1626

app/parse_v2.cpp

@@ -82,6 +82,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"))
+      ("password", "Password for accessing encrypted, password-protected files", cxxopts::value<std::string>())
       ("o,output", "Output file", cxxopts::value<std::string>())
       ("l,loglevel", "loglevel [error;warning;success;info]", cxxopts::value<std::string>())
       ("h,help", "Print usage");
@@ -158,6 +159,9 @@ int main(int argc, char* argv[]) {
 
       auto config = create_config(ifile, ofile, page);
       LOG_S(INFO) << "config: \n" << config.dump(2);
+      if (result.count("password")) {
+        config["password"] = result["password"].as<std::string>();
+      }
 
       utils::timer timer;
 

app/pybind_parse.cpp

@@ -1,5 +1,6 @@
 //-*-C++-*-
 
+#include <optional>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <pybind11/buffer_info.h>
@@ -247,17 +248,24 @@ PYBIND11_MODULE(pdf_parsers, m) {
         List[str]: A list of keys for the currently loaded documents.)")
 
     .def("load_document",
-	 [](docling::docling_parser_v2 &self, const std::string &key, const std::string &filename) -> bool {
-	   return self.load_document(key, filename);
+	 [](
+        docling::docling_parser_v2 &self,
+        const std::string &key,
+        const std::string &filename,
+        std::optional<std::string>& password
+     ) -> bool {
+	   return self.load_document(key, filename, password);
 	 },
 	 pybind11::arg("key"),
 	 pybind11::arg("filename"),
+     pybind11::arg("password") = pybind11::none(),
 	 R"(
     Load a document by key and filename.
 
     Parameters:
         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
 
     Returns:
         bool: True if the document was successfully loaded, False otherwise.)")

docling_parse/pdf_parser.py

@@ -601,14 +601,17 @@ def load(
         path_or_stream: Union[str, Path, BytesIO],
         lazy: bool = True,
         boundary_type: PdfPageBoundaryType = PdfPageBoundaryType.CROP_BOX,
+        password: Optional[str] = None,
     ) -> PdfDocument:
 
         if isinstance(path_or_stream, str):
             path_or_stream = Path(path_or_stream)
 
         if isinstance(path_or_stream, Path):
             key = f"key={str(path_or_stream)}"  # use filepath as internal handle
-            success = self._load_document(key=key, filename=str(path_or_stream))
+            success = self._load_document(
+                key=key, filename=str(path_or_stream), password=password
+            )
 
         elif isinstance(path_or_stream, BytesIO):
             hasher = hashlib.sha256(usedforsecurity=False)
@@ -632,17 +635,22 @@ def load(
         else:
             raise RuntimeError(f"Failed to load document with key {key}")
 
-    def _load_document(self, key: str, filename: str) -> bool:
+    def _load_document(
+        self, key: str, filename: str, password: Optional[str] = None
+    ) -> bool:
         """Load a document by key and filename.
 
         Parameters:
             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
 
         Returns:
             bool: True if the document was successfully loaded, False otherwise.)")
         """
-        return self.parser.load_document(key=key, filename=filename.encode("utf8"))
+        return self.parser.load_document(
+            key=key, filename=filename.encode("utf8"), password=password
+        )
 
     def _load_document_from_bytesio(self, key: str, data: BytesIO) -> bool:
         """Load a document by key from a BytesIO-like object.

docling_parse/visualize.py

@@ -2,6 +2,7 @@
 import logging
 import os
 from pathlib import Path
+from typing import Optional
 
 from docling_core.types.doc.page import SegmentedPdfPage, TextCellUnit
 
@@ -103,6 +104,14 @@ def parse_args():
         help="page to be displayed (default: -1 -> all)",
     )
 
+    # Add an argument for the output directory, defaulting to "./tmp"
+    parser.add_argument(
+        "--password",
+        type=str,
+        required=False,
+        help="Optional password for password-protected files",
+    )
+
     # Parse the command-line arguments
     args = parser.parse_args()
 
@@ -125,6 +134,7 @@ def parse_args():
         args.enforce_same_font,
         args.page_boundary,
         args.category,
+        args.password,
     )
 
 
@@ -140,10 +150,13 @@ def visualise_py(
     page_boundary: str = "crop_box",  # media_box
     category: str = "char",  # "both", "sanitized", "original"
     page_num: int = -1,
+    password: Optional[str] = None,
 ):
     parser = DoclingPdfParser(loglevel=log_level)
 
-    pdf_doc: PdfDocument = parser.load(path_or_stream=pdf_path, lazy=True)
+    pdf_doc: PdfDocument = parser.load(
+        path_or_stream=pdf_path, lazy=True, password=password
+    )
 
     page_nos = [page_num]
     if page_num == -1:
@@ -254,6 +267,7 @@ def main():
         enforce_same_font,
         page_boundary,
         category,
+        password,
     ) = parse_args()
 
     logging.info(f"page_boundary: {page_boundary}")
@@ -269,6 +283,7 @@ def main():
         page_boundary=page_boundary,
         category=category,
         page_num=page_num,
+        password=password,
     )
 
 

src/pybind/docling_parser_v2.h

@@ -3,6 +3,7 @@
 #ifndef PYBIND_PDF_PARSER_V2_H
 #define PYBIND_PDF_PARSER_V2_H
 
+#include <optional>
 #ifdef _WIN32
 #include <locale>
 #include <codecvt>
@@ -31,7 +32,7 @@ namespace docling
     bool is_loaded(std::string key);
     std::vector<std::string> list_loaded_keys();
 
-    bool load_document(std::string key, std::string filename);
+    bool load_document(std::string key, std::string filename, std::optional<std::string> password);
     bool load_document_from_bytesio(std::string key, pybind11::object bytes_io);
 
     bool unload_document(std::string key);
@@ -188,7 +189,7 @@ namespace docling
     return (key2doc.count(key)==1);
   }
 
-  bool docling_parser_v2::load_document(std::string key, std::string filename)
+  bool docling_parser_v2::load_document(std::string key, std::string filename, std::optional<std::string> password)
   {
 #ifdef _WIN32
     // Convert UTF-8 string to UTF-16 wstring
@@ -203,7 +204,7 @@ namespace docling
       {
         //key2doc[key] = std::filesystem::path(filename);
 	key2doc[key] = std::make_shared<decoder_type>();
-	key2doc.at(key)->process_document_from_file(filename);
+	key2doc.at(key)->process_document_from_file(filename, password);
 	return true;
       }
 

src/v2/parser.h

@@ -196,7 +196,16 @@ namespace plib
         return false;
       }
 
-    if(not document_decoder.process_document_from_file(inp_filename))
+    std::optional<std::string> password;
+    if (input_file["password"].is_null())
+      {
+        password = std::nullopt;
+      }
+    else
+      {
+        password = input_file["password"];
+      }
+    if(not document_decoder.process_document_from_file(inp_filename, password))
       {
         LOG_S(ERROR) << "aborting the parse of file "<< inp_filename;
         return false;

src/v2/pdf_decoders/document.h

@@ -3,6 +3,7 @@
 #ifndef PDF_DOCUMENT_DECODER_H
 #define PDF_DOCUMENT_DECODER_H
 
+#include <optional>
 #include <qpdf/QPDF.hh>
 //#include <qpdf/QPDFPageObjectHelper.hh>
 
@@ -27,7 +28,7 @@ namespace pdflib
     nlohmann::json get_meta_xml() { return json_annots["meta_xml"]; }
     nlohmann::json get_table_of_contents() { return json_annots["table_of_contents"]; }
 
-    bool process_document_from_file(std::string& _filename);
+    bool process_document_from_file(std::string& _filename, std::optional<std::string>& password);
     bool process_document_from_bytesio(std::string& _buffer);
 
     void decode_document(std::string page_boundary, bool do_sanitization);
@@ -150,7 +151,7 @@ namespace pdflib
     return json_document;
   }
 
-  bool pdf_decoder<DOCUMENT>::process_document_from_file(std::string& _filename)
+  bool pdf_decoder<DOCUMENT>::process_document_from_file(std::string& _filename, std::optional<std::string>& password)
   {
     filename = _filename; // save it    
     LOG_S(INFO) << "start processing '" << filename << "' by qpdf ...";        
@@ -159,7 +160,11 @@ namespace pdflib
 
     try
       {
-        qpdf_document.processFile(filename.c_str());
+        if (password.has_value()) {
+          qpdf_document.processFile(filename.c_str(), password.value().c_str());
+        } else {
+          qpdf_document.processFile(filename.c_str());
+        }
         LOG_S(INFO) << "filename: " << filename << " processed by qpdf!";        
 
         qpdf_root  = qpdf_document.getRoot();