pdfmark-ocr 0.1.0__tar.gz

pdfmark_ocr-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ather
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pdfmark_ocr-0.1.0/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: pdfmark-ocr
+Version: 0.1.0
+Summary: Fast, fully-local PDF to Markdown converter with image OCR. No API calls, runs 100% offline.
+Author: Ather
+License: MIT
+Project-URL: Homepage, https://github.com/yourname/pdfmark-ocr
+Project-URL: Issues, https://github.com/yourname/pdfmark-ocr/issues
+Keywords: pdf,markdown,ocr,convert,rapidocr,offline,local
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyMuPDF>=1.23
+Requires-Dist: pillow>=9.0
+Requires-Dist: rapidocr_onnxruntime>=1.3
+Provides-Extra: easyocr
+Requires-Dist: easyocr>=1.7; extra == "easyocr"
+Requires-Dist: torch>=2.0; extra == "easyocr"
+Dynamic: license-file
+
+# pdfmark-ocr
+
+**Fast, fully-local PDF → Markdown — with OCR for images.** No API calls, no
+cloud, nothing leaves your machine.
+
+Microsoft's `markitdown` only reads native text; if a PDF page is a scan or has
+text inside images, you lose it. `pdfmark-ocr` reads native text directly (instant)
+**and** runs OCR on embedded images, in parallel across your CPU cores.
+
+## Install
+
+```bash
+pip install pdfmark-ocr
+```
+
+That's it — works on **Windows, macOS, and Linux** (Python 3.9+). The default OCR
+engine is [RapidOCR](https://github.com/RapidAI/RapidOCR) (ONNX, fast, small).
+
+## Usage
+
+```bash
+pdf2md document.pdf                       # -> full_stitched_output.md
+pdf2md document.pdf -o notes.md           # choose output file
+pdf2md document.pdf --workers 4           # control parallelism
+pdf2md document.pdf --min-image 0         # OCR every image, even tiny ones
+```
+
+You can also run it as a module:
+
+```bash
+python -m pdf2md_ocr document.pdf
+```
+
+### Options
+
+| Flag | Default | Meaning |
+|------|---------|---------|
+| `-o, --output` | `full_stitched_output.md` | Output markdown path |
+| `--engine` | `rapidocr` | `rapidocr` (default) or `easyocr` |
+| `--workers` | auto | Parallel page workers |
+| `--max-dim` | `1500` | Downscale images larger than this (px) |
+| `--min-image` | `16` | Skip images smaller than this (px); `0` keeps all |
+
+## Optional: EasyOCR engine
+
+EasyOCR is heavier (pulls in PyTorch, hundreds of MB) but you may prefer its
+accuracy on some documents:
+
+```bash
+pip install "pdfmark-ocr[easyocr]"
+pdf2md document.pdf --engine easyocr
+```
+
+## How it works
+
+1. **Native text** is extracted directly from the PDF — instant, no OCR.
+2. **Embedded images** are downscaled and sent to the chosen OCR engine.
+3. Pages are processed **in parallel**, one OCR engine per worker process.
+4. A per-worker cache means repeated logos/headers are OCR'd only once.
+
+## Use from Python
+
+```python
+from pdf2md_ocr import stitch_full_pdf
+
+stitch_full_pdf("document.pdf", "out.md", engine="rapidocr")
+```
+
+## License
+
+MIT

pdfmark_ocr-0.1.0/README.md

@@ -0,0 +1,71 @@
+# pdfmark-ocr
+
+**Fast, fully-local PDF → Markdown — with OCR for images.** No API calls, no
+cloud, nothing leaves your machine.
+
+Microsoft's `markitdown` only reads native text; if a PDF page is a scan or has
+text inside images, you lose it. `pdfmark-ocr` reads native text directly (instant)
+**and** runs OCR on embedded images, in parallel across your CPU cores.
+
+## Install
+
+```bash
+pip install pdfmark-ocr
+```
+
+That's it — works on **Windows, macOS, and Linux** (Python 3.9+). The default OCR
+engine is [RapidOCR](https://github.com/RapidAI/RapidOCR) (ONNX, fast, small).
+
+## Usage
+
+```bash
+pdf2md document.pdf                       # -> full_stitched_output.md
+pdf2md document.pdf -o notes.md           # choose output file
+pdf2md document.pdf --workers 4           # control parallelism
+pdf2md document.pdf --min-image 0         # OCR every image, even tiny ones
+```
+
+You can also run it as a module:
+
+```bash
+python -m pdf2md_ocr document.pdf
+```
+
+### Options
+
+| Flag | Default | Meaning |
+|------|---------|---------|
+| `-o, --output` | `full_stitched_output.md` | Output markdown path |
+| `--engine` | `rapidocr` | `rapidocr` (default) or `easyocr` |
+| `--workers` | auto | Parallel page workers |
+| `--max-dim` | `1500` | Downscale images larger than this (px) |
+| `--min-image` | `16` | Skip images smaller than this (px); `0` keeps all |
+
+## Optional: EasyOCR engine
+
+EasyOCR is heavier (pulls in PyTorch, hundreds of MB) but you may prefer its
+accuracy on some documents:
+
+```bash
+pip install "pdfmark-ocr[easyocr]"
+pdf2md document.pdf --engine easyocr
+```
+
+## How it works
+
+1. **Native text** is extracted directly from the PDF — instant, no OCR.
+2. **Embedded images** are downscaled and sent to the chosen OCR engine.
+3. Pages are processed **in parallel**, one OCR engine per worker process.
+4. A per-worker cache means repeated logos/headers are OCR'd only once.
+
+## Use from Python
+
+```python
+from pdf2md_ocr import stitch_full_pdf
+
+stitch_full_pdf("document.pdf", "out.md", engine="rapidocr")
+```
+
+## License
+
+MIT

pdfmark_ocr-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pdfmark-ocr"
+version = "0.1.0"
+description = "Fast, fully-local PDF to Markdown converter with image OCR. No API calls, runs 100% offline."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Ather" }]
+keywords = ["pdf", "markdown", "ocr", "convert", "rapidocr", "offline", "local"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Text Processing :: Markup :: Markdown",
+    "Topic :: Utilities",
+]
+
+# Default install is light: native PDF text + the fast ONNX OCR engine.
+dependencies = [
+    "PyMuPDF>=1.23",          # PDF parsing: native text + embedded image extraction
+    "pillow>=9.0",            # image downscaling
+    "rapidocr_onnxruntime>=1.3",  # fast CPU OCR engine (default), uses onnxruntime
+]
+
+[project.optional-dependencies]
+# Heavier alternative engine: pip install "pdfmark-ocr[easyocr]"
+easyocr = ["easyocr>=1.7", "torch>=2.0"]
+
+[project.urls]
+Homepage = "https://github.com/yourname/pdfmark-ocr"
+Issues = "https://github.com/yourname/pdfmark-ocr/issues"
+
+[project.scripts]
+pdf2md = "pdf2md_ocr.converter:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

pdfmark_ocr-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pdfmark_ocr-0.1.0/src/pdf2md_ocr/__init__.py

@@ -0,0 +1,6 @@
+"""pdfmark-ocr: fast, fully-local PDF -> Markdown with image OCR."""
+
+from .converter import stitch_full_pdf, main
+
+__version__ = "0.1.0"
+__all__ = ["stitch_full_pdf", "main", "__version__"]

pdfmark_ocr-0.1.0/src/pdf2md_ocr/__main__.py

@@ -0,0 +1,6 @@
+"""Allow `python -m pdf2md_ocr file.pdf`."""
+
+from .converter import main
+
+if __name__ == "__main__":
+    main()

pdfmark_ocr-0.1.0/src/pdf2md_ocr/converter.py

@@ -0,0 +1,245 @@
+"""
+pdf2md_ocr.converter  --  Fast, fully-local PDF -> Markdown
+
+Native text is read directly from the PDF (instant). Only embedded IMAGES are
+sent to OCR. Speed comes from:
+
+  1. Engine choice at runtime:  --engine rapidocr  (ONNX, fastest on CPU)
+                                --engine easyocr   (optional, pip install pdfmark-ocr[easyocr])
+  2. Parallel page processing across CPU cores (one OCR engine per worker).
+  3. A per-worker image cache so repeated logos/headers are OCR'd only once.
+  4. Image downscaling + thread tuning + EasyOCR canvas/quantization.
+
+Everything runs locally. No API calls, no data leaves the machine.
+"""
+
+import os
+import io
+import ssl
+import time
+import hashlib
+import argparse
+from multiprocessing import Pool
+
+# --- PROXY / SSL OVERRIDE ---
+try:
+    if not os.environ.get('PYTHONHTTPSVERIFY', '') and getattr(ssl, '_create_unverified_context', None):
+        ssl._create_default_https_context = ssl._create_unverified_context
+except Exception:
+    pass
+# ----------------------------
+
+# ============================================================================
+# OCR ENGINE ABSTRACTION
+# Both engines take PNG bytes and return a list[str] of text lines, so the rest
+# of the pipeline doesn't care which one is used.
+# ============================================================================
+
+def build_engine(name, threads):
+    """Create an OCR engine. Called once per process (heavy)."""
+    if name == "rapidocr":
+        try:
+            from rapidocr_onnxruntime import RapidOCR
+        except ImportError as e:
+            raise SystemExit(
+                "rapidocr is not installed. Run:  pip install pdfmark-ocr"
+            ) from e
+        try:
+            eng = RapidOCR(intra_op_num_threads=threads, inter_op_num_threads=1)
+        except TypeError:                      # older rapidocr without these kwargs
+            eng = RapidOCR()
+        return ("rapidocr", eng)
+
+    if name == "easyocr":
+        try:
+            import torch
+            import easyocr
+        except ImportError as e:
+            raise SystemExit(
+                "easyocr is not installed. Run:  pip install \"pdfmark-ocr[easyocr]\""
+            ) from e
+        torch.set_num_threads(max(1, threads))
+        # quantize=True -> int8 CPU inference (faster). verbose=False -> quiet.
+        reader = easyocr.Reader(['en'], gpu=False, quantize=True,
+                                verbose=False, download_enabled=True)
+        return ("easyocr", reader)
+
+    raise ValueError(f"unknown engine: {name}")
+
+
+def run_ocr(engine, img_bytes, max_dim):
+    """Run OCR on PNG bytes, return list[str] of detected lines."""
+    name, eng = engine
+    if name == "rapidocr":
+        result, _ = eng(img_bytes)
+        return [line[1] for line in result] if result else []
+    # easyocr -- cap canvas at our downscale size so it doesn't re-upscale
+    return eng.readtext(img_bytes, detail=0, canvas_size=max_dim, mag_ratio=1.0)
+
+
+# ============================================================================
+# PER-PAGE WORKER
+# Each worker process opens the PDF once and keeps its own engine + image cache.
+# ============================================================================
+
+_W = {}  # per-process state: engine, doc, config, cache
+
+
+def _init_worker(pdf_path, engine_name, threads, max_dim, min_image):
+    # Limit BLAS/OMP threads BEFORE the engine builds its thread pools, so N
+    # workers x threads doesn't oversubscribe the CPU.
+    for var in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS"):
+        os.environ[var] = str(max(1, threads))
+    import fitz
+    _W["engine"] = build_engine(engine_name, threads)
+    _W["doc"] = fitz.open(pdf_path)
+    _W["max_dim"] = max_dim
+    _W["min_image"] = min_image
+    _W["cache"] = {}            # md5(img_bytes) -> ocr text (skip duplicates)
+
+
+def _ocr_image_block(block):
+    """OCR one image block, with downscale + dedup cache. Returns markdown str."""
+    width = block.get("width", 0)
+    height = block.get("height", 0)
+    if width < _W["min_image"] or height < _W["min_image"]:
+        return None  # skip tiny logos/icons
+
+    img_bytes = block["image"]
+    key = hashlib.md5(img_bytes).digest()
+    if key in _W["cache"]:                      # same image seen before
+        ocr_text = _W["cache"][key]
+    else:
+        from PIL import Image
+        max_dim = _W["max_dim"]
+        try:
+            img = Image.open(io.BytesIO(img_bytes))
+            if img.width > max_dim or img.height > max_dim:
+                img.thumbnail((max_dim, max_dim), Image.Resampling.LANCZOS)
+                buf = io.BytesIO()
+                img.save(buf, format="PNG")
+                img_bytes = buf.getvalue()
+            lines = run_ocr(_W["engine"], img_bytes, max_dim)
+            ocr_text = "\n".join(lines).strip()
+        except Exception as e:
+            return f"> **[Error processing image]** ({e})"
+        _W["cache"][key] = ocr_text
+
+    if ocr_text:
+        body = ocr_text.replace("\n", "\n> ")
+        return f"> **[Extracted from Image]**\n> {body}"
+    return "> **[Image contained no readable text]**"
+
+
+def _process_page(page_num):
+    """Build markdown for a single page. Returns (page_num, markdown, n_imgs)."""
+    page = _W["doc"][page_num]
+    parts = [f"\n## Page {page_num + 1}\n"]
+    n_imgs = 0
+
+    blocks = page.get_text("dict")["blocks"]
+    blocks.sort(key=lambda b: b["bbox"][1])     # top-to-bottom reading order
+
+    for block in blocks:
+        if block["type"] == 0:                  # native text
+            text = ""
+            for line in block["lines"]:
+                for span in line["spans"]:
+                    text += span["text"] + " "
+                text += "\n"
+            parts.append(text.strip())
+        elif block["type"] == 1:                # image
+            md = _ocr_image_block(block)
+            if md is not None:
+                n_imgs += 1
+                parts.append(md)
+
+    parts.append("\n---\n")
+    return page_num, "\n\n".join(parts), n_imgs
+
+
+# ============================================================================
+# DRIVER
+# ============================================================================
+
+def stitch_full_pdf(pdf_path, output_name="full_stitched_output.md",
+                    engine="rapidocr", workers=None, max_dim=1500, min_image=16):
+    if not os.path.exists(pdf_path):
+        print(f"Error: Cannot find '{pdf_path}'")
+        return
+
+    import fitz
+    total_start = time.perf_counter()
+
+    doc = fitz.open(pdf_path)
+    total_pages = len(doc)
+    doc.close()
+
+    cpu = os.cpu_count() or 4
+    if workers is None:
+        workers = min(cpu, total_pages)
+    workers = max(1, min(workers, total_pages))
+    threads = max(1, cpu // workers)            # split cores across workers
+
+    print(f"--- ENGINE: {engine} | pages: {total_pages} | "
+          f"workers: {workers} x {threads} threads ---")
+
+    header = f"# Full Extraction: {os.path.basename(pdf_path)}\n"
+    results = []
+
+    if workers == 1:
+        # Sequential: avoid process-spawn overhead for small PDFs.
+        _init_worker(pdf_path, engine, threads, max_dim, min_image)
+        print("[init] engine ready")
+        for pn in range(total_pages):
+            ps = time.perf_counter()
+            results.append(_process_page(pn))
+            print(f"  page {pn + 1}/{total_pages} done "
+                  f"[{time.perf_counter() - ps:.2f}s, {results[-1][2]} imgs]")
+    else:
+        with Pool(workers, initializer=_init_worker,
+                  initargs=(pdf_path, engine, threads, max_dim, min_image)) as pool:
+            for pn, md, n_imgs in pool.imap_unordered(_process_page,
+                                                      range(total_pages)):
+                results.append((pn, md, n_imgs))
+                print(f"  page {pn + 1}/{total_pages} done [{n_imgs} imgs] "
+                      f"({len(results)}/{total_pages})")
+
+    results.sort(key=lambda r: r[0])            # restore page order
+    final_md = header + "\n\n".join(r[1] for r in results)
+
+    with open(output_name, "w", encoding="utf-8") as f:
+        f.write(final_md)
+
+    total_imgs = sum(r[2] for r in results)
+    elapsed = time.perf_counter() - total_start
+    print(f"\nSaved -> {output_name}")
+    print(f"Pages: {total_pages} | Images OCR'd: {total_imgs} | "
+          f"TOTAL: {elapsed:.2f}s ({elapsed / max(1, total_pages):.2f}s/page)")
+
+
+def main():
+    p = argparse.ArgumentParser(
+        prog="pdf2md",
+        description="Fast local PDF -> Markdown (native text + image OCR). Runs fully offline.",
+    )
+    p.add_argument("pdf", help="input PDF file")
+    p.add_argument("-o", "--output", default="full_stitched_output.md",
+                   help="output markdown file (default: full_stitched_output.md)")
+    p.add_argument("--engine", choices=["rapidocr", "easyocr"], default="rapidocr",
+                   help="OCR engine (default: rapidocr; easyocr needs the [easyocr] extra)")
+    p.add_argument("--workers", type=int, default=None,
+                   help="parallel page workers (default: auto)")
+    p.add_argument("--max-dim", type=int, default=1500,
+                   help="downscale images larger than this (px)")
+    p.add_argument("--min-image", type=int, default=16,
+                   help="skip images smaller than this (px); use 0 to keep all")
+    args = p.parse_args()
+
+    stitch_full_pdf(args.pdf, args.output, engine=args.engine,
+                    workers=args.workers, max_dim=args.max_dim,
+                    min_image=args.min_image)
+
+
+if __name__ == "__main__":      # required for multiprocessing on Windows
+    main()

pdfmark_ocr-0.1.0/src/pdfmark_ocr.egg-info/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: pdfmark-ocr
+Version: 0.1.0
+Summary: Fast, fully-local PDF to Markdown converter with image OCR. No API calls, runs 100% offline.
+Author: Ather
+License: MIT
+Project-URL: Homepage, https://github.com/yourname/pdfmark-ocr
+Project-URL: Issues, https://github.com/yourname/pdfmark-ocr/issues
+Keywords: pdf,markdown,ocr,convert,rapidocr,offline,local
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyMuPDF>=1.23
+Requires-Dist: pillow>=9.0
+Requires-Dist: rapidocr_onnxruntime>=1.3
+Provides-Extra: easyocr
+Requires-Dist: easyocr>=1.7; extra == "easyocr"
+Requires-Dist: torch>=2.0; extra == "easyocr"
+Dynamic: license-file
+
+# pdfmark-ocr
+
+**Fast, fully-local PDF → Markdown — with OCR for images.** No API calls, no
+cloud, nothing leaves your machine.
+
+Microsoft's `markitdown` only reads native text; if a PDF page is a scan or has
+text inside images, you lose it. `pdfmark-ocr` reads native text directly (instant)
+**and** runs OCR on embedded images, in parallel across your CPU cores.
+
+## Install
+
+```bash
+pip install pdfmark-ocr
+```
+
+That's it — works on **Windows, macOS, and Linux** (Python 3.9+). The default OCR
+engine is [RapidOCR](https://github.com/RapidAI/RapidOCR) (ONNX, fast, small).
+
+## Usage
+
+```bash
+pdf2md document.pdf                       # -> full_stitched_output.md
+pdf2md document.pdf -o notes.md           # choose output file
+pdf2md document.pdf --workers 4           # control parallelism
+pdf2md document.pdf --min-image 0         # OCR every image, even tiny ones
+```
+
+You can also run it as a module:
+
+```bash
+python -m pdf2md_ocr document.pdf
+```
+
+### Options
+
+| Flag | Default | Meaning |
+|------|---------|---------|
+| `-o, --output` | `full_stitched_output.md` | Output markdown path |
+| `--engine` | `rapidocr` | `rapidocr` (default) or `easyocr` |
+| `--workers` | auto | Parallel page workers |
+| `--max-dim` | `1500` | Downscale images larger than this (px) |
+| `--min-image` | `16` | Skip images smaller than this (px); `0` keeps all |
+
+## Optional: EasyOCR engine
+
+EasyOCR is heavier (pulls in PyTorch, hundreds of MB) but you may prefer its
+accuracy on some documents:
+
+```bash
+pip install "pdfmark-ocr[easyocr]"
+pdf2md document.pdf --engine easyocr
+```
+
+## How it works
+
+1. **Native text** is extracted directly from the PDF — instant, no OCR.
+2. **Embedded images** are downscaled and sent to the chosen OCR engine.
+3. Pages are processed **in parallel**, one OCR engine per worker process.
+4. A per-worker cache means repeated logos/headers are OCR'd only once.
+
+## Use from Python
+
+```python
+from pdf2md_ocr import stitch_full_pdf
+
+stitch_full_pdf("document.pdf", "out.md", engine="rapidocr")
+```
+
+## License
+
+MIT

pdfmark_ocr-0.1.0/src/pdfmark_ocr.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/pdf2md_ocr/__init__.py
+src/pdf2md_ocr/__main__.py
+src/pdf2md_ocr/converter.py
+src/pdfmark_ocr.egg-info/PKG-INFO
+src/pdfmark_ocr.egg-info/SOURCES.txt
+src/pdfmark_ocr.egg-info/dependency_links.txt
+src/pdfmark_ocr.egg-info/entry_points.txt
+src/pdfmark_ocr.egg-info/requires.txt
+src/pdfmark_ocr.egg-info/top_level.txt

pdfmark_ocr-0.1.0/src/pdfmark_ocr.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pdfmark_ocr-0.1.0/src/pdfmark_ocr.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pdf2md = pdf2md_ocr.converter:main

pdfmark_ocr-0.1.0/src/pdfmark_ocr.egg-info/requires.txt

@@ -0,0 +1,7 @@
+PyMuPDF>=1.23
+pillow>=9.0
+rapidocr_onnxruntime>=1.3
+
+[easyocr]
+easyocr>=1.7
+torch>=2.0

pdfmark_ocr-0.1.0/src/pdfmark_ocr.egg-info/top_level.txt

@@ -0,0 +1 @@
+pdf2md_ocr