Updated script to output a dataset

pdf2png.py

@@ -1,57 +1,116 @@
 # /// script
 # requires-python = ">=3.10"
-# dependencies = ["pypdfium2>=4.30", "pillow>=10"]
+# dependencies = ["pypdfium2>=4.30", "pillow>=10", "pyarrow>=15", "huggingface-hub>=1.0"]
 # ///
-r"""Render every page of every PDF under INPUT to PNG under OUTPUT, one folder per PDF:
+r"""Render every page of every PDF under INPUT to PNG, saved either as files in a
+folder or as a Hugging Face dataset with one row per page:
 
-    INPUT/1850s/vol1.pdf  ->  OUTPUT/1850s/vol1/page-0001.png, page-0002.png, ...
+    OUTPUT ./pages                ->  pages/1850s/vol1/page-0001.png, page-0002.png, ...
+    OUTPUT hf://datasets/USER/X   ->  rows of (image, pdf, page) in Parquet, one file per PDF:
+                                      data/1850s/vol1.parquet, ...
 
-PDFs finished on an earlier run are skipped, so a run that stops partway
-(e.g. a job hitting its timeout) can simply be started again.
+PDFs finished on an earlier run are skipped either way, so a run that stops
+partway (e.g. a job hitting its timeout) can simply be started again.
 
     uv run pdf2png.py ./pdfs ./pages
 
-    hf jobs uv run --flavor cpu-upgrade --timeout 2h \
-        -v hf://datasets/USER/pdfs:/in -v hf://buckets/USER/pages:/out \
-        -- https://huggingface.co/datasets/USER/scripts/resolve/main/pdf2png.py /in /out
+    hf jobs uv run --flavor cpu-upgrade --timeout 3h -s HF_TOKEN -v hf://datasets/USER/pdfs:/in \
+        -- https://huggingface.co/datasets/USER/scripts/resolve/main/pdf2png.py /in hf://datasets/USER/pages
 """
 
 import argparse
+import io
+import json
 import os
 import sys
+import tempfile
 from concurrent.futures import ProcessPoolExecutor, as_completed
 from pathlib import Path
 
+import pyarrow as pa
+import pyarrow.parquet as pq
 import pypdfium2 as pdfium
+from huggingface_hub import CommitOperationAdd, HfApi
+from huggingface_hub.utils import disable_progress_bars
 
-DONE = ".done"  # written into a PDF's output folder once all of its pages are saved
+DONE = ".done"  # folder output: written into a PDF's folder once all of its pages are saved
+COMMIT_FILES, COMMIT_BYTES = 50, 5 * 10**9  # dataset output: commit every 50 PDFs or 5 GB, whichever comes first
+ROW_GROUP_BYTES = 100 * 10**6  # keeps Parquet row groups small enough for the dataset viewer
+FEATURES = {"image": {"_type": "Image"}, "pdf": {"dtype": "string", "_type": "Value"},
+            "page": {"dtype": "int32", "_type": "Value"}}
+SCHEMA = pa.schema(
+    [("image", pa.struct([("bytes", pa.binary()), ("path", pa.string())])), ("pdf", pa.string()), ("page", pa.int32())],
+    metadata={"huggingface": json.dumps({"info": {"features": FEATURES}})},  # so `image` loads as images
+)
+README = """---
+configs:
+- config_name: default
+  data_files: "data/**/*.parquet"
+---
+Pages rendered from PDFs with pdf2png.py: one row per page, with `image` (PNG), `pdf` and `page` columns.
+"""
 
 
-def convert(pdf_path: Path, out_dir: Path, dpi: int, grayscale: bool) -> int:
+def render(pdf_path: Path, dpi: int, grayscale: bool):
+    """Yield (filename, PNG bytes) for each page of a PDF."""
     pdf = pdfium.PdfDocument(pdf_path)
     try:
         pdf.init_forms()  # so filled-in form fields render as they do in a viewer
         n = len(pdf)
-        width = max(4, len(str(n)))
-        out_dir.mkdir(parents=True, exist_ok=True)
         for i in range(n):
             page = pdf[i]
-            image = page.render(scale=dpi / 72, grayscale=grayscale).to_pil()
+            buf = io.BytesIO()
             # still lossless; ~3x faster than the default level on scans, files ~10% larger
-            image.save(out_dir / f"page-{i + 1:0{width}d}.png", compress_level=1)
+            page.render(scale=dpi / 72, grayscale=grayscale).to_pil().save(buf, "PNG", compress_level=1)
             page.close()
+            yield f"page-{i + 1:0{max(4, len(str(n)))}d}.png", buf.getvalue()
     finally:
         pdf.close()
+
+
+def to_folder(pdf_path: Path, out_dir: Path, dpi: int, grayscale: bool) -> int:
+    out_dir.mkdir(parents=True, exist_ok=True)
+    n = 0
+    for n, (filename, png) in enumerate(render(pdf_path, dpi, grayscale), 1):
+        (out_dir / filename).write_bytes(png)
     (out_dir / DONE).touch()
     return n
 
 
+def to_parquet(pdf_path: Path, out_file: Path, name: str, dpi: int, grayscale: bool) -> int:
+    out_file.parent.mkdir(parents=True, exist_ok=True)
+    stem = Path(name).with_suffix("").as_posix()
+    rows, size, n = [], 0, 0
+    with pq.ParquetWriter(out_file, SCHEMA) as writer:
+        for n, (filename, png) in enumerate(render(pdf_path, dpi, grayscale), 1):
+            rows.append({"image": {"bytes": png, "path": f"{stem}/{filename}"}, "pdf": name, "page": n})
+            size += len(png)
+            if size >= ROW_GROUP_BYTES:
+                writer.write_table(pa.Table.from_pylist(rows, SCHEMA))
+                rows, size = [], 0
+        if rows:
+            writer.write_table(pa.Table.from_pylist(rows, SCHEMA))
+    return n
+
+
+def push(api: HfApi, repo: str, staging: Path, files: list) -> None:
+    """Commit finished Parquet files to the dataset repo, then delete the local copies."""
+    if files:
+        ops = [CommitOperationAdd(path_in_repo=f.relative_to(staging).as_posix(), path_or_fileobj=f) for f in files]
+        api.create_commit(repo, ops, commit_message=f"Add {len(files)} PDFs", repo_type="dataset")
+        print(f"committed {len(files)} PDFs to {repo}", flush=True)
+        for f in files:
+            f.unlink()
+        files.clear()
+
+
 def main() -> None:
     parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
     parser.add_argument("input", type=Path, help="folder of PDFs (searched recursively), or a single PDF")
-    parser.add_argument("output", type=Path, help="folder to write the PNGs to")
+    parser.add_argument("output", help="folder for the PNGs, or hf://datasets/USER/NAME for a dataset")
     parser.add_argument("--dpi", type=int, default=300, help="render resolution (default: 300)")
     parser.add_argument("--grayscale", action="store_true", help="8-bit grayscale PNGs: smaller files, faster")
+    parser.add_argument("--private", action="store_true", help="make the dataset repo private, if it gets created")
     parser.add_argument("--workers", type=int, default=int(os.environ.get("CPU_CORES") or os.cpu_count() or 1),
                         help="parallel processes (default: one per CPU core)")
     args = parser.parse_args()
@@ -61,25 +120,56 @@ def main() -> None:
     else:
         root = args.input
         pdfs = sorted(p for p in root.rglob("*") if p.suffix.lower() == ".pdf" and p.is_file())
-    todo = {}
-    for pdf in pdfs:
-        out_dir = args.output / pdf.relative_to(root).with_suffix("")
-        if not (out_dir / DONE).exists():
-            todo[pdf] = out_dir
+    names = {pdf: pdf.relative_to(root).as_posix() for pdf in pdfs}
+    stems = {pdf: pdf.relative_to(root).with_suffix("").as_posix() for pdf in pdfs}
+
+    todo = {}  # pdf -> (worker, *args)
+    repo = args.output.removeprefix("hf://datasets/").strip("/") if args.output.startswith("hf://datasets/") else None
+    if repo:
+        disable_progress_bars()
+        api = HfApi()  # authenticates with HF_TOKEN (pass it to a job with -s HF_TOKEN)
+        api.create_repo(repo, repo_type="dataset", private=args.private or None, exist_ok=True)
+        existing = set(api.list_repo_files(repo, repo_type="dataset"))
+        if "README.md" not in existing:
+            api.upload_file(path_or_fileobj=README.encode(), path_in_repo="README.md", repo_id=repo,
+                            repo_type="dataset", commit_message="Add dataset card")
+        tmp = tempfile.TemporaryDirectory(prefix="pdf2png-")  # removed when the script exits
+        staging = Path(tmp.name)
+        for pdf in pdfs:
+            target = f"data/{stems[pdf]}.parquet"
+            if target not in existing:
+                todo[pdf] = (to_parquet, pdf, staging / target, names[pdf], args.dpi, args.grayscale)
+    else:
+        for pdf in pdfs:
+            out_dir = Path(args.output, stems[pdf])
+            if not (out_dir / DONE).exists():
+                todo[pdf] = (to_folder, pdf, out_dir, args.dpi, args.grayscale)
     print(f"{len(pdfs)} PDFs found, {len(pdfs) - len(todo)} already done, {len(todo)} to convert", flush=True)
     if not todo:
         return
 
-    failed = []
+    failed, pending = [], []
     with ProcessPoolExecutor(min(args.workers, len(todo))) as pool:
-        futures = {pool.submit(convert, pdf, out, args.dpi, args.grayscale): pdf for pdf, out in todo.items()}
-        for i, future in enumerate(as_completed(futures), 1):
-            name = futures[future].relative_to(root)
-            try:
-                print(f"[{i}/{len(todo)}] {name}: {future.result()} pages", flush=True)
-            except Exception as e:
-                failed.append(str(name))
-                print(f"[{i}/{len(todo)}] {name}: FAILED ({e})", flush=True)
+        futures = {pool.submit(*job): pdf for pdf, job in todo.items()}
+        try:
+            for i, future in enumerate(as_completed(futures), 1):
+                pdf = futures[future]
+                try:
+                    n = future.result()
+                except Exception as e:
+                    failed.append(names[pdf])
+                    print(f"[{i}/{len(todo)}] {names[pdf]}: FAILED ({e})", flush=True)
+                    continue
+                print(f"[{i}/{len(todo)}] {names[pdf]}: {n} pages", flush=True)
+                if repo:
+                    pending.append(todo[pdf][2])
+                    if len(pending) >= COMMIT_FILES or sum(f.stat().st_size for f in pending) >= COMMIT_BYTES:
+                        push(api, repo, staging, pending)
+            if repo:
+                push(api, repo, staging, pending)
+        except BaseException:
+            pool.shutdown(cancel_futures=True)  # stop rendering PDFs whose output can't be saved
+            raise
     if failed:
         sys.exit(f"{len(failed)} PDF(s) failed: {', '.join(failed)}")