Sync from GitHub via hub-sync

CLAUDE.md

@@ -79,6 +79,8 @@ Legend: ✅ production-ready · ⚠️ works only with a required pinned image
 | `deepseek-ocr-vllm.py` | ✅ | vLLM (stable) | l4x1 | `NGramPerReqLogitsProcessor` anti-repeat |
 | `deepseek-ocr2-vllm.py` | ✅ | vLLM (nightly) | l4x1 | arch needs nightly; `addict`+`matplotlib` deps |
 | `lighton-ocr2.py` | ✅ | vLLM | a100-large / l4x1 | resize 1540px; `--max-model-len` 16384 |
+| `lighton-ocr3-bucket.py` | ✅ | vLLM `:v0.30.0` | a10g-small | `hf://buckets/...` or dir → `.md` (+ `.json` blocks in grounding); bucket I/O via `bucketbag` v0.3.1 (no mount); `.jp2` via imagecodecs; resume-by-skip; failed pages write nothing |
+| `lighton-ocr3.py` | ✅ | vLLM `:v0.30.0` | a10g-small | 4B/0.8B Qwen3.5; resize 2048px; `--mode grounding` → `layout_blocks`; pinned upstream `lightonocr` client dep — see gotcha |
 | `paddleocr-vl-1.5.py` | ✅ | transformers | l4x1 | not vLLM (server-only upstream); single-image |
 | `paddleocr-vl-1.6.py` | ✅ | vLLM | l4x1 | smart-resize ~1M px; SOTA OmniDocBench |
 | `paddleocr-vl.py` | ✅ | vLLM | l4x1 | |
@@ -198,6 +200,22 @@ client's `hunyuan_tasks.py`) and sampling is card-locked (temp 0.0, rep-penalty
 Chatty on blank pages / can emit degenerate repeats — that's **model quality, not a crash**; don't
 re-debug it as a recipe bug. (The actual historical crash was the `pyarrow<18` cap — see Conventions.)
 
+### `lighton-ocr3.py`
+Covers the two Qwen3.5 variants (`LightOnOCR-3-4B` default, `-0.8B`); **not** `LightOnOCR-3-1B`, which keeps
+the LightOnOCR-2 Pixtral arch (needs `transformers` ≤5.16 for `PixtralRotaryEmbedding`). Image pinned to
+**`vllm/vllm-openai:v0.30.0`** because upstream's `pyproject.toml` says vLLM 0.27.1 makes the models loop and
+0.30.0 is tested — loosen after re-checking outputs on a newer tag. Imports parser, `fit` (2048px) and
+`fix_escaped_dollars` from LightOn's own client (`lightonocr`, not on PyPI) via a commit-pinned GitHub
+archive URL, so post-processing matches upstream byte for byte. Sampling = model card vLLM example
+(temp 0.2, **top_p 0.9**, max_tokens 4096); LightOn's client `models.py` uses top_p 1.0 instead. Grounding mode writes `to_markdown(blocks)`
+to the output column and the parsed blocks JSON to `--blocks-column`; the card says prompts other than
+`""`/`grounding` are out of distribution, so no custom prompt flag. Very small type after the 2048
+resize (≲15 px line height) can give empty or looping output; a higher `--longest-edge` helps some pages.
+**Bucket sibling** (`lighton-ocr3-bucket.py`): input/output are `hf://buckets/...` URLs (bucketbag: list → batched
+download → `put_files`) or directories. Use URLs for big buckets: a `-v` mount of `biglam/britannica` (~1 TB)
+sat in RUNNING with no log output for 21 min (2026-10-22), while the same pages via bucketbag ran fine.
+Prefixes get a trailing `/` and go to bucketbag as `prefix=` (it strips a slash from the URL and matches string prefixes, so `vol` would also list `vol2/`). `--max-samples` caps files after listing: bucketbag lists and sorts the whole prefix first, so point smoke tests at a narrow prefix. Directory writes go through a temp file + rename; PDF markers are written in a separate call after their pages. A PDF counts as done once its `.complete.<mode>` marker exists (written with its last page; grounding needs a grounding marker, plain takes either); a re-run without it OCRs only the missing pages. `--overwrite` does not delete anything first: a page that fails keeps its old output, and the run lists those inputs. Known limit: `--overwrite --mode plain` over grounding output leaves the old `.json` + `.complete.grounding`, so a later grounding run skips those pages; use one output prefix per mode. PDF pages render one at a time and go to vLLM in windows of `--batch-size` pages, so a long PDF never sits in memory.
+
 ### `lighton-ocr2.py`
 The original breakage was **not** vLLM — it was a dead `HF_HUB_ENABLE_HF_TRANSFER=1` (the `hf_transfer`
 package is gone), which surfaced as "Can't load image processor". Removed. Pixtral ViT + Qwen3, RLVR-trained,

LANGUAGES.md

@@ -26,7 +26,7 @@ _Sorted by strength of evidence, then coverage:_
 | [HunyuanOCR-1.5](https://huggingface.co/tencent/HunyuanOCR) | "Multilingual" | Nothing enumerated, but explicitly targets **low-resource + ancient-script OCR** as a design goal (new in 1.5; the pinned 1.0 revision doesn't claim this) |
 | [dots.mocr](https://huggingface.co/rednote-hilab/dots.mocr) · [DeepSeek-OCR](https://huggingface.co/deepseek-ai/DeepSeek-OCR) / [-2](https://huggingface.co/deepseek-ai/DeepSeek-OCR-2) · [Unlimited-OCR](https://huggingface.co/baidu/Unlimited-OCR) · [NuExtract3](https://huggingface.co/numind/NuExtract3) | "Multilingual", unspecified | A tag or one-liner only — no count, list, or benchmark |
 | [olmOCR-2](https://huggingface.co/allenai/olmOCR-2-7B-1025-FP8) · [Nanonets-OCR-s](https://huggingface.co/nanonets/Nanonets-OCR-s) · [SmolDocling](https://huggingface.co/ds4sd/SmolDocling-256M-preview) · [LFM2.5-VL-Extract](https://huggingface.co/LiquidAI/LFM2.5-VL-1.6B-Extract) | English only | Stated on the card |
-| [Falcon-OCR](https://huggingface.co/tiiuae/Falcon-OCR) · [OvisOCR2](https://huggingface.co/ATH-MaaS/OvisOCR2) · [FireRed-OCR](https://huggingface.co/FireRedTeam/FireRed-OCR) · [ABot-OCR](https://huggingface.co/acvlab/ABot-OCR) · [RolmOCR](https://huggingface.co/reducto/RolmOCR) · [NuMarkdown-8B](https://huggingface.co/numind/NuMarkdown-8B-Thinking) · [lift](https://huggingface.co/datalab-to/lift) | Not stated | No language information on the card at all |
+| [Falcon-OCR](https://huggingface.co/tiiuae/Falcon-OCR) · [OvisOCR2](https://huggingface.co/ATH-MaaS/OvisOCR2) · [LightOnOCR-3](https://huggingface.co/collections/lightonai/lightonocr-3) · [FireRed-OCR](https://huggingface.co/FireRedTeam/FireRed-OCR) · [ABot-OCR](https://huggingface.co/acvlab/ABot-OCR) · [RolmOCR](https://huggingface.co/reducto/RolmOCR) · [NuMarkdown-8B](https://huggingface.co/numind/NuMarkdown-8B-Thinking) · [lift](https://huggingface.co/datalab-to/lift) | Not stated | No language information on the card at all |
 
 Text-only extraction: [LFM2-1.2B-Extract](https://huggingface.co/LiquidAI/LFM2-1.2B-Extract) (chains after OCR) names 9 languages: English, Arabic, Chinese, French, German, Japanese, Korean, Portuguese, Spanish.
 

README.md

@@ -83,6 +83,7 @@ These are the maintained recipes. Each one has a tested `[tool.hf-jobs]` header,
 | [`tesseract-ocr.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/tesseract-ocr.py) | [Tesseract 5](https://github.com/tesseract-ocr/tesseract) | classical | Baseline plain text, no GPU, 100+ language packs (`--lang`) | Apache-2.0 | `cpu-upgrade` |
 | [`pp-ocrv6.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/pp-ocrv6.py) | [PP-OCRv6](https://huggingface.co/collections/PaddlePaddle/pp-ocrv6) | 1.5M–34.5M | Small detection + recognition pipeline, plain text, 48 languages | Apache-2.0 | `t4-small` |
 | [`surya-ocr.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/surya-ocr.py) | [Surya OCR 2](https://huggingface.co/datalab-to/surya-ocr-2) | 0.65B | Per-block HTML with boxes and reading order; layout and table tasks; PDFs | modified OpenRAIL-M | `a10g-small` |
+| [`lighton-ocr3.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/lighton-ocr3.py) | [LightOnOCR-3](https://huggingface.co/collections/lightonai/lightonocr-3) | 0.8B / 4B | 86.3 olmOCR-Bench (4B), 85.5 (0.8B); `--mode grounding` adds labelled layout boxes, image descriptions and chart tables | Apache-2.0 | `a10g-small` |
 | [`glm-ocr.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/glm-ocr.py) | [GLM-OCR](https://huggingface.co/zai-org/GLM-OCR) | 0.9B | 94.62 OmniDocBench v1.5 | MIT | `a10g-small` |
 | [`paddleocr-vl-1.6.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/paddleocr-vl-1.6.py) | [PaddleOCR-VL-1.6](https://huggingface.co/PaddlePaddle/PaddleOCR-VL-1.6) | 0.9B | 96.33 OmniDocBench v1.6; six task modes | Apache-2.0 | `a10g-small` |
 | [`ovis-ocr2.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/ovis-ocr2.py) | [OvisOCR2](https://huggingface.co/ATH-MaaS/OvisOCR2) | 0.9B | 96.58 OmniDocBench v1.6; LaTeX and HTML tables | Apache-2.0 | `a10g-small` |
@@ -100,7 +101,7 @@ These are the maintained recipes. Each one has a tested `[tool.hf-jobs]` header,
 
 Start with a model under 2B. Use a larger model only if the output of a small one is not good enough. Check the licence before you use a model: Surya and lift use a modified OpenRAIL-M licence (free for research, personal use and startups under $5M; no competitive use against Datalab's API), and the Hunyuan licence excludes the EU, the UK and South Korea.
 
-**Variants and tools:** `glm-ocr-bucket.py` and `surya-ocr-bucket.py` read images and PDFs from a Bucket and write one `.md` per page. `surya-ocr-bucket.py` also writes a `.json` sidecar with the layout blocks, resumes from existing JSON, and can mount or copy its input (`--io-mode mount|copy`); the dataset version, `surya-ocr.py`, keeps the blocks in a `surya_blocks` column. `lighton-ocr2-saturate.py` and `ovis-ocr2-saturate.py` are for large runs, and `ocr-vllm-judge.py` compares outputs ([Scaling up](#scaling-up)). `pp-doclayout.py` and `lfm2-extract.py` are described in [Structured extraction and layout](#structured-extraction-and-layout).
+**Variants and tools:** `glm-ocr-bucket.py`, `surya-ocr-bucket.py` and `lighton-ocr3-bucket.py` read images and PDFs from a Bucket and write one `.md` per page. `lighton-ocr3-bucket.py` also takes `hf://buckets/...` URLs for input and output directly, so it reads large buckets in batches through the Hub API without mounting them. It reads `.jp2`, skips pages that already have output (so a re-run resumes), and in `--mode grounding` writes a `.json` sidecar with the layout blocks. `surya-ocr-bucket.py` also writes a `.json` sidecar with the layout blocks, resumes from existing JSON, and can mount or copy its input (`--io-mode mount|copy`); the dataset version, `surya-ocr.py`, keeps the blocks in a `surya_blocks` column. `lighton-ocr2-saturate.py` and `ovis-ocr2-saturate.py` are for large runs, and `ocr-vllm-judge.py` compares outputs ([Scaling up](#scaling-up)). `pp-doclayout.py` and `lfm2-extract.py` are described in [Structured extraction and layout](#structured-extraction-and-layout).
 
 Which model is best depends on your documents. The public olmOCR-Bench leaderboard is one command away:
 
@@ -169,6 +170,7 @@ Most dataset recipes also record the model and settings in an `inference_info` c
 | `glm-ocr.py` | `--task ocr\|formula\|table` |
 | `paddleocr-vl-1.6.py` | `--task-mode ocr\|table\|formula\|chart\|spotting\|seal` |
 | `ovis-ocr2.py` | `--keep-image-tags`, `--min-pixels`, `--max-pixels` |
+| `lighton-ocr3.py` | `--model lightonai/LightOnOCR-3-4B\|lightonai/LightOnOCR-3-0.8B`, `--mode plain\|grounding`, `--blocks-column`, `--longest-edge` |
 | `hunyuan-ocr-1.5.py` | `--task-type` (12 types, default `doc_parse`), `--custom-prompt` |
 | `dots-ocr.py` | `--prompt-mode ocr\|layout-all\|layout-only` |
 | `dots-mocr.py` | `--prompt-mode` (8 modes). For SVG: `--model rednote-hilab/dots.mocr-svg --prompt-mode svg` |

lighton-ocr3-bucket.py

@@ -0,0 +1,528 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "pillow",
+#     "imagecodecs",
+#     "toolz",
+#     "bucketbag @ https://github.com/davanstrien/bucketbag/archive/refs/tags/v0.3.1.tar.gz",
+#     # LightOn's official client, pinned to a commit (not on PyPI). Used for its
+#     # parser, page resize, PDF rendering and dollar-delimiter repair.
+#     "lightonocr @ https://github.com/lightonai/LightOnOCR/archive/36755d461be079737860a5f03ae0c803501269e9.tar.gz",
+# ]
+#
+# [tool.hf-jobs]
+# image = "vllm/vllm-openai:v0.30.0"
+# python = "/usr/bin/python3"
+# env = { PYTHONPATH = "/usr/local/lib/python3.12/dist-packages" }
+# flavor = "a10g-small"
+# secrets = ["HF_TOKEN"]
+# ///
+
+"""
+OCR images and PDFs from an HF Bucket (or a directory) using LightOnOCR-3,
+writing markdown files.
+
+Bucket sibling of lighton-ocr3.py: same model, prompt, sampling and post-processing.
+Writes one .md per image (or per PDF page), preserving the key/directory structure.
+In grounding mode each .md gets a .json sidecar with the parsed layout blocks.
+
+INPUT and OUTPUT are each either
+  - an `hf://buckets/<ns>/<bucket>[/<prefix>]` URL: read with bucketbag (list, then
+    download one batch at a time to scratch, no mount) / written with one upload call
+    per batch. Use this for large buckets: mounting a very large bucket can be slow.
+  - a directory: a local folder, or a bucket mounted with `-v`.
+
+Input:                          Output:
+  /input/page1.jp2        →      /output/page1.md   (+ page1.json with --mode grounding)
+  /input/report.pdf       →      /output/report/page_001.md
+  (3 pages)                       /output/report/page_002.md
+                                  /output/report/page_003.md
+                                  /output/report/.complete.plain
+  /input/sub/photo.jpg    →      /output/sub/photo.md
+
+Pages that already have their output are skipped, so re-running the same command
+resumes a stopped run. A page that fails writes nothing and is retried on the next
+run. A PDF gets a `.complete.<mode>` marker in its output folder once every page is
+written; until then, a re-run OCRs only its missing pages. --overwrite redoes
+everything, replacing outputs as it goes: a page that fails keeps its previous output
+(the run lists those inputs), so re-run them with --overwrite or use a fresh output prefix.
+Keep plain and grounding runs in separate output prefixes.
+
+Examples:
+
+  # Bucket to bucket on HF Jobs (image, flavor and HF_TOKEN come from the
+  # [tool.hf-jobs] header; needs hf CLI 1.32+). One folder of a large bucket:
+  hf jobs uv run \\
+      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr3-bucket.py \\
+      hf://buckets/biglam/britannica/source/pages/00070476bsb \\
+      hf://buckets/user/ocr-output/britannica --mode grounding --max-samples 20
+
+  # Mounted volumes work too (simplest for small buckets)
+  hf jobs uv run \\
+      -v hf://buckets/user/ocr-input:/input:ro \\
+      -v hf://buckets/user/ocr-output:/output \\
+      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr3-bucket.py \\
+      /input /output
+
+  # Own GPU (vLLM and torch come from the image on Jobs, so add them here)
+  uv run --with vllm==0.30.0 lighton-ocr3-bucket.py ./images ./output
+
+Models: lightonai/LightOnOCR-3-4B (default) or lightonai/LightOnOCR-3-0.8B (Apache-2.0).
+See lighton-ocr3.py for the settings and why the vLLM image is pinned.
+"""
+
+import argparse
+import json
+import logging
+import os
+import sys
+import time
+from pathlib import Path
+from typing import NamedTuple
+
+import torch
+from bucketbag import batched_files, iter_keys, put_files
+from lightonocr import (
+    DEFAULT_LONGEST_EDGE,
+    GROUNDING_PROMPT,
+    fit,
+    fix_escaped_dollars,
+    parse_blocks,
+    to_markdown,
+)
+from PIL import Image
+from toolz import partition_all
+
+# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
+# default uv-script image lacks (engine init then crashes). On the vllm/vllm-openai image it's
+# a harmless no-op.
+os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
+# DeepGEMM's init asserts on a missing nvcc (non-fatal traceback); OCR doesn't need it.
+os.environ.setdefault("VLLM_USE_DEEP_GEMM", "0")
+from vllm import LLM, SamplingParams
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+MODELS = ["lightonai/LightOnOCR-3-4B", "lightonai/LightOnOCR-3-0.8B"]
+DEFAULT_MODEL = MODELS[0]
+
+# Sampling from the model card's vLLM example (temperature 0.2, top_p 0.9, max_tokens 4096).
+DEFAULT_TEMPERATURE = 0.2
+DEFAULT_TOP_P = 0.9
+DEFAULT_MAX_TOKENS = 4096
+
+IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".tiff", ".tif", ".bmp", ".webp", ".jp2", ".j2k"}
+JP2_EXTENSIONS = {".jp2", ".j2k"}
+BUCKET_SCHEME = "hf://buckets/"
+
+
+def check_cuda_availability():
+    if not torch.cuda.is_available():
+        logger.error("CUDA is not available. This script requires a GPU.")
+        sys.exit(1)
+    logger.info(f"CUDA available. GPU: {torch.cuda.get_device_name(0)}")
+
+
+def is_bucket(location: str) -> bool:
+    return location.startswith(BUCKET_SCHEME)
+
+
+def as_bucket_dir(url: str) -> tuple[str, str]:
+    """Split a bucket URL into (bucket root URL, directory key prefix ending in "/").
+
+    Pass the prefix to bucketbag explicitly: it strips a trailing slash from the URL and
+    matches prefixes as strings, so `.../pages/00070476bsb` would also list
+    `.../pages/00070476bsb2/...`.
+    """
+    parts = url[len(BUCKET_SCHEME):].strip("/").split("/", 2)
+    if len(parts) < 2:
+        raise ValueError(f"Not a bucket URL: {url} (expected hf://buckets/<ns>/<bucket>[/<prefix>])")
+    prefix = parts[2] + "/" if len(parts) == 3 else ""
+    return BUCKET_SCHEME + "/".join(parts[:2]), prefix
+
+
+def output_collisions(rels: list[str]) -> list[str]:
+    """Inputs whose outputs would overwrite each other, e.g. scan.png + scan.jpg -> scan.md,
+    or report.pdf (report/page_001.md) + report/page_001.png."""
+    owners: dict[str, list[str]] = {}
+    for rel in rels:
+        # A PDF owns its whole output folder; an image owns one .md.
+        key = str(Path(rel).with_suffix("")) + "/" if rel.lower().endswith(".pdf") else md_rel(rel)
+        owners.setdefault(key, []).append(rel)
+    clashes = [group for group in owners.values() if len(group) > 1]
+    folders = {key for key in owners if key.endswith("/")}
+    for key, group in owners.items():
+        if not key.endswith("/") and any(key.startswith(folder) for folder in folders):
+            clashes.append(group + owners[next(f for f in folders if key.startswith(f))])
+    return [" + ".join(group) for group in clashes]
+
+
+def is_input_file(rel: str) -> bool:
+    ext = Path(rel).suffix.lower()
+    return ext in IMAGE_EXTENSIONS or ext == ".pdf"
+
+
+def list_inputs(source: str, include: str | None, limit: int | None) -> list[str]:
+    """Relative paths of image/PDF inputs, sorted. With `limit`, stops early."""
+    rels = []
+    if is_bucket(source):
+        url, prefix = as_bucket_dir(source)
+        keys = iter_keys(url, prefix=prefix, include=f"{prefix}{include}" if include else None)
+        candidates = (k[len(prefix):] for k in keys)
+    else:
+        root = Path(source)
+        paths = root.rglob(include or "*")
+        candidates = (str(p.relative_to(root)) for p in (paths if limit else sorted(paths)) if p.is_file())
+    for rel in candidates:
+        if is_input_file(rel):
+            rels.append(rel)
+            if limit is not None and len(rels) >= limit:
+                break
+    return rels
+
+
+def list_outputs(dest: str) -> set[str]:
+    """Relative paths of outputs already written (for resume)."""
+    if is_bucket(dest):
+        url, prefix = as_bucket_dir(dest)
+        return {k[len(prefix):] for k in iter_keys(url, prefix=prefix)}
+    root = Path(dest)
+    return {str(p.relative_to(root)) for p in root.rglob("*") if p.is_file()} if root.is_dir() else set()
+
+
+def md_rel(rel: str, page: int | None = None) -> str:
+    """Output path for an input: x.jp2 -> x.md; a PDF page -> x/page_001.md."""
+    stem = str(Path(rel).with_suffix(""))
+    return f"{stem}/page_{page:03d}.md" if page else f"{stem}.md"
+
+
+def marker_rel(rel: str, mode: str) -> str:
+    """Written into a PDF's output folder once all its pages are written in this mode."""
+    return f"{Path(rel).with_suffix('')}/.complete.{mode}"
+
+
+def page_done(md: str, existing: set[str], mode: str) -> bool:
+    if md not in existing:
+        return False
+    return mode != "grounding" or md[: -len(".md")] + ".json" in existing
+
+
+def is_done(rel: str, existing: set[str], mode: str) -> bool:
+    if rel.lower().endswith(".pdf"):
+        # Grounding needs the .json sidecars, so only a grounding marker will do;
+        # plain is satisfied by either (as for images, whose .md exists in both modes).
+        modes = ["grounding"] if mode == "grounding" else ["plain", "grounding"]
+        return any(marker_rel(rel, m) in existing for m in modes)
+    return page_done(md_rel(rel), existing, mode)
+
+
+def iter_local_batches(source: str, rels: list[str], n: int):
+    """Yield batches of (rel, local_path): straight from disk, or downloaded by bucketbag
+    (one batch at a time to scratch, deleted as the loop advances)."""
+    if not is_bucket(source):
+        for chunk in partition_all(n, rels):
+            yield [(rel, Path(source) / rel) for rel in chunk]
+        return
+    url, prefix = as_bucket_dir(source)
+    keys = [prefix + rel for rel in rels]
+    for batch in batched_files(url, keys=keys, n=n, prefetch=2):
+        yield [(it.key[len(prefix):], it.path) for it in batch]
+
+
+def open_image(path: Path) -> Image.Image:
+    """Open one image as RGB. JPEG-2000 falls back to imagecodecs when Pillow
+    was built without OpenJPEG."""
+    try:
+        return Image.open(path).convert("RGB")
+    except Exception:
+        if path.suffix.lower() not in JP2_EXTENSIONS:
+            raise
+        import imagecodecs
+
+        return Image.fromarray(imagecodecs.imread(str(path))).convert("RGB")
+
+
+class PageItem(NamedTuple):
+    rel: str  # input file
+    md: str | None  # output .md path; None for a marker-only item
+    image: Image.Image | None
+    last: bool  # last page still to do for a PDF: write its .complete.<mode> marker after it
+
+
+def iter_pages(rel: str, path: Path, existing: set[str], mode: str, longest_edge: int):
+    """PageItems for the pages of one input that still need OCR. PDF pages render one at
+    a time (as lightonocr.render.render_pdf does), so a long PDF never sits in memory."""
+    if not rel.lower().endswith(".pdf"):
+        yield PageItem(rel, md_rel(rel), fit(open_image(path), longest_edge), False)
+        return
+    import pypdfium2 as pdfium
+
+    pdf = pdfium.PdfDocument(str(path))
+    todo = [n for n in range(1, len(pdf) + 1) if not page_done(md_rel(rel, n), existing, mode)]
+    if not todo:  # every page written by an earlier run: only the marker is missing
+        yield PageItem(rel, None, None, True)
+        return
+    for n in todo:
+        page = pdf[n - 1]
+        w, h = page.get_size()  # points
+        image = page.render(scale=longest_edge / max(w, h)).to_pil().convert("RGB")
+        yield PageItem(rel, md_rel(rel, n), image, n == todo[-1])
+
+
+def build_prompt(llm: LLM, mode: str) -> str:
+    """Chat-template prompt with thinking disabled; grounding adds the "grounding" text."""
+    content = [{"type": "image"}]
+    if mode == "grounding":
+        content.append({"type": "text", "text": GROUNDING_PROMPT})
+    return llm.get_tokenizer().apply_chat_template(
+        [{"role": "user", "content": content}],
+        tokenize=False,
+        add_generation_prompt=True,
+        enable_thinking=False,
+    )
+
+
+def render_outputs(md: str, raw: str, image_size, mode: str, fix_dollars: bool, model: str):
+    """(relative path, content) pairs for one page: the .md, plus a .json in grounding mode."""
+    text = raw.strip()
+    if fix_dollars:
+        text = fix_escaped_dollars(text)
+    if mode != "grounding":
+        return [(md, text)]
+    blocks = parse_blocks(text)
+    sidecar = {
+        "model": model,
+        "image_size": list(image_size),  # size fed to the model; bbox is 0-1000 of this frame
+        "blocks": [b.to_dict() for b in blocks],
+    }
+    # .md before sidecar: a page counts as done in grounding mode only once its .json
+    # exists, so a write that stops between the two is redone (also when replacing a
+    # plain-mode .md).
+    return [
+        (md, to_markdown(blocks) if blocks else text),
+        (md[: -len(".md")] + ".json", json.dumps(sidecar, ensure_ascii=False)),
+    ]
+
+
+def write_outputs(dest: str, pairs: list[tuple[str, str]]):
+    if not pairs:
+        return
+    if is_bucket(dest):
+        url, prefix = as_bucket_dir(dest)
+        put_files([(prefix + rel, content) for rel, content in pairs], url)  # one upload call
+        return
+    for rel, content in pairs:
+        # Write to a temp file, then rename: a stopped job never leaves a partial .md that
+        # the next run would count as done.
+        path = Path(dest) / rel
+        path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = path.with_name(f".{path.name}.tmp")
+        tmp.write_text(content, encoding="utf-8")
+        os.replace(tmp, path)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="OCR images/PDFs from an HF Bucket or directory using LightOnOCR-3, output markdown files.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Modes:
+  plain      markdown transcription (default)
+  grounding  markdown + a .json sidecar of labelled layout blocks (0-1000 boxes)
+
+Examples:
+  lighton-ocr3-bucket.py hf://buckets/ns/scans/vol1 hf://buckets/ns/ocr/vol1 --mode grounding
+  lighton-ocr3-bucket.py /input /output        (directories, e.g. -v mounted buckets)
+  lighton-ocr3-bucket.py hf://buckets/ns/scans /output --include "**/*.jp2"
+        """,
+    )
+    parser.add_argument("input", help="hf://buckets/<ns>/<bucket>[/<prefix>] or a directory of images/PDFs")
+    parser.add_argument("output", help="hf://buckets/<ns>/<bucket>[/<prefix>] or a directory for the .md files")
+    parser.add_argument("--model", default=DEFAULT_MODEL, choices=MODELS,
+                        help=f"Model checkpoint (default: {DEFAULT_MODEL})")
+    parser.add_argument("--mode", default="plain", choices=["plain", "grounding"],
+                        help="plain = markdown; grounding = markdown + .json layout blocks (default: plain)")
+    parser.add_argument("--include", default=None,
+                        help='Glob relative to the input, e.g. "**/*.jp2" (default: all images and PDFs)')
+    parser.add_argument("--batch-size", type=int, default=16,
+                        help="Files downloaded, and pages sent to vLLM, per batch (default: 16)")
+    parser.add_argument("--max-model-len", type=int, default=16384,
+                        help="Max model context length (default: 16384)")
+    parser.add_argument("--max-tokens", type=int, default=DEFAULT_MAX_TOKENS,
+                        help=f"Max output tokens (default: {DEFAULT_MAX_TOKENS}, the card's vLLM example)")
+    parser.add_argument("--temperature", type=float, default=DEFAULT_TEMPERATURE,
+                        help=f"Sampling temperature (default: {DEFAULT_TEMPERATURE}, model card)")
+    parser.add_argument("--top-p", type=float, default=DEFAULT_TOP_P,
+                        help=f"Top-p (default: {DEFAULT_TOP_P}, model card; LightOn's client uses 1.0)")
+    parser.add_argument("--longest-edge", type=int, default=DEFAULT_LONGEST_EDGE,
+                        help=f"Downscale pages so the longest edge is at most this many pixels; "
+                        f"PDFs render at this size (default: {DEFAULT_LONGEST_EDGE})")
+    parser.add_argument("--no-fix-dollars", action="store_true",
+                        help="Keep the raw output instead of repairing escaped dollar delimiters")
+    parser.add_argument("--gpu-memory-utilization", type=float, default=0.8,
+                        help="GPU memory utilization (default: 0.8)")
+    parser.add_argument("--max-samples", type=int, default=None,
+                        help="Limit the number of input files (files, not pages; a PDF still yields "
+                        "all its pages). Counted before skipping files that are already done.")
+    parser.add_argument("--overwrite", action="store_true",
+                        help="Redo files that already have output (default: skip them, which resumes a run)")
+    parser.add_argument("--verbose", action="store_true", help="Print resolved package versions")
+
+    args = parser.parse_args()
+    if args.max_samples is not None and args.max_samples < 1:
+        parser.error("--max-samples must be 1 or more")
+    if args.max_tokens > args.max_model_len:
+        parser.error(f"--max-tokens ({args.max_tokens}) must be <= --max-model-len ({args.max_model_len})")
+    for loc in (args.input, args.output):
+        if is_bucket(loc):
+            try:
+                as_bucket_dir(loc)
+            except ValueError as e:
+                parser.error(str(e))
+    if not is_bucket(args.input) and not Path(args.input).is_dir():
+        parser.error(f"Input directory does not exist: {args.input}")
+
+    check_cuda_availability()
+
+    start_time = time.time()
+    logger.info(f"Listing inputs in {args.input} ...")
+    rels = list_inputs(args.input, args.include, args.max_samples)
+    if not rels:
+        logger.error(f"No image or PDF files found in {args.input}")
+        sys.exit(1)
+    clashes = output_collisions(rels)
+    if clashes:
+        logger.error("These inputs would write the same output file(s):")
+        for clash in clashes[:20]:
+            logger.error(f"  {clash}")
+        logger.error("Rename them, or narrow the input with --include.")
+        sys.exit(1)
+    existing = set() if args.overwrite else list_outputs(args.output)
+    todo = [rel for rel in rels if not is_done(rel, existing, args.mode)]
+    skipped = len(rels) - len(todo)
+    logger.info(f"Found {len(rels)} file(s); {skipped} already done; {len(todo)} to OCR")
+    if not todo:
+        logger.info("Nothing to do (--overwrite to redo).")
+        return
+
+    logger.info(f"Initializing vLLM with {args.model} ({args.mode} mode)...")
+    # Stock Qwen3_5ForConditionalGeneration arch; gdn_prefill_backend="triton" avoids the
+    # gated-delta-net prefill path that needs a CUDA JIT toolchain (as in lighton-ocr3.py).
+    llm = LLM(
+        model=args.model,
+        max_model_len=args.max_model_len,
+        gpu_memory_utilization=args.gpu_memory_utilization,
+        limit_mm_per_prompt={"image": 1},
+        gdn_prefill_backend="triton",
+    )
+    prompt = build_prompt(llm, args.mode)
+    sampling_params = SamplingParams(
+        temperature=args.temperature, top_p=args.top_p, max_tokens=args.max_tokens
+    )
+
+    pages_done = 0
+    errors = 0
+    files_seen = 0
+    failed: set[str] = set()  # inputs with a page that failed: no .complete.<mode> marker this run
+    open_errors: list[str] = []
+
+    def file_pages(batch):
+        for rel, path in batch:
+            try:
+                yield from iter_pages(rel, path, existing, args.mode, args.longest_edge)
+            except Exception as e:
+                logger.error(f"Failed to open {rel}: {e}")
+                failed.add(rel)
+                open_errors.append(rel)
+
+    total_batches = (len(todo) + args.batch_size - 1) // args.batch_size
+    for batch_num, batch in enumerate(iter_local_batches(args.input, todo, args.batch_size), 1):
+        logger.info(f"Batch {batch_num}/{total_batches} ({files_seen}/{len(todo)} files done)")
+        files_seen += len(batch)
+
+        # Windows of at most --batch-size pages, rendered lazily.
+        for window in partition_all(args.batch_size, file_pages(batch)):
+            pages = [it for it in window if it.image is not None]
+            outputs = []
+            if pages:
+                try:
+                    outputs = llm.generate(
+                        [{"prompt": prompt, "multi_modal_data": {"image": it.image}} for it in pages],
+                        sampling_params,
+                    )
+                except Exception as e:
+                    # Write nothing: these pages are retried on the next run.
+                    logger.error(f"Batch {batch_num} failed: {e}")
+                    errors += len(pages)
+                    failed.update(it.rel for it in pages)
+                    continue
+
+            pairs = []
+            for it, output in zip(pages, outputs, strict=True):
+                pairs.extend(render_outputs(it.md, output.outputs[0].text, it.image.size, args.mode,
+                                            not args.no_fix_dollars, args.model))
+            try:
+                write_outputs(args.output, pairs)
+                pages_done += len(pages)
+            except Exception as e:
+                logger.error(f"Writing batch {batch_num} failed: {e}")
+                errors += len(pages)
+                failed.update(it.rel for it in window)
+                continue
+            # Markers in a separate write, only after the page outputs are stored.
+            finished = [it.rel for it in window if it.last and it.rel not in failed]
+            try:
+                write_outputs(args.output, [(marker_rel(rel, args.mode), "ok\n") for rel in finished])
+            except Exception as e:
+                logger.error(f"Writing completion markers failed (pages are kept): {e}")
+                failed.update(finished)
+
+    errors += len(open_errors)
+    elapsed = time.time() - start_time
+    elapsed_str = f"{elapsed / 60:.1f} min" if elapsed > 60 else f"{elapsed:.1f}s"
+    logger.info("=" * 50)
+    logger.info(f"Done! Wrote {pages_done} page(s) from {files_seen} file(s) in {elapsed_str}")
+    logger.info(f"  Output: {args.output}")
+    logger.info(f"  Skipped (already done): {skipped}")
+    logger.info(f"  Errors (no output, retried next run): {errors}")
+    if failed:
+        listed = sorted(failed)
+        logger.warning(f"  Inputs with failures ({len(listed)}): {', '.join(listed[:20])}"
+                       + (" ..." if len(listed) > 20 else ""))
+        if args.overwrite:
+            logger.warning("  With --overwrite these keep their previous output: re-run them with --overwrite.")
+    if pages_done:
+        logger.info(f"  Speed: {pages_done / elapsed:.2f} pages/sec")
+
+    if args.verbose:
+        import importlib.metadata
+
+        logger.info("--- Package versions ---")
+        for pkg in ["vllm", "transformers", "torch", "pillow", "imagecodecs", "bucketbag", "lightonocr"]:
+            try:
+                logger.info(f"  {pkg}=={importlib.metadata.version(pkg)}")
+            except importlib.metadata.PackageNotFoundError:
+                logger.info(f"  {pkg}: not installed")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) == 1:
+        print("=" * 60)
+        print("LightOnOCR-3 Bucket Script")
+        print("=" * 60)
+        print("\nOCR images/PDFs from an HF Bucket or directory → markdown files")
+        print("(+ .json layout blocks in grounding mode). Re-running resumes.")
+        print()
+        print("Usage:")
+        print("  lighton-ocr3-bucket.py INPUT OUTPUT   (hf://buckets/... URLs or directories)")
+        print()
+        print("HF Jobs (image, flavor + secrets from the [tool.hf-jobs] header; hf CLI 1.32+):")
+        print("  hf jobs uv run \\")
+        print("      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr3-bucket.py \\")
+        print("      hf://buckets/ns/scans/vol1 hf://buckets/ns/ocr/vol1 --mode grounding")
+        print()
+        print("For full help: uv run --with vllm==0.30.0 lighton-ocr3-bucket.py --help")
+        sys.exit(0)
+
+    main()

lighton-ocr3.py

@@ -0,0 +1,806 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "datasets>=4.0.0",
+#     "huggingface-hub",
+#     "pillow",
+#     "toolz",
+#     # LightOn's official client, pinned to a commit (not on PyPI). Used for its
+#     # parser, page resize and dollar-delimiter repair so outputs match upstream.
+#     "lightonocr @ https://github.com/lightonai/LightOnOCR/archive/36755d461be079737860a5f03ae0c803501269e9.tar.gz",
+# ]
+#
+# [tool.hf-jobs]
+# image = "vllm/vllm-openai:v0.30.0"
+# python = "/usr/bin/python3"
+# env = { PYTHONPATH = "/usr/local/lib/python3.12/dist-packages" }
+# flavor = "a10g-small"
+# secrets = ["HF_TOKEN"]
+# ///
+
+"""
+Convert document images to markdown (or layout blocks) using LightOnOCR-3 with vLLM.
+
+LightOnOCR-3 is LightOn's third generation of end-to-end OCR models. The 4B and 0.8B
+variants use the stock Qwen3.5 vision-language architecture. Besides plain
+transcription, they have a grounding mode: every block of the page comes back with a
+label (title, text, table, chart, image, ...) and a bounding box. Images get a short
+description and charts become an HTML table of their data points.
+
+Models (Apache-2.0):
+  lightonai/LightOnOCR-3-4B    (default)  86.3 olmOCR-Bench, 75.1 ParseBench
+  lightonai/LightOnOCR-3-0.8B             85.5 olmOCR-Bench, 74.6 ParseBench
+LightOnOCR-3-1B is not supported here: it keeps the LightOnOCR-2 (Pixtral)
+architecture and needs a different vLLM/transformers pin.
+
+Run on HF Jobs (needs `hf` CLI 1.32+; the [tool.hf-jobs] header above sets the
+vllm/vllm-openai:v0.30.0 image, a10g-small flavor and HF_TOKEN secret):
+
+    hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr3.py \\
+        input-dataset output-dataset --max-samples 10
+
+    # Layout blocks with labels and boxes, smaller model
+    hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr3.py \\
+        input-dataset output-dataset --mode grounding --model lightonai/LightOnOCR-3-0.8B
+
+Run on your own GPU (vLLM and torch come from the image on Jobs, so add them here):
+
+    uv run --with vllm==0.30.0 lighton-ocr3.py input-dataset output-dataset
+
+For large scans with very small type, try a higher --longest-edge and --max-tokens.
+
+The image is pinned to vLLM 0.30.0 because LightOn's client reports that vLLM 0.27.1
+makes the models loop and 0.30.0 is the version they test. Loosen the pin once a newer
+vLLM is checked against the same outputs.
+
+Modes:
+- plain (default): the image alone -> markdown transcription. Same as LightOnOCR-2.
+- grounding: the image + the text "grounding" -> one `![label](x1,y1,x2,y2)` block per
+  region, coordinates normalised to 0-1000. The output column gets the block texts
+  joined as markdown; the --blocks-column gets the parsed blocks as JSON
+  ([{label, bbox, text, continues}, ...]). Grounding adds about 25% output tokens.
+The card says other instructions are out of distribution, so there is no custom prompt.
+
+Sampling matches the model card's vLLM example: temperature 0.2, top_p 0.9,
+max_tokens 4096, thinking disabled. (LightOn's client defaults to top_p 1.0 for
+LightOnOCR-3; pass --top-p 1.0 to match it.) Pre- and post-processing follow the
+official client (lightonocr/render.py, client.py): pages are downscaled to 2048 px on
+the longest edge (the card's rendering tip; the processor does no further resizing),
+and escaped dollar delimiters are repaired (`\\$x\\$` -> `$x$`) on every output.
+"""
+
+import argparse
+import io
+import json
+import logging
+import os
+import sys
+import time
+from datetime import datetime
+from typing import Any, Dict, Union
+
+import torch
+from datasets import load_dataset
+from huggingface_hub import DatasetCard, hf_hub_download, login
+from lightonocr import (
+    DEFAULT_LONGEST_EDGE,
+    GROUNDING_PROMPT,
+    fit,
+    fix_escaped_dollars,
+    parse_blocks,
+    to_markdown,
+)
+from PIL import Image
+from toolz import partition_all
+
+# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
+# default uv-script image lacks (engine init then crashes). On the vllm/vllm-openai image it's
+# a harmless no-op.
+os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
+# DeepGEMM's init asserts on a missing nvcc (non-fatal traceback); OCR doesn't need it.
+os.environ.setdefault("VLLM_USE_DEEP_GEMM", "0")
+from vllm import LLM, SamplingParams
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+MODELS = ["lightonai/LightOnOCR-3-4B", "lightonai/LightOnOCR-3-0.8B"]
+DEFAULT_MODEL = MODELS[0]
+
+# Sampling from the model card's vLLM example (temperature 0.2, top_p 0.9, max_tokens 4096).
+DEFAULT_TEMPERATURE = 0.2
+DEFAULT_TOP_P = 0.9
+DEFAULT_MAX_TOKENS = 4096
+
+
+def check_cuda_availability():
+    """Check if CUDA is available and exit if not."""
+    if not torch.cuda.is_available():
+        logger.error("CUDA is not available. This script requires a GPU.")
+        logger.error("Please run on a machine with a CUDA-capable GPU.")
+        sys.exit(1)
+    else:
+        logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
+
+
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
+def to_pil_image(image: Union[Image.Image, Dict[str, Any], str]) -> Image.Image:
+    """Convert a dataset image cell (PIL image, bytes dict, or path) to RGB PIL."""
+    if isinstance(image, Image.Image):
+        pil_img = image
+    elif isinstance(image, dict) and "bytes" in image:
+        pil_img = Image.open(io.BytesIO(image["bytes"]))
+    elif isinstance(image, str):
+        pil_img = Image.open(image)
+    else:
+        raise ValueError(f"Unsupported image type: {type(image)}")
+    return pil_img.convert("RGB")
+
+
+def build_prompt(llm: LLM, mode: str) -> str:
+    """Chat-template prompt for one page, with thinking disabled.
+
+    plain sends the image alone; grounding adds the text "grounding" after it
+    (client.py). The 0.8B and 4B were trained without thinking, so the template is
+    rendered with enable_thinking=False, as the card and client do.
+    """
+    content = [{"type": "image"}]
+    if mode == "grounding":
+        content.append({"type": "text", "text": GROUNDING_PROMPT})
+    return llm.get_tokenizer().apply_chat_template(
+        [{"role": "user", "content": content}],
+        tokenize=False,
+        add_generation_prompt=True,
+        enable_thinking=False,
+    )
+
+
+def postprocess_output(text: str, mode: str, fix_dollars: bool):
+    """Return (markdown, blocks_json or None) for one raw model output."""
+    text = text.strip()
+    if fix_dollars:
+        text = fix_escaped_dollars(text)
+    if mode != "grounding":
+        return text, None
+    blocks = parse_blocks(text)
+    if not blocks:
+        # No markers parsed: keep the raw text so nothing is lost.
+        return text, json.dumps([])
+    markdown = to_markdown(blocks)
+    return markdown, json.dumps([b.to_dict() for b in blocks], ensure_ascii=False)
+
+
+def jobs_flavor() -> str:
+    """Return the HF Jobs hardware flavor this run is on, or "" when it cannot be told.
+
+    HF Jobs sets ACCELERATOR to "cpu" or "gpu", not the flavor name, so the flavor is looked up
+    in the public Jobs hardware list: first by GPU model and count, then by the CPU_CORES and
+    MEMORY values that Jobs sets in the container (to tell a10g-small from a10g-large, or
+    cpu-basic from cpu-upgrade). Any failure (no network, older huggingface_hub) returns "".
+    """
+    hardware = os.environ.get("ACCELERATOR") or ""
+    if "-" in hardware or any(character.isdigit() for character in hardware):
+        return hardware  # already a flavor name
+    try:
+        from huggingface_hub import HfApi
+
+        gpu_name, gpu_count = "", 0
+        try:
+            import torch
+
+            if torch.cuda.is_available():
+                gpu_name = torch.cuda.get_device_name(0)
+                gpu_count = torch.cuda.device_count()
+        except ImportError:
+            # Torch-free drivers (e.g. the -server recipes): ask nvidia-smi instead.
+            import subprocess
+
+            try:
+                listed = subprocess.run(
+                    ["nvidia-smi", "--query-gpu=name", "--format=csv,noheader"],
+                    capture_output=True, text=True, timeout=10, check=True,
+                ).stdout
+                names = [line.strip() for line in listed.splitlines() if line.strip()]
+                if names:
+                    gpu_name, gpu_count = names[0], len(names)
+            except (OSError, subprocess.SubprocessError):
+                pass
+        if gpu_count == 0 and hardware == "gpu":
+            return ""  # a GPU run whose GPU cannot be identified: do not guess a CPU flavor
+
+        # Whole-word match, so "L4" does not match "NVIDIA L40S" ("NVIDIA A100-SXM4-80GB" -> A100).
+        gpu_words = gpu_name.upper().replace("-", " ").split()
+        candidates = []
+        for flavor in HfApi(token=False).list_jobs_hardware():
+            accelerator = flavor.accelerator
+            if gpu_count == 0 and accelerator is None:
+                candidates.append(flavor)
+            elif (
+                gpu_count > 0
+                and accelerator is not None
+                and accelerator.model.upper() in gpu_words
+                and int(accelerator.quantity) == gpu_count
+            ):
+                candidates.append(flavor)
+        if not candidates:
+            return ""
+
+        cores = float(os.environ.get("CPU_CORES") or 0)
+        memory_gb = float((os.environ.get("MEMORY") or "0").upper().rstrip("GIB ") or 0)
+
+        def distance(flavor) -> float:
+            # Relative gap to the listed vCPUs and RAM; Jobs reports slightly different numbers.
+            listed_cores = float(flavor.cpu.split()[0])
+            listed_memory = float(flavor.ram.split()[0])
+            return abs(listed_cores - cores) / listed_cores + abs(listed_memory - memory_gb) / listed_memory
+
+        return min(candidates, key=distance).name
+    except Exception:
+        return ""
+
+
+def create_dataset_card(
+    source_dataset: str,
+    model: str,
+    mode: str,
+    num_samples: int,
+    processing_time: str,
+    batch_size: int,
+    max_model_len: int,
+    max_tokens: int,
+    temperature: float,
+    top_p: float,
+    longest_edge: int,
+    gpu_memory_utilization: float,
+    output_column: str,
+    blocks_column: str,
+    image_column: str = "image",
+    split: str = "train",
+) -> str:
+    """Create a dataset card documenting the OCR process."""
+    model_name = model.split("/")[-1]
+
+    # Canonical provenance stamp (see AGENTS.md): Jobs claim gated on JOB_ID, set by HF Jobs in-container.
+    on_jobs = os.environ.get("JOB_ID") is not None
+    hw = jobs_flavor()  # flavor name, e.g. "a10g-small"; "" when it cannot be told
+    origin = (
+        "Produced on [Hugging Face Jobs](https://huggingface.co/docs/huggingface_hub/guides/jobs)"
+        + (f" (`{hw}`)" if hw else "")
+    ) if on_jobs else "Generated"
+    jobs_tag = "\n- hf-jobs" if on_jobs else ""
+
+    model_arg = f" \\\n    --model {model}" if model != DEFAULT_MODEL else ""
+    mode_arg = " \\\n    --mode grounding" if mode == "grounding" else ""
+    blocks_line = (
+        f"- `{blocks_column}`: JSON list of layout blocks "
+        "(`label`, `bbox` as x1,y1,x2,y2 normalised to 0-1000, `text`, `continues`)\n"
+        if mode == "grounding"
+        else ""
+    )
+
+    return f"""---
+tags:
+- ocr
+- document-processing
+- lighton-ocr-3
+- markdown
+- uv-script
+- generated{jobs_tag}
+---
+
+# Document OCR using {model_name}
+
+This dataset contains OCR results from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using [{model_name}](https://huggingface.co/{model}) in **{mode}** mode.
+
+## Processing Details
+
+- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
+- **Model**: [{model}](https://huggingface.co/{model})
+- **Mode**: `{mode}`
+- **Number of Samples**: {num_samples:,}
+- **Processing Time**: {processing_time}
+- **Processing Date**: {datetime.now().strftime("%Y-%m-%d %H:%M UTC")}
+
+### Configuration
+
+- **Image Column**: `{image_column}`
+- **Dataset Split**: `{split}`
+- **Batch Size**: {batch_size}
+- **Longest Image Edge**: {longest_edge}px
+- **Max Model Length**: {max_model_len:,} tokens
+- **Max Output Tokens**: {max_tokens:,}
+- **Temperature**: {temperature}
+- **Top P**: {top_p}
+- **GPU Memory Utilization**: {gpu_memory_utilization:.1%}
+
+## Dataset Structure
+
+The dataset contains all original columns plus:
+- `{output_column}`: The extracted text in markdown format
+{blocks_line}- `inference_info`: JSON list tracking all OCR models applied to this dataset
+
+## Reproduction
+
+{origin} with the [`lighton-ocr3.py`](https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr3.py) recipe from [uv-scripts](https://huggingface.co/uv-scripts). Run it yourself:
+
+```bash
+hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr3.py \\
+    {source_dataset} \\
+    <output-dataset> \\
+    --image-column {image_column} \\
+    --batch-size {batch_size}{model_arg}{mode_arg}
+```
+"""
+
+
+def main(
+    input_dataset: str,
+    output_dataset: str,
+    model: str = DEFAULT_MODEL,
+    mode: str = "plain",
+    image_column: str = "image",
+    batch_size: int = 16,
+    max_model_len: int = 16384,
+    max_tokens: int = DEFAULT_MAX_TOKENS,
+    temperature: float = DEFAULT_TEMPERATURE,
+    top_p: float = DEFAULT_TOP_P,
+    longest_edge: int = DEFAULT_LONGEST_EDGE,
+    no_fix_dollars: bool = False,
+    gpu_memory_utilization: float = 0.8,
+    hf_token: str = None,
+    split: str = "train",
+    max_samples: int = None,
+    private: bool = False,
+    shuffle: bool = False,
+    seed: int = 42,
+    output_column: str = "markdown",
+    blocks_column: str = "layout_blocks",
+    overwrite: bool = False,
+    verbose: bool = False,
+    config: str = None,
+    create_pr: bool = False,
+):
+    """Process images from HF dataset through LightOnOCR-3."""
+
+    check_cuda_availability()
+
+    start_time = datetime.now()
+
+    HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
+    if HF_TOKEN:
+        login(token=HF_TOKEN)
+
+    logger.info(f"Using model: {model} ({mode} mode)")
+
+    # Load dataset
+    logger.info(f"Loading dataset: {input_dataset}")
+    dataset = load_dataset(input_dataset, split=split)
+
+    if image_column not in dataset.column_names:
+        raise ValueError(
+            f"Column '{image_column}' not found. Available: {dataset.column_names}"
+        )
+
+    # Fail fast if an output column would collide with an existing input column
+    output_columns = [output_column] + ([blocks_column] if mode == "grounding" else [])
+    dataset = ensure_output_columns_free(dataset, output_columns, overwrite=overwrite)
+
+    if shuffle:
+        logger.info(f"Shuffling dataset with seed {seed}")
+        dataset = dataset.shuffle(seed=seed)
+
+    if max_samples:
+        dataset = dataset.select(range(min(max_samples, len(dataset))))
+        logger.info(f"Limited to {len(dataset)} samples")
+
+    # Initialize vLLM
+    logger.info(f"Initializing vLLM with {model}")
+    logger.info("This may take a few minutes on first run...")
+    # Stock Qwen3_5ForConditionalGeneration arch, so no trust_remote_code. A 2048px page
+    # is at most 64x64 = 4,096 image tokens (16px patches, 2x2 merge), so 16384 leaves
+    # room for the card's 4096 output tokens. gdn_prefill_backend="triton" avoids the
+    # Qwen3.5 gated-delta-net prefill path that needs a CUDA JIT toolchain (as ovis-ocr2.py).
+    llm = LLM(
+        model=model,
+        max_model_len=max_model_len,
+        gpu_memory_utilization=gpu_memory_utilization,
+        limit_mm_per_prompt={"image": 1},
+        gdn_prefill_backend="triton",
+    )
+
+    prompt = build_prompt(llm, mode)
+    sampling_params = SamplingParams(
+        temperature=temperature, top_p=top_p, max_tokens=max_tokens
+    )
+
+    logger.info(f"Processing {len(dataset)} images in batches of {batch_size}")
+    logger.info(f"Output will be written to column: {output_column}")
+    if mode == "grounding":
+        logger.info(f"Layout blocks will be written to column: {blocks_column}")
+
+    all_markdown = []
+    all_blocks = []
+    total_batches = (len(dataset) + batch_size - 1) // batch_size
+    processed = 0
+
+    for batch_num, batch_indices in enumerate(
+        partition_all(batch_size, range(len(dataset))), 1
+    ):
+        batch_indices = list(batch_indices)
+        batch_images = [dataset[i][image_column] for i in batch_indices]
+
+        logger.info(
+            f"Batch {batch_num}/{total_batches} "
+            f"({processed}/{len(dataset)} images done)"
+        )
+
+        try:
+            # Downscale to the training render size (never upscale), as the client does.
+            vllm_inputs = [
+                {
+                    "prompt": prompt,
+                    "multi_modal_data": {"image": fit(to_pil_image(img), longest_edge)},
+                }
+                for img in batch_images
+            ]
+
+            outputs = llm.generate(vllm_inputs, sampling_params)
+
+            for output in outputs:
+                markdown, blocks = postprocess_output(
+                    output.outputs[0].text, mode, fix_dollars=not no_fix_dollars
+                )
+                all_markdown.append(markdown)
+                all_blocks.append(blocks)
+
+            processed += len(batch_images)
+
+        except Exception as e:
+            logger.error(f"Error processing batch: {e}")
+            all_markdown.extend(["[OCR ERROR]"] * len(batch_images))
+            all_blocks.extend([json.dumps([])] * len(batch_images))
+            processed += len(batch_images)
+
+    processing_duration = datetime.now() - start_time
+    processing_time_str = f"{processing_duration.total_seconds() / 60:.1f} min"
+
+    logger.info(f"Adding '{output_column}' column to dataset")
+    dataset = dataset.add_column(output_column, all_markdown)
+    if mode == "grounding":
+        logger.info(f"Adding '{blocks_column}' column to dataset")
+        dataset = dataset.add_column(blocks_column, all_blocks)
+
+    # Inference info tracking
+    inference_entry = {
+        "model_id": model,
+        "model_name": model.split("/")[-1],
+        "mode": mode,
+        "column_name": output_column,
+        "blocks_column": blocks_column if mode == "grounding" else None,
+        "timestamp": datetime.now().isoformat(),
+        "temperature": temperature,
+        "top_p": top_p,
+        "max_tokens": max_tokens,
+        "longest_edge": longest_edge,
+        "fix_dollars": not no_fix_dollars,
+    }
+
+    if "inference_info" in dataset.column_names:
+        logger.info("Updating existing inference_info column")
+
+        def update_inference_info(example):
+            try:
+                existing_info = (
+                    json.loads(example["inference_info"])
+                    if example["inference_info"]
+                    else []
+                )
+            except (json.JSONDecodeError, TypeError):
+                existing_info = []
+            existing_info.append(inference_entry)
+            return {"inference_info": json.dumps(existing_info)}
+
+        dataset = dataset.map(update_inference_info)
+    else:
+        logger.info("Creating new inference_info column")
+        inference_list = [json.dumps([inference_entry])] * len(dataset)
+        dataset = dataset.add_column("inference_info", inference_list)
+
+    # Push to hub with retry and XET fallback
+    logger.info(f"Pushing to {output_dataset}")
+    max_retries = 3
+    for attempt in range(1, max_retries + 1):
+        try:
+            if attempt > 1:
+                logger.warning("Disabling XET (fallback to HTTP upload)")
+                os.environ["HF_HUB_DISABLE_XET"] = "1"
+            commit_info = dataset.push_to_hub(
+                output_dataset,
+                private=private,
+                token=HF_TOKEN,
+                max_shard_size="500MB",
+                **({"config_name": config} if config else {}),
+                create_pr=create_pr,
+                commit_message=f"Add {model} OCR results ({len(dataset)} samples)"
+                + (f" [{config}]" if config else ""),
+            )
+            break
+        except Exception as e:
+            logger.error(f"Upload attempt {attempt}/{max_retries} failed: {e}")
+            if attempt < max_retries:
+                delay = 30 * (2 ** (attempt - 1))
+                logger.info(f"Retrying in {delay}s...")
+                time.sleep(delay)
+            else:
+                logger.error("All upload attempts failed. OCR results are lost.")
+                sys.exit(1)
+
+    # Create and push dataset card
+    logger.info("Creating dataset card")
+    card_content = create_dataset_card(
+        source_dataset=input_dataset,
+        model=model,
+        mode=mode,
+        num_samples=len(dataset),
+        processing_time=processing_time_str,
+        batch_size=batch_size,
+        max_model_len=max_model_len,
+        max_tokens=max_tokens,
+        temperature=temperature,
+        top_p=top_p,
+        longest_edge=longest_edge,
+        gpu_memory_utilization=gpu_memory_utilization,
+        output_column=output_column,
+        blocks_column=blocks_column,
+        image_column=image_column,
+        split=split,
+    )
+
+    # With --create-pr the data went to a PR branch; the card goes to the same branch.
+    revision = commit_info.pr_revision if create_pr else None
+    card = DatasetCard(card_content)
+    # Keep the configs/dataset_info metadata push_to_hub just wrote, or named configs
+    # (--config) stop loading.
+    pushed = DatasetCard.load(
+        hf_hub_download(output_dataset, "README.md", repo_type="dataset",
+                        revision=revision, token=HF_TOKEN)
+    )
+    for key in ("configs", "dataset_info"):
+        if pushed.data.get(key) is not None:
+            card.data[key] = pushed.data[key]
+    card.push_to_hub(output_dataset, token=HF_TOKEN, revision=revision)
+
+    logger.info("Done! LightOnOCR-3 processing complete.")
+    logger.info(
+        f"Dataset available at: https://huggingface.co/datasets/{output_dataset}"
+    )
+    logger.info(f"Processing time: {processing_time_str}")
+    logger.info(
+        f"Processing speed: {len(dataset) / processing_duration.total_seconds():.2f} images/sec"
+    )
+
+    if verbose:
+        import importlib.metadata
+
+        logger.info("--- Resolved package versions ---")
+        for pkg in ["vllm", "transformers", "torch", "datasets", "pyarrow", "pillow", "lightonocr"]:
+            try:
+                logger.info(f"  {pkg}=={importlib.metadata.version(pkg)}")
+            except importlib.metadata.PackageNotFoundError:
+                logger.info(f"  {pkg}: not installed")
+        logger.info("--- End versions ---")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) == 1:
+        print("=" * 70)
+        print("LightOnOCR-3 Document Processing")
+        print("=" * 70)
+        print("\n4B (default) or 0.8B end-to-end OCR, Qwen3.5 architecture")
+        print("\nModes:")
+        print("  plain      markdown transcription (default)")
+        print("  grounding  labelled layout blocks with 0-1000 boxes")
+        print("\nExamples:")
+        print("\n1. Basic OCR (own GPU):")
+        print("   uv run --with vllm==0.30.0 lighton-ocr3.py input-dataset output-dataset")
+        print("\n2. Layout blocks with the 0.8B model:")
+        print("   uv run --with vllm==0.30.0 lighton-ocr3.py docs results \\")
+        print("       --mode grounding --model lightonai/LightOnOCR-3-0.8B")
+        print("\n3. Running on HF Jobs (hf CLI 1.32+; image/flavor/secrets from the script header):")
+        print("   hf jobs uv run \\")
+        print(
+            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr3.py \\"
+        )
+        print("       input-dataset output-dataset --max-samples 10")
+        print("\nFor full help: uv run --with vllm==0.30.0 lighton-ocr3.py --help")
+        sys.exit(0)
+
+    parser = argparse.ArgumentParser(
+        description="Document OCR using LightOnOCR-3 (4B or 0.8B, plain or grounding mode)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  uv run --with vllm==0.30.0 lighton-ocr3.py my-docs analyzed-docs
+  uv run --with vllm==0.30.0 lighton-ocr3.py docs results --mode grounding
+  uv run --with vllm==0.30.0 lighton-ocr3.py docs results --model lightonai/LightOnOCR-3-0.8B
+        """,
+    )
+
+    parser.add_argument("input_dataset", help="Input dataset ID from Hugging Face Hub")
+    parser.add_argument("output_dataset", help="Output dataset ID for Hugging Face Hub")
+    parser.add_argument(
+        "--model",
+        default=DEFAULT_MODEL,
+        choices=MODELS,
+        help=f"Model checkpoint (default: {DEFAULT_MODEL})",
+    )
+    parser.add_argument(
+        "--mode",
+        default="plain",
+        choices=["plain", "grounding"],
+        help="plain = markdown transcription; grounding = labelled layout blocks "
+        "with boxes, parsed into --blocks-column (default: plain)",
+    )
+    parser.add_argument(
+        "--image-column",
+        default="image",
+        help="Column containing images (default: image)",
+    )
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=16,
+        help="Batch size for processing (default: 16)",
+    )
+    parser.add_argument(
+        "--max-model-len",
+        type=int,
+        default=16384,
+        help="Maximum model context length (default: 16384; model supports 262144). "
+        "A 2048px page is at most 4,096 image tokens.",
+    )
+    parser.add_argument(
+        "--max-tokens",
+        type=int,
+        default=DEFAULT_MAX_TOKENS,
+        help=f"Maximum tokens to generate (default: {DEFAULT_MAX_TOKENS}, the card's "
+        "vLLM example). Raise it for very dense pages in grounding mode.",
+    )
+    parser.add_argument(
+        "--temperature",
+        type=float,
+        default=DEFAULT_TEMPERATURE,
+        help=f"Sampling temperature (default: {DEFAULT_TEMPERATURE}, model card)",
+    )
+    parser.add_argument(
+        "--top-p",
+        type=float,
+        default=DEFAULT_TOP_P,
+        help=f"Top-p (default: {DEFAULT_TOP_P}, model card; LightOn's client uses 1.0)",
+    )
+    parser.add_argument(
+        "--longest-edge",
+        type=int,
+        default=DEFAULT_LONGEST_EDGE,
+        help=f"Downscale pages so the longest edge is at most this many pixels "
+        f"(default: {DEFAULT_LONGEST_EDGE}, the training render size)",
+    )
+    parser.add_argument(
+        "--no-fix-dollars",
+        action="store_true",
+        help="Keep the raw model output instead of repairing escaped dollar "
+        "delimiters (the official client repairs them by default)",
+    )
+    parser.add_argument(
+        "--gpu-memory-utilization",
+        type=float,
+        default=0.8,
+        help="GPU memory utilization (default: 0.8)",
+    )
+    parser.add_argument("--hf-token", help="Hugging Face API token")
+    parser.add_argument(
+        "--split", default="train", help="Dataset split to use (default: train)"
+    )
+    parser.add_argument(
+        "--max-samples",
+        type=int,
+        help="Maximum number of samples to process (for testing)",
+    )
+    parser.add_argument(
+        "--private", action="store_true", help="Make output dataset private"
+    )
+    parser.add_argument(
+        "--config",
+        help="Config/subset name when pushing to Hub (for benchmarking multiple models in one repo)",
+    )
+    parser.add_argument(
+        "--create-pr",
+        action="store_true",
+        help="Create a pull request instead of pushing directly (for parallel benchmarking)",
+    )
+    parser.add_argument(
+        "--shuffle", action="store_true", help="Shuffle dataset before processing"
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=42,
+        help="Random seed for shuffling (default: 42)",
+    )
+    parser.add_argument(
+        "--output-column",
+        default="markdown",
+        help="Column name for output text (default: markdown)",
+    )
+    parser.add_argument(
+        "--blocks-column",
+        default="layout_blocks",
+        help="Column name for parsed layout blocks in grounding mode (default: layout_blocks)",
+    )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column(s) if they already exist in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Log resolved package versions after processing (useful for pinning deps)",
+    )
+
+    args = parser.parse_args()
+
+    if args.max_tokens > args.max_model_len:
+        parser.error(
+            f"--max-tokens ({args.max_tokens}) must be <= --max-model-len ({args.max_model_len})"
+        )
+
+    main(
+        input_dataset=args.input_dataset,
+        output_dataset=args.output_dataset,
+        model=args.model,
+        mode=args.mode,
+        image_column=args.image_column,
+        batch_size=args.batch_size,
+        max_model_len=args.max_model_len,
+        max_tokens=args.max_tokens,
+        temperature=args.temperature,
+        top_p=args.top_p,
+        longest_edge=args.longest_edge,
+        no_fix_dollars=args.no_fix_dollars,
+        gpu_memory_utilization=args.gpu_memory_utilization,
+        hf_token=args.hf_token,
+        split=args.split,
+        max_samples=args.max_samples,
+        private=args.private,
+        shuffle=args.shuffle,
+        seed=args.seed,
+        output_column=args.output_column,
+        blocks_column=args.blocks_column,
+        overwrite=args.overwrite,
+        verbose=args.verbose,
+        config=args.config,
+        create_pr=args.create_pr,
+    )

models.json

@@ -1,7 +1,7 @@
 {
   "_meta": {
     "description": "Machine-readable catalog of the OCR recipes in this directory: script -> model, params, backend, support level, the tested Jobs launch config (the script's [tool.hf-jobs] header), and what the model's own card claims about language coverage. Human-readable language notes: LANGUAGES.md. Language evidence levels, strongest first: per-language-benchmark | count-claim | named-list | multilingual-unspecified | english-only | not-stated | not-applicable. Claims come from model cards (compiled 2026-07-15) - treat as claims, not guarantees.",
-    "updated": "2026-09-24",
+    "updated": "2026-10-22",
     "run_pattern": "hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/<script> <input-dataset> <output-dataset>  (hf CLI >= 1.32 reads image/flavor/secrets from the script's [tool.hf-jobs] header; add --timeout for long runs. Scripts without a `jobs` entry need --flavor/-s HF_TOKEN (and any --image in their docstring).)",
     "support_levels": {
       "core": "Maintained. Smoke-tested flagless on HF Jobs on 2026-09-23/24 with the pinned launch config in `jobs`.",
@@ -314,6 +314,58 @@
     },
     "image": "vllm/vllm-openai:v0.22.1"
   },
+  "lighton-ocr3.py": {
+    "model_id": "lightonai/LightOnOCR-3-4B",
+    "params": "4B (or 0.8B via --model)",
+    "backend": "vllm",
+    "task": "ocr",
+    "output": "markdown; --mode grounding adds labelled layout blocks with 0-1000 boxes (layout_blocks JSON column)",
+    "license": "apache-2.0",
+    "languages": {
+      "evidence": "not-stated",
+      "notes": "LightOnOCR-3 cards give no language list (LightOnOCR-2 named 11)."
+    },
+    "support": "core",
+    "jobs": {
+      "image": "vllm/vllm-openai:v0.30.0",
+      "python": "/usr/bin/python3",
+      "env": {
+        "PYTHONPATH": "/usr/local/lib/python3.12/dist-packages"
+      },
+      "flavor": "a10g-small",
+      "secrets": [
+        "HF_TOKEN"
+      ]
+    },
+    "image": "vllm/vllm-openai:v0.30.0",
+    "notes": "Also runs lightonai/LightOnOCR-3-0.8B. Not LightOnOCR-3-1B (Pixtral arch, different pins). vLLM 0.30.0 pinned: upstream reports 0.27.1 loops."
+  },
+  "lighton-ocr3-bucket.py": {
+    "model_id": "lightonai/LightOnOCR-3-4B",
+    "params": "4B (or 0.8B via --model)",
+    "backend": "vllm",
+    "task": "ocr",
+    "output": "one .md per image/PDF page in an output dir; --mode grounding adds a .json sidecar of layout blocks",
+    "license": "apache-2.0",
+    "languages": {
+      "evidence": "not-stated",
+      "notes": "LightOnOCR-3 cards give no language list (LightOnOCR-2 named 11)."
+    },
+    "support": "core",
+    "jobs": {
+      "image": "vllm/vllm-openai:v0.30.0",
+      "python": "/usr/bin/python3",
+      "env": {
+        "PYTHONPATH": "/usr/local/lib/python3.12/dist-packages"
+      },
+      "flavor": "a10g-small",
+      "secrets": [
+        "HF_TOKEN"
+      ]
+    },
+    "image": "vllm/vllm-openai:v0.30.0",
+    "notes": "Bucket sibling of lighton-ocr3.py (same model, prompt, sampling). Input/output: hf://buckets/... URLs via bucketbag v0.3.1 (no mount) or directories. Reads .jp2; resume-by-skip."
+  },
   "lighton-ocr2-server.py": {
     "model_id": "lightonai/LightOnOCR-2-1B",
     "params": "1B",