opendataloader-pdf 0.0.0__py3-none-any.whl → 1.8.2__py3-none-any.whl

opendataloader_pdf/runner.py

@@ -0,0 +1,71 @@
+"""
+Low-level JAR runner for opendataloader-pdf.
+"""
+import locale
+import subprocess
+import sys
+import importlib.resources as resources
+from typing import List
+
+# The consistent name of the JAR file bundled with the package
+_JAR_NAME = "opendataloader-pdf-cli.jar"
+
+
+def run_jar(args: List[str], quiet: bool = False) -> str:
+    """Run the opendataloader-pdf JAR with the given arguments."""
+    try:
+        # Access the embedded JAR inside the package
+        jar_ref = resources.files("opendataloader_pdf").joinpath("jar", _JAR_NAME)
+        with resources.as_file(jar_ref) as jar_path:
+            command = ["java", "-jar", str(jar_path), *args]
+
+            if quiet:
+                # Quiet mode → capture all output
+                result = subprocess.run(
+                    command,
+                    capture_output=True,
+                    text=True,
+                    check=True,
+                    encoding=locale.getpreferredencoding(False),
+                )
+                return result.stdout
+
+            # Streaming mode → live output
+            with subprocess.Popen(
+                command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                encoding=locale.getpreferredencoding(False),
+            ) as process:
+                output_lines: List[str] = []
+                for line in process.stdout:
+                    sys.stdout.write(line)
+                    output_lines.append(line)
+
+                return_code = process.wait()
+                captured_output = "".join(output_lines)
+
+                if return_code:
+                    raise subprocess.CalledProcessError(
+                        return_code, command, output=captured_output
+                    )
+                return captured_output
+
+    except FileNotFoundError:
+        print(
+            "Error: 'java' command not found. Please ensure Java is installed and in your system's PATH.",
+            file=sys.stderr,
+        )
+        raise
+
+    except subprocess.CalledProcessError as error:
+        print("Error running opendataloader-pdf CLI.", file=sys.stderr)
+        print(f"Return code: {error.returncode}", file=sys.stderr)
+        if error.output:
+            print(f"Output: {error.output}", file=sys.stderr)
+        if error.stderr:
+            print(f"Stderr: {error.stderr}", file=sys.stderr)
+        if error.stdout:
+            print(f"Stdout: {error.stdout}", file=sys.stderr)
+        raise

opendataloader_pdf/wrapper.py

@@ -1,126 +1,117 @@
+import argparse
 import subprocess
 import sys
-import importlib_resources
-from pathlib import Path
+import warnings
+from typing import List, Optional
 
-# The consistent name of the JAR file bundled with the package
-_JAR_NAME = "opendataloader-pdf-cli.jar"
+from .cli_options_generated import add_options_to_parser
+from .convert_generated import convert
+from .runner import run_jar
 
+# Re-export for backward compatibility
+__all__ = ["convert", "run", "run_jar", "main"]
 
+
+# Deprecated : Use `convert()` instead. This function will be removed in a future version.
 def run(
     input_path: str,
-    output_folder: str,
-    password: str = None,
-    to_markdown: bool = False,
-    to_annotated_pdf: bool = False,
+    output_folder: Optional[str] = None,
+    password: Optional[str] = None,
+    replace_invalid_chars: Optional[str] = None,
+    generate_markdown: bool = False,
+    generate_html: bool = False,
+    generate_annotated_pdf: bool = False,
     keep_line_breaks: bool = False,
-    find_hidden_text: bool = False,
+    content_safety_off: Optional[str] = None,
     html_in_markdown: bool = False,
     add_image_to_markdown: bool = False,
+    no_json: bool = False,
     debug: bool = False,
+    use_struct_tree: bool = False,
 ):
     """
     Runs the opendataloader-pdf with the given arguments.
 
+    .. deprecated::
+        Use :func:`convert` instead. This function will be removed in a future version.
+
     Args:
         input_path: Path to the input PDF file or folder.
         output_folder: Path to the output folder. Defaults to the input folder.
         password: Password for the PDF file.
-        to_markdown: If True, generates a Markdown output file.
-        to_annotated_pdf: If True, generates an annotated PDF output file.
+        replace_invalid_chars: Character to replace invalid or unrecognized characters (e.g., , \\u0000) with.
+        generate_markdown: If True, generates a Markdown output file.
+        generate_html: If True, generates an HTML output file.
+        generate_annotated_pdf: If True, generates an annotated PDF output file.
         keep_line_breaks: If True, keeps line breaks in the output.
-        find_hidden_text: If True, finds hidden text in the PDF.
         html_in_markdown: If True, uses HTML in the Markdown output.
         add_image_to_markdown: If True, adds images to the Markdown output.
+        no_json: If True, disable the JSON output.
         debug: If True, prints all messages from the CLI to the console during execution.
-
-    Returns:
-        The stdout from the CLI tool if successful.
+        use_struct_tree: If True, enable processing structure tree (disabled by default)
 
     Raises:
         FileNotFoundError: If the 'java' command is not found or input_path is invalid.
         subprocess.CalledProcessError: If the CLI tool returns a non-zero exit code.
     """
-    if not Path(input_path).exists():
-        raise FileNotFoundError(f"Input file or folder not found: {input_path}")
-
-    args = []
-    if output_folder:
-        args.extend(["--folder", output_folder])
-    if password:
-        args.extend(["--password", password])
-    if to_markdown:
-        args.append("--markdown")
-    if to_annotated_pdf:
-        args.append("--pdf")
-    if keep_line_breaks:
-        args.append("--keeplinebreaks")
-    if find_hidden_text:
-        args.append("--findhiddentext")
-    if html_in_markdown:
-        args.append("--htmlinmarkdown")
-    if add_image_to_markdown:
-        args.append("--addimagetomarkdown")
-
-    args.append(input_path)
+    warnings.warn(
+        "run() is deprecated and will be removed in a future version. Use convert() instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
+    # Build format list based on legacy boolean options
+    formats: List[str] = []
+    if not no_json:
+        formats.append("json")
+    if generate_markdown:
+        if add_image_to_markdown:
+            formats.append("markdown-with-images")
+        elif html_in_markdown:
+            formats.append("markdown-with-html")
+        else:
+            formats.append("markdown")
+    if generate_html:
+        formats.append("html")
+    if generate_annotated_pdf:
+        formats.append("pdf")
+
+    convert(
+        input_path=input_path,
+        output_dir=output_folder,
+        password=password,
+        replace_invalid_chars=replace_invalid_chars,
+        keep_line_breaks=keep_line_breaks,
+        content_safety_off=content_safety_off,
+        use_struct_tree=use_struct_tree,
+        format=formats if formats else None,
+        quiet=not debug,
+    )
+
+
+def main(argv=None) -> int:
+    """CLI entry point for running the wrapper from the command line."""
+    parser = argparse.ArgumentParser(
+        description="Run the opendataloader-pdf CLI using the bundled JAR."
+    )
+    parser.add_argument(
+        "input_path", nargs="+", help="Path to the input PDF file or directory."
+    )
+
+    # Register CLI options from auto-generated module
+    add_options_to_parser(parser)
+
+    args = parser.parse_args(argv)
 
     try:
-        # Find the JAR file within the package
-        jar_ref = importlib_resources.files("opendataloader_pdf").joinpath(
-            "jar", _JAR_NAME
-        )
-        with importlib_resources.as_file(jar_ref) as jar_path:
-            command = ["java", "-jar", str(jar_path)] + args
-
-            if debug:
-                print(f"Running command: {' '.join(command)}", file=sys.stderr)
-                process = subprocess.Popen(
-                    command,
-                    stdout=subprocess.PIPE,
-                    stderr=subprocess.STDOUT,
-                    text=True,
-                    encoding="utf-8",
-                )
-
-                output_lines = []
-                for line in iter(process.stdout.readline, ""):
-                    sys.stdout.write(line)
-                    output_lines.append(line)
-
-                process.stdout.close()
-                return_code = process.wait()
-                captured_output = "".join(output_lines)
-
-                if return_code:
-                    # Manually raise error with the combined output
-                    raise subprocess.CalledProcessError(
-                        return_code, command, output=captured_output
-                    )
-                return captured_output
-            else:
-                result = subprocess.run(
-                    command,
-                    capture_output=True,
-                    text=True,
-                    check=True,
-                    encoding="utf-8",
-                )
-                return result.stdout
-
-    except FileNotFoundError:
-        print(
-            "Error: 'java' command not found. Please ensure Java is installed and in your system's PATH.",
-            file=sys.stderr,
-        )
-        raise
-
-    except subprocess.CalledProcessError as e:
-        print("Error running opendataloader-pdf CLI.", file=sys.stderr)
-        print(f"Return code: {e.returncode}", file=sys.stderr)
-        if e.output:
-            print(f"Output: {e.output}", file=sys.stderr)
-        elif e.stderr:
-            print(f"Stderr: {e.stderr}", file=sys.stderr)
-        if e.stdout:
-            print(f"Stdout: {e.stdout}", file=sys.stderr)
-        raise e
+        convert(**vars(args))
+        return 0
+    except FileNotFoundError as err:
+        print(err, file=sys.stderr)
+        return 1
+    except subprocess.CalledProcessError as err:
+        return err.returncode or 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

opendataloader_pdf-1.8.2.dist-info/METADATA

@@ -0,0 +1,361 @@
+Metadata-Version: 2.4
+Name: opendataloader-pdf
+Version: 1.8.2
+Summary: A Python wrapper for the opendataloader-pdf Java CLI.
+Project-URL: Homepage, https://github.com/opendataloader-project/opendataloader-pdf
+Author-email: opendataloader-project <open.dataloader@hancom.com>
+License-Expression: MPL-2.0
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Provides-Extra: hybrid
+Requires-Dist: docling[easyocr]>=2.0.0; extra == 'hybrid'
+Requires-Dist: fastapi>=0.100.0; extra == 'hybrid'
+Requires-Dist: python-multipart>=0.0.6; extra == 'hybrid'
+Requires-Dist: uvicorn>=0.20.0; extra == 'hybrid'
+Description-Content-Type: text/markdown
+
+# OpenDataLoader PDF
+
+**PDF Parsing for RAG** — Convert to Markdown & JSON, Fast, Local, No GPU
+
+[![License](https://img.shields.io/pypi/l/opendataloader-pdf.svg)](https://github.com/opendataloader-project/opendataloader-pdf/blob/main/LICENSE)
+[![PyPI version](https://img.shields.io/pypi/v/opendataloader-pdf.svg)](https://pypi.org/project/opendataloader-pdf/)
+[![npm version](https://img.shields.io/npm/v/@opendataloader/pdf.svg)](https://www.npmjs.com/package/@opendataloader/pdf)
+[![Maven Central](https://img.shields.io/maven-central/v/org.opendataloader/opendataloader-pdf-core.svg)](https://search.maven.org/artifact/org.opendataloader/opendataloader-pdf-core)
+[![GHCR Version](https://ghcr-badge.egpl.dev/opendataloader-project/opendataloader-pdf-cli/latest_tag?trim=major&label=docker)](https://github.com/opendataloader-project/opendataloader-pdf/pkgs/container/opendataloader-pdf-cli)
+[![Java](https://img.shields.io/badge/Java-11%2B-blue.svg)](https://github.com/opendataloader-project/opendataloader-pdf#java)
+
+Convert PDFs into **LLM-ready Markdown and JSON** with accurate reading order, table extraction, and bounding boxes — all running locally on your machine.
+
+**Why developers choose OpenDataLoader:**
+- **Deterministic** — Same input always produces same output (no LLM hallucinations)
+- **Fast** — Process 100+ pages per second on CPU
+- **Private** — 100% local, zero data transmission
+- **Accurate** — Bounding boxes for every element, correct multi-column reading order
+
+```bash
+pip install -U opendataloader-pdf
+```
+
+```python
+import opendataloader_pdf
+
+# PDF to Markdown for RAG
+opendataloader_pdf.convert(
+    input_path="document.pdf",
+    output_dir="output/",
+    format="markdown,json"
+)
+```
+
+<br/>
+
+## Why OpenDataLoader?
+
+Building RAG pipelines? You've probably hit these problems:
+
+| Problem | How We Solve It |
+|---------|-----------------|
+| **Multi-column text reads left-to-right incorrectly** | XY-Cut++ algorithm preserves correct reading order |
+| **Tables lose structure** | Border + cluster detection keeps rows/columns intact |
+| **Headers/footers pollute context** | Auto-filtered before output |
+| **No coordinates for citations** | Bounding box for every element |
+| **Cloud APIs = privacy concerns** | 100% local, no data leaves your machine |
+| **GPU required** | Pure CPU, rule-based — runs anywhere |
+
+<br/>
+
+## Key Features
+
+### For RAG & LLM Pipelines
+
+- **Structured Output** — JSON with semantic types (heading, paragraph, table, list, caption)
+- **Bounding Boxes** — Every element includes `[x1, y1, x2, y2]` coordinates for citations
+- **Reading Order** — XY-Cut++ algorithm handles multi-column layouts correctly
+- **Noise Filtering** — Headers, footers, hidden text, watermarks auto-removed
+- **LangChain Integration** — [Official document loader](https://python.langchain.com/docs/integrations/document_loaders/opendataloader_pdf/)
+
+### Performance & Privacy
+
+- **No GPU** — Fast, rule-based heuristics
+- **Local-First** — Your documents never leave your machine
+- **High Throughput** — Process thousands of PDFs efficiently
+- **Multi-Language SDK** — Python, Node.js, Java, Docker
+
+### Document Understanding
+
+- **Tables** — Detects borders, handles merged cells
+- **Lists** — Numbered, bulleted, nested
+- **Headings** — Auto-detects hierarchy levels
+- **Images** — Extracts with captions linked
+- **Tagged PDF Support** — Uses native PDF structure when available
+- **AI Safety** — Auto-filters prompt injection content
+
+<br/>
+
+## Output Formats
+
+| Format | Use Case |
+|--------|----------|
+| **JSON** | Structured data with bounding boxes, semantic types |
+| **Markdown** | Clean text for LLM context, RAG chunks |
+| **HTML** | Web display with styling |
+| **Annotated PDF** | Visual debugging — see detected structures ([sample](https://opendataloader.org/demo/samples/01030000000000?view1=annot&view2=json)) |
+
+<br/>
+
+## JSON Output Example
+
+```json
+{
+  "type": "heading",
+  "id": 42,
+  "level": "Title",
+  "page number": 1,
+  "bounding box": [72.0, 700.0, 540.0, 730.0],
+  "heading level": 1,
+  "font": "Helvetica-Bold",
+  "font size": 24.0,
+  "text color": "[0.0]",
+  "content": "Introduction"
+}
+```
+
+| Field | Description |
+|-------|-------------|
+| `type` | Element type: heading, paragraph, table, list, image, caption |
+| `id` | Unique identifier for cross-referencing |
+| `page number` | 1-indexed page reference |
+| `bounding box` | `[left, bottom, right, top]` in PDF points |
+| `heading level` | Heading depth (1+) |
+| `font`, `font size` | Typography info |
+| `content` | Extracted text |
+
+[Full JSON Schema →](https://opendataloader.org/docs/json-schema)
+
+<br/>
+
+## Quick Start
+
+- [Python](https://opendataloader.org/docs/quick-start-python)
+- [Node.js / TypeScript](https://opendataloader.org/docs/quick-start-nodejs)
+- [Docker](https://opendataloader.org/docs/quick-start-docker)
+- [Java](https://opendataloader.org/docs/quick-start-java)
+
+<br/>
+
+## Advanced Options
+
+```python
+opendataloader_pdf.convert(
+    input_path="document.pdf",
+    output_dir="output/",
+    format="json,markdown,pdf",
+
+    # Image output mode: "off", "embedded" (Base64), or "external" (default)
+    image_output="embedded",
+
+    # Image format: "png" or "jpeg"
+    image_format="jpeg",
+
+    # Tagged PDF
+    use_struct_tree=True,            # Use native PDF structure
+)
+```
+
+[Full CLI Options Reference →](https://opendataloader.org/docs/cli-options-reference)
+
+<br/>
+
+## AI Safety
+
+PDFs can contain hidden prompt injection attacks. OpenDataLoader automatically filters:
+
+- Hidden text (transparent, zero-size)
+- Off-page content
+- Suspicious invisible layers
+
+This is **enabled by default**. [Learn more →](https://opendataloader.org/docs/ai-safety)
+
+<br/>
+
+## Tagged PDF Support
+
+**Why it matters:** The [European Accessibility Act (EAA)](https://commission.europa.eu/strategy-and-policy/policies/justice-and-fundamental-rights/disability/union-equality-strategy-rights-persons-disabilities-2021-2030/european-accessibility-act_en) took effect June 28, 2025, requiring accessible digital documents across the EU. This means more PDFs will be properly tagged with semantic structure.
+
+**OpenDataLoader leverages this:**
+
+- When a PDF has structure tags, we extract the **exact layout** the author intended
+- Headings, lists, tables, reading order — all preserved from the source
+- No guessing, no heuristics needed — **pixel-perfect semantic extraction**
+
+```python
+opendataloader_pdf.convert(
+    input_path="accessible_document.pdf",
+    use_struct_tree=True  # Use native PDF structure tags
+)
+```
+
+Most PDF parsers ignore structure tags entirely. We're one of the few that fully support them.
+
+[Learn more about Tagged PDF →](https://opendataloader.org/docs/tagged-pdf)
+
+<br/>
+
+## Hybrid Mode
+
+For documents with complex tables or OCR needs, enable hybrid mode to route challenging pages to an AI backend while keeping simple pages fast and local.
+
+**Results**: Table accuracy jumps from 0.49 → 0.93 (+90%) with acceptable speed trade-off.
+
+```bash
+pip install -U "opendataloader-pdf[hybrid]"
+```
+
+Terminal 1: Start the backend server
+
+```bash
+opendataloader-pdf-hybrid --port 5002
+```
+
+Terminal 2: Process PDFs with hybrid mode
+
+```bash
+opendataloader-pdf --hybrid docling-fast input.pdf
+```
+
+Or use in Python:
+
+```python
+opendataloader_pdf.convert(
+    input_path="complex_tables.pdf",
+    output_dir="output/",
+    hybrid="docling-fast"  # Routes complex pages to AI backend
+)
+```
+
+- **Local-first**: Simple pages processed locally, complex pages routed to backend
+- **Fallback**: If backend unavailable, gracefully falls back to local processing
+- **Privacy**: Run the backend locally in Docker for 100% on-premise
+
+[Hybrid Mode Guide →](https://opendataloader.org/docs/hybrid-mode)
+
+<br/>
+
+## LangChain Integration
+
+OpenDataLoader PDF has an official LangChain integration for seamless RAG pipeline development.
+
+```bash
+pip install -U langchain-opendataloader-pdf
+```
+
+```python
+from langchain_opendataloader_pdf import OpenDataLoaderPDFLoader
+
+loader = OpenDataLoaderPDFLoader(
+    file_path=["document.pdf"],
+    format="text"
+)
+documents = loader.load()
+
+# Use with any LangChain pipeline
+for doc in documents:
+    print(doc.page_content[:100])
+```
+
+- [LangChain Documentation](https://python.langchain.com/docs/integrations/document_loaders/opendataloader_pdf/)
+- [GitHub Repository](https://github.com/opendataloader-project/langchain-opendataloader-pdf)
+- [PyPI Package](https://pypi.org/project/langchain-opendataloader-pdf/)
+
+<br/>
+
+## Benchmarks
+
+We continuously benchmark against real-world documents.
+
+[View full benchmark results →](https://github.com/opendataloader-project/opendataloader-bench)
+
+### Quick Comparison
+
+| Engine                      | Overall  | Reading Order | Table    | Heading  | Speed (s/page) |
+|-----------------------------|----------|---------------|----------|----------|----------------|
+| **opendataloader**          | 0.68     | 0.91          | 0.49     | 0.65     | **0.05**       |
+| **opendataloader [hybrid]** | **0.88** | **0.93**      | **0.93** | 0.78     | 0.48           |
+| docling                     | 0.86     | 0.90          | 0.89     | **0.80** | 0.73           |
+| marker                      | 0.83     | 0.89          | 0.81     | **0.80** | 53.93          |
+| mineru                      | 0.82     | 0.86          | 0.87     | 0.74     | 5.96           |
+| pymupdf4llm                 | 0.57     | 0.89          | 0.40     | 0.41     | 0.09           |
+| markitdown                  | 0.29     | 0.88          | 0.00     | 0.00     | **0.04**       |
+
+> Scores are normalized to [0, 1]. Higher is better for accuracy metrics; lower is better for speed. **Bold** indicates best performance.
+
+### Visual Comparison
+
+[![Benchmark](https://github.com/opendataloader-project/opendataloader-bench/raw/refs/heads/main/charts/benchmark.png)](https://github.com/opendataloader-project/opendataloader-bench)
+
+
+<br/>
+
+## Roadmap
+
+See our [upcoming features and priorities →](https://opendataloader.org/docs/upcoming-roadmap)
+
+<br/>
+
+## Documentation
+
+- [Quick Start Guide](https://opendataloader.org/docs/quick-start-python)
+- [JSON Schema Reference](https://opendataloader.org/docs/json-schema)
+- [CLI Options](https://opendataloader.org/docs/cli-options-reference)
+- [Tagged PDF Support](https://opendataloader.org/docs/tagged-pdf)
+- [AI Safety Features](https://opendataloader.org/docs/ai-safety)
+
+<br/>
+
+## Frequently Asked Questions
+
+### What is the best PDF parser for RAG?
+
+For RAG pipelines, you need a parser that preserves document structure, maintains correct reading order, and provides element coordinates for citations. OpenDataLoader is designed specifically for this use case — it outputs structured JSON with bounding boxes, handles multi-column layouts correctly with XY-Cut++, and runs locally without GPU requirements.
+
+### How do I extract tables from PDF for LLM?
+
+OpenDataLoader detects tables using both border analysis and text clustering, preserving row/column structure in the output. Tables are exported as structured data in JSON or as formatted Markdown tables, ready for LLM consumption.
+
+### Can I use this without sending data to the cloud?
+
+Yes. OpenDataLoader runs 100% locally on your machine. No API calls, no data transmission — your documents never leave your environment. This makes it ideal for sensitive documents in legal, healthcare, and financial industries.
+
+### What makes OpenDataLoader unique?
+
+OpenDataLoader takes a different approach from many PDF parsers:
+
+- **Rule-based extraction** — Deterministic output without GPU requirements
+- **Bounding boxes for all elements** — Essential for citation systems
+- **XY-Cut++ reading order** — Handles multi-column layouts correctly
+- **Built-in AI safety filters** — Protects against prompt injection
+- **Native Tagged PDF support** — Leverages accessibility metadata
+
+This means: consistent output (same input = same output), no GPU required, faster processing, and no model hallucinations.
+
+### How do I get better accuracy for complex tables?
+
+Enable hybrid mode with `pip install -U "opendataloader-pdf[hybrid]"`. This routes pages with complex tables to an AI backend (like docling-serve) while keeping simple pages fast and local. Table accuracy improves from 0.49 to 0.93 — matching or exceeding dedicated AI parsers while remaining faster and more cost-effective.
+
+<br/>
+
+## Contributing
+
+We welcome contributions! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+<br/>
+
+## License
+
+[Mozilla Public License 2.0](LICENSE)
+
+---
+
+**Found this useful?** Give us a star to help others discover OpenDataLoader.

{opendataloader_pdf-0.0.0.dist-info → opendataloader_pdf-1.8.2.dist-info}/RECORD

@@ -1,7 +1,12 @@
 opendataloader_pdf/LICENSE,sha256=rxdbnZbuk8IaA2FS4bkFsLlTBNSujCySHHYJEAuo334,15921
-opendataloader_pdf/NOTICE.md,sha256=Uxc6sEbVz2hfsDinzzSNMtmsjx9HsQUod0yy0cswUwg,562
-opendataloader_pdf/__init__.py,sha256=T5RV-dcgjNCm8klNy_EH-IgOeodcPg6Yc34HHXtuAmQ,44
-opendataloader_pdf/wrapper.py,sha256=ahbxo7YYunsNt3w66eXn_oa0XKy1LLfoA5GQcSuMvvM,4407
+opendataloader_pdf/NOTICE.md,sha256=KKi_EHvEr5PHlWqtQ-IF-S0luNdVUjdVGkWmXtgDr3c,567
+opendataloader_pdf/__init__.py,sha256=fdiSf1klK66Nr_gAeKXC86YVMPu3f4wt9e6WDcy4Hio,84
+opendataloader_pdf/__main__.py,sha256=lmla4yz3SaYBfRJXOXnwO_8ID31-Ja20aQmomiz1eEc,84
+opendataloader_pdf/cli_options_generated.py,sha256=207MSvhFzLFrh99lLLvR6DcLC32IOH8IB_F7bc_rOHc,7537
+opendataloader_pdf/convert_generated.py,sha256=0A6_wIatkQpHvbGVmT5COGS6n-cn1C7KFUxdb7zffoQ,5869
+opendataloader_pdf/hybrid_server.py,sha256=p_wV_Wi-waEwZpa__5-gBfsRhLfdLF6vzKQcbOpD3cE,8445
+opendataloader_pdf/runner.py,sha256=hJPSGZyZ2UcULh-ZpIwN7Sh2sjk_Q_3cJsRMC-tnTO8,2494
+opendataloader_pdf/wrapper.py,sha256=2a47-EhuJ_na-U5URNCK9DB2EomzV3qClslRvwgsPy8,4020
 opendataloader_pdf/THIRD_PARTY/THIRD_PARTY_LICENSES.md,sha256=QRYYiXFS2zBDGdmWRo_SrRfGhrdRBwhiRo1SdUKfrQo,11235
 opendataloader_pdf/THIRD_PARTY/THIRD_PARTY_NOTICES.md,sha256=pB2ZitFM1u0x3rIDpMHsLxOe4OFNCZRqkzeR-bfpFzE,8911
 opendataloader_pdf/THIRD_PARTY/licenses/Apache-2.0.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
@@ -13,8 +18,8 @@ opendataloader_pdf/THIRD_PARTY/licenses/LICENSE-JJ2000.txt,sha256=itSesIy3XiNWgJ
 opendataloader_pdf/THIRD_PARTY/licenses/MIT.txt,sha256=JPCdbR3BU0uO_KypOd3sGWnKwlVHGq4l0pmrjoGtop8,1078
 opendataloader_pdf/THIRD_PARTY/licenses/MPL-2.0.txt,sha256=CGF6Fx5WV7DJmRZJ8_6w6JEt2N9bu4p6zDo18fTHHRw,15818
 opendataloader_pdf/THIRD_PARTY/licenses/Plexus Classworlds License.txt,sha256=ZQuKXwVz4FeC34ApB20vYg8kPTwgIUKRzEk5ew74-hU,1937
-opendataloader_pdf/jar/opendataloader-pdf-cli.jar,sha256=jUVcuDXxNBFweOQbusLebCX1AZ3l3ssns4nJtSWsRTI,22116373
-opendataloader_pdf-0.0.0.dist-info/METADATA,sha256=y-T7UA9NodfcETSd2tX5FJdXMNArmpgXZG22wINIHRo,3382
-opendataloader_pdf-0.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-opendataloader_pdf-0.0.0.dist-info/top_level.txt,sha256=xee0qFQd6HPfS50E2NLICGuR6cq9C9At5SJ81yv5HkY,19
-opendataloader_pdf-0.0.0.dist-info/RECORD,,
+opendataloader_pdf/jar/opendataloader-pdf-cli.jar,sha256=BIiShJd5yfr7fqXi_f5bJWA5L5P4JgsoyKerC_3siuo,23819110
+opendataloader_pdf-1.8.2.dist-info/METADATA,sha256=wWrKyJ52avv_xa6swj4k6SGN_gxyk4dMNq6JmcqCOvw,13418
+opendataloader_pdf-1.8.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+opendataloader_pdf-1.8.2.dist-info/entry_points.txt,sha256=svIY_pCftFm2_nca5m0RVtPtdpQ_uj5KTEuZS5TR0DQ,137
+opendataloader_pdf-1.8.2.dist-info/RECORD,,