Upload pdf_to_png.py

pdf_to_png.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""
+PDF → PNG otimizado para 32 vCPUs / 64 GB RAM
+
+Pipeline:
+  mp.Pool(32 workers)  →  cada worker abre o PDF UMA VEZ no initializer
+                           e renderiza N páginas sem reabrir o arquivo
+  ThreadPoolExecutor   →  salva PNGs em paralelo (I/O bound, não bloqueia render)
+
+Por que mp.Pool + initializer?
+  - Abre o documento fitz uma vez por worker (não uma vez por página).
+  - imap_unordered devolve resultados assim que ficam prontos → sem straggler.
+  - ThreadPoolExecutor para save: I/O bound, pode ter mais threads que cores.
+  - Sem dependência de GPU (RTX 5090 sm_120 não suportado pelo PyTorch estável).
+"""
+
+import argparse
+import multiprocessing as mp
+import os
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+
+try:
+    import fitz  # PyMuPDF
+except ImportError:
+    os.system("pip install pymupdf pillow numpy")
+    import fitz
+
+DPI_DEFAULT = 150
+
+# ─── Estado por worker ─────────────────────────────────────────────────────────
+# Variáveis globais dentro de cada processo filho.
+# Inicializadas uma vez por _init_worker(); reusadas em todas as tarefas.
+_doc  = None
+_zoom = None
+
+
+def _init_worker(pdf_path: str, zoom: float) -> None:
+    """Abre o PDF uma vez por worker. Chamado pelo mp.Pool initializer."""
+    global _doc, _zoom
+    _doc  = fitz.open(pdf_path)
+    _zoom = zoom
+
+
+def _render_page(page_idx: int) -> tuple[int, int, int, bytes]:
+    """Renderiza uma página. _doc já está aberto neste processo."""
+    page = _doc.load_page(page_idx)
+    mat  = fitz.Matrix(_zoom, _zoom)
+    pix  = page.get_pixmap(matrix=mat, alpha=False, colorspace=fitz.csRGB)
+    return page_idx, pix.width, pix.height, bytes(pix.samples)
+
+
+# ─── Save (roda em thread pool — I/O bound) ────────────────────────────────────
+
+def _save_page(args: tuple) -> None:
+    page_idx, w, h, raw, out_path = args
+    arr = np.frombuffer(raw, dtype=np.uint8).reshape(h, w, 3)
+    # compress_level=1 → máxima velocidade (PNG ~15% maior, irrelevante para OCR)
+    Image.fromarray(arr).save(str(out_path), compress_level=1)
+
+
+# ─── Função principal ──────────────────────────────────────────────────────────
+
+def pdf_to_png(
+    pdf_path: Path,
+    dpi: int = DPI_DEFAULT,
+    workers: int | None = None,
+    save_threads: int | None = None,
+) -> Path:
+    n_cpu        = mp.cpu_count()
+    workers      = workers      or n_cpu
+    # I/O bound: pode ter mais threads que cores físicos
+    save_threads = save_threads or min(workers * 2, 32)
+
+    output_dir = pdf_path.parent / pdf_path.stem
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    zoom = dpi / 72.0
+
+    with fitz.open(str(pdf_path)) as doc:
+        total = doc.page_count
+
+    print(f"\n[pdf_to_png] {pdf_path.name}")
+    print(f"  Páginas     : {total}")
+    print(f"  DPI         : {dpi}  (zoom {zoom:.3f}×)")
+    print(f"  Render      : {workers} workers (mp.Pool + initializer)")
+    print(f"  Save        : {save_threads} threads (ThreadPoolExecutor)")
+    print(f"  Output      : {output_dir}/\n")
+
+    t0   = time.perf_counter()
+    done = 0
+
+    with ThreadPoolExecutor(max_workers=save_threads) as save_pool:
+        save_futures = []
+
+        with mp.Pool(
+            processes=workers,
+            initializer=_init_worker,
+            initargs=(str(pdf_path), zoom),
+        ) as pool:
+            # imap_unordered: devolve resultados assim que ficam prontos
+            # chunksize=1: páginas variam em complexidade → balanceamento justo
+            for page_idx, w, h, raw in pool.imap_unordered(
+                _render_page, range(total), chunksize=1
+            ):
+                out_path = output_dir / f"page_{page_idx + 1:04d}.png"
+                fut = save_pool.submit(_save_page, (page_idx, w, h, raw, out_path))
+                save_futures.append(fut)
+
+        # Aguarda todos os saves e mostra progresso
+        for fut in as_completed(save_futures):
+            fut.result()  # propaga exceções imediatamente
+            done += 1
+            print(f"\r  {done}/{total} páginas salvas", end="", flush=True)
+
+    elapsed = time.perf_counter() - t0
+    rate    = total / elapsed if elapsed > 0 else float("inf")
+
+    print(f"\n\n  Concluído em {elapsed:.1f}s — {rate:.1f} pág/s")
+    print(f"  Imagens em : {output_dir}/")
+    return output_dir
+
+
+# ─── CLI ───────────────────────────────────────────────────────────────────────
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="PDF → PNG @ 150 DPI  |  32 vCPU otimizado"
+    )
+    parser.add_argument("pdf", help="Caminho para o arquivo PDF")
+    parser.add_argument(
+        "--dpi", type=int, default=DPI_DEFAULT,
+        help=f"Resolução (padrão: {DPI_DEFAULT})",
+    )
+    parser.add_argument(
+        "--workers", "-w", type=int, default=None,
+        help="Workers de render CPU (padrão: cpu_count())",
+    )
+    parser.add_argument(
+        "--save-threads", "-s", type=int, default=None,
+        help="Threads para salvar PNG (padrão: min(workers×2, 32))",
+    )
+    args = parser.parse_args()
+
+    pdf_path = Path(args.pdf).resolve()
+    if not pdf_path.exists():
+        print(f"Erro: arquivo não encontrado: {pdf_path}")
+        raise SystemExit(1)
+
+    pdf_to_png(pdf_path, dpi=args.dpi, workers=args.workers, save_threads=args.save_threads)
+
+
+if __name__ == "__main__":
+    main()