I need pull

AGENTS.md

@@ -1,109 +0,0 @@
-# For coding agents
-
-This repo is a curated collection of ready-to-run OCR scripts — each one self-contained
-via UV inline metadata, runnable over the network via `hf jobs uv run`. No clone, no
-install, no setup.
-
-## Don't rely on this doc — discover the current state
-
-This file will go stale. Prefer these sources of truth:
-
-- `hf jobs uv run --help` — job submission flags (volumes, secrets, flavors, timeouts)
-- `hf jobs hardware` — current GPU flavors and pricing
-- `hf auth whoami` — check HF token is set
-- `hf jobs ps` / `hf jobs logs <id>` — monitor running jobs
-- `ls` the repo to see which scripts actually exist (bucket variants especially)
-- [README.md](./README.md) — the table of scripts with model sizes and notes
-
-## Picking a script
-
-The [README.md](./README.md) table lists every script with model size, backend, and
-a short note. Axes that matter:
-
-- **Model size** vs accuracy vs GPU cost. Smaller = cheaper per doc.
-- **Backend**: vLLM scripts are usually fastest at scale. `transformers` and
-  `falcon-perception` are alternatives for specific models.
-- **Task support**: most scripts do plain text; some expose `--task-mode`
-  (table, formula, layout, etc.) — check the script's own docstring.
-- **Language coverage**: [`models.json`](./models.json) maps every script to its model,
-  params, backend, required image pins, and what the model card claims about languages —
-  with an `evidence` level (`per-language-benchmark` beats a bare `multilingual` tag).
-  Human-readable version: [LANGUAGES.md](./LANGUAGES.md).
-
-For the authoritative benchmark numbers on any model in the table, query the model
-card programmatically — every OCR model publishes eval results on its card:
-
-    from huggingface_hub import HfApi
-    info = HfApi().model_info("tiiuae/Falcon-OCR", expand=["evalResults"])
-    for r in info.eval_results:
-        print(r.dataset_id, r.value)
-
-See the [leaderboard data guide](https://huggingface.co/docs/hub/en/leaderboard-data-guide)
-for the full API. This is more reliable than any markdown table that might drift.
-
-## Getting help from a specific script
-
-Each script has a docstring at the top with a description and usage examples. To read it
-without downloading:
-
-    curl -s https://huggingface.co/datasets/uv-scripts/ocr/raw/main/<script>.py | head -100
-
-Or open the URL in a browser. Running `uv run <url> --help` locally may fail if the
-script has GPU-only dependencies — reading the docstring is more reliable.
-
-## The main pattern: dataset → dataset
-
-Most scripts take an input HF dataset ID and push results to an output HF dataset ID:
-
-    hf jobs uv run --flavor l4x1 -s HF_TOKEN \
-      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/<script>.py \
-      <input-dataset-id> <output-dataset-id> [--max-samples N] [--shuffle]
-
-The script adds a `markdown` column to the input dataset and pushes the merged result
-to the output dataset ID on the Hub.
-
-## Alternative: directory → directory (bucket variants)
-
-A couple of scripts have `-bucket.py` variants (currently `falcon-ocr-bucket.py` and
-`glm-ocr-bucket.py`) that read from a mounted directory and write one `.md` per image
-(or per PDF page). Useful with HF Buckets via `-v`:
-
-    hf jobs uv run --flavor l4x1 -s HF_TOKEN \
-      -v hf://buckets/<user>/<input>:/input:ro \
-      -v hf://buckets/<user>/<output>:/output \
-      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/<script>-bucket.py \
-      /input /output
-
-`ls` the repo to check whether a `-bucket.py` variant exists for the model you want
-before assuming it's available.
-
-The `-v` source can also be a **local directory** (`huggingface_hub` ≥ 1.22) — the CLI
-syncs it to a private bucket and mounts it, so local images/PDFs need no upload step:
-
-    hf jobs uv run --flavor l4x1 -s HF_TOKEN \
-      -v ./pages:/input \
-      -v hf://buckets/<user>/<output>:/output \
-      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/<script>-bucket.py \
-      /input /output
-
-Re-runs only sync new/changed files. Local mounts are read-only by default; a local
-*output* dir works too with `:rw` — pull results back with the `hf buckets sync`
-command the CLI prints at launch.
-
-## Common flags across dataset-mode scripts
-
-Most scripts support: `--max-samples`, `--shuffle`, `--seed`, `--split`, `--image-column`,
-`--output-column`, `--private`, `--config`, `--create-pr`, `--verbose`. Read the script's
-docstring for the authoritative list — individual scripts may add model-specific options
-like `--task-mode`.
-
-## Gotchas
-
-- **Secrets**: pass `-s HF_TOKEN` to forward the user's token into the job.
-- **GPU required**: all scripts exit if CUDA isn't available. `l4x1` is the cheapest
-  GPU flavor and works for models up to ~3B. Check `hf jobs hardware` for current options.
-- **First run is slow**: model download + `torch.compile` / vLLM warmup dominates small
-  runs. Cost per doc drops sharply past a few hundred images — test with `--max-samples 10`
-  first, then scale.
-- **Don't poll jobs**: jobs run async. Submit once, check status later with
-  `hf jobs ps` or `hf jobs logs <id>`.

CLAUDE.md

@@ -1,444 +1,213 @@
-# OCR Scripts — Development Notes
+# OCR Scripts - Development Notes
 
-Dev notes for the `ocr/` recipes: the **conventions** to follow, the **per-script gotchas** (the
-"why" behind each script's quirks), and the **internal tooling**. Runnable examples live in each
-script's docstring and `README.md`; benchmark result tables live in `OCR-BENCHMARK.md`.
+## Active Scripts
 
-- [Conventions & invariants](#conventions--invariants) — read before adding/changing a recipe
-- [Script status](#script-status) · [Per-script gotchas](#per-script-gotchas)
-- [Internal tooling](#internal-tooling) · [Deferred / tracked](#deferred--tracked) · [Change log](#change-log)
+### DeepSeek-OCR v1 (`deepseek-ocr-vllm.py`)
+✅ **Production Ready**
+- Fully supported by vLLM
+- Fast batch processing
+- Tested and working on HF Jobs
 
----
-
-## Conventions & invariants
-
-Read this before adding or changing a recipe. Each rule maps to a failure we've actually hit; the
-planned **self-review skill** (see [Deferred](#deferred--tracked)) just enforces this list.
-
-- **Catalog entry.** Adding or changing a recipe means updating [`models.json`](./models.json)
-  (script → model, params, backend, image pins, language claim) and, if the language claim
-  changed, [LANGUAGES.md](./LANGUAGES.md). Language fields record what the **model card claims**
-  (with an evidence level), never inferred coverage. Hand-maintained for now; if drift becomes a
-  problem, the follow-up is generating the README table from the JSON.
-- **Model-card fidelity.** Default prompts, sampling and processor settings come from the model
-  card or official client — cite the exact source in a comment (e.g. `# glmocr/config.py
-  PageLoaderConfig`), or say "card gives none" if upstream is silent. Upstream-locked values stay
-  locked; expose only the knobs upstream sanctions. Deliberate deviations go in the docstring with
-  the why. Benchmark before overriding a card value that looks wrong (e.g. hunyuan-1.5
-  `repetition_penalty` on tables, [#85](https://github.com/davanstrien/uv-scripts/issues/85))
-  — never silently "improve" it. Docstring/card claims (params, scores, languages) must match the
-  card too.
-- **Self-contained single file.** Each recipe is one PEP 723 UV script runnable from a raw URL
-  (`hf jobs uv run <url>`). No shared *importable local* module (the job env only gets the one file).
-  Extra pip deps are fine — **pin them**. A heavy/stable/shared subsystem may become an opt-in *package*
-  dep (e.g. bucket I/O → `bucketbag`, [#67](https://github.com/davanstrien/uv-scripts/issues/67)),
-  never a local import. Recipes = inline; internal tooling may share freely.
-- **GPU + output.** Check `torch.cuda.is_available()` and exit clearly if absent. Write to the Hub
-  (`push_to_hub`) or a bucket (`-v hf://…`), never bare local paths (Jobs disk is ephemeral; local *input*
-  dirs mount via `-v ./dir:/mnt`, synced to a bucket automatically).
-- **vLLM image + fail-fast preflight.** If the model's arch isn't in a stable vLLM wheel, **omit
-  `vllm`/`torch` from deps** and run on the pinned `vllm/vllm-openai` image via
-  `--image … --python … -e PYTHONPATH=…`; add a preflight that `sys.exit(1)`s naming the exact flags
-  (surya-class — see gotchas). Pinned-image scripts: `surya-ocr` (`:v0.20.1`, **site-packages**),
-  `nanonets-ocr2` (`:v0.10.2`), `unlimited-ocr` (`:unlimited-ocr`), `deepseek-ocr2`/`glm-ocr` (nightly).
-- **Pins are temporary.** An image/version pin (`:v0.10.2`, `:v0.20.1`, a nightly, `surya-ocr==0.20.0`,
-  …) is a workaround for a *current* ecosystem gap — a decode regression, an arch not yet in a stable
-  wheel, a resolver backtrack. In the recipe, record **why** the pin exists and **what would loosen it**
-  (e.g. "move back to the default image when a newer vLLM ships a Qwen2.5-VL decode fix"; "drop the
-  nightly once the arch lands in a stable release"). Re-test periodically and relax when the gap closes —
-  that's what the `maintain-recipes` skill is for; prefer floors over exact pins once you can.
-  This applies to **active** recipes. **Frozen** recipes (superseded or little used) pin image digest,
-  package cutoff and model revision on purpose and get fixes only when they break — see
-  [MAINTAINING.md](https://github.com/davanstrien/uv-scripts/blob/main/MAINTAINING.md).
-- **Env guards on the bare image.** Set `VLLM_USE_FLASHINFER_SAMPLER=0` (and `VLLM_USE_DEEP_GEMM=0`
-  for nightly vLLM) **before** importing `vllm` — both JIT paths need `nvcc`, which the bare uv image lacks.
-- **Context-length invariant.** `--max-tokens` ≤ `--max-model-len` ≤ the model's real max context
-  (`config.json` `max_position_embeddings`; VLMs → `text_config`, mind `rope_scaling`). vLLM refuses to
-  start if `max_model_len` is over (we don't set `VLLM_ALLOW_LONG_MAX_MODEL_LEN`); output can't fit if
-  `max_tokens` > `max_model_len`. Check:
-  `curl -s https://huggingface.co/<model>/raw/main/config.json | python -c "import json,sys;c=json.load(sys.stdin);t=c.get('text_config',c);print(t.get('max_position_embeddings'),t.get('rope_scaling'))"`.
-- **Output-column collision guard.** Every recipe that adds an output column calls
-  `ensure_output_columns_free(dataset, [cols], overwrite)` (or the inline sink guard for pp-*) so it
-  fails fast instead of duplicating/clobbering an input column; `--overwrite` opts into replacing it.
-  Default `--output-column` is `markdown` (never a bare `text`). ([#66](https://github.com/davanstrien/uv-scripts/pull/66))
-- **Bound large images.** Full-page recipes cap input pixels / resize, or size `max_model_len` to fit —
-  a 7–9 MP page is ~14k image tokens. Prefer bounding the input (deterministic) over a giant context;
-  don't auto-size `max_model_len` from images (it's fixed at engine init, before images are seen).
-- **Dep sanity.** No stale version *caps* that drag a transitive lib back — e.g. `pyarrow<18` forced an
-  old `datasets` lacking the `Json` feature → `load_dataset` crashed (the glm-ocr bug). Use floors, not ceilings.
-  **Exception: image limits.** On a pinned image the image's copy of a shared package wins over uv's, so a
-  cap that encodes what the image ships is correct (e.g. `datasets<5.1` because 5.1 needs
-  `huggingface_hub>=1.31` and images before v0.30 ship older). Comment the reason next to the cap
-  ([MAINTAINING.md](https://github.com/davanstrien/uv-scripts/blob/main/MAINTAINING.md), "Image-mode recipes").
-- **Error signalling (known gap).** Scripts currently write sentinels (`[OCR ERROR]`, `[SURYA GENERATE
-  ERROR]`) *into* the output column, so partial failures are silent. A companion `ocr_error` status
-  column is the deferred fix (see [Deferred](#deferred--tracked)).
+### LightOnOCR-2-1B (`lighton-ocr2.py`)
+✅ **Production Ready** (Fixed 2026-01-29)
 
----
+**Status:** Working with vLLM nightly
 
-## Script status
-
-Legend: ✅ production-ready · ⚠️ works only with a required pinned image · 🧪 experimental/on-hold.
-"+image" = needs a `--image vllm/vllm-openai:<tag>` override (not the default uv image).
-
-| Script | | Backend | Flavor | Note |
-|--------|--|---------|--------|------|
-| `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 | |
-| `dots-ocr.py` | ✅ | vLLM (stable) | l4x1 | `--max-model-len` 32768; no internal resize |
-| `dots-ocr-1.5.py` | ✅ | vLLM 0.17.1 | l4x1 | see gotcha (`content_format`, mirror, bbox space) |
-| `glm-ocr.py` | ✅ | vLLM (nightly) | l4x1 | `VLLM_USE_DEEP_GEMM=0`; no pyarrow cap |
-| `ovis-ocr2.py` | ✅ | vLLM (stable ≥0.22.1) | l4x1 / a10g-small | `gdn_prefill_backend="triton"` (card); card-exact prompt via `enable_thinking=False` template + `llm.generate`; `<img>` region tags filtered by default (`--keep-image-tags`) |
-| `xiaomi-ocr-0-saturate.py` | ✅ | vLLM or SGLang + saturate | a10g-small / rtx-pro-6000 | single-stage only; OTSL→HTML + math delimiters vendored from upstream; `max_tokens` 12000 to fit the 16384 context; default `Auto()` window |
-| `glm-ocr-v2.py` | 🧪 | vLLM (nightly) | l4x1 | CommitScheduler incremental — on hold (see Deferred) |
-| `nanonets-ocr.py` | ✅ | vLLM | a10g-small | `--max-model-len` 32768 (`--max-tokens` 15000) |
-| `nanonets-ocr2.py` | ⚠️+image | vLLM `:v0.10.2` | a10g-small | Qwen2.5-VL ≥0.11 regression → pure `!` |
-| `unlimited-ocr-vllm.py` | ✅+image | vLLM `:unlimited-ocr` | l4x1 | single-image; multi-page → serve |
-| `unlimited-ocr2.py` | ✅+image | SGLang (Baidu wheel) on `lmsysorg/sglang:v0.5.20-cu130` | rtx-pro-6000 | 16-page windows; ≥48 GB GPU |
-| `unlimited-ocr2-saturate.py` | 🧪+image | same | rtx-pro-6000 | tuned/experimental: repair pass, JP2 fast decode, PDFs |
-| `unlimited-ocr2-live.py` | 🧪+image | same | rtx-pro-6000 | experimental: minimal script + `--live-port` dashboard (streams the page being read) |
-| `hpd-parsing-saturate.py` | 🧪+image | saturate + Paddle's vLLM fork on `cr.hf.co/davanstrien/hpd-parsing-vllm` (vendor image + uv) | l4x1 | `markdown` + `hpd_blocks` + `looped_blocks` — see gotcha |
-| `minicpm-ocr.py` | 🧪+image | in-job vLLM nightly + minicpm-ocr SDK on `cr.hf.co/davanstrien/minicpm-ocr` | a10g-large | vendor pipeline; custom public image; dataset **or** bucket I/O (bucketbag), `markdown_status` |
-| `surya-ocr.py` | ✅+image | vLLM `:v0.20.1` | l4x1 | offline backend inject; site-packages PYTHONPATH |
-| `surya-ocr-bucket.py` | ✅+image | vLLM `:v0.20.1` | l4x1 | bucket I/O; pin `surya-ocr==0.20.0` |
-| `lift-extract.py` | ✅ | hf / vLLM | a100-large | schema-constrained extraction; naming gotcha |
-| `nuextract3.py`, `lfm2-extract.py`, `lfm2-vl-extract.py` | ✅ | vLLM | l4x1 | structured extraction |
-| `hunyuan-ocr.py` | ✅ | vLLM | l4x1 | **1.0, revision-pinned** (root repo became 1.5 in-place); `transformers<5.13` cap — see gotcha |
-| `hunyuan-ocr-1.5.py` | ✅ | vLLM | l4x1 | tracks repo root (=1.5); task-locked prompts; `transformers<5.13` cap — see gotcha |
-| `rolm-ocr.py`, `smoldocling-ocr.py`, `numarkdown-ocr.py`, `qianfan-ocr.py`, `firered-ocr.py`, `abot-ocr.py`, `falcon-ocr.py`, `olmocr2-vllm.py`, `dots-mocr.py` | ✅ | vLLM | varies | see `README.md` for flags |
-| `pp-ocrv6.py`, `pp-doclayout.py` | ✅ | PaddleOCR / PaddleX | l4x1 | classical det+rec; dataset **or** bucket I/O |
-
-**License note:** Surya and `lift` ship code as Apache-2.0 but **weights under a modified OpenRAIL-M**
-(research/personal/<$5M, no competitive use vs Datalab's API) — surfaced in each docstring + card.
-HunyuanOCR (1.0 + 1.5) is under the [Tencent Hunyuan Community License](https://huggingface.co/tencent/HunyuanOCR/blob/main/LICENSE)
-(territory excludes EU/UK/South Korea; standard across Tencent's Hunyuan releases) — surfaced in each docstring + card.
+**What was fixed:**
+- Root cause was NOT vLLM - it was the deprecated `HF_HUB_ENABLE_HF_TRANSFER=1` env var
+- The script was setting this env var but `hf_transfer` package no longer exists
+- This caused download failures that manifested as "Can't load image processor" errors
+- Fix: Removed the `HF_HUB_ENABLE_HF_TRANSFER=1` setting from the script
 
----
+**Test results (2026-01-29):**
+- 10/10 samples processed successfully
+- Clean markdown output with proper headers and paragraphs
+- Output dataset: `davanstrien/lighton-ocr2-test-v4`
 
-## Per-script gotchas
-
-Only the scripts with load-bearing quirks; the rest are unremarkable (`README.md` covers flags).
-
-### `surya-ocr.py` / `surya-ocr-bucket.py` — pinned image + site-packages path
-Surya-2 (`datalab-to/surya-ocr-2`, 650M, `qwen3_5`) needs its **known-good** vLLM build, and the
-`:v0.20.1` image puts python at `/usr/local/bin/python3` and libs at
-**`/usr/local/lib/python3.12/site-packages`** (not the usual `dist-packages`) — wrong path →
-`No module named 'vllm'` → 0/5. It can't Docker-in-Docker Surya's normal server, so it **injects an
-in-process `OfflineVLLMBackend`** into `SuryaInferenceManager` (subclassing Surya's `Backend` ABC) and
-reuses Surya's own prompts/`scale_to_fit`/HTML+bbox parsing so the offline path matches the server.
-`mm_processor_kwargs={min_pixels:3136, max_pixels:6291456}`, `max_model_len=18000`, `logprobs=1` →
-per-block `confidence`. Writes two columns (`--output-column` markdown + `surya_blocks` JSON). Never
-name the file `surya.py` (shadows the package). The recipe now **fails fast** if `vllm` isn't importable,
-naming the required flags. **Bucket variant:** pin `surya-ocr==0.20.0` (loosening it, or adding
-`huggingface-hub>=1.6.0`, lets uv backtrack to a surya without `surya.inference`); **copy beats mount**
-for bucket reads (FUSE `rglob` is ~26× slower on a 38k-file bucket; mount also hit a transient CSI flake);
-`.jp2` via an `imagecodecs` fallback (Pillow lacks OpenJPEG); resume-by-skip on the output `.json`.
-
-### `nanonets-ocr2.py` — pinned `:v0.10.2` image
-Nanonets-OCR2-3B is **Qwen2.5-VL**, which has a vLLM **≥0.11 decode regression** (outputs pure `!` on
-every page) — [vllm#27775](https://github.com/vllm-project/vllm/issues/27775). 0.9.2/0.10.1/**0.10.2**
-are known-good. Not context length (still `!` at 32768) and not torch.compile. Pip-pinning `vllm==0.10.2`
-clashes with modern `transformers` (old tokenizer API), so run on the **`:v0.10.2` image** (ships a
-consistent vLLM 0.10.2 + transformers 4.56.1); `vllm`/`torch` omitted from deps. `--max-model-len` 32768
-(the 15000 `--max-tokens` can't fit 8192). Re-test the default image when a newer vLLM ships a Qwen2.5-VL
-decode fix.
-
-### `dots-ocr-1.5.py` — `content_format="string"` + resized-bbox space
-Must pass `chat_template_content_format="string"` to `llm.chat()` — the model's `tokenizer_config.json`
-template expects string content; without it you get ~1 token then EOS (empty output). The v1.5 weights
-aren't on HF from the authors — **mirrored to `davanstrien/dots.ocr-1.5`** from ModelScope (MIT-based).
-Layout bboxes are in the **resized** image space (`Qwen2VLImageProcessor.smart_resize`,
-`max_pixels=11,289,600`, `factor=28`); map back with:
-```python
-import math
-def smart_resize(h, w, factor=28, min_pixels=3136, max_pixels=11289600):
-    h_bar, w_bar = max(factor, round(h/factor)*factor), max(factor, round(w/factor)*factor)
-    if h_bar*w_bar > max_pixels:
-        beta = math.sqrt((h*w)/max_pixels); h_bar, w_bar = math.floor(h/beta/factor)*factor, math.floor(w/beta/factor)*factor
-    elif h_bar*w_bar < min_pixels:
-        beta = math.sqrt(min_pixels/(h*w)); h_bar, w_bar = math.ceil(h*beta/factor)*factor, math.ceil(w*beta/factor)*factor
-    return h_bar, w_bar
-# orig_x = bbox_x * (orig_w / w_bar);  orig_y = bbox_y * (orig_h / h_bar)
+**Example usage:**
+```bash
+hf jobs uv run --flavor a100-large \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr2.py \
+    davanstrien/ufo-ColPali output-dataset \
+    --max-samples 10 --shuffle --seed 42
 ```
-(Same `smart_resize`/`max_pixels=11.29M` applies to `dots-ocr.py` v1's processor cap — but the
-`content_format="string"` fix does **not**: v1 works with the auto-detected `openai` chat format.)
-
-### `unlimited-ocr-vllm.py` — dedicated image, single-image batch
-Baidu `baidu/Unlimited-OCR` (3.3B, DeepSeek-OCR descendant); arch is in **no stable vLLM wheel**, so it
-runs on **`vllm/vllm-openai:unlimited-ocr`** (`:unlimited-ocr-cu129` on Hopper), standard `/usr/bin/python3`
-+ `dist-packages`. `NGramPerReqLogitsProcessor` (re-exported via `unlimited_ocr`), prompt
-`<image>document parsing.`, `limit_mm_per_prompt={"image":1}`, `--strip-grounding` drops `<|det|>`/`<|ref|>`.
-**Batch recipe stays single-image**; multi-page is finicky offline (one `<image>` per page; degrades on
-hard scans) and belongs to **serving** — both engines read clean multi-page docs, but **SGLang is more
-robust on hard/degraded scans**. Serving setup (SGLang pin `lmsysorg/sglang:v0.5.10.post1`, a100+flashinfer
-— HF `h200` nodes fail with `CUDA error 802`) is in `serving-unlimited-ocr.md`.
-
-### `minicpm-ocr.py` — vendor SDK pipeline on a custom `cr.hf.co` image
-MiniCPM-OCR 1.0 is a region reader: OpenBMB's SDK runs PP-DocLayoutV3, crops regions, prompts each by
-type and assembles Markdown. The recipe runs that SDK unchanged (separate venv `/opt/sdk`, as OpenBMB
-require) against `vllm serve` started in the job. Measured/learned 2026-10-27:
-- `MiniCPMOcrForConditionalGeneration` is in vLLM main (18343393b4, 23 Oct) but not in v0.32.0, and
-  OpenBMB's install builds vLLM from source (~40 min). The image uses nightly 5d35ce3 pinned by digest
-  instead; Dockerfile + digest in `images/minicpm-ocr/`. Move to a stock tag when a release has the arch.
-- pip warns `transformers 5.21.0.dev0` (OpenBMB's pin 549e5b4) violates vLLM's `<5.21.0` (a pre-release
-  of 5.21.0 is excluded by `<5.21.0`); vLLM serves the model anyway.
-- The SDK's default layout path is `${ASSETS_DIR}/PP-DocLayoutV3`, not the docs' `models/PP-DocLayoutV3_infer`;
-  the recipe passes the baked path explicitly. The layout tar is sha256-checked at build time.
-- Built with kaniko on a `cpu-upgrade` Job (~20 min); container repo creation needed the stored `cli` token
-  (the OAuth login gets 403). `l4x1` had no capacity on 27 Oct; smoke ran on `a10g-large`.
-- The SDK reads a folder: the recipe writes each batch as `{i:06d}.png` and reads `output/{i:06d}.md` back.
-- The SDK writes a `.md` even when regions fail (empty for a failed text region); the page status lives in
-  `per_page_metrics.jsonl` (`ok` / `partial_failed` / `failed`). The recipe reads it: dataset mode keeps it in
-  `markdown_status`; bucket mode writes only `ok` pages so a re-run retries the rest (Codex review, 27 Oct).
-- vLLM runs in its own process group and is terminated → killed → reaped on every exit path; one bad
-  image or a failed SDK run marks its pages `error: ...` instead of losing finished batches.
-
-### `hpd-parsing-saturate.py` — Paddle's vLLM fork, on their image plus uv
-`PaddlePaddle/HPD-Parsing` (1B, InternVL3.5 + Qwen3-0.6B) runs only on Paddle's **fork of vLLM**
-(`0.17.1+hpdparsing`), which adds the request forking its decoding needs. The fork ships only in
-`ccr-2vdh3abv-pub.cnc.bj.baidubce.com/paddlepaddle/hpd-parsing-vllm` (tags `latest-nvidia-gpu`, and
-`-offline` with weights baked in). It pulls anonymously; the recipe pins `latest-nvidia-gpu` by digest
-(`87496aa5…`, built 2026-07-16, unchanged as of 2026-11-05). ~11 GB. Job scheduling time (queue + pull) on
-5 Nov: 7–27 min from Paddle's registry, 2.5 min for the same image from `cr.hf.co`.
-Inside: CUDA 12.8.1, python3.10 venv at `/home/hpd/venv` first on `PATH`, user `hpd`, FlashInfer.
-Measured 2026-07-27 and 2026-11-05:
-1. **No `uv` in Paddle's image**, which `hf jobs uv run` needs. The header uses
-   `cr.hf.co/davanstrien/hpd-parsing-vllm`: Paddle's image (digest-pinned) plus one layer with `uv`/`uvx`
-   (`images/hpd-parsing/build.sh`, `crane append` on a CPU Job, ~7 min; public). To rebuild after a Paddle
-   update, change `BASE_DIGEST` in `build.sh`. The docstring keeps a `hf jobs run … bash -lc 'pip install uv
-   && uv run …'` command for Paddle's image directly.
-2. `requires-python` includes 3.10 so uv uses the image's own Python instead of downloading one.
-3. **Speculative head path:** the entrypoint's `"model": "PaddlePaddle/HPD-Parsing/P-MTP"` is a local
-   directory in the `-offline` image only. The recipe downloads the `P-MTP/*` subfolder and passes its
-   path. Expected log line, every run: `Error retrieving safetensors: Repo id must be in the form …`.
-4. **`--enable-prefix-caching` stays ON** (forked children share the parent's prefix KV; 43.9–52.9% hit
-   rate). `--attention-config '{"use_prefill_query_quantization":true}'` is fork-only. Both come from
-   `/home/hpd/entrypoint.sh`. Works on `a100-large` (sm80) as well as `l4x1`.
-5. **Bboxes are 0–1000 normalized**, not pixels (`px = v/1000 * width`), verified by overlay in July.
-   The parser is the demo Space's bbox-preserving `parse_blocks`; the model repo's `eval/hpd_to_markdown.py`
-   drops chart/seal blocks and bboxes. Re-parsing July's `hpd_raw` reproduced July's markdown on 34/34 pages.
-6. saturate's readiness probe logs `The model 'readiness-probe' does not exist` (404) once; that is the
-   "server is alive" signal, not an error.
-
-**Limits seen in testing: loops, and `max_tokens` does not bound a page.** Each forked child branch has
-its own `max_tokens` budget, so a page that fragments into hundreds of regions can emit far more than the
-cap (179k completion tokens for one page at `max_tokens` 8000). On 12 Chronicling America pages
-(1774–1809), 3 pages looped: 726,706 chars (July) / 544,120 (November) vs 24,907 in LoC's OCR on the
-worst. Those 3 ended with `finish_reason=length`, the other 9 with `stop`, and `looped_blocks` > 0 on
-exactly the same 3. One UFO page had a 26,675-char loop. `looped_blocks` counts blocks
-of ≥2000 bytes whose zlib ratio is ≥4 (≥10 for `table`): ordinary text compresses ~2×, loops 6–330×
-(a counting loop "of the 860th of the 861th …" is the 6× case), the most compressible real block was a
-1.5 KB table at 5.3×. Calibrated on 345 blocks from the July outputs: 0 false positives. The text is
-kept as the model wrote it; filter rows on `looped_blocks == 0`. Accuracy (94.91 OmniDocBench v1.6) is
-below `ovis-ocr2`/`paddleocr-vl-1.6`; the recipe earns its place with the layout column. en/zh only.
-
-`hpd-parsing-server.py` (PR #95, July) is the hand-rolled driver for the same server; this recipe
-replaces it.
-
-### `unlimited-ocr2.py` / `unlimited-ocr2-saturate.py` — Baidu SGLang wheel, multi-page windows
-v2 has no vLLM support; Baidu ships a custom SGLang wheel in the model repo. Its pins (torch 2.13.0,
-transformers 5.12.1, flashinfer 0.6.18 cu13) match **`lmsysorg/sglang:v0.5.20`** exactly → `-cu130` image,
-wheel installed `--no-deps` into the image's **`/opt/sglang` venv** (found on PATH past the uv venv). Move
-image and wheel together. Gotchas measured 2026-10-27 on 1771 Britannica:
-- The card's n-gram guard is a pure-Python logit processor run every decode step → decode is
-  scheduler-CPU-bound (A100 at ~33% GPU util). Turning it off breaks windows (13/32 failed); window 128
-  is 1.3x faster but loops more → keep 1024. The processor string is a fixed pickled global (no sglang
-  or dill needed in the driver).
-- 16-page windows reach ~31k tokens of KV each: 24 GB GPUs thrash (retractions), l40s (48 GB) hits KV
-  pressure; rtx-pro-6000 (96 GB, 23 vCPU) was 1.6x a100-large throughput at ~30% lower $/page.
-- ~2% of dense pages (mathematics) loop; the per-page token cap then forces a `<PAGE>` and shifts the next
-  page's text by one. `-saturate` re-reads looping pages + empty neighbours alone in gundam mode (28/33 fixed).
-- Send pages at 1280 px in base mode (the model sees a 1024 view): 1600+ px bodies (~14 MB per window)
-  stalled SGLang's HTTP front end past saturate's fixed 30 s connect/write timeouts.
-- saturate 0.2.0: `RETRY_BUDGET_S` (300 s) < one window, so retries always timed out → raised to 3600 in
-  the scripts; `Auto` widens only on completions (start it at 32); `flush_every=4`. Pinned `==0.2.0`.
-- JP2 decode at a reduced level (`img.reduce`) failed intermittently in Jobs ("broken data stream", not
-  reproducible on macOS) → fallback to a fuller decode.
-
-### `lift-extract.py` — naming + backends
-Datalab `lift` (9B, Qwen3.5), schema-constrained image/PDF → JSON; the only recipe ingesting PDFs directly.
-**Must not be named `lift.py`** (shadows the installed `lift` package → ImportError). Two in-process backends
-via `--method`: `hf` (default image, plain `model.generate`) and `vllm` (needs the `vllm/vllm-openai` image;
-reproduces lift's own recipe: `mm_processor_kwargs={min_pixels:3136,max_pixels:861696}`, guided JSON schema,
-`temperature=0.0,top_p=0.1,max_tokens=12384`). Pin `--model datalab-to/lift` via the `MODEL_CHECKPOINT` env
-(settings read env at import).
-
-### `deepseek-ocr-vllm.py` / `deepseek-ocr2-vllm.py`
-v1 uses the official offline pattern (`llm.generate()` + `NGramPerReqLogitsProcessor` for repetition).
-**Known bug** (hit on vLLM *nightly*, 2026-02-12; unverified on the stable wheels v1 now resolves):
-some aspect ratios trip `images_crop dim[2] expected 1024, got 640` (gundam-mode
-default vs a validator expecting 1024²) — hit 2/10 on `ufo-ColPali`, aspect-ratio dependent, no upstream
-issue filed ([vllm#28160](https://github.com/vllm-project/vllm/issues/28160) is the related request). v2
-needs **nightly** vLLM (`DeepseekOCR2ForCausalLM` not in stable) + `addict`/`matplotlib` (its HF custom
-code), plus `limit_mm_per_prompt={"image":1}`.
-
-### `hunyuan-ocr.py` / `hunyuan-ocr-1.5.py` — upstream replaced the repo root in-place
-On 2026-07-06 Tencent pushed HunyuanOCR-1.5 **into the same repo** `tencent/HunyuanOCR` (1.5 at root,
-1.0 archived under `v1.0/`, DFlash draft under `dflash/`, **no 1.0 tag or branch**). vLLM can't load a
-repo subfolder, so `hunyuan-ocr.py` pins the last 1.0 commit by `revision` (`f6af82ee…`) — that pin is
-the 1.0 *identity*, never loosen it to `main`; 1.5 is its own recipe (`hunyuan-ocr-1.5.py`, tracks root,
-has `--revision` as insurance against the next in-place swap). Separate breakage, both scripts: stable
-vLLM ≤0.24.0's `hunyuan_vl_image.py` does a string-key `AutoImageProcessor.register(...)` which
-transformers 5.13 rejects (`'str' object has no attribute '__module__'` → "architectures failed to be
-inspected" at engine init) — hence the `transformers<5.13` cap in both; drop it when the vllm#47872 fix
-ships in a stable wheel. 1.5 prompts are task-locked (12 types, Chinese wording, from the official
-client's `hunyuan_tasks.py`) and sampling is card-locked (temp 0.0, rep-penalty 1.08) — don't
-"improve" either; upstream observed hand-tweaked prompts silently degrade quality.
-
-### `glm-ocr.py`
-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,
-resize 1540px @200 DPI, `--max-model-len` 16384. `paddleocr-vl-1.5.py` uses the **transformers** backend
-(single-image) because PaddleOCR-VL only supports vLLM in server mode.
 
----
+**Model Info:**
+- Model: `lightonai/LightOnOCR-2-1B`
+- Architecture: Pixtral ViT encoder + Qwen3 LLM
+- Training: RLVR (Reinforcement Learning with Verifiable Rewards)
+- Performance: 83.2% on OlmOCR-Bench, 42.8 pages/sec on H100
+
+### PaddleOCR-VL-1.5 (`paddleocr-vl-1.5.py`)
+✅ **Production Ready** (Added 2026-01-30)
+
+**Status:** Working with transformers
 
-## Internal tooling
+**Note:** Uses transformers backend (not vLLM) because PaddleOCR-VL only supports vLLM in server mode, which doesn't fit the single-command UV script pattern. Images are processed one at a time for stability.
 
-Not user recipes — benchmark/eval infra. **Result tables + validation history → `OCR-BENCHMARK.md`.**
+**Test results (2026-01-30):**
+- 10/10 samples processed successfully
+- Processing time: ~50s per image on L4 GPU
+- Output dataset: `davanstrien/paddleocr-vl15-final-test`
 
-### `ocr-bench-run.py` — coordinator
-Launches N OCR models on the same dataset, each pushing to a shared repo as a separate config via
-`--config/--create-pr`. Eval separately with `ocr-vllm-judge.py` / `ocr-elo-bench.py`. Registry (4 models):
-`glm-ocr`, `deepseek-ocr` (auto `--prompt-mode free`), `lighton-ocr-2`, `dots-ocr`; each has a `default_args`.
+**Example usage:**
 ```bash
-uv run ocr-bench-run.py source-dataset --output my-bench --max-samples 50
-uv run ocr-bench-run.py --list-models              # registry table
-uv run ocr-bench-run.py ... --models glm-ocr dots-ocr --dry-run
-uv run ocr-elo-bench.py my-bench --from-prs --mode both   # eval from PRs, no merge
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl-1.5.py \
+    davanstrien/ufo-ColPali output-dataset \
+    --max-samples 10 --shuffle --seed 42
 ```
 
-### `ocr-vllm-judge.py` — offline vLLM jury judge
-Pairwise OCR-quality comparisons via vLLM offline `LLM()`; jury mode (multiple models vote, majority
-aggregation) with **0 parse failures** (structured output via the `StructuredOutputsParams` → `GuidedDecodingParams`
-→ prompt shim). Prefer over the API judge (`ocr-jury-bench.py`) for batch eval — no rate limits, reproducible.
-`--from-prs` loads configs from open PRs without merging; `--save-results REPO` persists comparisons/leaderboard/metadata.
-A100 recommended for jury mode; L4 works for a single 7B judge.
-```bash
-hf jobs uv run --flavor a100-large -s HF_TOKEN ocr-vllm-judge.py davanstrien/ocr-bench-nls-50 --from-prs \
-    --judge-model Qwen/Qwen2.5-VL-7B-Instruct --judge-model Qwen/Qwen3-VL-8B-Instruct --max-samples 50
+**Task modes:**
+- `ocr` (default): General text extraction to markdown
+- `table`: Table extraction to HTML format
+- `formula`: Mathematical formula recognition to LaTeX
+- `chart`: Chart and diagram analysis
+- `spotting`: Text spotting with localization (uses higher resolution)
+- `seal`: Seal and stamp recognition
+
+**Model Info:**
+- Model: `PaddlePaddle/PaddleOCR-VL-1.5`
+- Size: 0.9B parameters (ultra-compact)
+- Performance: 94.5% SOTA on OmniDocBench v1.5
+- Backend: Transformers (single image processing)
+- Requires: `transformers>=5.0.0`
+
+## Pending Development
+
+### DeepSeek-OCR-2 (Visual Causal Flow Architecture)
+
+**Status:** ⏳ Waiting for vLLM upstream support
+
+**Context:**
+DeepSeek-OCR-2 is the next generation OCR model (3B parameters) with Visual Causal Flow architecture offering improved quality. We attempted to create a UV script (`deepseek-ocr2-vllm.py`) but encountered a blocker.
+
+**Blocker:**
+vLLM does not yet support `DeepseekOCR2ForCausalLM` architecture in the official release.
+
+**PR to Watch:**
+🔗 https://github.com/vllm-project/vllm/pull/33165
+
+This PR adds DeepSeek-OCR-2 support but is currently:
+- ⚠️ **Open** (not merged)
+- Has unresolved review comments
+- Pre-commit checks failing
+- Issues: hardcoded parameters, device mismatch bugs, missing error handling
+
+**What's Needed:**
+1. PR #33165 needs to be reviewed, fixed, and merged
+2. vLLM needs to release a version including the merge
+3. Then we can add these dependencies to our script:
+   ```python
+   # dependencies = [
+   #     "datasets>=4.0.0",
+   #     "huggingface-hub",
+   #     "pillow",
+   #     "vllm",
+   #     "tqdm",
+   #     "toolz",
+   #     "torch",
+   #     "addict",
+   #     "matplotlib",
+   # ]
+   ```
+
+**Implementation Progress:**
+- ✅ Created `deepseek-ocr2-vllm.py` script
+- ✅ Fixed dependency issues (pyarrow, datasets>=4.0.0)
+- ✅ Tested script structure on HF Jobs
+- ❌ Blocked: vLLM doesn't recognize architecture
+
+**Partial Implementation:**
+The file `deepseek-ocr2-vllm.py` exists in this repo but is **not functional** until vLLM support lands. Consider it a draft.
+
+**Testing Evidence:**
+When we ran on HF Jobs, we got:
+```
+ValidationError: Model architectures ['DeepseekOCR2ForCausalLM'] are not supported for now.
+Supported architectures: [...'DeepseekOCRForCausalLM'...]
 ```
 
-### `ocr-human-eval.py` — blind human A/B
-Gradio app for blind A/B with ELO + optional agreement-vs-judge analysis (split-jury comparisons shown
-first; round-robin image variety). Resume-safe (atomic JSON per vote).
-```bash
-uv run ocr-human-eval.py davanstrien/ocr-bench-rubenstein --from-prs \
-    --judge-results davanstrien/ocr-bench-rubenstein-judge --max-samples 5
+**Next Steps (when PR merges):**
+1. Update `deepseek-ocr2-vllm.py` dependencies to include `addict` and `matplotlib`
+2. Test on HF Jobs with small dataset (10 samples)
+3. Verify output quality
+4. Update README.md with DeepSeek-OCR-2 section
+5. Document v1 vs v2 differences
+
+**Alternative Approaches (if urgent):**
+- Create transformers-based script (slower, no vLLM batching)
+- Use DeepSeek's official repo setup (complex, not UV-script compatible)
+
+**Model Information:**
+- Model ID: `deepseek-ai/DeepSeek-OCR-2`
+- Model Card: https://huggingface.co/deepseek-ai/DeepSeek-OCR-2
+- GitHub: https://github.com/deepseek-ai/DeepSeek-OCR-2
+- Parameters: 3B
+- Resolution: (0-6)×768×768 + 1×1024×1024 patches
+- Key improvement: Visual Causal Flow architecture
+
+**Resolution Modes (for v2):**
+```python
+RESOLUTION_MODES = {
+    "tiny": {"base_size": 512, "image_size": 512, "crop_mode": False},
+    "small": {"base_size": 640, "image_size": 640, "crop_mode": False},
+    "base": {"base_size": 1024, "image_size": 768, "crop_mode": False},  # v2 optimized
+    "large": {"base_size": 1280, "image_size": 1024, "crop_mode": False},
+    "gundam": {"base_size": 1024, "image_size": 768, "crop_mode": True},  # v2 optimized
+}
 ```
 
-**Validation headline** (full tables in `OCR-BENCHMARK.md`): DeepSeek-OCR is consistently #1 across
-datasets and eval methods; middle-pack rankings are dataset-dependent; a jury of small models gives 0
-parse failures; **Kimi K2.5 (170B)** is the only judge matching the human's #1 (small judges overrate
-LightOnOCR-2's commentary style).
+## Other OCR Scripts
+
+### Nanonets OCR (`nanonets-ocr.py`, `nanonets-ocr2.py`)
+✅ Both versions working
+
+### PaddleOCR-VL (`paddleocr-vl.py`)
+✅ Working
 
 ---
 
-## Deferred / tracked
-
-- **bucketbag adoption** — evaluate adopting `bucketbag` for the bucket recipes (slim recipes / harden
-  bucketbag / find other beneficiaries) → [#67](https://github.com/davanstrien/uv-scripts/issues/67).
-- **Self-review skill** (spark) — a dev-only skill (sibling to `maintain-recipes`) that reviews a recipe/diff
-  against the [Conventions](#conventions--invariants) block: context-length, collision guard, vLLM-image +
-  preflight, env guards, dep sanity, image bounding, optional Jobs smoke. Enforces that list; build after
-  the current work.
-- **Error-signalling** — companion `ocr_error` status column (null cell + truncated exception) instead of
-  sentinels in the output column, so "read nothing" ≠ "run errored". Touches ~all recipes; deferred.
-- **OCR smoke-test dataset** — a tiny curated set (~20–30 images across doc-type/quality/language/layout,
-  ground truth where possible) for fast CI-style regression checks after dep bumps. Pairs with the skill.
-- **Multi-page batch (Unlimited-OCR)** — an SGLang-server-in-job recipe for robust multi-page at scale
-  (single-image vLLM stays the batch default). Gated on a real corpus-scale need + the `h200`/`fa3` infra
-  fix; see `serving-unlimited-ocr.md`.
-- **ALTO XML export** — from `surya_blocks` (block-level bbox→`HPOS/VPOS/…`, label→`TextBlock`/`Illustration`);
-  the surya-ocr-bucket test bucket ships CA's own ALTO `.xml` as a diff target.
-- **Incremental uploads** — superseded by HF Buckets / `bucketbag` ([#67](https://github.com/davanstrien/uv-scripts/issues/67));
-  `glm-ocr-v2.py` keeps the older CommitScheduler resume path for very large jobs today (do not port it — on hold).
-- **Leaderboard Space** — public ELO/pointwise view fed by the benchmark datasets. Idea only.
-- **MonkeyOCRv2 — evaluated, not added** (2026-07-14). `zenosai/MonkeyOCRv2-S-Parsing` (0.6B) needs the
-  [GitHub repo's](https://github.com/Yuliang-Liu/MonkeyOCRv2) custom multi-stage pipeline (`parsing/parse.py`,
-  structure detection) — not pip-packaged, pins `vllm==0.11.2`, and the card text says "academic research and
-  non-commercial use only" while the metadata tag says `apache-2.0` (conflicting license signals). Revisit if
-  it gets packaged / vLLM-native support or the license is clarified.
-
-**Watch:** `deepseek-ocr2` / `glm-ocr` stay on nightly vLLM until their arch lands in a stable release.
-The nightly index (`https://wheels.vllm.ai/nightly`) occasionally has transient build issues (e.g. only
-ARM wheels) — if a nightly-recipe install fails on resolution, wait and retry before debugging the recipe.
+## Future: OCR Smoke Test Dataset
+
+**Status:** Idea (noted 2026-02-12)
+
+Build a small curated dataset (`uv-scripts/ocr-smoke-test`?) with ~2-5 samples from diverse sources. Purpose: fast CI-style verification that scripts still work after dep updates, without downloading full datasets.
+
+**Design goals:**
+- Tiny (~20-30 images total) so download is seconds not minutes
+- Covers the axes that break things: document type, image quality, language, layout complexity
+- Has ground truth text where possible for quality regression checks
+- All permissively licensed (CC0/CC-BY preferred)
+
+**Candidate sources:**
+
+| Source | What it covers | Why |
+|--------|---------------|-----|
+| `NationalLibraryOfScotland/medical-history-of-british-india` | Historical English, degraded scans | Has hand-corrected `text` column for comparison. CC0. Already tested with GLM-OCR. |
+| `davanstrien/ufo-ColPali` | Mixed modern documents | Already used as our go-to test set. Varied layouts. |
+| Something with **tables** | Structured data extraction | Tests `--task table` modes. Maybe a financial report or census page. |
+| Something with **formulas/LaTeX** | Math notation | Tests `--task formula`. arXiv pages or textbook scans. |
+| Something **multilingual** (CJK, Arabic, etc.) | Non-Latin scripts | GLM-OCR claims zh/ja/ko support. Good to verify. |
+| Something **handwritten** | Handwriting recognition | Edge case that reveals model limits. |
+
+**How it would work:**
+```bash
+# Quick smoke test for any script
+uv run glm-ocr.py uv-scripts/ocr-smoke-test smoke-out --max-samples 5
+# Or a dedicated test runner that checks all scripts against it
+```
+
+**Open questions:**
+- Build as a proper HF dataset, or just a folder of images in the repo?
+- Should we include expected output for regression testing (fragile if models change)?
+- Could we add a `--smoke-test` flag to each script that auto-uses this dataset?
+- Worth adding to HF Jobs scheduled runs for ongoing monitoring?
 
 ---
 
-## Change log
-
-- **2026-11-05** — added `hpd-parsing-saturate.py` (experimental) for `PaddlePaddle/HPD-Parsing` (1B,
-  Apache-2.0): the July server recipe's serve command and block parser, driven by saturate `==0.3.0`
-  (`Engine(cmd=…)` for the vendor fork), plus a `looped_blocks` flag. Header image
-  `cr.hf.co/davanstrien/hpd-parsing-vllm` = Paddle's image (pinned by digest) + uv (`images/hpd-parsing/`). Smoke-tested on HF Jobs: `a100-large`, 10 UFO pages, 10/10, 0
-  error rows, 12 s pump time; `l4x1`, 12 Chronicling America pages in two runs to one repo (5, then 12:
-  the second run skipped the 5 done rows), 12/12, 0 error rows; 9 clean pages within 1–5% of LoC's OCR
-  length, 3 looping pages flagged. Header defaults on the public image (`l4x1`, published-path
-  equivalent: local script, no flags but `--max-samples 5`): 5/5, 0 error rows, 153 s scheduling incl. pull.
-
-- **2026-11-02** — `xiaomi-ocr-0-saturate.py` moved to `core`. NASA demo: 7/7 in 31 s; checked pages read well, but a table lost one item and some cells lost separators. 16 multilingual historical newspaper pages: 16/16 with no error rows, but repetition loops on 2 small-print German Fraktur pages (lines about 10–13 px after the 2048 px fit), a partial loop on a third, and Chinese characters inserted on 3 pages. `finish_reason` stayed `stop` on all of them.
-- **2026-10-30** — added `xiaomi-ocr-0-saturate.py` for `xiaomi-research/Xiaomi-OCR-0` (0.8B, Qwen3.5 arch), on
-  saturate `==0.3.0`. Do not set `max_limit` by copying older saturate recipes: on `rtx-pro-6000`, `Auto(max_limit=48)`
-  gave 4.7 pages/s and the default `Auto()` with `prepare_workers` gave 9.7 (1,200 pages, 95% GPU, 0 failures).
-  On `a10g-small`: 2.9 vs 3.4 pages/s. Output cost is about $0.08 per 1,000 pages on both, excluding boot.
-
-- **2026-10-27** — added `minicpm-ocr.py` (experimental) for `openbmb/MiniCPM-OCR-1.0`: OpenBMB's SDK
-  pipeline on a public custom image `cr.hf.co/davanstrien/minicpm-ocr` (first recipe on the HF container
-  registry; Dockerfile in `images/minicpm-ocr/`).
-- **2026-10-27** — added `unlimited-ocr2.py` (minimal) and `unlimited-ocr2-saturate.py` (tuned, experimental)
-  for `baidu/Unlimited-OCR-2`: whole-document OCR in 16-page windows on Baidu's SGLang build, driven by
-  saturate (pinned `==0.2.0`). First recipes whose unit of work is a document, not a page; input is a
-  glob/folder of page files (Buckets), output one row per window with a `status` column. Header flavor
-  `rtx-pro-6000` from a flavor sweep. Full 1771 Britannica (2,724 pages): 171 windows, 0 errors, 123
-  pages re-read by the repair pass. New `support` level `experimental` in models.json.
-
-- **2026-07-29** — added the first two **`-saturate.py` companions**: `lighton-ocr2-saturate.py` and
-  `ovis-ocr2-saturate.py`. Same model/prompt/sampling/post-processing as their `-server.py` siblings;
-  the driver half (concurrency, retries, output, resume) is the `saturate` package (pinned `>=0.1.1`,
-  the allowed *package*-dep pattern — no local imports). Each carries a `SERVING` dict at the top
-  (serve flags + client sampling + context-math assert) as the machine-readable tuning prior — the
-  runtime-consumed successor to the dropped `[tool.serving]` header idea. Output shape differs from
-  `-server.py`: a NEW dataset repo of `{id, markdown, …, error}` parquet rows keyed by input id
-  (resume = anti-join on id), not input+column push; failed pages become durable error rows
-  (`--retry-errors` heals), NOT `[OCR ERROR]` sentinels — the first recipes closing the
-  error-signalling gap noted in Conventions.
-- **2026-07-14** — added `ovis-ocr2.py` (`ATH-MaaS/OvisOCR2`, 0.9B Qwen3.5, 96.58 OmniDocBench v1.6,
-  Apache-2.0; stable vLLM ≥0.22.1, `gdn_prefill_backend="triton"`, card-exact prompt/postprocessing).
-  Smoke-tested green on the default uv image, a10g-small, resolved vLLM 0.25.1 (5/5 pages, tags filtered,
-  stamp OK). Evaluated MonkeyOCRv2 alongside it — deferred (see Deferred / tracked).
-- **2026-07-08** — HunyuanOCR upstream repo swap: pinned `hunyuan-ocr.py` to the last 1.0 revision +
-  added `hunyuan-ocr-1.5.py` (12 task types, locked sampling); `transformers<5.13` cap in both for the
-  stable-vLLM HunyuanVL register breakage (vllm#47872). See the hunyuan gotcha above.
-- **2026-07-01** — large full-page scan fixes ([#65](https://github.com/davanstrien/uv-scripts/pull/65)):
-  surya vLLM-missing preflight; `dots` 8192→32768 + `--max-pixels`; `lighton-ocr2` 8192→16384; `glm` dropped
-  `pyarrow<18` (→ `datasets` `Json` load crash) + `VLLM_USE_DEEP_GEMM=0` + `--max-pixels`; `pp-ocrv6`
-  `--output-column` + collision guard. Then the output-column collision-guard + `--overwrite` sweep across
-  the recipes ([#66](https://github.com/davanstrien/uv-scripts/pull/66)); `nanonets-ocr` 8192→32768.
-- **Earlier** — per-script fixes are recorded in git history + the gotchas above; benchmark runs in `OCR-BENCHMARK.md`.
+**Last Updated:** 2026-02-12
+**Watch PRs:**
+- DeepSeek-OCR-2: https://github.com/vllm-project/vllm/pull/33165

LANGUAGES.md

@@ -1,40 +0,0 @@
-# Language support
-
-What each model's own card claims about language coverage — compiled from the model cards as of **2026-07-15**. Treat these as **claims, not guarantees**: only one model (Surya) publishes per-language scores, and a "multilingual" tag tells you very little. Machine-readable version (plus params, backend, image pins): [`models.json`](models.json).
-
-The fastest way to find out whether a model handles *your* language is to run it on a few of your own pages — `--max-samples 10` costs a few cents on a T4/L4:
-
-```bash
-hf jobs uv run --flavor l4x1 -s HF_TOKEN \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/surya-ocr.py \
-    your-dataset your-output --max-samples 10
-```
-
-_Sorted by strength of evidence, then coverage:_
-
-| Model | Card claim | Evidence |
-|-------|-----------|----------|
-| [Surya OCR 2](https://huggingface.co/datalab-to/surya-ocr-2) | **91 languages** | The only **per-language benchmark** published ([full table](https://github.com/datalab-to/surya/blob/master/static/docs/multilingual.md)): 38/91 score ≥90%, 76/91 ≥80%. Weakest of the top-15: Arabic 72.7%, Vietnamese 73.2% |
-| [dots.ocr](https://huggingface.co/rednote-hilab/dots.ocr) | 100 languages | Explicit **low-resource** claim, backed by an in-house benchmark (1,493 PDFs across 100 languages) — aggregate scores only, not per-language |
-| [Tesseract 5](https://github.com/tesseract-ocr/tesseract) | 125 traineddata packs (~100+ languages + script models) | Fully **enumerable** ([tessdata_best](https://github.com/tesseract-ocr/tessdata_best)) — the broadest *named* coverage here, incl. many low-resource languages; script models (Latin, Cyrillic, Devanagari, …) cover languages without a dedicated pack |
-| [Qianfan-OCR](https://huggingface.co/baidu/Qianfan-OCR) | 192 languages | Headline claim; no list or per-language numbers |
-| [PaddleOCR-VL](https://huggingface.co/PaddlePaddle/PaddleOCR-VL) / [1.5](https://huggingface.co/PaddlePaddle/PaddleOCR-VL-1.5) / [1.6](https://huggingface.co/PaddlePaddle/PaddleOCR-VL-1.6) | 109 languages; 1.5 adds Tibetan + Bengali | Names scripts (Cyrillic, Arabic, Devanagari, Thai) and claims handwriting + historical documents; no per-language numbers |
-| [PP-OCRv6](https://huggingface.co/collections/PaddlePaddle/pp-ocrv6) | 48 languages | Official card claim |
-| [MiniCPM-OCR 1.0](https://huggingface.co/openbmb/MiniCPM-OCR-1.0) | Chinese and English ("primary languages") | Card names two; no per-language numbers. Examples include historical scans |
-| [HPD-Parsing](https://huggingface.co/PaddlePaddle/HPD-Parsing) | 2 (en, zh) | Card metadata only. On degraded French scans our smoke runs (July and November 2026) produced stray Chinese characters mid-word, so treat languages other than en/zh as unsupported |
-| [Nanonets-OCR2-3B](https://huggingface.co/nanonets/Nanonets-OCR2-3B) | 11 named + "many more" (incl. Arabic + CJK) | Illustrative list, no benchmark — but the only card claiming multilingual **handwriting** |
-| [LightOnOCR-2-1B](https://huggingface.co/lightonai/LightOnOCR-2-1B) | 11 (9 European + zh/ja) | Declared, not benchmarked. [v1](https://huggingface.co/lightonai/LightOnOCR-1B-1025) is explicitly European/Latin-script only (9) |
-| [GLM-OCR](https://huggingface.co/zai-org/GLM-OCR) | 8 (zh en fr es ru de ja ko) | Declared in card metadata only; no per-language evidence in the card body |
-| [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) · [Xiaomi-OCR-0](https://huggingface.co/xiaomi-research/Xiaomi-OCR-0) · [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.
-
-## Reading the table for low-resource work
-
-- **Only Surya lets you check your language before running anything** — its [benchmark table](https://github.com/datalab-to/surya/blob/master/static/docs/multilingual.md) has a row per language.
-- **Tesseract's coverage is enumerable** — if your language has a [traineddata pack](https://github.com/tesseract-ocr/tessdata_best), it's supported (quality varies; it's the legacy baseline, not the quality leader).
-- **dots.ocr and HunyuanOCR-1.5 are the VLMs that talk about low-resource languages at all**; PaddleOCR-VL-1.5 names Tibetan and Bengali specifically.
-- A big claimed number (192, 109) without a list or per-language scores means you're testing it yourself either way — which is cheap (see the command above).

OCR-BENCHMARK.md

@@ -1,93 +0,0 @@
-# OCR Benchmark — results & history
-
-Result tables and validation history for the OCR benchmark tooling. **How to *run* the tools**
-(`ocr-bench-run.py`, `ocr-vllm-judge.py`, `ocr-human-eval.py`) lives in `CLAUDE.md` → "Internal
-tooling"; this file is the accumulated *evidence*.
-
-## Model registry (as benchmarked)
-
-| Slug | Model | Size | GPU | Notes |
-|------|-------|------|-----|-------|
-| `glm-ocr` | `zai-org/GLM-OCR` | 0.9B | l4x1 | |
-| `deepseek-ocr` | `deepseek-ai/DeepSeek-OCR` | 4B | l4x1 | auto `--prompt-mode free` (no grounding tags) |
-| `lighton-ocr-2` | `lightonai/LightOnOCR-2-1B` | 1B | a100-large | |
-| `dots-ocr` | `rednote-hilab/dots.ocr` | 1.7B | l4x1 | stable vLLM (>=0.9.1) |
-
-## Run 1 — NLS Medical History (2026-02-14, pilot)
-
-`NationalLibraryOfScotland/medical-history-of-british-india`, 10 samples, seed 42. Judge:
-`Qwen2.5-VL-72B` via Inference Providers. Historical English, degraded scans.
-
-- **ELO (pairwise, 5 samples):** DoTS 1540 (67%) · DeepSeek 1539 (57%) · LightOnOCR-2 1486 (50%) · GLM 1436 (29%)
-- **Pointwise (5):** DeepSeek 5.0 · GLM 4.6 · LightOnOCR-2 4.4 · DoTS 4.2
-- **Key finding:** DeepSeek's `--prompt-mode document` emits grounding tags (`<|ref|>`/`<|det|>`) the
-  judge penalises heavily; switching to `--prompt-mode free` moved it last→top-2 (now the registry default).
-- **Caveat:** 5 samples is far too few for stable rankings.
-
-## Run 2 — Rubenstein Manuscript Catalog (2026-02-15, first full run)
-
-`biglam/rubenstein-manuscript-catalog`, 50 samples, seed 42. Judge: jury of `Qwen2.5-VL-7B` +
-`Qwen3-VL-8B` on A100 (`ocr-vllm-judge.py`). ~48K typewritten + handwritten cards (Duke, CC0).
-
-**ELO (50 samples, 300 comparisons, 0 parse failures):**
-
-| Rank | Model | ELO | W | L | T | Win% |
-|------|-------|-----|---|---|---|------|
-| 1 | LightOnOCR-2-1B | 1595 | 100 | 50 | 0 | 67% |
-| 2 | DeepSeek-OCR | 1497 | 73 | 77 | 0 | 49% |
-| 3 | GLM-OCR | 1471 | 57 | 93 | 0 | 38% |
-| 4 | dots.ocr | 1437 | 70 | 80 | 0 | 47% |
-
-Job times (50 samples): dots 5.3 min (L4) · deepseek 5.6 (L4) · glm 5.7 (L4) · lighton 6.4 (A100).
-
-**Findings:** LightOnOCR-2 dominates on manuscript cards (very different from the NLS pilot) — rankings
-are **dataset-dependent**; a jury of small models works well (0 parse failures via vLLM structured output);
-50 samples gives meaningful separation.
-
-## Run 3 — UFO-ColPali (2026-02-15, cross-dataset validation)
-
-`davanstrien/ufo-ColPali`, 50 samples, seed 42. Judge: `Qwen3-VL-30B-A3B` on A100 (updated prompt).
-Mixed modern documents.
-
-**ELO (50 samples, 294 comparisons):**
-
-| Rank | Model | ELO | W | L | T | Win% |
-|------|-------|-----|---|---|---|------|
-| 1 | DeepSeek-OCR | 1827 | 130 | 17 | 0 | 88% |
-| 2 | dots.ocr | 1510 | 64 | 83 | 0 | 44% |
-| 3 | LightOnOCR-2-1B | 1368 | 77 | 70 | 0 | 52% |
-| 4 | GLM-OCR | 1294 | 23 | 124 | 0 | 16% |
-
-**Human validation (30 comparisons):** DeepSeek #1 (matches judge), LightOnOCR-2 #3 (matches). Middle
-pack (GLM, dots) shuffled between human and judge.
-
-## Cross-dataset comparison (human-validated)
-
-| Model | Rubenstein Human | Rubenstein Kimi | UFO Human | UFO 30B |
-|-------|:---:|:---:|:---:|:---:|
-| DeepSeek-OCR | **#1** | **#1** | **#1** | **#1** |
-| GLM-OCR | #2 | #3 | #2 | #4 |
-| LightOnOCR-2 | #4 | #2 | #3 | #3 |
-| dots.ocr | #3 | #4 | #4 | #2 |
-
-**Conclusion:** DeepSeek-OCR is consistently #1 across datasets and eval methods; middle-pack rankings
-are dataset-dependent. (NLS pilot omitted — 5 samples / 72B API judge, not comparable with the newer
-methodology.)
-
-## Judge validation — `ocr-vllm-judge.py` (2026-02-15)
-
-- **Test 1** (single judge, 1 sample, L4): `Qwen2.5-VL-7B`, 6/6 comparisons, 0 parse failures, ~3 min.
-- **Test 2** (jury of 2, 3 samples, A100): `Qwen2.5-VL-7B` + `Qwen3-VL-8B`, 15/15, 0 failures; GPU cleanup
-  between models OK; majority-vote aggregation working (`[2/2]` unanimous, `[1/2]` split).
-- **Test 3** (full, 50 samples, A100, Rubenstein): 300/300 comparisons, 0 parse failures; clear ELO
-  separation. First saved dataset: `davanstrien/ocr-bench-rubenstein-judge`.
-
-Structured output via a compatibility shim: `StructuredOutputsParams` (vLLM ≥0.12) → `GuidedDecodingParams`
-(older) → prompt-based fallback. Position bias mitigated by A/B randomisation. A100 recommended for jury mode.
-
-## Human eval — `ocr-human-eval.py` first validation (Rubenstein, 30 annotations)
-
-Tested 3 judge configs against 30 human annotations. **Kimi K2.5 (170B) via Novita + the updated prompt**
-is the only judge to match the human's #1 (DeepSeek-OCR); it's now the default in `ocr-jury-bench.py`.
-Small models (7B/8B/30B) overrate LightOnOCR-2 (bias toward its commentary style); the updated prompt
-(faithfulness > completeness > accuracy) helps, but model size is the bigger factor.

README.md

@@ -1,307 +1,647 @@
 ---
 viewer: false
-tags: [uv-script, ocr, extraction, vision-language-model, document-processing, hf-jobs]
+tags: [uv-script, ocr, vision-language-model, document-processing, hf-jobs]
 ---
 
 # OCR UV Scripts
 
-<a href="https://huggingface.co/uv-scripts"><picture><source media="(prefers-color-scheme: dark)" srcset="https://huggingface.co/datasets/huggingface/badges/resolve/main/follow-us-on-hf-md-dark.svg"><img src="https://huggingface.co/datasets/huggingface/badges/resolve/main/follow-us-on-hf-md.svg" alt="Follow uv-scripts on Hugging Face"></picture></a>
+> Part of [uv-scripts](https://huggingface.co/uv-scripts) - ready-to-run ML tools powered by UV and HuggingFace Jobs.
 
-> Part of [uv-scripts](https://huggingface.co/uv-scripts): self-contained UV scripts you run on Hugging Face Jobs in one command.
+14 OCR models from 0.9B to 8B parameters. Pick a model, point at your dataset, get markdown — no setup required.
 
-One script per OCR model. Each script runs the model on a GPU with [Hugging Face Jobs](https://huggingface.co/docs/hub/jobs) and writes the text as markdown: as a new column in a Hub dataset, as `.md` files in a Bucket, or as resumable parquet parts (the `-saturate` recipes). A few scripts return JSON from a schema, detect layout regions, or compare the output of two models.
+## 🚀 Quick Start
 
-## Quick Start
+Run OCR on any dataset without needing your own GPU:
 
-First, [install the `hf` CLI and sign in](https://huggingface.co/docs/hub/jobs-quickstart). Jobs needs pay-as-you-go credit.
+```bash
+# Quick test with 10 samples
+hf jobs uv run --flavor l4x1 \
+    --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py \
+    your-input-dataset your-output-dataset \
+    --max-samples 10
+```
 
-Run [GLM-OCR](https://huggingface.co/zai-org/GLM-OCR) on seven scanned pages from [NASA's *Food for Space Flight* booklet](https://huggingface.co/datasets/uv-scripts/ocr-demo). Replace `your-username` with your Hugging Face username:
+That's it! The script will:
+
+- Process first 10 images from your dataset
+- Add OCR results as a new `markdown` column
+- Push the results to a new dataset
+- View results at: `https://huggingface.co/datasets/[your-output-dataset]`
+
+<details><summary>All scripts at a glance (sorted by model size)</summary>
+
+| Script | Model | Size | Backend | Notes |
+|--------|-------|------|---------|-------|
+| `smoldocling-ocr.py` | [SmolDocling](https://huggingface.co/ds4sd/SmolDocling-256M-preview) | 256M | Transformers | DocTags structured output |
+| `glm-ocr.py` | [GLM-OCR](https://huggingface.co/zai-org/GLM-OCR) | 0.9B | vLLM | 94.62% OmniDocBench V1.5 |
+| `paddleocr-vl.py` | [PaddleOCR-VL](https://huggingface.co/PaddlePaddle/PaddleOCR-VL) | 0.9B | Transformers | 4 task modes (ocr/table/formula/chart) |
+| `paddleocr-vl-1.5.py` | [PaddleOCR-VL-1.5](https://huggingface.co/PaddlePaddle/PaddleOCR-VL-1.5) | 0.9B | Transformers | 94.5% OmniDocBench, 6 task modes |
+| `lighton-ocr.py` | [LightOnOCR-1B](https://huggingface.co/lightonai/LightOnOCR-1B-1025) | 1B | vLLM | Fast, 3 vocab sizes |
+| `lighton-ocr2.py` | [LightOnOCR-2-1B](https://huggingface.co/lightonai/LightOnOCR-2-1B) | 1B | vLLM | 7× faster than v1, RLVR trained |
+| `hunyuan-ocr.py` | [HunyuanOCR](https://huggingface.co/tencent/HunyuanOCR) | 1B | vLLM | Lightweight VLM |
+| `dots-ocr.py` | [DoTS.ocr](https://huggingface.co/Tencent/DoTS.ocr) | 1.7B | vLLM | 100+ languages |
+| `firered-ocr.py` | [FireRed-OCR](https://huggingface.co/FireRedTeam/FireRed-OCR) | 2.1B | vLLM | Qwen3-VL fine-tune, Apache 2.0 |
+| `nanonets-ocr.py` | [Nanonets-OCR-s](https://huggingface.co/nanonets/Nanonets-OCR-s) | 2B | vLLM | LaTeX, tables, forms |
+| `dots-ocr-1.5.py` | [DoTS.ocr-1.5](https://huggingface.co/Tencent/DoTS.ocr-1.5) | 3B | vLLM | Updated multilingual model |
+| `nanonets-ocr2.py` | [Nanonets-OCR2-3B](https://huggingface.co/nanonets/Nanonets-OCR2-s) | 3B | vLLM | Next-gen, Qwen2.5-VL base |
+| `deepseek-ocr-vllm.py` | [DeepSeek-OCR](https://huggingface.co/deepseek-ai/DeepSeek-OCR) | 4B | vLLM | 5 resolution + 5 prompt modes |
+| `deepseek-ocr.py` | [DeepSeek-OCR](https://huggingface.co/deepseek-ai/DeepSeek-OCR) | 4B | Transformers | Same model, Transformers backend |
+| `deepseek-ocr2-vllm.py` | [DeepSeek-OCR-2](https://huggingface.co/deepseek-ai/DeepSeek-OCR-2) | 3B | vLLM | Newer, requires nightly vLLM |
+| `olmocr2-vllm.py` | [olmOCR-2-7B](https://huggingface.co/allenai/olmOCR-2-7B-1025-FP8) | 7B | vLLM | 82.4% olmOCR-Bench |
+| `rolm-ocr.py` | [RolmOCR](https://huggingface.co/reducto/RolmOCR) | 7B | vLLM | Qwen2.5-VL based, general-purpose |
+| `numarkdown-ocr.py` | [NuMarkdown-8B](https://huggingface.co/numind/NuMarkdown-8B-Thinking) | 8B | vLLM | Reasoning-based OCR |
+
+</details>
+
+## Common Options
+
+All scripts accept the same core flags. Model-specific defaults (batch size, context length, temperature) are tuned per model based on model card recommendations and can be overridden.
+
+| Option | Description |
+|--------|-------------|
+| `--image-column` | Column containing images (default: `image`) |
+| `--output-column` | Output column name (default: `markdown`) |
+| `--split` | Dataset split (default: `train`) |
+| `--max-samples` | Limit number of samples (useful for testing) |
+| `--private` | Make output dataset private |
+| `--shuffle` | Shuffle dataset before processing |
+| `--seed` | Random seed for shuffling (default: `42`) |
+| `--batch-size` | Images per batch (default varies per model) |
+| `--max-model-len` | Max context length (default varies per model) |
+| `--max-tokens` | Max output tokens (default varies per model) |
+| `--gpu-memory-utilization` | GPU memory fraction (default: `0.8`) |
+| `--config` | Config name for Hub push (for benchmarking) |
+| `--create-pr` | Push as PR instead of direct commit |
+| `--verbose` | Log resolved package versions after run |
+
+Every script supports `--help` to see all available options:
 
 ```bash
-hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py \
-    uv-scripts/ocr-demo your-username/ocr-demo-results
+uv run glm-ocr.py --help
 ```
 
-The Job adds a `markdown` column to all seven rows and saves them in `your-username/ocr-demo-results`. Dependency installation and model loading can take a few minutes before OCR starts. The [dataset card](https://huggingface.co/datasets/uv-scripts/ocr-demo) gives the source and licence.
+## Example: GLM-OCR
 
-> **Note:** the command needs no flags because the script's [`[tool.hf-jobs]` header](https://huggingface.co/docs/hub/jobs-configuration#define-the-launch-config-in-the-script) sets the GPU, the Docker image and the `HF_TOKEN` secret. The `hf` CLI reads the header from version 1.32. `hf jobs uv run --dry-run <script>` shows the resolved settings. Flags override the header, for example `--timeout 1h` for a larger dataset or `--flavor` for other hardware. **Older CLIs ignore the header without a warning**, and the Job then fails on a CPU without your token. Check with `hf version` and upgrade. If you cannot upgrade, copy the header values from the top of the script (or from `jobs` in [`models.json`](models.json)) as flags. For `glm-ocr.py` that is `--flavor a10g-small --secrets HF_TOKEN --image vllm/vllm-openai:v0.30.0 --python /usr/bin/python3 -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages`.
+[GLM-OCR](https://huggingface.co/zai-org/GLM-OCR) (0.9B) scores 94.62% on OmniDocBench V1.5 and supports OCR, formula, and table extraction:
 
-### Try the same pages as a PDF
+```bash
+# Basic OCR
+hf jobs uv run --flavor l4x1 -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py \
+    my-documents my-ocr-output
 
-The [OCR demo Bucket](https://huggingface.co/buckets/uv-scripts/ocr-demo) holds the original PDF, a seven-page extract that matches the dataset, and the page images. Mount the `demo/` prefix to process only the extract, and create your own Bucket for the results. The header sets the GPU and image, but the `-v` mounts are always flags:
+# Table extraction
+hf jobs uv run --flavor l4x1 -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py \
+    my-documents my-tables --task table
 
-```bash
-hf buckets create your-username/ocr-output --private
-hf jobs uv run --timeout 15m \
-    -v hf://buckets/uv-scripts/ocr-demo/demo:/input:ro \
-    -v hf://buckets/your-username/ocr-output/pdf:/output:rw \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr-bucket.py \
-    /input /output
+# Test on 10 samples first
+hf jobs uv run --flavor l4x1 -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py \
+    my-documents my-test --max-samples 10
 ```
 
-This writes `food-for-space-flight/page_001.md` through `page_007.md` under the `pdf/` prefix of your output Bucket.
+<details><summary>Detailed per-model documentation</summary>
+
+### PaddleOCR-VL-1.5 (`paddleocr-vl-1.5.py`) — 6 task modes
+
+OCR using [PaddlePaddle/PaddleOCR-VL-1.5](https://huggingface.co/PaddlePaddle/PaddleOCR-VL-1.5) with 94.5% accuracy:
 
-## Use your own documents
+- **94.5% on OmniDocBench v1.5** (0.9B parameters)
+- 🧩 **Ultra-compact** - Only 0.9B parameters
+- 📝 **OCR mode** - General text extraction to markdown
+- 📊 **Table mode** - HTML table recognition
+- 📐 **Formula mode** - LaTeX mathematical notation
+- 📈 **Chart mode** - Chart and diagram analysis
+- 🔍 **Spotting mode** - Text spotting with localization (higher resolution)
+- 🔖 **Seal mode** - Seal and stamp recognition
+- 🌍 **Multilingual** - Support for multiple languages
 
-**Images in a Hub dataset:** in the Quick Start command, replace the input dataset ID and choose a new output dataset ID. Start with `--max-samples 10`. This limits OCR, but loading the input dataset can still download more rows. The defaults expect a `train` split and an `image` column. Use `--split` and `--image-column` if yours differ. If the input already has a `markdown` column, choose a different `--output-column`, for example `glm_markdown`. Add `--private` for a private output dataset.
+**Task Modes:**
 
-**Scans or PDFs on your machine:** put a few images or a short PDF in `./my-scans` for the first run. The recipe processes every supported file in the folder and its subfolders, and every page of each PDF. Create the output folder before you start the Job:
+- `ocr`: General text extraction (default)
+- `table`: Table extraction to HTML
+- `formula`: Mathematical formula to LaTeX
+- `chart`: Chart and diagram analysis
+- `spotting`: Text spotting with localization
+- `seal`: Seal and stamp recognition
+
+**Quick start:**
 
 ```bash
-mkdir -p ./ocr-output
-hf jobs uv run --timeout 15m \
-    -v ./my-scans:/input -v ./ocr-output:/output:rw \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr-bucket.py \
-    /input /output
+# Basic OCR mode
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl-1.5.py \
+    your-input-dataset your-output-dataset \
+    --max-samples 100
+
+# Table extraction
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl-1.5.py \
+    documents tables-extracted \
+    --task-mode table
+
+# Seal recognition
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl-1.5.py \
+    documents seals-extracted \
+    --task-mode seal
 ```
 
-The CLI uploads the local folders to a private Bucket and mounts them in the Job. `:rw` lets the Job write output. The script saves one `.md` file per image, or per PDF page. See [mounting local data](https://huggingface.co/docs/huggingface_hub/en/guides/jobs#mount-local-data).
+### PaddleOCR-VL (`paddleocr-vl.py`) 🎯 Smallest model with task-specific modes!
 
-## Get and check your results
+Ultra-compact OCR using [PaddlePaddle/PaddleOCR-VL](https://huggingface.co/PaddlePaddle/PaddleOCR-VL) with only 0.9B parameters:
 
-The CLI prints a link to the Job page, which shows status and logs. From the terminal:
+- 🎯 **Smallest model** - Only 0.9B parameters (even smaller than LightOnOCR!)
+- 📝 **OCR mode** - General text extraction to markdown
+- 📊 **Table mode** - HTML table recognition and extraction
+- 📐 **Formula mode** - LaTeX mathematical notation
+- 📈 **Chart mode** - Structured chart and diagram analysis
+- 🌍 **Multilingual** - Support for multiple languages
+- ⚡ **Fast initialization** - Tiny model size for quick startup
+- 🔧 **ERNIE-4.5 based** - Different architecture from Qwen models
 
-```bash
-hf jobs inspect JOB_ID
-hf jobs logs JOB_ID
-```
+**Task Modes:**
 
-When the Job completes:
+- `ocr`: General text extraction (default)
+- `table`: Table extraction to HTML
+- `formula`: Mathematical formula to LaTeX
+- `chart`: Chart and diagram analysis
 
-- **Dataset output:** open `https://huggingface.co/datasets/your-username/ocr-demo-results` and compare the images with their `markdown` results.
-- **Bucket output:** browse the output Bucket, or download the files with `hf buckets sync hf://buckets/your-username/ocr-output/pdf ./ocr-output`.
-- **Local-folder output:** run the `hf buckets sync` command that the CLI printed at launch. The results are not synced back automatically. Images give files such as `page.md`. A PDF gives files such as `report/page_001.md`.
+**Quick start:**
 
-A completed Job does not mean every page worked. Look for empty results and `[OCR ERROR]` markers, and compare a few outputs with their pages before you scale up. Check tables and reading order in particular. Each dataset run also writes a dataset card with the model settings and a command to reproduce the run.
+```bash
+# Basic OCR mode
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl.py \
+    your-input-dataset your-output-dataset \
+    --max-samples 100
+
+# Table extraction
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl.py \
+    documents tables-extracted \
+    --task-mode table \
+    --batch-size 32
+```
 
-## Pick a model
+### GLM-OCR (`glm-ocr.py`) 🏆 SOTA on OmniDocBench V1.5!
 
-These are the maintained recipes. Each one has a tested `[tool.hf-jobs]` header, so the Quick Start command works with only the script name changed. The exception is `lift-extract.py`, which also needs `--schema`. The table is sorted by model size, smallest first. Scores are the model authors' own numbers. [OmniDocBench](https://github.com/opendatalab/OmniDocBench) scores document parsing of text, tables and formulas across varied PDF pages. [olmOCR-Bench](https://huggingface.co/datasets/allenai/olmOCR-bench) runs pass/fail unit tests on hard PDF pages.
+Compact high-performance OCR using [zai-org/GLM-OCR](https://huggingface.co/zai-org/GLM-OCR) with 0.9B parameters:
 
-| Script | Model | Size | Good at | Licence | GPU |
-|--------|-------|------|---------|---------|-----|
-| [`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` |
-| [`xiaomi-ocr-0-saturate.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/xiaomi-ocr-0-saturate.py) | [Xiaomi-OCR-0](https://huggingface.co/xiaomi-research/Xiaomi-OCR-0) | 0.8B | Whole-page Markdown with LaTeX and HTML tables on vLLM or SGLang; the card's benchmark scores use a two-stage pipeline this recipe does not run; it can loop or insert Chinese characters on small-print historical newspapers | Apache-2.0 | `a10g-small` |
-| [`lighton-ocr2.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/lighton-ocr2.py) | [LightOnOCR-2-1B](https://huggingface.co/lightonai/LightOnOCR-2-1B) | 1B | 83.2 olmOCR-Bench | Apache-2.0 | `a10g-small` |
-| [`hunyuan-ocr-1.5.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/hunyuan-ocr-1.5.py) | [HunyuanOCR-1.5](https://huggingface.co/tencent/HunyuanOCR) | 1B | 12 task types, including spotting, charts and translation | [Hunyuan Community](https://huggingface.co/tencent/HunyuanOCR/blob/main/LICENSE) (excludes EU, UK, South Korea) | `a10g-small` |
-| [`minicpm-ocr.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/minicpm-ocr.py) | [MiniCPM-OCR 1.0](https://huggingface.co/openbmb/MiniCPM-OCR-1.0) | 1.3B | OpenBMB's full pipeline: layout regions, per-region prompts, Markdown with HTML tables; Hub dataset or Bucket in/out; runs on a public [`cr.hf.co`](https://huggingface.co/containers/davanstrien/minicpm-ocr) image (experimental) | Apache-2.0 | `a10g-large` |
-| [`dots-ocr.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/dots-ocr.py) | [dots.ocr](https://huggingface.co/rednote-hilab/dots.ocr) | 1.7B | 100+ languages; layout modes | MIT | `a10g-small` |
-| [`dots-mocr.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/dots-mocr.py) | [dots.mocr](https://huggingface.co/rednote-hilab/dots.mocr) | 3B | Eight prompt modes, including SVG from charts | MIT | `a10g-small` |
-| [`deepseek-ocr2-vllm.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/deepseek-ocr2-vllm.py) | [DeepSeek-OCR-2](https://huggingface.co/deepseek-ai/DeepSeek-OCR-2) | 3B | Newer DeepSeek-OCR | Apache-2.0 | `a10g-small` |
-| [`unlimited-ocr2.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/unlimited-ocr2.py) | [Unlimited-OCR-2](https://huggingface.co/baidu/Unlimited-OCR-2) | 3.3B | Whole documents: 16 pages per request, paragraphs continue across page breaks; reads page folders or Buckets; resumable | MIT | `rtx-pro-6000` |
-| [`unlimited-ocr-vllm.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/unlimited-ocr-vllm.py) | [Unlimited-OCR](https://huggingface.co/baidu/Unlimited-OCR) | 3.3B | Markdown with layout boxes (`--strip-grounding` for clean text) | MIT | `a10g-small` |
-| [`deepseek-ocr-vllm.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/deepseek-ocr-vllm.py) | [DeepSeek-OCR](https://huggingface.co/deepseek-ai/DeepSeek-OCR) | 4B | Five prompt modes, including figure description | MIT | `a10g-small` |
-| [`nuextract3.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/nuextract3.py) | [NuExtract3](https://huggingface.co/numind/NuExtract3) | 4B | Markdown, or JSON from a template ([below](#structured-extraction-and-layout)) | Apache-2.0 | `a10g-small` |
-| [`qianfan-ocr.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/qianfan-ocr.py) | [Qianfan-OCR](https://huggingface.co/baidu/Qianfan-OCR) | 4.7B | 93.12 OmniDocBench v1.5; optional reasoning (`--think`); key-information extraction | Apache-2.0 | `a10g-small` |
-| [`olmocr2-vllm.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/olmocr2-vllm.py) | [olmOCR-2-7B](https://huggingface.co/allenai/olmOCR-2-7B-1025-FP8) | 7B (FP8) | 82.4 olmOCR-Bench | Apache-2.0 | `a10g-small` |
-| [`lift-extract.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/lift-extract.py) | [lift](https://huggingface.co/datalab-to/lift) | 9B | JSON from a schema, from images or multi-page PDFs | modified OpenRAIL-M | `a100-large` |
+- 🏆 **94.62% on OmniDocBench V1.5** - #1 overall ranking
+- 🧠 **Multi-Token Prediction** - MTP loss + stable full-task RL for quality
+- 📝 **Text recognition** - Clean markdown output
+- 📐 **Formula recognition** - LaTeX mathematical notation
+- 📊 **Table recognition** - Structured table extraction
+- 🌍 **Multilingual** - zh, en, fr, es, ru, de, ja, ko
+- ⚡ **Compact** - Only 0.9B parameters, MIT licensed
+- 🔧 **CogViT + GLM** - Visual encoder with efficient token downsampling
 
-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.
+**Task Modes:**
 
-**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-ocr3-saturate.py`, `lighton-ocr2-saturate.py`, `ovis-ocr2-saturate.py` and `xiaomi-ocr-0-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).
+- `ocr`: Text recognition (default)
+- `formula`: LaTeX formula recognition
+- `table`: Table extraction
 
-Which model is best depends on your documents. The public olmOCR-Bench leaderboard is one command away:
+**Quick start:**
 
 ```bash
-hf datasets leaderboard allenai/olmOCR-bench
-```
+# Basic OCR
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py \
+    your-input-dataset your-output-dataset \
+    --max-samples 100
 
-To rank models on your own collection, [ocr-bench](https://github.com/davanstrien/ocr-bench) builds a per-collection leaderboard (pairwise VLM judge, optional human checks) with these scripts. [LANGUAGES.md](LANGUAGES.md) lists the language coverage that each model card claims. [`models.json`](models.json) is the machine-readable catalogue: model, size, backend, licence, support level, tested launch config and languages for every script.
-
-### Less supported and unsupported
-
-These scripts stay in the repo but have no header, so copy the complete launch command from each script's docstring, including any `--image`, `--python` and `-e` flags. If the docstring gives no hardware, `--flavor a10g-small --secrets HF_TOKEN` is a reasonable start. Status was checked on HF Jobs on 2026-09-23. The `support_note` field in [`models.json`](models.json) has details.
-
-| Script | Status | Use instead |
-|--------|--------|-------------|
-| `lighton-ocr.py`, `nanonets-ocr.py`, `paddleocr-vl.py` | works, older model | `lighton-ocr2.py`, `nanonets-ocr2.py`, `paddleocr-vl-1.6.py` |
-| `lighton-ocr2-server.py`, `ovis-ocr2-server.py` | works | the matching `-saturate.py` recipe |
-| `glm-ocr-v2.py` | works | `glm-ocr.py`, unless you need its resume support |
-| `lfm2-vl-extract.py` | works | `nuextract3.py` or `lift-extract.py` |
-| `nanonets-ocr2.py` | works on its pinned `vllm/vllm-openai:v0.10.2` image | |
-| `falcon-ocr.py`, `falcon-ocr-bucket.py` | works (Falcon-OCR v1; a v1.5 update is in progress) | |
-| `abot-ocr.py`, `firered-ocr.py`, `numarkdown-ocr.py` | works, little used | |
-| `deepseek-ocr.py` | broken: every row is `None` | `deepseek-ocr-vllm.py` |
-| `hunyuan-ocr.py` | broken on current vLLM | `hunyuan-ocr-1.5.py` |
-| `paddleocr-vl-1.5.py` | broken: every row is an `[OCR ERROR]` | `paddleocr-vl-1.6.py` |
-| `rolm-ocr.py` | broken: no room for the KV cache on a 24 GB GPU | `olmocr2-vllm.py` |
-| `jina-ocr-v1.py` | broken on vLLM 0.30 (CC-BY-NC-4.0 model) | |
-| `smoldocling-ocr.py` | broken: rows are raw DocTags, not markdown | |
-
-## Common options
-
-Every dataset recipe takes `INPUT_DATASET OUTPUT_DATASET` as positional arguments, so you can usually switch models by changing the script URL. Defaults such as batch size and context length follow each model card. Run `--help`, or read the script source on the Hub, for the full list. Local `uv run <script-url> --help` installs the dependencies first.
-
-| Option | What it does | Notes |
-|--------|--------------|-------|
-| `--max-samples N` | Process only the first N rows | All recipes. The `-saturate.py` recipes also accept `--limit`. The three `-bucket.py` recipes count input files, not PDF pages |
-| `--shuffle`, `--seed` | Shuffle before `--max-samples` for a representative sample (seed default 42) | Not the `-saturate.py` recipes |
-| `--split` | Input split (default `train`) | |
-| `--image-column` | Input image column (default `image`) | |
-| `--output-column` | Output column (default `markdown`; `extraction` for lift and LFM2 extract) | Not the `-saturate.py` recipes or `pp-doclayout.py` (fixed `layout` column) |
-| `--overwrite` | Replace the output column if the input already has it. Without it the script stops | Not the `-saturate.py` recipes |
-| `--private` | Make the output dataset private | Not the `-saturate.py` recipes |
-| `--batch-size` | Images per batch (default 8 or 16 for the OCR recipes) | Not `tesseract-ocr.py`, `pp-ocrv6.py` or the `-saturate.py` recipes |
-| `--max-model-len`, `--max-tokens`, `--gpu-memory-utilization` | vLLM engine limits | Most vLLM recipes |
-| `--config NAME`, `--create-pr` | Push the output as a named config, as a pull request | Most dataset recipes. Used to compare models in one repo ([Scaling up](#scaling-up)). In `-saturate.py`, `--config` selects the input config |
-| `--verbose` | Log resolved package versions | Most recipes |
-
-To compare models on the same pages, run them into one dataset with a separate output column each:
+# Formula recognition
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py \
+    scientific-papers formulas-extracted \
+    --task formula
 
-```bash
-hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py \
-    my-dataset my-dataset --max-samples 100 --output-column glm_markdown
-hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr2.py \
-    my-dataset my-dataset --max-samples 100 --output-column lighton_markdown
+# Table extraction
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py \
+    documents tables-extracted \
+    --task table
 ```
 
-Most dataset recipes also record the model and settings in an `inference_info` column. The `-saturate.py` recipes write a `model` column instead and keep run metadata under `data/completions/`.
-
-### Model-specific flags
-
-| Script | Flags |
-|--------|-------|
-| `tesseract-ocr.py` | `--lang` (for example `eng+fra`), `--psm`, `--oem` |
-| `pp-ocrv6.py` | `--model-tier tiny\|small\|medium` |
-| `surya-ocr.py` | `--task ocr\|layout\|table`, `--table-mode full\|simple`, `--pdf-column`, `--page-range` |
-| `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` |
-| `deepseek-ocr-vllm.py` | `--prompt-mode document\|image\|free\|figure\|describe` |
-| `deepseek-ocr2-vllm.py` | `--prompt-mode document\|free` |
-| `unlimited-ocr-vllm.py` | `--strip-grounding`, `--grounding-column` |
-| `qianfan-ocr.py` | `--prompt-mode ocr\|table\|formula\|chart\|scene\|kie`, `--think`. `kie` needs `--custom-prompt` |
-
-For example, key-information extraction with Qianfan-OCR:
+### LightOnOCR (`lighton-ocr.py`) ⚡ Good one to test first since it's small and fast!
 
-```bash
-hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/qianfan-ocr.py \
-    invoices extracted-fields \
-    --prompt-mode kie --custom-prompt "Extract: name, date, total. Output as JSON."
-```
+Fast and compact OCR using [lightonai/LightOnOCR-1B-1025](https://huggingface.co/lightonai/LightOnOCR-1B-1025):
 
-## Structured extraction and layout
+- ⚡ **Fastest**: 5.71 pages/sec on H100, ~6.25 images/sec on A100 with batch_size=4096
+- 🎯 **Compact**: Only 1B parameters - quick to download and initialize
+- 🌍 **Multilingual**: 3 vocabulary sizes for different use cases
+- 📐 **LaTeX formulas**: Mathematical notation in LaTeX format
+- 📊 **Table extraction**: Markdown table format
+- 📝 **Document structure**: Preserves hierarchy and layout
+- 🚀 **Production-ready**: 76.1% benchmark score, used in production
 
-These recipes return structured data instead of page text.
+**Vocabulary sizes:**
 
-**[NuExtract3](https://huggingface.co/numind/NuExtract3)** (`nuextract3.py`, 4B, Apache-2.0) does markdown OCR by default. Give it a `--template` or a JSON Schema (`--schema`) and it returns JSON in that shape. Both flags accept inline JSON, a URL or a file path, so you can host a schema once and reuse it. Template field names act as instructions to the model, so name them clearly and check the output on a few examples. `--enable-thinking` helps with hard layouts; it is slower and stores the reasoning in a `<output-column>_reasoning` column.
+- `151k`: Full vocabulary, all languages (default)
+- `32k`: European languages, ~12% faster decoding
+- `16k`: European languages, ~12% faster decoding
+
+**Quick start:**
 
 ```bash
-hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nuextract3.py \
-    receipts extracted \
-    --template '{"store": "verbatim-string", "date": "date", "total": "number"}'
+# Test on 100 samples with English text (32k vocab is fastest for European languages)
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr.py \
+    your-input-dataset your-output-dataset \
+    --vocab-size 32k \
+    --batch-size 32 \
+    --max-samples 100
+
+# Full production run on A100 (can handle huge batches!)
+hf jobs uv run --flavor a100-large \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr.py \
+    your-input-dataset your-output-dataset \
+    --vocab-size 32k \
+    --batch-size 4096 \
+    --temperature 0.0
 ```
 
-**[lift](https://huggingface.co/datalab-to/lift)** (`lift-extract.py`, 9B) returns JSON that matches a JSON Schema, which you must pass with `--schema` (inline JSON, a URL or a file path). It also reads multi-page PDFs (`--pdf-column`, `--page-range`) and extracts one result per document. The default Transformers backend (`--method hf`) is the tested path. Its weights use a modified OpenRAIL-M licence, so check the terms.
+### LightOnOCR-2 (`lighton-ocr2.py`) ⚡ Fastest OCR model!
 
-**[LFM2-1.2B-Extract](https://huggingface.co/LiquidAI/LFM2-1.2B-Extract)** (`lfm2-extract.py`) works on a **text** column, so you can run it after an OCR recipe: OCR turns a page into `markdown`, then this recipe turns the markdown into fields. `--format` selects JSON, XML or YAML.
+Next-generation fast OCR using [lightonai/LightOnOCR-2-1B](https://huggingface.co/lightonai/LightOnOCR-2-1B) with RLVR training:
 
-```bash
-hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lfm2-extract.py \
-    your-username/ocr-demo-results your-username/ocr-demo-fields \
-    --text-column markdown --schema '{"title": "the document title", "date": "any date shown"}'
-```
+- ⚡ **7× faster than v1**: 42.8 pages/sec on H100 (vs 5.71 for v1)
+- 🎯 **Higher accuracy**: 83.2% on OlmOCR-Bench (+7.1% vs v1)
+- 🧠 **RLVR trained**: Eliminates repetition loops and formatting errors
+- 📚 **Better dataset**: 2.5× larger training data with cleaner annotations
+- 🌍 **Multilingual**: Optimized for European languages
+- 📐 **LaTeX formulas**: Mathematical notation support
+- 📊 **Table extraction**: Markdown table format
+- 💪 **Production-ready**: Outperforms models 9× larger
 
-**[PP-DocLayout](https://huggingface.co/PaddlePaddle/PP-DocLayout-L)** (`pp-doclayout.py`, 123M) finds layout regions but does not read text. It writes a `layout` column with a box, a class (text, title, table, figure, formula, header, footer and more) and a score for each region. Use it to filter pages, crop regions for OCR, or prepare training data. `--model-name` selects the L, M, S or plus-L model. The input and output can each be a dataset or an `hf://buckets/...` path. Bucket output is written in resumable parquet shards.
+**Quick start:**
 
 ```bash
-hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/pp-doclayout.py \
-    your-dataset your-layout-output --max-samples 10
+# Test on 100 samples
+hf jobs uv run --flavor a100-large \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr2.py \
+    your-input-dataset your-output-dataset \
+    --batch-size 32 \
+    --max-samples 100
+
+# Full production run
+hf jobs uv run --flavor a100-large \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr2.py \
+    your-input-dataset your-output-dataset \
+    --batch-size 32
 ```
 
-**[HPD-Parsing](https://huggingface.co/PaddlePaddle/HPD-Parsing)** (`hpd-parsing-saturate.py`, 1B, Apache-2.0, experimental) reads text and layout in one pass. Next to the `markdown` it writes an `hpd_blocks` column with a type, a box and the text for each block, in reading order. The boxes are on a 0–1000 scale, not pixels. The model needs Paddle's own vLLM build; the script header picks an image with it ([`images/hpd-parsing/`](images/hpd-parsing/)).
+### DeepSeek-OCR (`deepseek-ocr-vllm.py`)
 
-```bash
-hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/hpd-parsing-saturate.py \
-    your-dataset your-output --max-samples 5
-```
+Advanced document OCR using [deepseek-ai/DeepSeek-OCR](https://huggingface.co/deepseek-ai/DeepSeek-OCR) with visual-text compression:
+
+- 📐 **LaTeX equations** - Mathematical formulas in LaTeX format
+- 📊 **Tables** - Extracted as HTML/markdown
+- 📝 **Document structure** - Headers, lists, formatting preserved
+- 🖼️ **Image grounding** - Spatial layout with bounding boxes
+- 🔍 **Complex layouts** - Multi-column and hierarchical structures
+- 🌍 **Multilingual** - Multiple language support
+- 🎚️ **Resolution modes** - 5 presets for speed/quality trade-offs
+- 💬 **Prompt modes** - 5 presets for different OCR tasks
+- ⚡ **Fast batch processing** - vLLM acceleration
+
+**Resolution Modes:**
+
+- `tiny` (512×512): Fast, 64 vision tokens
+- `small` (640×640): Balanced, 100 vision tokens
+- `base` (1024×1024): High quality, 256 vision tokens
+- `large` (1280×1280): Maximum quality, 400 vision tokens
+- `gundam` (dynamic): Adaptive multi-tile (default)
+
+**Prompt Modes:**
+
+- `document`: Convert to markdown with grounding (default)
+- `image`: OCR any image with grounding
+- `free`: Fast OCR without layout
+- `figure`: Parse figures from documents
+- `describe`: Detailed image descriptions
+
+### RolmOCR (`rolm-ocr.py`)
+
+Fast general-purpose OCR using [reducto/RolmOCR](https://huggingface.co/reducto/RolmOCR) based on Qwen2.5-VL-7B:
+
+- 🚀 **Fast extraction** - Optimized for speed and efficiency
+- 📄 **Plain text output** - Clean, natural text representation
+- 💪 **General-purpose** - Works well on various document types
+- 🔥 **Large context** - Handles up to 16K tokens
+- ⚡ **Batch optimized** - Efficient processing with vLLM
+
+### Nanonets OCR (`nanonets-ocr.py`)
+
+State-of-the-art document OCR using [nanonets/Nanonets-OCR-s](https://huggingface.co/nanonets/Nanonets-OCR-s) that handles:
+
+- 📐 **LaTeX equations** - Mathematical formulas preserved
+- 📊 **Tables** - Extracted as HTML format
+- 📝 **Document structure** - Headers, lists, formatting maintained
+- 🖼️ **Images** - Captions and descriptions included
+- ☑️ **Forms** - Checkboxes rendered as ☐/☑
 
-The image is about 11 GB, so a cold start takes several minutes. On dense pages with hundreds of blocks the model can repeat itself inside many blocks at once. The `looped_blocks` column counts those blocks; keep rows where it is 0. The model card lists English and Chinese only.
+### Nanonets OCR2 (`nanonets-ocr2.py`)
 
-## Scaling up
+Next-generation Nanonets OCR using [nanonets/Nanonets-OCR2-3B](https://huggingface.co/nanonets/Nanonets-OCR2-3B) with improved accuracy:
 
-**Large datasets:** `lighton-ocr3-saturate.py`, `lighton-ocr2-saturate.py`, `ovis-ocr2-saturate.py` and `xiaomi-ocr-0-saturate.py` start a vLLM server in the Job (the Xiaomi recipe can use SGLang instead) and send pages to it with adaptive concurrency. They stream results to the output repo as parquet parts. If a run stops, run the same command again and it skips the rows that are done. A failed page is stored as an error row, and `--retry-errors` tries those rows again. The output layout is different from the other recipes; the script header explains how to read it. [SERVING.md](SERVING.md) compares server mode with offline batches (measured throughput and output parity). For LightOnOCR-3-0.8B, `lighton-ocr3-saturate.py` measured 2.2 pages/s on `a10g-small` and 10.0 pages/s on `rtx-pro-6000` (about $0.08 per 1,000 pages), against 0.90 and 1.27 pages/s for `lighton-ocr3.py` on `a10g-small` and `a100-large`.
+- 🎯 **Enhanced quality** - 3.75B parameters for superior OCR accuracy
+- 📐 **LaTeX equations** - Mathematical formulas preserved in LaTeX format
+- 📊 **Advanced tables** - Improved HTML table extraction
+- 📝 **Document structure** - Headers, lists, formatting maintained
+- 🖼️ **Smart image captions** - Intelligent descriptions and captions
+- ☑️ **Forms** - Checkboxes rendered as ☐/☑
+- 🌍 **Multilingual** - Enhanced language support
+- 🔧 **Based on Qwen2.5-VL** - Built on state-of-the-art vision-language model
 
-**Whole books and long documents:** `unlimited-ocr2.py` runs [Unlimited-OCR-2](https://huggingface.co/baidu/Unlimited-OCR-2) on Baidu's own SGLang build. It groups page images into documents and sends 16 consecutive pages per request, so a paragraph that runs over a page break comes back joined. Point it at a folder of pages, for example a Bucket:
+### SmolDocling (`smoldocling-ocr.py`)
+
+Ultra-compact document understanding using [ds4sd/SmolDocling-256M-preview](https://huggingface.co/ds4sd/SmolDocling-256M-preview) with only 256M parameters:
+
+- 🏷️ **DocTags format** - Efficient XML-like representation
+- 💻 **Code blocks** - Preserves indentation and syntax
+- 🔢 **Formulas** - Mathematical expressions with layout
+- 📊 **Tables & charts** - Structured data extraction
+- 📐 **Layout preservation** - Bounding boxes and spatial info
+- ⚡ **Ultra-fast** - Tiny model size for quick inference
+
+### NuMarkdown (`numarkdown-ocr.py`)
+
+Advanced reasoning-based OCR using [numind/NuMarkdown-8B-Thinking](https://huggingface.co/numind/NuMarkdown-8B-Thinking) that analyzes documents before converting to markdown:
+
+- 🧠 **Reasoning Process** - Thinks through document layout before generation
+- 📊 **Complex Tables** - Superior table extraction and formatting
+- 📐 **Mathematical Formulas** - Accurate LaTeX/math notation preservation
+- 🔍 **Multi-column Layouts** - Handles complex document structures
+- ✨ **Thinking Traces** - Optional inclusion of reasoning process with `--include-thinking`
+
+### DoTS.ocr (`dots-ocr.py`)
+
+Compact multilingual OCR using [rednote-hilab/dots.ocr](https://huggingface.co/rednote-hilab/dots.ocr) with only 1.7B parameters:
+
+- 🌍 **100+ Languages** - Extensive multilingual support
+- 📝 **Simple OCR** - Clean text extraction (default mode)
+- 📊 **Layout Analysis** - Optional structured output with bboxes and categories
+- 📐 **Formula recognition** - LaTeX format support
+- 🎯 **Compact** - Only 1.7B parameters, efficient on smaller GPUs
+- 🔀 **Flexible prompts** - Switch between OCR, layout-all, and layout-only modes
+
+### FireRed-OCR (`firered-ocr.py`)
+
+Document OCR using [FireRedTeam/FireRed-OCR](https://huggingface.co/FireRedTeam/FireRed-OCR), a 2.1B model fine-tuned from Qwen3-VL-2B-Instruct:
+
+- 📝 **Structured Markdown** - Preserves headings, paragraphs, lists
+- 📐 **LaTeX formulas** - Inline and block math support
+- 📊 **HTML tables** - Table extraction with `<table>` tags
+- 🪶 **Lightweight** - 2.1B parameters, runs on L4 GPU
+- 📜 **Apache 2.0** - Permissive license
+
+**Quick start:**
 
 ```bash
-hf jobs uv run --detach \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/unlimited-ocr2.py \
-    "hf://buckets/biglam/britannica/source/pages/1771EncyclopediaBritannicaNLS/*.jp2" \
-    your-username/britannica-1771
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/firered-ocr.py \
+    your-input-dataset your-output-dataset \
+    --max-samples 100
 ```
 
-The header picks `rtx-pro-6000` (the fastest per dollar in our tests; 24 GB GPUs are too small for 16-page requests). Results are one row per 16-page window. About 2% of pages in 18th-century print (mostly mathematics) send the model into a loop; `unlimited-ocr2-saturate.py`, an experimental tuned version, reads those pages again one at a time and adds PDF input and Baidu's Markdown post-processing. `unlimited-ocr2-live.py`, also experimental, is the minimal script plus a live view you can open while the Job runs (add `--live-port 7860` and `--expose-public 7860`): the page being read with its text streaming in, finished pages, pages per minute and GPU load.
+### olmOCR2 (`olmocr2-vllm.py`)
+
+High-quality document OCR using [allenai/olmOCR-2-7B-1025-FP8](https://huggingface.co/allenai/olmOCR-2-7B-1025-FP8) optimized with GRPO reinforcement learning:
+
+- 🎯 **High accuracy** - 82.4 ± 1.1 on olmOCR-Bench (84.9% on math)
+- 📐 **LaTeX equations** - Mathematical formulas in LaTeX format
+- 📊 **Table extraction** - Structured table recognition
+- 📑 **Multi-column layouts** - Complex document structures
+- 🗜️ **FP8 quantized** - Efficient 8B model for faster inference
+- 📜 **Degraded scans** - Works well on old/historical documents
+- 📝 **Long text extraction** - Headers, footers, and full document content
+- 🧩 **YAML metadata** - Structured front matter (language, rotation, content type)
+- 🚀 **Based on Qwen2.5-VL-7B** - Fine-tuned with reinforcement learning
+
+## 🆕 New Features
+
+### Multi-Model Comparison Support
+
+All scripts now include `inference_info` tracking for comparing multiple OCR models:
 
 ```bash
-hf jobs uv run --detach --timeout 4h \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr3-saturate.py \
-    your-dataset your-output
+# First model
+uv run rolm-ocr.py my-dataset my-dataset --max-samples 100
+
+# Second model (appends to same dataset)
+uv run nanonets-ocr.py my-dataset my-dataset --max-samples 100
+
+# View all models used
+python -c "import json; from datasets import load_dataset; ds = load_dataset('my-dataset'); print(json.loads(ds[0]['inference_info']))"
 ```
 
-**A live endpoint for an app or agent:** [Jobs serving](https://huggingface.co/docs/hub/jobs-serving) exposes a model server that stays up until you cancel the Job or it reaches its timeout. The [Unlimited-OCR walkthrough](serving-unlimited-ocr.md) covers setup, requests, and parsing several pages in one request.
+### Random Sampling
 
-**Compare models:** run several recipes into one repo with `--config <name> --create-pr`, then judge the outputs pairwise with `ocr-vllm-judge.py` ([ocr-bench](https://github.com/davanstrien/ocr-bench) automates this):
+Get representative samples with the new `--shuffle` flag:
 
 ```bash
-hf jobs uv run --timeout 1h \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/ocr-vllm-judge.py \
-    your-username/my-bench --from-prs --judge-model Qwen/Qwen3-VL-8B-Instruct --max-samples 50
+# Random 50 samples instead of first 50
+uv run rolm-ocr.py ordered-dataset output --max-samples 50 --shuffle
+
+# Reproducible random sampling
+uv run nanonets-ocr.py dataset output --max-samples 100 --shuffle --seed 42
 ```
 
-**Python API:** `run_uv_job` does not read the `[tool.hf-jobs]` header, so pass the header values yourself:
+### Automatic Dataset Cards
 
-```python
-from huggingface_hub import get_token, run_uv_job
+Every OCR run now generates comprehensive dataset documentation including:
 
-job = run_uv_job(
-    "https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py",
-    script_args=["input-dataset", "output-dataset", "--max-samples", "10"],
-    flavor="a10g-small",
-    image="vllm/vllm-openai:v0.30.0",
-    python="/usr/bin/python3",
-    env={"PYTHONPATH": "/usr/local/lib/python3.12/dist-packages"},
-    secrets={"HF_TOKEN": get_token()},
-)
-```
+- Model configuration and parameters
+- Processing statistics
+- Column descriptions
+- Reproduction instructions
 
-## Troubleshooting
+## 💻 Usage Examples
 
-**The Job runs on a CPU, or cannot push to the Hub.** Your `hf` CLI is older than 1.32 and ignored the header. Upgrade, or pass the header values as flags (see the [Quick Start](#quick-start) note).
+### Run on HuggingFace Jobs (Recommended)
 
-**A vLLM recipe crashes at startup with an `nvcc` or `nvrtc` error:**
+No GPU? No problem! Run on HF infrastructure:
 
+```bash
+# PaddleOCR-VL - Smallest model (0.9B) with task modes
+hf jobs uv run --flavor l4x1 \
+    --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl.py \
+    your-input-dataset your-output-dataset \
+    --task-mode ocr \
+    --max-samples 100
+
+# PaddleOCR-VL - Extract tables from documents
+hf jobs uv run --flavor l4x1 \
+    --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl.py \
+    documents tables-dataset \
+    --task-mode table
+
+# PaddleOCR-VL - Formula recognition
+hf jobs uv run --flavor l4x1 \
+    --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl.py \
+    scientific-papers formulas-extracted \
+    --task-mode formula \
+    --batch-size 32
+
+# GLM-OCR - SOTA 0.9B model (94.62% OmniDocBench)
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py \
+    your-input-dataset your-output-dataset \
+    --batch-size 16 \
+    --max-samples 100
+
+# DeepSeek-OCR - Real-world example (National Library of Scotland handbooks)
+hf jobs uv run --flavor a100-large \
+    -s HF_TOKEN \
+    -e UV_TORCH_BACKEND=auto \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/deepseek-ocr-vllm.py \
+    NationalLibraryOfScotland/Britain-and-UK-Handbooks-Dataset \
+    davanstrien/handbooks-deep-ocr \
+    --max-samples 100 \
+    --shuffle \
+    --resolution-mode large
+
+# DeepSeek-OCR - Fast testing with tiny mode
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    -e UV_TORCH_BACKEND=auto \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/deepseek-ocr-vllm.py \
+    your-input-dataset your-output-dataset \
+    --max-samples 10 \
+    --resolution-mode tiny
+
+# DeepSeek-OCR - Parse figures from scientific papers
+hf jobs uv run --flavor a100-large \
+    -s HF_TOKEN \
+    -e UV_TORCH_BACKEND=auto \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/deepseek-ocr-vllm.py \
+    scientific-papers figures-extracted \
+    --prompt-mode figure
+
+# Basic OCR job with Nanonets
+hf jobs uv run --flavor l4x1 \
+    --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nanonets-ocr.py \
+    your-input-dataset your-output-dataset
+
+# DoTS.ocr - Multilingual OCR with compact 1.7B model
+hf jobs uv run --flavor a100-large \
+    --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-ocr.py \
+    davanstrien/ufo-ColPali \
+    your-username/ufo-ocr \
+    --batch-size 256 \
+    --max-samples 1000 \
+    --shuffle
+
+# Real example with UFO dataset 🛸
+hf jobs uv run \
+    --flavor a10g-large \
+    --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nanonets-ocr.py \
+    davanstrien/ufo-ColPali \
+    your-username/ufo-ocr \
+    --image-column image \
+    --max-model-len 16384 \
+    --batch-size 128
+
+# Nanonets OCR2 - Next-gen quality with 3B model
+hf jobs uv run \
+    --flavor l4x1 \
+    --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nanonets-ocr2.py \
+    your-input-dataset \
+    your-output-dataset \
+    --batch-size 16
+
+# NuMarkdown with reasoning traces for complex documents
+hf jobs uv run \
+    --flavor l4x4 \
+    --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/numarkdown-ocr.py \
+    your-input-dataset your-output-dataset \
+    --max-samples 50 \
+    --include-thinking \
+    --shuffle
+
+# olmOCR2 - High-quality OCR with YAML metadata
+hf jobs uv run \
+    --flavor a100-large \
+    --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/olmocr2-vllm.py \
+    your-input-dataset your-output-dataset \
+    --batch-size 16 \
+    --max-samples 100
+
+# Private dataset with custom settings
+hf jobs uv run --flavor l40sx1 \
+    --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nanonets-ocr.py \
+    private-input private-output \
+    --private \
+    --batch-size 32
 ```
-RuntimeError: Could not find nvcc and default cuda_home='/usr/local/cuda' doesn't exist
-nvrtc: error: failed to open libnvrtc-builtins.so...
+
+### Python API
+
+```python
+from huggingface_hub import run_uv_job
+
+job = run_uv_job(
+    "https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nanonets-ocr.py",
+    args=["input-dataset", "output-dataset", "--batch-size", "16"],
+    flavor="l4x1"
+)
 ```
 
-The Job ran on the default image, which has no CUDA toolkit. This happens with an older CLI, with a legacy recipe, or when you override `--image`. Run it on the `vllm/vllm-openai` image:
+### Run Locally (Requires GPU)
 
 ```bash
---image vllm/vllm-openai:v0.30.0 --python /usr/bin/python3 -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages
-```
+# Clone and run
+git clone https://huggingface.co/datasets/uv-scripts/ocr
+cd ocr
+uv run nanonets-ocr.py input-dataset output-dataset
 
-Use the tag from the script's header. The Surya recipes use `/usr/local/bin/python3` and `site-packages` instead; copy their header exactly. `unlimited-ocr-vllm.py` needs Baidu's `vllm/vllm-openai:unlimited-ocr` image (`:unlimited-ocr-cu129` on H100 or H200).
+# Or run directly from URL
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nanonets-ocr.py \
+    input-dataset output-dataset
 
-**The Job stops before it finishes.** Jobs stop at their timeout. Pass a longer `--timeout`, or use a `-saturate.py` recipe, which can resume.
+# PaddleOCR-VL for task-specific OCR (smallest model!)
+uv run paddleocr-vl.py documents extracted --task-mode ocr
+uv run paddleocr-vl.py papers tables --task-mode table  # Extract tables
+uv run paddleocr-vl.py textbooks formulas --task-mode formula  # LaTeX formulas
 
-**Run locally on your own GPU.** Most recipes get vLLM from the Docker image, not from their dependencies. Add the vLLM version from the header tag:
+# RolmOCR for fast text extraction
+uv run rolm-ocr.py documents extracted-text
+uv run rolm-ocr.py images texts --shuffle --max-samples 100  # Random sample
+
+# Nanonets OCR2 for highest quality
+uv run nanonets-ocr2.py documents ocr-results
 
-```bash
-uv run --with vllm==0.29.0 \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py \
-    input-dataset output-dataset --max-samples 10
 ```
 
-The Surya recipes need `vllm==0.20.1`. `unlimited-ocr-vllm.py` needs an architecture that no stable vLLM wheel has yet, so it runs only inside its image.
+</details>
+
+Works with any HuggingFace dataset containing images — documents, forms, receipts, books, handwriting.

SERVING.md

@@ -1,111 +0,0 @@
-# Server-mode OCR: official support per model + the `-server.py` recipes
-
-The recipes in this folder come in two shapes:
-
-- **Offline batch** (`<model>.py`): the script owns the vLLM engine (`LLM.generate`)
-  and processes the dataset in fixed-size batches. One `hf jobs uv run` command.
-- **Server + driver** (`<model>-server.py`): one job starts `vllm serve` in the
-  background, then a lightweight driver (no torch/vllm deps — installs in seconds)
-  posts images concurrently to the OpenAI-compatible endpoint on localhost.
-
-Why server mode? Two measured reasons (100-page historical-scan A/B on `l4x1`,
-same data, same sampling, driver concurrency 32):
-
-| Model | Offline (inference-only) | Server | Speedup | Output parity |
-|---|---|---|---|---|
-| OvisOCR2 0.9B | 0.83 img/s | 1.44 img/s | ~1.7× | 94/100 byte-identical, rest ≥0.978 similar |
-| LightOnOCR-2 1B | 0.33 img/s | 0.59 img/s | ~1.8× | 64/100 byte-identical at temp 0.2, rest median 0.998 |
-| Nanonets-OCR2 3B | 0.31 img/s (steady-state) | 0.36 img/s | ~1.2× | 52/100 byte-identical, median 0.999; 3 hard plate pages fork under greedy (worst case was the *offline* arm degenerating into a 22k-char repetition loop) |
-
-1. **Throughput**: offline `llm.generate` drains at every batch boundary (GPU idles
-   while the CPU decodes the next batch of images); a concurrent driver keeps vLLM's
-   continuous batching fed. The speedup is a floor, not a ceiling — at concurrency 32
-   the server's KV cache was <10% used.
-2. **Failure isolation**: offline, one bad image (e.g. a None cell) fails its whole
-   batch of 16; server mode fails that one request. On a real dataset where ~half the
-   image cells were empty, the offline recipe produced 0 usable outputs and the server
-   recipe produced all of the valid ones.
-
-**LightOnOCR-3-0.8B** (`lighton-ocr3.py` against `lighton-ocr3-saturate.py`, 600 pages: 350
-book pages from finebooks/bhl-impact-gt and 250 typed industry documents, 2026-11-05, steady
-state): `a10g-small` 0.90 → 2.2 pages/s, `a100-large` 1.27 → 7.2 pages/s. Most of the gain is
-pages in flight (the offline recipe sends batches of 16 and waits for the slowest page); on
-small flavors the window is capped by host memory, because each page in flight holds about
-0.1 GiB of image data. On fast GPUs one vLLM API server cannot preprocess images quickly
-enough (128-256 pages in flight, 36-60 running in the engine, none waiting); 4 API servers
-(`--api-server-count 4`) gave +16% on `a100-large`, +9% on `rtx-pro-6000`, +10% on `a10g-large`. At temperature 0.2 the outputs of two server runs differ on about 40%
-of pages; the offline recipe differs from a server run by the same amount. The character
-error rate on the 282 book pages with at least 20 characters of ground truth (IMPACT) was
-0.077 to 0.083 mean and 0.020 median in every 0.8B run, offline or server.
-
-The job command stays the standard `hf jobs uv run` shape: the driver spawns
-`vllm serve` itself as a subprocess when no server is reachable (flags live in the
-script's `SERVE_ARGS`, taken from the model's own card where they exist), so the only
-thing to get right is `--image vllm/vllm-openai:<tag>` — which provides the `vllm`
-binary. Without it the script fails fast, printing the exact correct command. Pass
-`--server URL` to use an already-running or remote endpoint instead (nothing is
-spawned when the server is reachable, so the moss-style explicit `bash -c` serve
-command keeps working too).
-
-For **interactive/agent** use (a live endpoint instead of a batch run), see
-[serving-unlimited-ocr.md](serving-unlimited-ocr.md) — `hf jobs run --expose` gives an
-OpenAI-compatible URL that outlives a single script.
-
-## The recurring official serve pattern for OCR
-
-Three flags recur across independent vendors' official serve commands (DeepSeek's vLLM
-recipe, LightOn's card, Paddle's vLLM recipe, Unlimited-OCR's recipe):
-
-```
---no-enable-prefix-caching --mm-processor-cache-gb 0 --limit-mm-per-prompt '{"image": 1}'
-```
-
-OCR workloads never reuse images, so prefix/multimodal caches only cost memory.
-
-**One exception: HPD-Parsing** (`hpd-parsing-saturate.py`). Its vendor entrypoint sets
-`--enable-prefix-caching` on purpose. Hierarchical parallel decoding forks a child branch per
-page region, and the children reuse the parent branch's prefix KV, so the cache does real work
-(hit rate 52.9% on 5 UFO pages in July 2026, 43.9% on 10 in November). Do not change it to
-`--no-enable-prefix-caching` in a sweep.
-
-## Version pins carry over — via the image tag
-
-Where an offline recipe pins an engine version, the server variant needs the same pin
-as a `vllm/vllm-openai:<tag>` image (e.g. Nanonets-OCR2-3B uses `v0.10.2`, matching its
-offline recipe). [`models.json`](models.json) records the required image per script.
-When trying a new model/image combination, sanity-check the first few outputs before
-scaling: a mismatched combination can produce degenerate output while looking like
-normal load from the outside (full GPU utilisation, no errors).
-
-## Which models document server mode themselves? (surveyed 2026-07-16)
-
-Server mode is the officially documented path for most models in this collection —
-for several of them it's the *only* documented vLLM path. Summary of each model's own
-card/docs (verbatim commands live in the linked sources):
-
-| Model | Official server example | Notes |
-|---|---|---|
-| lightonai/LightOnOCR-1B / 2-1B | ✅ vLLM | Card ships the serve command + client; ≥0.11.1 for v1; images longest-dim 1540px |
-| nanonets/OCR-s / OCR2-3B | ✅ vLLM | Bare `vllm serve` + client in card; **pin v0.10.2 for OCR2** (see above) |
-| rednote-hilab/dots.mocr | ✅ vLLM ≥0.11 | Direct from Hub id on `vllm/vllm-openai:v0.11.0`+ |
-| rednote-hilab/dots.ocr | ✅ (GitHub) | HF card shows a legacy pre-0.11 hack; GitHub README: integrated upstream since 0.11 |
-| tencent/HunyuanOCR | ✅ vLLM 0.18.1 | serve.sh in repo; nightly adds DFlash speculative decoding |
-| zai-org/GLM-OCR | ✅ vLLM + SGLang + Ollama | Only card here with an SGLang serve example; needs vLLM nightly |
-| numind/NuExtract3 | ✅ vLLM | Production-grade recipe: MTP speculative decoding, per-request `chat_template_kwargs` |
-| numind/NuMarkdown-8B-Thinking | ✅ vLLM | Thinking always on — parse `<think>`/`<answer>` |
-| baidu/Unlimited-OCR | ✅ vLLM + SGLang | Custom image / dev wheel; see [serving-unlimited-ocr.md](serving-unlimited-ocr.md) |
-| baidu/Qianfan-OCR | ✅ vLLM (minimal) | Needs `--hf-overrides '{"architectures": ["InternVLChatModel"]}'` |
-| PaddlePaddle/PaddleOCR-VL 1.x | ✅ paddle `genai_server` + vLLM recipe | Serves the 0.9B VLM only; raw serve skips the layout stage (official quality warning) |
-| deepseek-ai/DeepSeek-OCR / -2 | ⚠️ vLLM recipe pages only | docs.vllm.ai recipes; needs the DeepSeek n-gram logits processor flags |
-| allenai/olmOCR-2-7B-FP8 | ✅ (GitHub) | olmocr toolkit spawns `vllm serve` itself; YAML-front-matter prompt required |
-| reducto/RolmOCR | ✅ vLLM | Card serve + client (client's model string has a typo — pass `--served-model-name`) |
-| tiiuae/Falcon-OCR | ✅ vLLM in official Docker | `ghcr.io/tiiuae/falcon-ocr`; task-token prompts |
-| datalab-to/surya-ocr-2, lift | ⚠️ wrapper-mediated | Server-native but driven via their own managers (`SURYA_INFERENCE_URL`, `lift_vllm`) |
-| LiquidAI LFM2.5-VL-Extract | ⚠️ family docs | vLLM ≥0.23 + SGLang cookbooks, not Extract-specific |
-| ATH-MaaS/OvisOCR2 | ❌ offline vLLM only | `ovis-ocr2-server.py` is our translation of the card's offline args (parity-validated, table above) |
-| FireRedTeam/FireRed-OCR | ❌ transformers only | |
-| acvlab/ABot-OCR | ❌ offline script only | pinned vllm 0.18.0 |
-
-SGLang reality check: only GLM-OCR and Unlimited-OCR ship SGLang serve paths (olmOCR
-dropped SGLang for vLLM in v0.1.75). For this collection, "server mode" effectively
-means a vLLM OpenAI-compatible endpoint.

abot-ocr.py

@@ -1,600 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "datasets>=4.0.0",
-#     "huggingface-hub",
-#     "pillow",
-#     "vllm>=0.15.1",
-#     "tqdm",
-#     "toolz",
-#     "torch",
-# ]
-#
-# ///
-
-"""
-Convert document images to Markdown using ABot-OCR with vLLM.
-
-ABot-OCR (acvlab/ABot-OCR) is a compact Qwen3-VL-based document OCR model that
-converts PDF/document page images into structured Markdown, including:
-- Text with original document structure (headings, paragraphs, lists)
-- Mathematical formulas in LaTeX (inline \\( \\) and block \\[ \\])
-- Tables in HTML (<table>…</table>)
-
-Model:  https://huggingface.co/acvlab/ABot-OCR
-Paper:  https://arxiv.org/abs/2605.27978
-Code:   https://github.com/amap-cvlab/ABot-OCR
-
-HF Jobs note: ABot-OCR (Qwen3-VL) uses vLLM's flashinfer sampler, which needs CUDA
-kernels the default uv-script image can't build ("Could not find nvcc"). Run on Jobs
-with the pre-built vLLM image so the kernels are reused (same image-mode pattern as
-nuextract3.py / paddleocr-vl-1.6.py):
-    --image vllm/vllm-openai:latest
-    --python /usr/bin/python3 -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages
-"""
-
-import argparse
-import base64
-import io
-import json
-import logging
-import os
-import sys
-from typing import Any, Dict, List, Union
-from datetime import datetime
-
-import torch
-from datasets import load_dataset
-from huggingface_hub import DatasetCard, login
-from PIL import Image
-from toolz import partition_all
-from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
-from vllm import LLM, SamplingParams
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# ABot-OCR's recommended document→Markdown prompt (from the model's reference
-# inference script; LaTeX delimiters de-mangled to proper \( \) and \[ \]).
-DEFAULT_PROMPT = r"""You are an AI assistant specialized in converting PDF images to Markdown format. Please follow these instructions for the conversion:
-
-1. Text Processing:
-- Accurately recognize all text content in the PDF image without guessing or inferring.
-- Convert the recognized text into Markdown format.
-- Maintain the original document structure, including headings, paragraphs, lists, etc.
-
-2. Mathematical Formula Processing:
-- Convert all mathematical formulas to LaTeX format.
-- Enclose inline formulas with \( \). For example: This is an inline formula \( E = mc^2 \)
-- Enclose block formulas with \[ \]. For example: \[ \frac{-b \pm \sqrt{b^2 - 4ac}}{2a} \]
-
-3. Table Processing:
-- Convert tables to HTML format.
-- Wrap the entire table with <table> and </table>.
-
-4. Figure Handling:
-- Ignore figures content in the PDF image. Do not attempt to describe or convert images.
-
-5. Output Format:
-- Ensure the output Markdown document has a clear structure with appropriate line breaks between elements.
-- For complex layouts, try to maintain the original document's structure and format as closely as possible.
-
-Please strictly follow these guidelines to ensure accuracy and consistency in the conversion. Your task is to accurately convert the content of the PDF image into Markdown format without adding any extra explanations or comments."""
-
-
-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 post_process_text(text: str, threshold: int = 8000) -> str:
-    """Trim runaway repetition loops that VLM OCR can fall into on dense pages.
-
-    Mirrors ABot-OCR's reference post-processing: if the tail of a long output
-    repeats the same short substring many times, collapse it to a single copy.
-    """
-    n = len(text)
-    if n < threshold:
-        return text
-    for length in range(2, n // 10 + 1):
-        candidate = text[-length:]
-        count = 0
-        i = n - length
-        while i >= 0 and text[i:i + length] == candidate:
-            count += 1
-            i -= length
-        if count >= 10:
-            return text[: n - length * (count - 1)]
-    return text
-
-
-def make_ocr_message(
-    image: Union[Image.Image, Dict[str, Any], str],
-    prompt: str = DEFAULT_PROMPT,
-) -> List[Dict]:
-    """Create a vLLM chat message for OCR processing."""
-    # Convert to PIL Image if needed
-    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)}")
-
-    if pil_img.mode != "RGB":
-        pil_img = pil_img.convert("RGB")
-
-    # Convert to base64 data URI
-    buf = io.BytesIO()
-    pil_img.save(buf, format="PNG")
-    data_uri = f"data:image/png;base64,{base64.b64encode(buf.getvalue()).decode()}"
-
-    return [
-        {
-            "role": "user",
-            "content": [
-                {"type": "image_url", "image_url": {"url": data_uri}},
-                {"type": "text", "text": prompt},
-            ],
-        }
-    ]
-
-
-def create_dataset_card(
-    source_dataset: str,
-    model: str,
-    num_samples: int,
-    processing_time: str,
-    batch_size: int,
-    max_model_len: int,
-    max_tokens: int,
-    gpu_memory_utilization: float,
-    image_column: str = "image",
-    split: str = "train",
-) -> str:
-    """Create a dataset card documenting the OCR process."""
-    model_name = model.split("/")[-1]
-
-    return f"""---
-tags:
-- ocr
-- document-processing
-- abot
-- abot-ocr
-- markdown
-- uv-script
-- generated
----
-
-# Document OCR using {model_name}
-
-This dataset contains Markdown-formatted OCR results from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using [ABot-OCR](https://huggingface.co/{model}).
-
-## Processing Details
-
-- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
-- **Model**: [{model}](https://huggingface.co/{model})
-- **Paper**: [arxiv.org/abs/2605.27978](https://arxiv.org/abs/2605.27978)
-- **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}`
-- **Output Column**: `markdown`
-- **Dataset Split**: `{split}`
-- **Batch Size**: {batch_size}
-- **Max Model Length**: {max_model_len:,} tokens
-- **Max Output Tokens**: {max_tokens:,}
-- **GPU Memory Utilization**: {gpu_memory_utilization:.1%}
-
-## Model Information
-
-ABot-OCR is a compact Qwen3-VL-based document OCR model that converts page images to Markdown:
-- 📐 **LaTeX equations** — inline `\\( \\)` and block `\\[ \\]`
-- 📊 **Tables** — extracted as HTML (`<table>…</table>`)
-- 📝 **Document structure** — headings, paragraphs, and lists preserved
-
-## Dataset Structure
-
-The dataset contains all original columns plus:
-- `markdown`: The extracted text in Markdown format with preserved structure
-- `inference_info`: JSON list tracking all OCR models applied to this dataset
-
-## Usage
-
-```python
-from datasets import load_dataset
-
-dataset = load_dataset("{{{{output_dataset_id}}}}", split="{split}")
-for example in dataset:
-    print(example["markdown"])
-    break
-```
-
-## Reproduction
-
-This dataset was generated using the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) ABot-OCR script:
-
-```bash
-uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/abot-ocr.py \\
-    {source_dataset} \\
-    <output-dataset> \\
-    --image-column {image_column} \\
-    --batch-size {batch_size} \\
-    --max-model-len {max_model_len} \\
-    --max-tokens {max_tokens} \\
-    --gpu-memory-utilization {gpu_memory_utilization}
-```
-
-Generated with 🤖 [UV Scripts](https://huggingface.co/uv-scripts)
-"""
-
-
-def main(
-    input_dataset: str,
-    output_dataset: str,
-    image_column: str = "image",
-    batch_size: int = 16,
-    model: str = "acvlab/ABot-OCR",
-    max_model_len: int = 16384,
-    max_tokens: int = 8192,
-    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",
-    overwrite: bool = False,
-    verbose: bool = False,
-):
-    """Process images from a HF dataset through the ABot-OCR model."""
-
-    # Check CUDA availability first
-    check_cuda_availability()
-
-    # Track processing start time
-    start_time = datetime.now()
-
-    # Enable high-performance Xet downloads
-    os.environ["HF_XET_HIGH_PERFORMANCE"] = "1"
-
-    # Login to HF if token provided
-    HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
-    if HF_TOKEN:
-        login(token=HF_TOKEN)
-
-    # Load dataset
-    logger.info(f"Loading dataset: {input_dataset}")
-    dataset = load_dataset(input_dataset, split=split)
-
-    # Validate image column
-    if image_column not in dataset.column_names:
-        raise ValueError(
-            f"Column '{image_column}' not found. Available: {dataset.column_names}"
-        )
-
-    # Fail fast if the output column would collide with an existing input column
-    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
-
-    # Shuffle if requested
-    if shuffle:
-        logger.info(f"Shuffling dataset with seed {seed}")
-        dataset = dataset.shuffle(seed=seed)
-
-    # Limit samples if requested
-    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: {model}")
-    llm = LLM(
-        model=model,
-        trust_remote_code=True,
-        max_model_len=max_model_len,
-        gpu_memory_utilization=gpu_memory_utilization,
-        limit_mm_per_prompt={"image": 1},
-        enforce_eager=True,  # avoid warmup kernel compilation (no nvcc in the image)
-    )
-
-    sampling_params = SamplingParams(
-        temperature=0.0,  # Deterministic for OCR
-        max_tokens=max_tokens,
-    )
-
-    # Process images in batches
-    all_markdown = []
-
-    logger.info(f"Processing {len(dataset)} images in batches of {batch_size}")
-
-    for batch_indices in tqdm(
-        partition_all(batch_size, range(len(dataset))),
-        total=(len(dataset) + batch_size - 1) // batch_size,
-        desc="OCR processing",
-    ):
-        batch_indices = list(batch_indices)
-        batch_images = [dataset[i][image_column] for i in batch_indices]
-
-        try:
-            batch_messages = [make_ocr_message(img) for img in batch_images]
-            outputs = llm.chat(batch_messages, sampling_params)
-            for output in outputs:
-                markdown_text = post_process_text(output.outputs[0].text.strip())
-                all_markdown.append(markdown_text)
-        except Exception as e:
-            logger.error(f"Error processing batch: {e}")
-            all_markdown.extend(["[OCR FAILED]"] * len(batch_images))
-
-    # Add output column to dataset
-    logger.info(f"Adding '{output_column}' column to dataset")
-    dataset = dataset.add_column(output_column, all_markdown)
-
-    # Handle inference_info tracking
-    logger.info("Updating inference_info...")
-
-    inference_entry = {
-        "model_id": model,
-        "model_name": "ABot-OCR",
-        "column_name": output_column,
-        "timestamp": datetime.now().isoformat(),
-        "batch_size": batch_size,
-        "max_tokens": max_tokens,
-        "gpu_memory_utilization": gpu_memory_utilization,
-        "max_model_len": max_model_len,
-        "script": "abot-ocr.py",
-        "script_url": "https://huggingface.co/datasets/uv-scripts/ocr/raw/main/abot-ocr.py",
-    }
-
-    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
-    logger.info(f"Pushing to {output_dataset}")
-    dataset.push_to_hub(output_dataset, private=private, token=HF_TOKEN)
-
-    # Calculate processing time
-    end_time = datetime.now()
-    processing_duration = end_time - start_time
-    processing_time = f"{processing_duration.total_seconds() / 60:.1f} minutes"
-
-    # Create and push dataset card
-    logger.info("Creating dataset card...")
-    card_content = create_dataset_card(
-        source_dataset=input_dataset,
-        model=model,
-        num_samples=len(dataset),
-        processing_time=processing_time,
-        batch_size=batch_size,
-        max_model_len=max_model_len,
-        max_tokens=max_tokens,
-        gpu_memory_utilization=gpu_memory_utilization,
-        image_column=image_column,
-        split=split,
-    )
-
-    card = DatasetCard(card_content)
-    card.push_to_hub(output_dataset, token=HF_TOKEN)
-    logger.info("✅ Dataset card created and pushed!")
-
-    logger.info("✅ OCR conversion complete!")
-    logger.info(
-        f"Dataset available at: https://huggingface.co/datasets/{output_dataset}"
-    )
-
-    if verbose:
-        import importlib.metadata
-
-        logger.info("--- Resolved package versions ---")
-        for pkg in ["vllm", "transformers", "torch", "datasets", "pyarrow", "pillow"]:
-            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__":
-    # Show example usage if no arguments
-    if len(sys.argv) == 1:
-        print("=" * 80)
-        print("ABot-OCR to Markdown Converter")
-        print("=" * 80)
-        print("\nConverts document images to structured Markdown using the")
-        print("ABot-OCR model (Qwen3-VL based) with vLLM acceleration.")
-        print("\nFeatures:")
-        print("- Document structure preserved (headings, paragraphs, lists)")
-        print("- LaTeX equation recognition (inline \\( \\) and block \\[ \\])")
-        print("- Table extraction as HTML")
-        print("\nExample usage:")
-        print("\n1. Basic OCR conversion:")
-        print("   uv run abot-ocr.py document-images markdown-docs")
-        print("\n2. Process a subset for testing:")
-        print("   uv run abot-ocr.py large-dataset test-output --max-samples 10")
-        print("\n3. Running on HF Jobs (use the pre-built vLLM image for flashinfer kernels):")
-        print("   hf jobs uv run --flavor l4x1 \\")
-        print("     --image vllm/vllm-openai:latest \\")
-        print(
-            "     --python /usr/bin/python3 -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages \\"
-        )
-        print("     -s HF_TOKEN \\")
-        print(
-            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/abot-ocr.py \\"
-        )
-        print("       your-document-dataset \\")
-        print("       your-markdown-output \\")
-        print("       --max-samples 10")
-        print("\n" + "=" * 80)
-        print("\nFor full help, run: uv run abot-ocr.py --help")
-        sys.exit(0)
-
-    parser = argparse.ArgumentParser(
-        description="OCR images to Markdown using ABot-OCR (Qwen3-VL)",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  # Basic usage
-  uv run abot-ocr.py my-images-dataset ocr-results
-
-  # With specific image column
-  uv run abot-ocr.py documents extracted-text --image-column scan
-
-  # Process subset for testing
-  uv run abot-ocr.py large-dataset test-output --max-samples 100
-
-  # Random sample from ordered dataset
-  uv run abot-ocr.py ordered-dataset random-sample --max-samples 50 --shuffle
-        """,
-    )
-
-    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(
-        "--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(
-        "--model",
-        default="acvlab/ABot-OCR",
-        help="Model to use (default: acvlab/ABot-OCR)",
-    )
-    parser.add_argument(
-        "--max-model-len",
-        type=int,
-        default=16384,
-        help="Maximum model context length (default: 16384)",
-    )
-    parser.add_argument(
-        "--max-tokens",
-        type=int,
-        default=8192,
-        help="Maximum tokens to generate (default: 8192)",
-    )
-    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(
-        "--shuffle",
-        action="store_true",
-        help="Shuffle the dataset before processing (useful for random sampling)",
-    )
-    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 the OCR output text (default: markdown)",
-    )
-    parser.add_argument(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists 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()
-
-    main(
-        input_dataset=args.input_dataset,
-        output_dataset=args.output_dataset,
-        image_column=args.image_column,
-        batch_size=args.batch_size,
-        model=args.model,
-        max_model_len=args.max_model_len,
-        max_tokens=args.max_tokens,
-        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,
-        overwrite=args.overwrite,
-        verbose=args.verbose,
-    )

deepseek-ocr-vllm.py

@@ -1,19 +1,14 @@
 # /// script
 # requires-python = ">=3.11"
 # dependencies = [
-#     "datasets>=4.0.0,<5.1",  # 5.1 needs huggingface_hub>=1.31; the image ships an older 1.x on PYTHONPATH, which wins
+#     "datasets>=4.0.0",
 #     "huggingface-hub",
 #     "pillow",
+#     "vllm>=0.15.1",
 #     "tqdm",
 #     "toolz",
+#     "torch",
 # ]
-#
-# [tool.hf-jobs]
-# image = "vllm/vllm-openai:v0.29.0"
-# python = "/usr/bin/python3"
-# env = { PYTHONPATH = "/usr/local/lib/python3.12/dist-packages" }
-# flavor = "a10g-small"
-# secrets = ["HF_TOKEN"]
 # ///
 
 """
@@ -26,11 +21,8 @@ Uses the official vLLM offline pattern: llm.generate() with PIL images
 and NGramPerReqLogitsProcessor to prevent repetition on complex documents.
 See: https://docs.vllm.ai/projects/recipes/en/latest/DeepSeek/DeepSeek-OCR.html
 
-Run on HF Jobs. vLLM and torch come from the vllm/vllm-openai:v0.29.0 image declared
-in the [tool.hf-jobs] header (`hf` CLI 1.32+), which also sets the hardware and the
-HF_TOKEN secret. The tag is pinned: vLLM 0.30 breaks the DeepEncoder Triton kernel
-(LOG2E NameError), and nightly wheels moved the logits-processor API. Pass --timeout
-for a long run. To run on your own GPU: `uv run --with vllm==0.29.0 deepseek-ocr-vllm.py ...`.
+NOTE: Uses vLLM nightly wheels. First run may take a few minutes to download
+and install dependencies.
 
 Features:
 - LaTeX equation recognition
@@ -56,10 +48,6 @@ from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 from vllm.model_executor.models.deepseek_ocr import NGramPerReqLogitsProcessor
 
@@ -86,28 +74,6 @@ def check_cuda_availability():
         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: Union[Image.Image, Dict[str, Any], str]) -> Image.Image:
     """Convert various image formats to PIL Image."""
     if isinstance(image, Image.Image):
@@ -241,8 +207,6 @@ def main(
     private: bool = False,
     shuffle: bool = False,
     seed: int = 42,
-    output_column: str = "markdown",
-    overwrite: bool = False,
     config: str = None,
     create_pr: bool = False,
     verbose: bool = False,
@@ -285,9 +249,6 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
-    # Fail fast if the output column would collide with an existing input column
-    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
-
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -361,9 +322,9 @@ def main(
     processing_duration = datetime.now() - start_time
     processing_time_str = f"{processing_duration.total_seconds() / 60:.1f} min"
 
-    # Add output column to dataset
-    logger.info(f"Adding '{output_column}' column to dataset")
-    dataset = dataset.add_column(output_column, all_markdown)
+    # Add markdown column to dataset
+    logger.info("Adding markdown column to dataset")
+    dataset = dataset.add_column("markdown", all_markdown)
 
     # Handle inference_info tracking
     logger.info("Updating inference_info...")
@@ -371,7 +332,7 @@ def main(
     inference_entry = {
         "model_id": model,
         "model_name": "DeepSeek-OCR",
-        "column_name": output_column,
+        "column_name": "markdown",
         "timestamp": datetime.now().isoformat(),
         "prompt_mode": prompt_mode if prompt is None else "custom",
         "batch_size": batch_size,
@@ -481,8 +442,8 @@ if __name__ == "__main__":
             "   uv run deepseek-ocr-vllm.py large-dataset test-output --max-samples 10"
         )
         print("\n5. Running on HF Jobs:")
-        print("   (image, hardware and HF_TOKEN come from the script's [tool.hf-jobs] header)")
-        print("   hf jobs uv run \\")
+        print("   hf jobs uv run --flavor l4x1 \\")
+        print("     -s HF_TOKEN \\")
         print(
             "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/deepseek-ocr-vllm.py \\"
         )
@@ -520,7 +481,7 @@ Examples:
   uv run deepseek-ocr-vllm.py dataset output --batch-size 16 --max-model-len 16384
 
   # Running on HF Jobs
-  hf jobs uv run \\
+  hf jobs uv run --flavor l4x1 -s HF_TOKEN \\
       https://huggingface.co/datasets/uv-scripts/ocr/raw/main/deepseek-ocr-vllm.py \\
       my-dataset my-output --max-samples 10
         """,
@@ -604,17 +565,6 @@ Examples:
         default=42,
         help="Random seed for shuffling (default: 42)",
     )
-    parser.add_argument(
-        "--output-column",
-        default="markdown",
-        help="Column name for the OCR output text (default: markdown)",
-    )
-    parser.add_argument(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists in the input dataset "
-        "(default: error out to avoid clobbering an existing column).",
-    )
     parser.add_argument(
         "--verbose",
         action="store_true",
@@ -640,8 +590,6 @@ Examples:
         private=args.private,
         shuffle=args.shuffle,
         seed=args.seed,
-        output_column=args.output_column,
-        overwrite=args.overwrite,
         config=args.config,
         create_pr=args.create_pr,
         verbose=args.verbose,

deepseek-ocr.py

@@ -1,8 +1,8 @@
 # /// script
 # requires-python = ">=3.11"
 # dependencies = [
-#     "datasets>=4.0.0",
-#     "huggingface-hub",
+#     "datasets",
+#     "huggingface-hub[hf_transfer]",
 #     "pillow",
 #     "torch",
 #     "torchvision",
@@ -18,8 +18,6 @@
 # ///
 
 """
-UNSUPPORTED: Broken (2026-09-23): every output row is the string 'None' (model.infer returns None). Use deepseek-ocr-vllm.py. See models.json (`support`).
-
 Convert document images to markdown using DeepSeek-OCR with Transformers.
 
 This script processes images through the DeepSeek-OCR model to extract
@@ -78,28 +76,6 @@ def check_cuda_availability():
         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 create_dataset_card(
     source_dataset: str,
     model: str,
@@ -267,8 +243,6 @@ def main(
     private: bool = False,
     shuffle: bool = False,
     seed: int = 42,
-    output_column: str = "markdown",
-    overwrite: bool = False,
 ):
     """Process images from HF dataset through DeepSeek-OCR model."""
 
@@ -278,7 +252,8 @@ def main(
     # Track processing start time
     start_time = datetime.now()
 
-
+    # Enable HF_TRANSFER for faster downloads
+    os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
 
     # Login to HF if token provided
     HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
@@ -320,9 +295,6 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
-    # Fail fast if the output column would collide with an existing input column
-    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
-
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -408,12 +380,12 @@ def main(
         try:
             shutil.rmtree(temp_dir)
             shutil.rmtree(temp_output_dir)
-        except Exception:
+        except:
             pass
 
-    # Add output column to dataset
-    logger.info(f"Adding '{output_column}' column to dataset")
-    dataset = dataset.add_column(output_column, all_markdown)
+    # Add markdown column to dataset
+    logger.info("Adding markdown column to dataset")
+    dataset = dataset.add_column("markdown", all_markdown)
 
     # Handle inference_info tracking
     logger.info("Updating inference_info...")
@@ -432,7 +404,7 @@ def main(
 
     # Add new inference info
     new_info = {
-        "column_name": output_column,
+        "column_name": "markdown",
         "model_id": model,
         "processing_date": datetime.now().isoformat(),
         "resolution_mode": resolution_mode,
@@ -610,17 +582,6 @@ Examples:
         default=42,
         help="Random seed for shuffling (default: 42)",
     )
-    parser.add_argument(
-        "--output-column",
-        default="markdown",
-        help="Column name for the OCR output text (default: markdown)",
-    )
-    parser.add_argument(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists in the input dataset "
-        "(default: error out to avoid clobbering an existing column).",
-    )
 
     args = parser.parse_args()
 
@@ -640,6 +601,4 @@ Examples:
         private=args.private,
         shuffle=args.shuffle,
         seed=args.seed,
-        output_column=args.output_column,
-        overwrite=args.overwrite,
     )

deepseek-ocr2-vllm.py

@@ -1,21 +1,22 @@
 # /// script
 # requires-python = ">=3.11"
 # dependencies = [
-#     "datasets>=4.0.0,<5.1",  # 5.1 needs huggingface_hub>=1.31; the image ships an older 1.x on PYTHONPATH, which wins
+#     "datasets>=4.0.0",
 #     "huggingface-hub",
 #     "pillow",
+#     "vllm",
 #     "tqdm",
 #     "toolz",
+#     "torch",
 #     "addict",
 #     "matplotlib",
 # ]
 #
-# [tool.hf-jobs]
-# image = "vllm/vllm-openai:v0.29.0"
-# python = "/usr/bin/python3"
-# env = { PYTHONPATH = "/usr/local/lib/python3.12/dist-packages" }
-# flavor = "a10g-small"
-# secrets = ["HF_TOKEN"]
+# [[tool.uv.index]]
+# url = "https://wheels.vllm.ai/nightly/cu129"
+#
+# [tool.uv]
+# prerelease = "allow"
 # ///
 
 """
@@ -29,11 +30,8 @@ Uses the official vLLM offline pattern: llm.generate() with PIL images
 and NGramPerReqLogitsProcessor to prevent repetition on complex documents.
 See: https://docs.vllm.ai/projects/recipes/en/latest/DeepSeek/DeepSeek-OCR.html
 
-Run on HF Jobs. vLLM and torch come from the vllm/vllm-openai:v0.29.0 image declared
-in the [tool.hf-jobs] header (`hf` CLI 1.32+), which also sets the hardware and the
-HF_TOKEN secret. The tag is pinned: vLLM 0.30 breaks the DeepEncoder Triton kernel
-(LOG2E NameError), and nightly wheels moved the logits-processor API. Pass --timeout
-for a long run. To run on your own GPU: `uv run --with vllm==0.29.0 deepseek-ocr2-vllm.py ...`.
+NOTE: Uses vLLM nightly wheels. First run may take a few minutes to download
+and install dependencies.
 
 Features:
 - Visual Causal Flow architecture for enhanced visual encoding
@@ -61,10 +59,6 @@ from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 from vllm.model_executor.models.deepseek_ocr import NGramPerReqLogitsProcessor
 
@@ -88,28 +82,6 @@ def check_cuda_availability():
         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: Union[Image.Image, Dict[str, Any], str]) -> Image.Image:
     """Convert various image formats to PIL Image."""
     if isinstance(image, Image.Image):
@@ -249,7 +221,6 @@ def main(
     shuffle: bool = False,
     seed: int = 42,
     output_column: str = "markdown",
-    overwrite: bool = False,
     config: str = None,
     create_pr: bool = False,
     verbose: bool = False,
@@ -292,9 +263,6 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
-    # Fail fast if the output column would collide with an existing input column
-    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
-
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -500,8 +468,8 @@ if __name__ == "__main__":
             "   uv run deepseek-ocr2-vllm.py large-dataset test-output --max-samples 10"
         )
         print("\n4. Running on HF Jobs:")
-        print("   (image, hardware and HF_TOKEN come from the script's [tool.hf-jobs] header)")
-        print("   hf jobs uv run \\")
+        print("   hf jobs uv run --flavor l4x1 \\")
+        print("     -s HF_TOKEN \\")
         print(
             "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/deepseek-ocr2-vllm.py \\"
         )
@@ -533,7 +501,7 @@ Examples:
   uv run deepseek-ocr2-vllm.py dataset output --batch-size 16 --max-model-len 16384
 
   # Running on HF Jobs
-  hf jobs uv run \\
+  hf jobs uv run --flavor l4x1 -s HF_TOKEN \\
       https://huggingface.co/datasets/uv-scripts/ocr/raw/main/deepseek-ocr2-vllm.py \\
       my-dataset my-output --max-samples 10
         """,
@@ -602,12 +570,6 @@ Examples:
         default="markdown",
         help="Column name for OCR output (default: markdown). Use a different name to add alongside existing OCR.",
     )
-    parser.add_argument(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists in the input dataset "
-        "(default: error out to avoid clobbering an existing column).",
-    )
     parser.add_argument(
         "--shuffle",
         action="store_true",
@@ -654,7 +616,6 @@ Examples:
         shuffle=args.shuffle,
         seed=args.seed,
         output_column=args.output_column,
-        overwrite=args.overwrite,
         config=args.config,
         create_pr=args.create_pr,
         verbose=args.verbose,

dots-mocr.py → dots-ocr-1.5.py

@@ -1,55 +1,35 @@
 # /// script
 # requires-python = ">=3.11"
 # dependencies = [
-#     "datasets>=4.0.0",
+#     "datasets",
 #     "huggingface-hub",
 #     "pillow",
+#     "vllm>=0.15.1",
 #     "tqdm",
 #     "toolz",
+#     "torch",
 # ]
 #
-# [tool.hf-jobs]
-# # >=v0.30.0: ships huggingface_hub>=1.31, which datasets>=5.1 imports (httpx). On v0.29.0,
-# # PYTHONPATH puts the image's older hub first and `import datasets` crashes.
-# 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 using dots.mocr with vLLM.
+Convert document images to markdown using DoTS.ocr-1.5 with vLLM.
 
-dots.mocr is a 3B multilingual document parsing model with SOTA performance
-on 100+ languages. It excels at converting structured graphics (charts, UI
-layouts, scientific figures) directly into SVG code. Core capabilities include
-grounding, recognition, semantic understanding, and interactive dialogue.
+DoTS.ocr-1.5 is a 3B multilingual document parsing model with SOTA performance
+on 100+ languages. Compared to v1 (1.7B), it adds web screen parsing, scene text
+spotting, SVG code generation, and stronger multilingual document parsing.
 
 Features:
 - Multilingual support (100+ languages)
 - Table extraction and formatting
 - Formula recognition
 - Layout-aware text extraction
-- Web screen parsing
-- Scene text spotting
-- SVG code generation (use --prompt-mode svg, or --model rednote-hilab/dots.mocr-svg for best results)
+- Web screen parsing (NEW in v1.5)
+- Scene text spotting (NEW in v1.5)
+- SVG code generation (requires dots.ocr-1.5-svg variant)
 
-Model: rednote-hilab/dots.mocr
-SVG variant: rednote-hilab/dots.mocr-svg
-vLLM: Officially integrated since v0.11.0
-GitHub: https://github.com/rednote-hilab/dots.mocr
-Paper: https://arxiv.org/abs/2603.13032
-
-Run on HF Jobs (the [tool.hf-jobs] header sets image, flavor and secrets;
-needs the hf CLI 1.32+):
-
-    hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-mocr.py \
-        input-dataset output-dataset
-
-On your own GPU, vLLM is not in the dependencies (the Jobs image provides it):
-
-    uv run --with vllm==0.30.0 dots-mocr.py input-dataset output-dataset
+Model: rednote-hilab/dots.ocr-1.5
+vLLM: Officially supported (same DotsOCRForCausalLM architecture as v1)
 """
 
 import argparse
@@ -66,13 +46,9 @@ from typing import Any, Dict, List, Union
 import torch
 from datasets import load_dataset
 from huggingface_hub import DatasetCard, login
-from PIL import Image, UnidentifiedImageError
+from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)
@@ -80,8 +56,8 @@ logger = logging.getLogger(__name__)
 
 
 # ────────────────────────────────────────────────────────────────
-# dots.mocr Prompt Templates
-# Source: https://github.com/rednote-hilab/dots.mocr/blob/master/dots_mocr/utils/prompts.py
+# DoTS OCR 1.5 Prompt Templates (from official dots.ocr repo)
+# Source: https://github.com/rednote-hilab/dots.ocr/blob/master/dots_ocr/utils/prompts.py
 # ────────────────────────────────────────────────────────────────
 
 PROMPT_TEMPLATES = {
@@ -104,19 +80,11 @@ PROMPT_TEMPLATES = {
 
 5. Final Output: The entire output must be a single JSON object.
 """,
-    # NOTE: Bboxes from layout-all/layout-only are in the resized image coordinate
-    # space (Qwen2VLImageProcessor smart_resize: max_pixels=11289600, factor=28),
-    # NOT original image coordinates. To map back, compute:
-    #   resized_h, resized_w = smart_resize(orig_h, orig_w)
-    #   scale_x, scale_y = orig_w / resized_w, orig_h / resized_h
     "layout-only": """Please output the layout information from this PDF image, including each layout's bbox and its category. The bbox should be in the format [x1, y1, x2, y2]. The layout categories for the PDF document include ['Caption', 'Footnote', 'Formula', 'List-item', 'Page-footer', 'Page-header', 'Picture', 'Section-header', 'Table', 'Text', 'Title']. Do not output the corresponding text. The layout result should be in JSON format.""",
+    # NEW in v1.5:
     "web-parsing": """Parsing the layout info of this webpage image with format json:\n""",
     "scene-spotting": """Detect and recognize the text in the image.""",
     "grounding-ocr": """Extract text from the given bounding box on the image (format: [x1, y1, x2, y2]).\nBounding Box:\n""",
-    # SVG code generation — {width} and {height} are replaced with actual image dimensions.
-    # For best results, use --model rednote-hilab/dots.mocr-svg
-    # Uses higher temperature (0.9) and top_p (1.0) per official recommendation.
-    "svg": """Please generate the SVG code based on the image. viewBox="0 0 {width} {height}" """,
     "general": """ """,
 }
 
@@ -131,28 +99,6 @@ def check_cuda_availability():
         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 make_ocr_message(
     image: Union[Image.Image, Dict[str, Any], str],
     prompt: str = PROMPT_TEMPLATES["ocr"],
@@ -171,12 +117,6 @@ def make_ocr_message(
     # Convert to RGB
     pil_img = pil_img.convert("RGB")
 
-    # For SVG mode, inject actual image dimensions into the prompt
-    if "{width}" in prompt and "{height}" in prompt:
-        prompt = prompt.replace("{width}", str(pil_img.width)).replace(
-            "{height}", str(pil_img.height)
-        )
-
     # Convert to base64 data URI
     buf = io.BytesIO()
     pil_img.save(buf, format="PNG")
@@ -214,7 +154,7 @@ def create_dataset_card(
 tags:
 - ocr
 - document-processing
-- dots-mocr
+- dots-ocr-1.5
 - multilingual
 - markdown
 - uv-script
@@ -223,7 +163,7 @@ tags:
 
 # Document OCR using {model_name}
 
-This dataset contains OCR results from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using dots.mocr, a 3B multilingual model with SOTA document parsing and SVG generation.
+This dataset contains OCR results from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using DoTS.ocr-1.5, a 3B multilingual model with SOTA document parsing.
 
 ## Processing Details
 
@@ -246,14 +186,13 @@ This dataset contains OCR results from images in [{source_dataset}](https://hugg
 
 ## Model Information
 
-dots.mocr is a 3B multilingual document parsing model that excels at:
+DoTS.ocr-1.5 is a 3B multilingual document parsing model that excels at:
 - 100+ Languages — Multilingual document support
 - Table extraction — Structured data recognition
 - Formulas — Mathematical notation preservation
 - Layout-aware — Reading order and structure preservation
 - Web screen parsing — Webpage layout analysis
 - Scene text spotting — Text detection in natural scenes
-- SVG code generation — Charts, UI layouts, scientific figures to SVG
 
 ## Dataset Structure
 
@@ -283,10 +222,10 @@ for info in inference_info:
 
 ## Reproduction
 
-This dataset was generated using the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) dots.mocr script:
+This dataset was generated using the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) DoTS OCR 1.5 script:
 
 ```bash
-uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-mocr.py \\
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-ocr-1.5.py \\
     {source_dataset} \\
     <output-dataset> \\
     --image-column {image_column} \\
@@ -306,7 +245,7 @@ def main(
     output_dataset: str,
     image_column: str = "image",
     batch_size: int = 16,
-    model: str = "rednote-hilab/dots.mocr",
+    model: str = "rednote-hilab/dots.ocr-1.5",
     max_model_len: int = 24000,
     max_tokens: int = 24000,
     gpu_memory_utilization: float = 0.9,
@@ -319,14 +258,13 @@ def main(
     prompt_mode: str = "ocr",
     custom_prompt: str = None,
     output_column: str = "markdown",
-    overwrite: bool = False,
     config: str = None,
     create_pr: bool = False,
     temperature: float = 0.1,
     top_p: float = 0.9,
     verbose: bool = False,
 ):
-    """Process images from HF dataset through dots.mocr model."""
+    """Process images from HF dataset through DoTS.ocr-1.5 model."""
 
     # Check CUDA availability first
     check_cuda_availability()
@@ -357,9 +295,6 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
-    # Fail fast if the output column would collide with an existing input column
-    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
-
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -380,12 +315,6 @@ def main(
         gpu_memory_utilization=gpu_memory_utilization,
     )
 
-    # SVG mode uses higher temperature/top_p per official recommendation
-    if prompt_mode == "svg" and temperature == 0.1 and top_p == 0.9:
-        logger.info("SVG mode: using recommended temperature=0.9, top_p=1.0")
-        temperature = 0.9
-        top_p = 1.0
-
     sampling_params = SamplingParams(
         temperature=temperature,
         top_p=top_p,
@@ -401,35 +330,17 @@ def main(
     for batch_indices in tqdm(
         partition_all(batch_size, range(len(dataset))),
         total=(len(dataset) + batch_size - 1) // batch_size,
-        desc="dots.mocr processing",
+        desc="DoTS.ocr-1.5 processing",
     ):
         batch_indices = list(batch_indices)
-
-        # Fetch images first, with per-batch fallback for unreadable files.
-        # One corrupt image used to take down the entire run via the list
-        # comprehension; now we mark the whole batch as skipped and continue.
-        try:
-            batch_images = [dataset[i][image_column] for i in batch_indices]
-        except (UnidentifiedImageError, OSError) as e:
-            logger.warning(
-                f"Skipping batch of {len(batch_indices)} — unreadable image "
-                f"in batch: {type(e).__name__}: {e}"
-            )
-            all_outputs.extend(
-                ["[OCR SKIPPED — UNREADABLE IMAGE]"] * len(batch_indices)
-            )
-            continue
+        batch_images = [dataset[i][image_column] for i in batch_indices]
 
         try:
             # Create messages for batch
             batch_messages = [make_ocr_message(img, prompt) for img in batch_images]
 
-            # Process with vLLM (dots.mocr needs "string" content format)
-            outputs = llm.chat(
-                batch_messages,
-                sampling_params,
-                chat_template_content_format="string",
-            )
+            # Process with vLLM
+            outputs = llm.chat(batch_messages, sampling_params)
 
             # Extract outputs
             for output in outputs:
@@ -452,7 +363,7 @@ def main(
     # Handle inference_info tracking (for multi-model comparisons)
     inference_entry = {
         "model_id": model,
-        "model_name": "dots.mocr",
+        "model_name": "DoTS.ocr-1.5",
         "column_name": output_column,
         "timestamp": datetime.now().isoformat(),
         "prompt_mode": prompt_mode if not custom_prompt else "custom",
@@ -533,7 +444,7 @@ def main(
     card = DatasetCard(card_content)
     card.push_to_hub(output_dataset, token=HF_TOKEN)
 
-    logger.info("dots.mocr processing complete!")
+    logger.info("DoTS.ocr-1.5 processing complete!")
     logger.info(
         f"Dataset available at: https://huggingface.co/datasets/{output_dataset}"
     )
@@ -555,83 +466,77 @@ if __name__ == "__main__":
     # Show example usage if no arguments
     if len(sys.argv) == 1:
         print("=" * 80)
-        print("dots.mocr Document Processing")
+        print("DoTS.ocr-1.5 Document Processing")
         print("=" * 80)
-        print("\n3B multilingual OCR model with SVG generation")
+        print("\n3B multilingual OCR model supporting 100+ languages")
         print("\nFeatures:")
         print("- Multilingual support (100+ languages)")
         print("- Fast processing with vLLM")
         print("- Table extraction and formatting")
         print("- Formula recognition")
         print("- Layout-aware text extraction")
-        print("- Web screen parsing")
-        print("- Scene text spotting")
-        print("- SVG code generation (charts, UI, figures)")
+        print("- Web screen parsing (NEW in v1.5)")
+        print("- Scene text spotting (NEW in v1.5)")
         print("\nPrompt modes:")
-        print("  ocr            - Text extraction (default)")
-        print("  layout-all     - Layout + bboxes + text (JSON)")
-        print("  layout-only    - Layout + bboxes only (JSON)")
-        print("  web-parsing    - Webpage layout analysis (JSON)")
+        print("  ocr           - Text extraction (default)")
+        print("  layout-all    - Layout + bboxes + text (JSON)")
+        print("  layout-only   - Layout + bboxes only (JSON)")
+        print("  web-parsing   - Webpage layout analysis (JSON)")
         print("  scene-spotting - Scene text detection")
-        print("  grounding-ocr  - Text from bounding box region")
-        print("  svg            - SVG code generation")
-        print("  general        - Free-form (use with --custom-prompt)")
+        print("  grounding-ocr - Text from bounding box region")
+        print("  general       - Free-form (use with --custom-prompt)")
         print("\nExample usage:")
         print("\n1. Basic OCR:")
-        print("   uv run --with vllm==0.30.0 dots-mocr.py input-dataset output-dataset")
-        print("\n2. SVG generation:")
-        print(
-            "   uv run --with vllm==0.30.0 dots-mocr.py charts svg-output --prompt-mode svg --model rednote-hilab/dots.mocr-svg"
-        )
-        print("\n3. Web screen parsing:")
-        print("   uv run --with vllm==0.30.0 dots-mocr.py screenshots parsed --prompt-mode web-parsing")
+        print("   uv run dots-ocr-1.5.py input-dataset output-dataset")
+        print("\n2. Web screen parsing:")
+        print("   uv run dots-ocr-1.5.py screenshots parsed --prompt-mode web-parsing")
+        print("\n3. Scene text spotting:")
+        print("   uv run dots-ocr-1.5.py photos detected --prompt-mode scene-spotting")
         print("\n4. Layout analysis with structure:")
-        print("   uv run --with vllm==0.30.0 dots-mocr.py papers analyzed --prompt-mode layout-all")
+        print("   uv run dots-ocr-1.5.py papers analyzed --prompt-mode layout-all")
         print("\n5. Running on HF Jobs:")
-        print("   # [tool.hf-jobs] header sets image/flavor/secrets (hf CLI 1.32+)")
-        print("   hf jobs uv run \\")
+        print("   hf jobs uv run --flavor l4x1 \\")
+        print("     -s HF_TOKEN \\")
         print(
-            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-mocr.py \\"
+            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-ocr-1.5.py \\"
         )
         print("       input-dataset output-dataset")
         print("\n" + "=" * 80)
-        print("\nFor full help, run: uv run --with vllm==0.30.0 dots-mocr.py --help")
+        print("\nFor full help, run: uv run dots-ocr-1.5.py --help")
         sys.exit(0)
 
     parser = argparse.ArgumentParser(
-        description="Document OCR using dots.mocr (3B multilingual model with SVG generation)",
+        description="Document OCR using DoTS.ocr-1.5 (3B multilingual model)",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="""
-Prompt Modes (official dots.mocr prompts):
+Prompt Modes (official DoTS.ocr-1.5 prompts):
   ocr            - Simple text extraction (default)
   layout-all     - Layout analysis with bboxes, categories, and text (JSON output)
   layout-only    - Layout detection with bboxes and categories only (JSON output)
-  web-parsing    - Webpage layout analysis (JSON output)
-  scene-spotting - Scene text detection and recognition
-  grounding-ocr  - Extract text from bounding box region
-  svg            - SVG code generation (auto-injects image dimensions into viewBox)
-  general        - Free-form QA (use with --custom-prompt)
+  web-parsing    - Webpage layout analysis (JSON output) [NEW in v1.5]
+  scene-spotting - Scene text detection and recognition [NEW in v1.5]
+  grounding-ocr  - Extract text from bounding box region [NEW in v1.5]
+  general        - Free-form QA (use with --custom-prompt) [NEW in v1.5]
 
 SVG Code Generation:
-  Use --prompt-mode svg for SVG output. For best results, combine with
-  --model rednote-hilab/dots.mocr-svg (the SVG-optimized variant).
-  SVG mode automatically uses temperature=0.9, top_p=1.0 unless overridden.
+  For SVG output, use --model rednote-hilab/dots.ocr-1.5-svg with:
+  --custom-prompt 'Please generate the SVG code based on the image.'
 
 Examples:
   # Basic text OCR (default)
-  uv run --with vllm==0.30.0 dots-mocr.py my-docs analyzed-docs
-
-  # SVG generation with optimized variant
-  uv run --with vllm==0.30.0 dots-mocr.py charts svg-out --prompt-mode svg --model rednote-hilab/dots.mocr-svg
+  uv run dots-ocr-1.5.py my-docs analyzed-docs
 
   # Web screen parsing
-  uv run --with vllm==0.30.0 dots-mocr.py screenshots parsed --prompt-mode web-parsing
+  uv run dots-ocr-1.5.py screenshots parsed --prompt-mode web-parsing
+
+  # Scene text spotting
+  uv run dots-ocr-1.5.py photos spotted --prompt-mode scene-spotting
 
   # Full layout analysis with structure
-  uv run --with vllm==0.30.0 dots-mocr.py papers structured --prompt-mode layout-all
+  uv run dots-ocr-1.5.py papers structured --prompt-mode layout-all
 
   # Random sampling for testing
-  uv run --with vllm==0.30.0 dots-mocr.py large-dataset test --max-samples 50 --shuffle
+  uv run dots-ocr-1.5.py large-dataset test --max-samples 50 --shuffle
         """,
     )
 
@@ -650,8 +555,8 @@ Examples:
     )
     parser.add_argument(
         "--model",
-        default="rednote-hilab/dots.mocr",
-        help="Model to use (default: rednote-hilab/dots.mocr, or rednote-hilab/dots.mocr-svg for SVG)",
+        default="rednote-hilab/dots.ocr-1.5",
+        help="Model to use (default: rednote-hilab/dots.ocr-1.5)",
     )
     parser.add_argument(
         "--max-model-len",
@@ -707,12 +612,6 @@ Examples:
         default="markdown",
         help="Column name for output text (default: markdown)",
     )
-    parser.add_argument(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists in the input dataset "
-        "(default: error out to avoid clobbering an existing column).",
-    )
     parser.add_argument(
         "--config",
         help="Config/subset name when pushing to Hub (for benchmarking multiple models in one repo)",
@@ -760,7 +659,6 @@ Examples:
         prompt_mode=args.prompt_mode,
         custom_prompt=args.custom_prompt,
         output_column=args.output_column,
-        overwrite=args.overwrite,
         config=args.config,
         create_pr=args.create_pr,
         temperature=args.temperature,

dots-ocr.py

@@ -1,21 +1,15 @@
 # /// script
 # requires-python = ">=3.11"
 # dependencies = [
-#     "datasets>=4.0.0",
+#     "datasets",
 #     "huggingface-hub",
 #     "pillow",
+#     "vllm>=0.15.1",
 #     "tqdm",
 #     "toolz",
+#     "torch",
 # ]
 #
-# [tool.hf-jobs]
-# # >=v0.30.0: ships huggingface_hub>=1.31, which datasets>=5.1 imports (httpx). On v0.29.0,
-# # PYTHONPATH puts the image's older hub first and `import datasets` crashes.
-# 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"]
 # ///
 
 """
@@ -33,16 +27,6 @@ Features:
 
 Model: rednote-hilab/dots.ocr
 vLLM: Officially tested with 0.9.1+ (native support via PR #24645)
-
-Run on HF Jobs (the [tool.hf-jobs] header sets image, flavor and secrets;
-needs `hf` CLI 1.32+):
-
-    hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-ocr.py \\
-        input-dataset output-dataset
-
-Run on your own GPU (vLLM and torch come from the image on Jobs, so add them):
-
-    uv run --with vllm==0.30.0 dots-ocr.py input-dataset output-dataset
 """
 
 import argparse
@@ -61,10 +45,6 @@ from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)
@@ -109,28 +89,6 @@ def check_cuda_availability():
         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 make_ocr_message(
     image: Union[Image.Image, Dict[str, Any], str],
     prompt: str = PROMPT_TEMPLATES["ocr"],
@@ -277,8 +235,7 @@ def main(
     image_column: str = "image",
     batch_size: int = 16,
     model: str = "rednote-hilab/dots.ocr",
-    max_model_len: int = 32768,
-    max_pixels: int = None,
+    max_model_len: int = 8192,
     max_tokens: int = 8192,
     gpu_memory_utilization: float = 0.8,
     hf_token: str = None,
@@ -290,7 +247,6 @@ def main(
     prompt_mode: str = "ocr",
     custom_prompt: str = None,
     output_column: str = "markdown",
-    overwrite: bool = False,
     config: str = None,
     create_pr: bool = False,
 ):
@@ -325,9 +281,6 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
-    # Fail fast if the output column would collide with an existing input column
-    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
-
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -341,17 +294,13 @@ def main(
     # Initialize vLLM model
     logger.info(f"Initializing vLLM with model: {model}")
     logger.info("This may take a few minutes on first run...")
-    llm_kwargs = dict(
+    llm = LLM(
         model=model,
         trust_remote_code=True,
         max_model_len=max_model_len,
         gpu_memory_utilization=gpu_memory_utilization,
         limit_mm_per_prompt={"image": 1},
     )
-    if max_pixels is not None:
-        logger.info(f"Capping input images to max_pixels={max_pixels}")
-        llm_kwargs["mm_processor_kwargs"] = {"max_pixels": max_pixels}
-    llm = LLM(**llm_kwargs)
 
     sampling_params = SamplingParams(
         temperature=0.0,  # Deterministic for OCR
@@ -490,25 +439,28 @@ if __name__ == "__main__":
         print("- 📝 Layout-aware text extraction")
         print("\nExample usage:")
         print("\n1. Basic OCR:")
-        print("   uv run --with vllm==0.30.0 dots-ocr.py input-dataset output-dataset")
+        print("   uv run dots-ocr.py input-dataset output-dataset")
         print("\n2. With custom settings:")
         print(
-            "   uv run --with vllm==0.30.0 dots-ocr.py docs analyzed-docs --batch-size 20 --max-samples 100"
+            "   uv run dots-ocr.py docs analyzed-docs --batch-size 20 --max-samples 100"
         )
         print("\n3. Layout analysis with structure:")
         print(
-            "   uv run --with vllm==0.30.0 dots-ocr.py papers analyzed-structure --prompt-mode layout-all"
+            "   uv run dots-ocr.py papers analyzed-structure --prompt-mode layout-all"
         )
         print("\n4. Layout detection only (no text):")
-        print("   uv run --with vllm==0.30.0 dots-ocr.py docs layout-info --prompt-mode layout-only")
-        print("\n5. Running on HF Jobs (header sets image/flavor/secrets; hf CLI 1.32+):")
-        print("   hf jobs uv run \\")
+        print("   uv run dots-ocr.py docs layout-info --prompt-mode layout-only")
+        print("\n5. Running on HF Jobs:")
+        print("   hf jobs uv run --flavor l4x1 \\")
+        print(
+            '     -e HF_TOKEN=$(python3 -c "from huggingface_hub import get_token; print(get_token())") \\'
+        )
         print(
             "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-ocr.py \\"
         )
         print("       input-dataset output-dataset")
         print("\n" + "=" * 80)
-        print("\nFor full help, run: uv run --with vllm==0.30.0 dots-ocr.py --help")
+        print("\nFor full help, run: uv run dots-ocr.py --help")
         sys.exit(0)
 
     parser = argparse.ArgumentParser(
@@ -522,13 +474,13 @@ Prompt Modes (official DoTS.ocr prompts):
 
 Examples:
   # Basic text OCR (default)
-  uv run --with vllm==0.30.0 dots-ocr.py my-docs analyzed-docs
+  uv run dots-ocr.py my-docs analyzed-docs
 
   # Full layout analysis with structure
-  uv run --with vllm==0.30.0 dots-ocr.py papers structured --prompt-mode layout-all
+  uv run dots-ocr.py papers structured --prompt-mode layout-all
 
   # Random sampling for testing
-  uv run --with vllm==0.30.0 dots-ocr.py large-dataset test --max-samples 50 --shuffle
+  uv run dots-ocr.py large-dataset test --max-samples 50 --shuffle
         """,
     )
 
@@ -553,23 +505,8 @@ Examples:
     parser.add_argument(
         "--max-model-len",
         type=int,
-        default=32768,
-        help=(
-            "Maximum model context length (default: 32768). dots.ocr does NOT resize "
-            "input images, so a full page can reach ~14k image tokens (the model's "
-            "11.29M-px processor cap); the old 8192 default rejected such requests and "
-            "the row was written as '[OCR ERROR]'. Pair with --max-pixels to cap memory."
-        ),
-    )
-    parser.add_argument(
-        "--max-pixels",
-        type=int,
-        default=None,
-        help=(
-            "Optional cap on input image pixels (width*height) passed to vLLM's "
-            "mm_processor. Lower this (e.g. 4000000) to bound image tokens and GPU "
-            "memory on very large scans. Default: model's own cap (~11.29M px)."
-        ),
+        default=8192,
+        help="Maximum model context length (default: 8192)",
     )
     parser.add_argument(
         "--max-tokens",
@@ -619,12 +556,6 @@ Examples:
         default="markdown",
         help="Column name for output text (default: markdown)",
     )
-    parser.add_argument(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists in the input dataset "
-        "(default: error out to avoid clobbering an existing column).",
-    )
     parser.add_argument(
         "--config",
         help="Config/subset name when pushing to Hub (for benchmarking multiple models in one repo)",
@@ -644,7 +575,6 @@ Examples:
         batch_size=args.batch_size,
         model=args.model,
         max_model_len=args.max_model_len,
-        max_pixels=args.max_pixels,
         max_tokens=args.max_tokens,
         gpu_memory_utilization=args.gpu_memory_utilization,
         hf_token=args.hf_token,
@@ -656,7 +586,6 @@ Examples:
         prompt_mode=args.prompt_mode,
         custom_prompt=args.custom_prompt,
         output_column=args.output_column,
-        overwrite=args.overwrite,
         config=args.config,
         create_pr=args.create_pr,
     )

examples/nls-index-card-v2.json

@@ -1,13 +0,0 @@
-{
-  "image_type": ["index_card", "verso", "cover", "blank", "other"],
-  "heading": "verbatim-string",
-  "heading_type": ["person", "family", "corporate", "geographic", "subject"],
-  "epithet": "string",
-  "entries": [
-    {
-      "ms_no": "verbatim-string",
-      "folios": ["verbatim-string"],
-      "description": "string"
-    }
-  ]
-}

examples/nls-index-card-verbose.json

@@ -1,13 +0,0 @@
-{
-  "image_type": ["index_card", "verso", "cover", "blank", "other"],
-  "main_heading_name": "verbatim-string",
-  "heading_category": ["person", "family", "corporate", "geographic", "subject"],
-  "epithet_title_or_occupation": "string",
-  "manuscript_references": [
-    {
-      "manuscript_number": "verbatim-string",
-      "folio_references": ["verbatim-string"],
-      "entry_description_with_date": "string"
-    }
-  ]
-}

falcon-ocr-bucket.py

@@ -1,303 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "pillow",
-#     "pymupdf",
-#     "torch>=2.5",
-#     "torchvision",
-#     "falcon-perception[ocr]",
-# ]
-# ///
-
-"""
-OCR images and PDFs from a directory using Falcon OCR, writing markdown files.
-
-Designed to work with HF Buckets mounted as volumes via `hf jobs uv run -v ...`.
-Reads images/PDFs from INPUT_DIR, runs Falcon OCR via the optimized falcon-perception
-engine (CUDA graphs + paged inference), and writes one .md file per image (or per
-PDF page) to OUTPUT_DIR, preserving directory structure.
-
-Input:                          Output:
-  /input/page1.png        ->      /output/page1.md
-  /input/report.pdf       ->      /output/report/page_001.md
-  (3 pages)                       /output/report/page_002.md
-                                  /output/report/page_003.md
-  /input/sub/photo.jpg    ->      /output/sub/photo.md
-
-Examples:
-
-  # Local test
-  uv run falcon-ocr-bucket.py ./test-images ./test-output
-
-  # HF Jobs with bucket volumes
-  hf jobs uv run --flavor l4x1 \\
-      -s HF_TOKEN \\
-      -v hf://buckets/user/ocr-input:/input:ro \\
-      -v hf://buckets/user/ocr-output:/output \\
-      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/falcon-ocr-bucket.py \\
-      /input /output
-
-Model: tiiuae/Falcon-OCR (0.3B, 80.3% olmOCR, Apache 2.0)
-Backend: falcon-perception (OCRInferenceEngine with CUDA graphs)
-"""
-
-import argparse
-import logging
-import sys
-import time
-from pathlib import Path
-
-import torch
-from PIL import Image
-
-logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
-logger = logging.getLogger(__name__)
-
-MODEL_ID = "tiiuae/Falcon-OCR"
-IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".tiff", ".tif", ".bmp", ".webp"}
-
-
-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 discover_files(input_dir: Path, limit: int | None = None) -> list[Path]:
-    """Discover image and PDF files under input_dir.
-
-    Without `limit`, returns the full sorted list (deterministic order).
-    With `limit`, stops scanning once `limit` matching files are found
-    and returns them in filesystem order (much faster on huge mounted
-    buckets, but ordering is not deterministic).
-    """
-    files = []
-    iterator = (
-        input_dir.rglob("*") if limit is not None else sorted(input_dir.rglob("*"))
-    )
-    for path in iterator:
-        if not path.is_file():
-            continue
-        ext = path.suffix.lower()
-        if ext in IMAGE_EXTENSIONS or ext == ".pdf":
-            files.append(path)
-            if limit is not None and len(files) >= limit:
-                break
-    return files
-
-
-def prepare_images(
-    files: list[Path], input_dir: Path, output_dir: Path, pdf_dpi: int
-) -> list[tuple[Image.Image, Path]]:
-    import fitz  # pymupdf
-
-    items: list[tuple[Image.Image, Path]] = []
-
-    for file_path in files:
-        rel = file_path.relative_to(input_dir)
-        ext = file_path.suffix.lower()
-
-        if ext == ".pdf":
-            pdf_output_dir = output_dir / rel.with_suffix("")
-            try:
-                doc = fitz.open(file_path)
-                num_pages = len(doc)
-                logger.info(f"PDF: {rel} ({num_pages} pages)")
-                for page_num in range(num_pages):
-                    page = doc[page_num]
-                    zoom = pdf_dpi / 72.0
-                    mat = fitz.Matrix(zoom, zoom)
-                    pix = page.get_pixmap(matrix=mat)
-                    img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
-                    md_path = pdf_output_dir / f"page_{page_num + 1:03d}.md"
-                    items.append((img, md_path))
-                doc.close()
-            except Exception as e:
-                logger.error(f"Failed to open PDF {rel}: {e}")
-        else:
-            try:
-                img = Image.open(file_path).convert("RGB")
-                md_path = output_dir / rel.with_suffix(".md")
-                items.append((img, md_path))
-            except Exception as e:
-                logger.error(f"Failed to open image {rel}: {e}")
-
-    return items
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="OCR images/PDFs from a directory using Falcon OCR, output markdown files.",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog=__doc__,
-    )
-    parser.add_argument("input_dir", help="Directory containing images and/or PDFs")
-    parser.add_argument("output_dir", help="Directory to write markdown output files")
-    parser.add_argument(
-        "--batch-size", type=int, default=8, help="Images per batch (default: 8)",
-    )
-    parser.add_argument(
-        "--pdf-dpi", type=int, default=300,
-        help="DPI for PDF page rendering (default: 300)",
-    )
-    parser.add_argument(
-        "--no-compile", action="store_true", help="Disable torch.compile",
-    )
-    parser.add_argument(
-        "--no-cudagraph", action="store_true", help="Disable CUDA graph capture",
-    )
-    parser.add_argument(
-        "--max-samples", type=int, default=None,
-        help="Limit number of input files to discover. Stops scanning early "
-             "once the limit is reached (much faster on large mounted buckets). "
-             "Applied before PDF page expansion. With --max-samples set, file "
-             "ordering is filesystem-dependent rather than sorted.",
-    )
-    parser.add_argument(
-        "--verbose", action="store_true", help="Print resolved package versions",
-    )
-
-    args = parser.parse_args()
-
-    check_cuda_availability()
-
-    input_dir = Path(args.input_dir)
-    output_dir = Path(args.output_dir)
-
-    if not input_dir.is_dir():
-        logger.error(f"Input directory does not exist: {input_dir}")
-        sys.exit(1)
-
-    output_dir.mkdir(parents=True, exist_ok=True)
-
-    start_time = time.time()
-
-    # Discover files
-    if args.max_samples is not None:
-        logger.info(
-            f"Scanning {input_dir} for up to {args.max_samples} images/PDFs "
-            f"(early termination, --max-samples)..."
-        )
-    else:
-        logger.info(f"Scanning {input_dir} for images and PDFs...")
-    files = discover_files(input_dir, limit=args.max_samples)
-    if not files:
-        logger.error(f"No image or PDF files found in {input_dir}")
-        sys.exit(1)
-
-    pdf_count = sum(1 for f in files if f.suffix.lower() == ".pdf")
-    img_count = len(files) - pdf_count
-    logger.info(f"Found {img_count} image(s) and {pdf_count} PDF(s)")
-
-    # Prepare images
-    logger.info("Preparing images (rendering PDFs)...")
-    items = prepare_images(files, input_dir, output_dir, args.pdf_dpi)
-    if not items:
-        logger.error("No processable images after preparation")
-        sys.exit(1)
-
-    logger.info(f"Total images to OCR: {len(items)}")
-
-    # Load model
-    logger.info(f"Loading {MODEL_ID} via falcon-perception engine...")
-    from falcon_perception import load_and_prepare_model
-    from falcon_perception.data import ImageProcessor
-    from falcon_perception.paged_ocr_inference import OCRInferenceEngine
-
-    do_compile = not args.no_compile
-    do_cudagraph = not args.no_cudagraph
-
-    model, tokenizer, model_args = load_and_prepare_model(
-        hf_model_id=MODEL_ID,
-        device="cuda",
-        dtype="bfloat16",
-        compile=do_compile,
-    )
-
-    image_processor = ImageProcessor(patch_size=16, merge_size=1)
-    engine = OCRInferenceEngine(
-        model, tokenizer, image_processor, capture_cudagraph=do_cudagraph
-    )
-    logger.info(f"Engine loaded. compile={do_compile}, cudagraph={do_cudagraph}")
-
-    # Process in batches
-    errors = 0
-    processed = 0
-    total = len(items)
-    batch_size = args.batch_size
-
-    for batch_start in range(0, total, batch_size):
-        batch_end = min(batch_start + batch_size, total)
-        batch = items[batch_start:batch_end]
-        batch_num = batch_start // batch_size + 1
-        total_batches = (total + batch_size - 1) // batch_size
-
-        logger.info(f"Batch {batch_num}/{total_batches} ({processed}/{total} done)")
-
-        try:
-            batch_images = [img for img, _ in batch]
-            texts = engine.generate_plain(images=batch_images, use_tqdm=False)
-
-            for (_, md_path), text in zip(batch, texts):
-                md_path.parent.mkdir(parents=True, exist_ok=True)
-                md_path.write_text(text.strip(), encoding="utf-8")
-                processed += 1
-
-        except Exception as e:
-            logger.error(f"Batch {batch_num} failed: {e}")
-            for _, md_path in batch:
-                md_path.parent.mkdir(parents=True, exist_ok=True)
-                md_path.write_text(f"[OCR ERROR: {e}]", encoding="utf-8")
-            errors += len(batch)
-            processed += len(batch)
-
-    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! Processed {total} images in {elapsed_str}")
-    logger.info(f"  Output: {output_dir}")
-    logger.info(f"  Errors: {errors}")
-    if total > 0:
-        logger.info(f"  Speed: {total / elapsed:.2f} images/sec")
-
-    if args.verbose:
-        import importlib.metadata
-
-        logger.info("--- Package versions ---")
-        for pkg in ["falcon-perception", "torch", "pillow", "pymupdf"]:
-            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("Falcon OCR Bucket Script")
-        print("=" * 60)
-        print(f"\nModel: {MODEL_ID} (0.3B, Apache 2.0)")
-        print("OCR images/PDFs from a directory -> markdown files.")
-        print("Designed for HF Buckets mounted as volumes.")
-        print()
-        print("Usage:")
-        print("  uv run falcon-ocr-bucket.py INPUT_DIR OUTPUT_DIR")
-        print()
-        print("Examples:")
-        print("  uv run falcon-ocr-bucket.py ./images ./output")
-        print()
-        print("HF Jobs with bucket volumes:")
-        print("  hf jobs uv run --flavor l4x1 -s HF_TOKEN \\")
-        print("      -v hf://buckets/user/ocr-input:/input:ro \\")
-        print("      -v hf://buckets/user/ocr-output:/output \\")
-        print(
-            "      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/falcon-ocr-bucket.py \\"
-        )
-        print("      /input /output")
-        print()
-        print("For full help: uv run falcon-ocr-bucket.py --help")
-        sys.exit(0)
-
-    main()

falcon-ocr.py

@@ -1,466 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "datasets>=4.0.0",
-#     "huggingface-hub",
-#     "pillow",
-#     "torch>=2.5",
-#     "torchvision",
-#     "falcon-perception",
-# ]
-# ///
-
-"""
-Convert document images to text using Falcon OCR with the falcon-perception engine.
-
-Uses the optimized OCRInferenceEngine with CUDA graphs and paged inference
-for much faster throughput than the raw transformers API.
-
-Features:
-- Compact: Only 0.3B parameters
-- Fast: Optimized inference with CUDA graphs
-- Multi-format: Plain text, LaTeX formulas, HTML tables
-- Layout-aware: Optional 2-stage pipeline (layout detection + per-region OCR)
-
-Model: tiiuae/Falcon-OCR
-Backend: falcon-perception (OCRInferenceEngine)
-License: Apache 2.0
-
-Examples:
-    # Basic text OCR
-    uv run falcon-ocr.py input-dataset output-dataset
-
-    # Test with small sample
-    uv run falcon-ocr.py dataset test --max-samples 5 --shuffle
-
-    # Run on HF Jobs with GPU
-    hf jobs uv run --flavor l4x1 \\
-        -s HF_TOKEN \\
-        falcon-ocr.py \\
-        input-dataset output-dataset --max-samples 10
-"""
-
-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, login
-from PIL import Image
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-MODEL_ID = "tiiuae/Falcon-OCR"
-
-TASK_MODES = {
-    "plain": "Full-page text extraction",
-}
-
-
-def check_cuda_availability():
-    if not torch.cuda.is_available():
-        logger.error("CUDA is not available. This script requires a GPU.")
-        logger.error("For cloud execution, use HF Jobs with --flavor l4x1 or similar.")
-        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 prepare_image(image: Union[Image.Image, Dict[str, Any], str]) -> Image.Image:
-    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 create_dataset_card(
-    source_dataset: str,
-    task_mode: str,
-    num_samples: int,
-    processing_time: str,
-    image_column: str = "image",
-    split: str = "train",
-) -> str:
-    task_description = TASK_MODES[task_mode]
-    return f"""---
-tags:
-- ocr
-- document-processing
-- falcon-ocr
-- {task_mode}
-- uv-script
-- generated
----
-
-# Document Processing using Falcon OCR ({task_mode} mode)
-
-This dataset contains OCR results from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using [Falcon OCR](https://huggingface.co/tiiuae/Falcon-OCR), a 0.3B early-fusion vision-language model.
-
-## Processing Details
-
-- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
-- **Model**: [{MODEL_ID}](https://huggingface.co/{MODEL_ID})
-- **Task Mode**: `{task_mode}` - {task_description}
-- **Number of Samples**: {num_samples:,}
-- **Processing Time**: {processing_time}
-- **Processing Date**: {datetime.now().strftime("%Y-%m-%d %H:%M UTC")}
-- **Backend**: falcon-perception (OCRInferenceEngine)
-
-## Reproduction
-
-```bash
-uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/falcon-ocr.py \\
-    {source_dataset} \\
-    <output-dataset> \\
-    --task-mode {task_mode} \\
-    --image-column {image_column}
-```
-
-Generated with [UV Scripts](https://huggingface.co/uv-scripts)
-"""
-
-
-def main(
-    input_dataset: str,
-    output_dataset: str,
-    image_column: str = "image",
-    task_mode: str = "plain",
-    hf_token: str = None,
-    split: str = "train",
-    max_samples: int = None,
-    private: bool = False,
-    shuffle: bool = False,
-    seed: int = 42,
-    output_column: str = "markdown",
-    overwrite: bool = False,
-    config: str = None,
-    create_pr: bool = False,
-    compile: bool = True,
-    cudagraph: bool = True,
-    progress: bool = False,
-    verbose: bool = False,
-):
-    check_cuda_availability()
-    start_time = datetime.now()
-
-    HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
-    if HF_TOKEN:
-        login(token=HF_TOKEN)
-
-    if task_mode not in TASK_MODES:
-        raise ValueError(
-            f"Invalid task_mode '{task_mode}'. Choose from: {list(TASK_MODES.keys())}"
-        )
-
-    logger.info(f"Task mode: {task_mode} - {TASK_MODES[task_mode]}")
-    logger.info(f"Output column: {output_column}")
-
-    # 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 the output column would collide with an existing input column
-    dataset = ensure_output_columns_free(dataset, [output_column], 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")
-
-    # Load model using falcon-perception
-    logger.info(f"Loading model: {MODEL_ID} via falcon-perception engine")
-    from falcon_perception import load_and_prepare_model
-    from falcon_perception.data import ImageProcessor
-    from falcon_perception.paged_ocr_inference import OCRInferenceEngine
-
-    model, tokenizer, model_args = load_and_prepare_model(
-        hf_model_id=MODEL_ID,
-        device="cuda",
-        dtype="bfloat16",
-        compile=compile,
-    )
-
-    image_processor = ImageProcessor(patch_size=16, merge_size=1)
-    engine = OCRInferenceEngine(
-        model, tokenizer, image_processor, capture_cudagraph=cudagraph
-    )
-    logger.info(f"Engine loaded. compile={compile}, cudagraph={cudagraph}")
-
-    # Prepare all images
-    logger.info(f"Processing {len(dataset)} images...")
-    all_outputs = []
-
-    # Batch plain OCR for better throughput
-    batch_size = 8
-    total_batches = (len(dataset) + batch_size - 1) // batch_size
-    for batch_idx, batch_start in enumerate(range(0, len(dataset), batch_size), 1):
-        batch_end = min(batch_start + batch_size, len(dataset))
-        logger.info(f"Batch {batch_idx}/{total_batches} ({batch_start}/{len(dataset)} done)")
-        batch_images = []
-        for i in range(batch_start, batch_end):
-            try:
-                batch_images.append(prepare_image(dataset[i][image_column]))
-            except Exception as e:
-                logger.error(f"Error preparing image {i}: {e}")
-                batch_images.append(Image.new("RGB", (100, 100)))
-
-        try:
-            texts = engine.generate_plain(
-                images=batch_images, use_tqdm=progress
-            )
-            all_outputs.extend(texts)
-        except Exception as e:
-            logger.error(f"Error processing batch {batch_start}-{batch_end}: {e}")
-            all_outputs.extend(
-                [f"[OCR ERROR: {str(e)[:200]}]"] * len(batch_images)
-            )
-
-    # Calculate processing time
-    processing_duration = datetime.now() - start_time
-    processing_time_str = f"{processing_duration.total_seconds() / 60:.1f} min"
-
-    # Add output column
-    logger.info(f"Adding '{output_column}' column to dataset")
-    dataset = dataset.add_column(output_column, all_outputs)
-
-    # Track inference info
-    inference_entry = {
-        "model_id": MODEL_ID,
-        "model_name": "Falcon-OCR",
-        "model_size": "0.3B",
-        "task_mode": task_mode,
-        "column_name": output_column,
-        "timestamp": datetime.now().isoformat(),
-        "backend": "falcon-perception",
-    }
-
-    if "inference_info" in dataset.column_names:
-        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:
-        inference_list = [json.dumps([inference_entry])] * len(dataset)
-        dataset = dataset.add_column("inference_info", inference_list)
-
-    # Push to hub
-    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"
-            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_ID} 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,
-        task_mode=task_mode,
-        num_samples=len(dataset),
-        processing_time=processing_time_str,
-        image_column=image_column,
-        split=split,
-    )
-    card = DatasetCard(card_content)
-    card.push_to_hub(output_dataset, token=HF_TOKEN)
-
-    logger.info("Falcon OCR 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"Speed: {len(dataset) / processing_duration.total_seconds():.2f} images/sec"
-    )
-
-    if verbose:
-        import importlib.metadata
-
-        logger.info("--- Resolved package versions ---")
-        for pkg in [
-            "falcon-perception", "transformers", "torch", "datasets", "pillow"
-        ]:
-            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("=" * 70)
-        print("Falcon OCR - 0.3B Document OCR (falcon-perception engine)")
-        print("=" * 70)
-        print(f"\nModel: {MODEL_ID}")
-        print("License: Apache 2.0")
-        print("\nTask Modes:")
-        for mode, description in TASK_MODES.items():
-            print(f"  {mode:10} - {description}")
-        print("\nExamples:")
-        print("  uv run falcon-ocr.py input-dataset output-dataset")
-        print("  uv run falcon-ocr.py dense-docs output --task-mode layout")
-        print("\nFor full help: uv run falcon-ocr.py --help")
-        sys.exit(0)
-
-    parser = argparse.ArgumentParser(
-        description="Document OCR using Falcon OCR (0.3B, falcon-perception engine)",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog=__doc__,
-    )
-
-    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(
-        "--image-column", default="image",
-        help="Column containing images (default: image)",
-    )
-    parser.add_argument(
-        "--task-mode", choices=list(TASK_MODES.keys()), default="plain",
-        help="Task type: plain (default), layout",
-    )
-    parser.add_argument("--hf-token", help="Hugging Face API token")
-    parser.add_argument(
-        "--split", default="train", help="Dataset split (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(
-        "--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(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists in the input dataset "
-        "(default: error out to avoid clobbering an existing column).",
-    )
-    parser.add_argument(
-        "--config",
-        help="Config/subset name for Hub (for benchmarking multiple models)",
-    )
-    parser.add_argument(
-        "--create-pr", action="store_true",
-        help="Create a pull request instead of pushing directly",
-    )
-    parser.add_argument(
-        "--no-compile", action="store_true",
-        help="Disable torch.compile",
-    )
-    parser.add_argument(
-        "--no-cudagraph", action="store_true",
-        help="Disable CUDA graph capture",
-    )
-    parser.add_argument(
-        "--progress", action="store_true",
-        help="Show per-image progress bar from the inference engine",
-    )
-    parser.add_argument(
-        "--verbose", action="store_true", help="Log resolved package versions",
-    )
-
-    args = parser.parse_args()
-
-    main(
-        input_dataset=args.input_dataset,
-        output_dataset=args.output_dataset,
-        image_column=args.image_column,
-        task_mode=args.task_mode,
-        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,
-        overwrite=args.overwrite,
-        config=args.config,
-        create_pr=args.create_pr,
-        compile=not args.no_compile,
-        cudagraph=not args.no_cudagraph,
-        progress=args.progress,
-        verbose=args.verbose,
-    )

firered-ocr.py

@@ -1,7 +1,7 @@
 # /// script
 # requires-python = ">=3.11"
 # dependencies = [
-#     "datasets>=4.0.0",
+#     "datasets",
 #     "huggingface-hub",
 #     "pillow",
 #     "vllm>=0.15.1",
@@ -39,10 +39,6 @@ from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)
@@ -90,28 +86,6 @@ def check_cuda_availability():
         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 make_ocr_message(
     image: Union[Image.Image, Dict[str, Any], str],
     prompt: str = FIRERED_OCR_PROMPT,
@@ -130,10 +104,10 @@ def make_ocr_message(
     # Convert to RGB
     pil_img = pil_img.convert("RGB")
 
-    # Convert to base64 data URI (JPEG is faster than PNG for encoding)
+    # Convert to base64 data URI
     buf = io.BytesIO()
-    pil_img.save(buf, format="JPEG", quality=95)
-    data_uri = f"data:image/jpeg;base64,{base64.b64encode(buf.getvalue()).decode()}"
+    pil_img.save(buf, format="PNG")
+    data_uri = f"data:image/png;base64,{base64.b64encode(buf.getvalue()).decode()}"
 
     # Return message in vLLM format
     return [
@@ -254,7 +228,7 @@ def main(
     image_column: str = "image",
     batch_size: int = 16,
     model: str = "FireRedTeam/FireRed-OCR",
-    max_model_len: int = 32768,
+    max_model_len: int = 8192,
     max_tokens: int = 8192,
     gpu_memory_utilization: float = 0.8,
     hf_token: str = None,
@@ -264,7 +238,6 @@ def main(
     shuffle: bool = False,
     seed: int = 42,
     output_column: str = "markdown",
-    overwrite: bool = False,
     config: str = None,
     create_pr: bool = False,
 ):
@@ -291,9 +264,6 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
-    # Fail fast if the output column would collide with an existing input column
-    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
-
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -365,10 +335,7 @@ def main(
     processing_duration = datetime.now() - start_time
     processing_time_str = f"{processing_duration.total_seconds() / 60:.1f} min"
 
-    # Add output column to dataset (remove existing column if present)
-    if output_column in dataset.column_names:
-        logger.info(f"Removing existing '{output_column}' column before adding new results")
-        dataset = dataset.remove_columns([output_column])
+    # Add output column to dataset
     logger.info(f"Adding '{output_column}' column to dataset")
     dataset = dataset.add_column(output_column, all_outputs)
 
@@ -513,8 +480,8 @@ Examples:
     parser.add_argument(
         "--max-model-len",
         type=int,
-        default=32768,
-        help="Maximum model context length (default: 32768)",
+        default=8192,
+        help="Maximum model context length (default: 8192)",
     )
     parser.add_argument(
         "--max-tokens",
@@ -554,12 +521,6 @@ Examples:
         default="markdown",
         help="Column name for output text (default: markdown)",
     )
-    parser.add_argument(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists in the input dataset "
-        "(default: error out to avoid clobbering an existing column).",
-    )
     parser.add_argument(
         "--config",
         help="Config/subset name when pushing to Hub (for benchmarking multiple models in one repo)",
@@ -588,7 +549,6 @@ Examples:
         shuffle=args.shuffle,
         seed=args.seed,
         output_column=args.output_column,
-        overwrite=args.overwrite,
         config=args.config,
         create_pr=args.create_pr,
     )

glm-ocr-bucket.py

@@ -1,394 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "pillow",
-#     "pymupdf",
-# ]
-#
-# [tool.hf-jobs]
-# image = "vllm/vllm-openai:v0.29.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 a directory using GLM-OCR, writing markdown files.
-
-Designed to work with HF Buckets mounted as volumes via `hf jobs uv run -v ...`.
-
-The script reads images/PDFs from INPUT_DIR, runs GLM-OCR via vLLM, and writes
-one .md file per image (or per PDF page) to OUTPUT_DIR, preserving directory structure.
-
-Input:                          Output:
-  /input/page1.png        →      /output/page1.md
-  /input/report.pdf       →      /output/report/page_001.md
-  (3 pages)                       /output/report/page_002.md
-                                  /output/report/page_003.md
-  /input/sub/photo.jpg    →      /output/sub/photo.md
-
-Examples:
-
-  # Local test
-  uv run --with vllm==0.29.0 glm-ocr-bucket.py ./test-images ./test-output
-
-  # HF Jobs with bucket volumes (flavor + secrets come from the
-  # [tool.hf-jobs] header; needs hf CLI 1.32+)
-  hf jobs uv run \\
-      -v hf://buckets/user/ocr-input:/input:ro \\
-      -v hf://buckets/user/ocr-output:/output \\
-      glm-ocr-bucket.py /input /output
-
-Model: zai-org/GLM-OCR (0.9B, 94.62% OmniDocBench V1.5, MIT licensed)
-"""
-
-import argparse
-import base64
-import io
-import logging
-import sys
-import time
-from pathlib import Path
-
-import torch
-from PIL import Image
-import os
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
-from vllm import LLM, SamplingParams
-
-logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
-logger = logging.getLogger(__name__)
-
-MODEL = "zai-org/GLM-OCR"
-
-TASK_PROMPTS = {
-    "ocr": "Text Recognition:",
-    "formula": "Formula Recognition:",
-    "table": "Table Recognition:",
-}
-
-IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".tiff", ".tif", ".bmp", ".webp"}
-
-
-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 make_ocr_message(image: Image.Image, task: str = "ocr") -> list[dict]:
-    """Create chat message for GLM-OCR from a PIL Image."""
-    image = image.convert("RGB")
-    buf = io.BytesIO()
-    image.save(buf, format="PNG")
-    data_uri = f"data:image/png;base64,{base64.b64encode(buf.getvalue()).decode()}"
-
-    return [
-        {
-            "role": "user",
-            "content": [
-                {"type": "image_url", "image_url": {"url": data_uri}},
-                {"type": "text", "text": TASK_PROMPTS.get(task, TASK_PROMPTS["ocr"])},
-            ],
-        }
-    ]
-
-
-def discover_files(input_dir: Path, limit: int | None = None) -> list[Path]:
-    """Discover image and PDF files under input_dir.
-
-    Without `limit`, returns the full sorted list (deterministic order).
-    With `limit`, stops scanning once `limit` matching files are found
-    and returns them in filesystem order (much faster on huge mounted
-    buckets, but ordering is not deterministic).
-    """
-    files = []
-    iterator = (
-        input_dir.rglob("*") if limit is not None else sorted(input_dir.rglob("*"))
-    )
-    for path in iterator:
-        if not path.is_file():
-            continue
-        ext = path.suffix.lower()
-        if ext in IMAGE_EXTENSIONS or ext == ".pdf":
-            files.append(path)
-            if limit is not None and len(files) >= limit:
-                break
-    return files
-
-
-def prepare_images(
-    files: list[Path], input_dir: Path, output_dir: Path, pdf_dpi: int
-) -> list[tuple[Image.Image, Path]]:
-    """
-    Convert discovered files into (PIL.Image, output_md_path) pairs.
-
-    Images map 1:1. PDFs expand to one image per page in a subdirectory.
-    """
-    import fitz  # pymupdf
-
-    items: list[tuple[Image.Image, Path]] = []
-
-    for file_path in files:
-        rel = file_path.relative_to(input_dir)
-        ext = file_path.suffix.lower()
-
-        if ext == ".pdf":
-            # PDF → one .md per page in a subdirectory named after the PDF
-            pdf_output_dir = output_dir / rel.with_suffix("")
-            try:
-                doc = fitz.open(file_path)
-                num_pages = len(doc)
-                logger.info(f"PDF: {rel} ({num_pages} pages)")
-                for page_num in range(num_pages):
-                    page = doc[page_num]
-                    # Render at specified DPI
-                    zoom = pdf_dpi / 72.0
-                    mat = fitz.Matrix(zoom, zoom)
-                    pix = page.get_pixmap(matrix=mat)
-                    img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
-                    md_path = pdf_output_dir / f"page_{page_num + 1:03d}.md"
-                    items.append((img, md_path))
-                doc.close()
-            except Exception as e:
-                logger.error(f"Failed to open PDF {rel}: {e}")
-        else:
-            # Image → single .md
-            try:
-                img = Image.open(file_path).convert("RGB")
-                md_path = output_dir / rel.with_suffix(".md")
-                items.append((img, md_path))
-            except Exception as e:
-                logger.error(f"Failed to open image {rel}: {e}")
-
-    return items
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="OCR images/PDFs from a directory using GLM-OCR, output markdown files.",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Task modes:
-  ocr      Text recognition to markdown (default)
-  formula  LaTeX formula recognition
-  table    Table extraction (HTML)
-
-Examples:
-  uv run --with vllm==0.29.0 glm-ocr-bucket.py ./images ./output
-  uv run --with vllm==0.29.0 glm-ocr-bucket.py /input /output --task table --pdf-dpi 200
-
-HF Jobs with bucket volumes (flavor + secrets from the [tool.hf-jobs] header; hf CLI 1.32+):
-  hf jobs uv run \\
-      -v hf://buckets/user/input-bucket:/input:ro \\
-      -v hf://buckets/user/output-bucket:/output \\
-      glm-ocr-bucket.py /input /output
-        """,
-    )
-    parser.add_argument("input_dir", help="Directory containing images and/or PDFs")
-    parser.add_argument("output_dir", help="Directory to write markdown output files")
-    parser.add_argument(
-        "--task",
-        choices=["ocr", "formula", "table"],
-        default="ocr",
-        help="OCR task mode (default: ocr)",
-    )
-    parser.add_argument(
-        "--batch-size", type=int, default=16, help="Batch size for vLLM (default: 16)"
-    )
-    parser.add_argument(
-        "--max-model-len",
-        type=int,
-        default=8192,
-        help="Max model context length (default: 8192)",
-    )
-    parser.add_argument(
-        "--max-tokens",
-        type=int,
-        default=8192,
-        help="Max output tokens (default: 8192)",
-    )
-    parser.add_argument(
-        "--gpu-memory-utilization",
-        type=float,
-        default=0.8,
-        help="GPU memory utilization (default: 0.8)",
-    )
-    parser.add_argument(
-        "--pdf-dpi",
-        type=int,
-        default=300,
-        help="DPI for PDF page rendering (default: 300)",
-    )
-    parser.add_argument(
-        "--temperature",
-        type=float,
-        default=0.01,
-        help="Sampling temperature (default: 0.01)",
-    )
-    parser.add_argument(
-        "--top-p", type=float, default=0.00001, help="Top-p sampling (default: 0.00001)"
-    )
-    parser.add_argument(
-        "--repetition-penalty",
-        type=float,
-        default=1.1,
-        help="Repetition penalty (default: 1.1)",
-    )
-    parser.add_argument(
-        "--max-samples",
-        type=int,
-        default=None,
-        help="Limit the number of input files to process (files, not pages; "
-        "a PDF still yields all its pages). Stops scanning early once the "
-        "limit is reached; file order is then filesystem-dependent.",
-    )
-    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")
-
-    check_cuda_availability()
-
-    input_dir = Path(args.input_dir)
-    output_dir = Path(args.output_dir)
-
-    if not input_dir.is_dir():
-        logger.error(f"Input directory does not exist: {input_dir}")
-        sys.exit(1)
-
-    output_dir.mkdir(parents=True, exist_ok=True)
-
-    # Discover and prepare
-    start_time = time.time()
-
-    if args.max_samples is not None:
-        logger.info(
-            f"Scanning {input_dir} for up to {args.max_samples} images/PDFs "
-            f"(early termination, --max-samples)..."
-        )
-    else:
-        logger.info(f"Scanning {input_dir} for images and PDFs...")
-    files = discover_files(input_dir, limit=args.max_samples)
-    if not files:
-        logger.error(f"No image or PDF files found in {input_dir}")
-        sys.exit(1)
-
-    pdf_count = sum(1 for f in files if f.suffix.lower() == ".pdf")
-    img_count = len(files) - pdf_count
-    logger.info(f"Found {img_count} image(s) and {pdf_count} PDF(s)")
-
-    logger.info("Preparing images (rendering PDFs)...")
-    items = prepare_images(files, input_dir, output_dir, args.pdf_dpi)
-    if not items:
-        logger.error("No processable images after preparation")
-        sys.exit(1)
-
-    logger.info(f"Total images to OCR: {len(items)}")
-
-    # Init vLLM
-    logger.info(f"Initializing vLLM with {MODEL}...")
-    llm = LLM(
-        model=MODEL,
-        trust_remote_code=True,
-        max_model_len=args.max_model_len,
-        gpu_memory_utilization=args.gpu_memory_utilization,
-        limit_mm_per_prompt={"image": 1},
-    )
-
-    sampling_params = SamplingParams(
-        temperature=args.temperature,
-        top_p=args.top_p,
-        max_tokens=args.max_tokens,
-        repetition_penalty=args.repetition_penalty,
-    )
-
-    # Process in batches
-    errors = 0
-    processed = 0
-    total = len(items)
-
-    for batch_start in range(0, total, args.batch_size):
-        batch_end = min(batch_start + args.batch_size, total)
-        batch = items[batch_start:batch_end]
-        batch_num = batch_start // args.batch_size + 1
-        total_batches = (total + args.batch_size - 1) // args.batch_size
-
-        logger.info(f"Batch {batch_num}/{total_batches} ({processed}/{total} done)")
-
-        try:
-            messages = [make_ocr_message(img, task=args.task) for img, _ in batch]
-            outputs = llm.chat(messages, sampling_params)
-
-            for (_, md_path), output in zip(batch, outputs):
-                text = output.outputs[0].text.strip()
-                md_path.parent.mkdir(parents=True, exist_ok=True)
-                md_path.write_text(text, encoding="utf-8")
-                processed += 1
-
-        except Exception as e:
-            logger.error(f"Batch {batch_num} failed: {e}")
-            # Write error markers for failed batch
-            for _, md_path in batch:
-                md_path.parent.mkdir(parents=True, exist_ok=True)
-                md_path.write_text(f"[OCR ERROR: {e}]", encoding="utf-8")
-            errors += len(batch)
-            processed += len(batch)
-
-    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! Processed {total} images in {elapsed_str}")
-    logger.info(f"  Output: {output_dir}")
-    logger.info(f"  Errors: {errors}")
-    if total > 0:
-        logger.info(f"  Speed: {total / elapsed:.2f} images/sec")
-
-    if args.verbose:
-        import importlib.metadata
-
-        logger.info("--- Package versions ---")
-        for pkg in ["vllm", "transformers", "torch", "pillow", "pymupdf"]:
-            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("GLM-OCR Bucket Script")
-        print("=" * 60)
-        print("\nOCR images/PDFs from a directory → markdown files.")
-        print("Designed for HF Buckets mounted as volumes.")
-        print()
-        print("Usage:")
-        print("  uv run --with vllm==0.29.0 glm-ocr-bucket.py INPUT_DIR OUTPUT_DIR")
-        print()
-        print("Examples:")
-        print("  uv run --with vllm==0.29.0 glm-ocr-bucket.py ./images ./output")
-        print("  uv run --with vllm==0.29.0 glm-ocr-bucket.py /input /output --task table")
-        print()
-        print("HF Jobs with bucket volumes (flavor + secrets from the")
-        print("[tool.hf-jobs] header; needs hf CLI 1.32+):")
-        print("  hf jobs uv run \\")
-        print("      -v hf://buckets/user/ocr-input:/input:ro \\")
-        print("      -v hf://buckets/user/ocr-output:/output \\")
-        print("      glm-ocr-bucket.py /input /output")
-        print()
-        print("For full help: uv run --with vllm==0.29.0 glm-ocr-bucket.py --help")
-        sys.exit(0)
-
-    main()

glm-ocr-v2.py

@@ -69,10 +69,6 @@ from datasets import load_dataset
 from huggingface_hub import CommitScheduler, DatasetCard, HfApi, login
 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). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)
@@ -136,28 +132,6 @@ def check_cuda_availability():
         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 make_ocr_message(
     image: Union[Image.Image, Dict[str, Any], str],
     task: str = "ocr",
@@ -408,7 +382,6 @@ def main(
     shuffle: bool = False,
     seed: int = 42,
     output_column: str = "markdown",
-    overwrite: bool = False,
     verbose: bool = False,
     config: str = None,
     create_pr: bool = False,
@@ -461,11 +434,6 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
-    # Fail fast if the output column would collide with an existing input column.
-    # The incremental path derives batch datasets via dataset.select(...), so dropping
-    # it here (on --overwrite) also keeps those per-batch add_columns clean.
-    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
-
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
         dataset = dataset.shuffle(seed=seed)
@@ -983,12 +951,6 @@ Examples:
         default="markdown",
         help="Column name for output text (default: markdown)",
     )
-    parser.add_argument(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists in the input dataset "
-        "(default: error out to avoid clobbering an existing column).",
-    )
     parser.add_argument(
         "--verbose",
         action="store_true",
@@ -1033,7 +995,6 @@ Examples:
         shuffle=args.shuffle,
         seed=args.seed,
         output_column=args.output_column,
-        overwrite=args.overwrite,
         verbose=args.verbose,
         config=args.config,
         create_pr=args.create_pr,

glm-ocr.py

@@ -1,20 +1,21 @@
 # /// script
 # requires-python = ">=3.11"
 # dependencies = [
-#     "datasets>=4.0.0",
+#     "datasets>=3.1.0",
+#     "pyarrow>=17.0.0,<18.0.0",
 #     "huggingface-hub",
 #     "pillow",
+#     "vllm",
 #     "toolz",
+#     "torch",
 # ]
 #
-# [tool.hf-jobs]
-# # >=v0.30.0: ships huggingface_hub>=1.31, which datasets>=5.1 imports (httpx). On v0.29.0,
-# # PYTHONPATH puts the image's older hub first and `import datasets` crashes.
-# 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"]
+# [[tool.uv.index]]
+# url = "https://wheels.vllm.ai/nightly/cu129"
+#
+# [tool.uv]
+# prerelease = "allow"
+# override-dependencies = ["transformers>=5.1.0"]
 # ///
 
 """
@@ -24,10 +25,10 @@ GLM-OCR is a compact 0.9B parameter OCR model achieving 94.62% on OmniDocBench V
 Uses CogViT visual encoder with GLM-0.5B language decoder and Multi-Token Prediction
 (MTP) loss for fast, accurate document parsing.
 
-NOTE: On Jobs, vLLM, torch and transformers come from the vllm/vllm-openai:v0.30.0
-image pinned in the [tool.hf-jobs] header (`hf` CLI 1.32+). GLM-OCR needs vLLM
->=0.16.0 (PR #33005) and transformers>=5.1.0; the image has both. To run on your
-own GPU: `uv run --with vllm==0.30.0 glm-ocr.py ...`.
+NOTE: Requires vLLM nightly wheels from cu129 variant (GLM-OCR added in v0.16.0,
+PR #33005) and transformers>=5.1.0 (GLM-OCR support landed in stable release).
+Uses https://wheels.vllm.ai/nightly/cu129 which has x86_64 wheels.
+First run may take a few minutes to download and install dependencies.
 
 Features:
 - 0.9B parameters (ultra-compact)
@@ -39,7 +40,7 @@ Features:
 - MIT licensed
 
 Model: zai-org/GLM-OCR
-vLLM: vllm/vllm-openai:v0.30.0 image (see the header)
+vLLM: Requires vLLM nightly build + transformers>=5.1.0
 Performance: 94.62% on OmniDocBench V1.5
 """
 
@@ -52,21 +53,13 @@ import os
 import sys
 import time
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Union
 
 import torch
 from datasets import load_dataset
 from huggingface_hub import DatasetCard, login
 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). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
-# Same story for DeepGEMM: its init calls _find_cuda_home, which asserts on the
-# nvcc-less base image (a non-fatal warning that clutters the log and hides the real traceback).
-# Greedy OCR doesn't need the DeepGEMM JIT path, so disable it explicitly.
-os.environ.setdefault("VLLM_USE_DEEP_GEMM", "0")
 from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)
@@ -92,49 +85,9 @@ def check_cuda_availability():
         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 downscale_to_max_pixels(img: Image.Image, max_pixels: Optional[int]) -> Image.Image:
-    """Shrink an image so width*height <= max_pixels, preserving aspect ratio.
-
-    GLM-OCR does no internal resizing and its card gives no resolution guidance. Capping
-    input pixels bounds both image tokens and vision-encoder memory, a safety valve for very
-    large (multi-MP) scans that can pressure GPU memory at high batch sizes. No-op when
-    max_pixels is None or the image is already small enough (never upscales)."""
-    if not max_pixels:
-        return img
-    w, h = img.size
-    if w * h <= max_pixels:
-        return img
-    scale = (max_pixels / (w * h)) ** 0.5
-    new_size = (max(1, int(w * scale)), max(1, int(h * scale)))
-    return img.resize(new_size, Image.Resampling.LANCZOS)
-
-
 def make_ocr_message(
     image: Union[Image.Image, Dict[str, Any], str],
     task: str = "ocr",
-    max_pixels: Optional[int] = None,
 ) -> List[Dict]:
     """
     Create chat message for OCR processing.
@@ -155,9 +108,6 @@ def make_ocr_message(
     # Convert to RGB
     pil_img = pil_img.convert("RGB")
 
-    # Optionally cap resolution to protect the vision encoder from OOM on huge scans
-    pil_img = downscale_to_max_pixels(pil_img, max_pixels)
-
     # Convert to base64 data URI
     buf = io.BytesIO()
     pil_img.save(buf, format="PNG")
@@ -176,75 +126,6 @@ def make_ocr_message(
     ]
 
 
-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,
@@ -268,15 +149,6 @@ def create_dataset_card(
         "table": "table recognition",
     }
 
-    # 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"; "" on CPU
-    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 ""
-
     return f"""---
 tags:
 - ocr
@@ -284,7 +156,7 @@ tags:
 - glm-ocr
 - markdown
 - uv-script
-- generated{jobs_tag}
+- generated
 ---
 
 # Document OCR using {model_name}
@@ -330,16 +202,16 @@ The dataset contains all original columns plus:
 
 ## Reproduction
 
-{origin} with the [`glm-ocr.py`](https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.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/glm-ocr.py \\
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py \\
     {source_dataset} \\
     <output-dataset> \\
     --image-column {image_column} \\
     --batch-size {batch_size} \\
     --task {task}
 ```
+
+Generated with [UV Scripts](https://huggingface.co/uv-scripts)
 """
 
 
@@ -349,7 +221,6 @@ def main(
     image_column: str = "image",
     batch_size: int = 16,
     max_model_len: int = 8192,
-    max_pixels: Optional[int] = None,
     max_tokens: int = 8192,
     temperature: float = 0.01,
     top_p: float = 0.00001,
@@ -363,7 +234,6 @@ def main(
     shuffle: bool = False,
     seed: int = 42,
     output_column: str = "markdown",
-    overwrite: bool = False,
     verbose: bool = False,
     config: str = None,
     create_pr: bool = False,
@@ -395,9 +265,6 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
-    # Fail fast if the output column would collide with an existing input column
-    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
-
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
         dataset = dataset.shuffle(seed=seed)
@@ -448,10 +315,7 @@ def main(
         )
 
         try:
-            batch_messages = [
-                make_ocr_message(img, task=task, max_pixels=max_pixels)
-                for img in batch_images
-            ]
+            batch_messages = [make_ocr_message(img, task=task) for img in batch_images]
 
             outputs = llm.chat(batch_messages, sampling_params)
 
@@ -589,20 +453,21 @@ if __name__ == "__main__":
         print("  table    - Table extraction")
         print("\nExamples:")
         print("\n1. Basic OCR:")
-        print("   uv run --with vllm==0.30.0 glm-ocr.py input-dataset output-dataset")
+        print("   uv run glm-ocr.py input-dataset output-dataset")
         print("\n2. Formula recognition:")
-        print("   uv run --with vllm==0.30.0 glm-ocr.py docs results --task formula")
+        print("   uv run glm-ocr.py docs results --task formula")
         print("\n3. Table extraction:")
-        print("   uv run --with vllm==0.30.0 glm-ocr.py docs results --task table")
+        print("   uv run glm-ocr.py docs results --task table")
         print("\n4. Test with small sample:")
-        print("   uv run --with vllm==0.30.0 glm-ocr.py large-dataset test --max-samples 10 --shuffle")
-        print("\n5. Running on HF Jobs (hardware and HF_TOKEN come from the")
-        print("   script's [tool.hf-jobs] header; --flavor/--timeout override it):")
+        print("   uv run glm-ocr.py large-dataset test --max-samples 10 --shuffle")
+        print("\n5. Running on HF Jobs:")
+        print("   hf jobs uv run --flavor l4x1 \\")
+        print("     -s HF_TOKEN \\")
         print(
-            "   hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py \\"
+            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py \\"
         )
         print("       input-dataset output-dataset --batch-size 16")
-        print("\nFor full help: uv run --with vllm==0.30.0 glm-ocr.py --help")
+        print("\nFor full help: uv run glm-ocr.py --help")
         sys.exit(0)
 
     parser = argparse.ArgumentParser(
@@ -615,9 +480,9 @@ Task modes:
   table    Table extraction
 
 Examples:
-  uv run --with vllm==0.30.0 glm-ocr.py my-docs analyzed-docs
-  uv run --with vllm==0.30.0 glm-ocr.py docs results --task formula
-  uv run --with vllm==0.30.0 glm-ocr.py large-dataset test --max-samples 50 --shuffle
+  uv run glm-ocr.py my-docs analyzed-docs
+  uv run glm-ocr.py docs results --task formula
+  uv run glm-ocr.py large-dataset test --max-samples 50 --shuffle
         """,
     )
 
@@ -640,17 +505,6 @@ Examples:
         default=8192,
         help="Maximum model context length (default: 8192)",
     )
-    parser.add_argument(
-        "--max-pixels",
-        type=int,
-        default=None,
-        help=(
-            "Optional cap on input image pixels (width*height); larger scans are "
-            "downscaled (aspect preserved) before OCR. GLM-OCR does no internal resizing, "
-            "so this bounds vision-encoder memory on very large scans — set e.g. 4000000 "
-            "if you hit a GPU OOM at high batch sizes on a big-page corpus. Default: no cap."
-        ),
-    )
     parser.add_argument(
         "--max-tokens",
         type=int,
@@ -722,12 +576,6 @@ Examples:
         default="markdown",
         help="Column name for output text (default: markdown)",
     )
-    parser.add_argument(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists in the input dataset "
-        "(default: error out to avoid clobbering an existing column).",
-    )
     parser.add_argument(
         "--verbose",
         action="store_true",
@@ -742,7 +590,6 @@ Examples:
         image_column=args.image_column,
         batch_size=args.batch_size,
         max_model_len=args.max_model_len,
-        max_pixels=args.max_pixels,
         max_tokens=args.max_tokens,
         temperature=args.temperature,
         top_p=args.top_p,
@@ -756,7 +603,6 @@ Examples:
         shuffle=args.shuffle,
         seed=args.seed,
         output_column=args.output_column,
-        overwrite=args.overwrite,
         verbose=args.verbose,
         config=args.config,
         create_pr=args.create_pr,

hpd-parsing-saturate.py

@@ -1,558 +0,0 @@
-# /// script
-# requires-python = ">=3.10,<3.15"
-# dependencies = [
-#     "saturate[hf]==0.3.0",
-#     "pillow>=10",
-# ]
-#
-# [tool.hf-jobs]
-# image = "cr.hf.co/davanstrien/hpd-parsing-vllm:87496aa5-uv0.13.6"
-# flavor = "l4x1"
-# timeout = "2h"
-# secrets = ["HF_TOKEN"]
-# ///
-"""
-Parse document images with HPD-Parsing via saturate.
-
-HPD-Parsing (1B, InternVL3.5-1B vision + Qwen3-0.6B) parses a page with
-*hierarchical parallel decoding*: a main layout branch emits `<BLOCK> <type>
-[bbox]` headers and forks a child branch per region (children reuse the parent's
-prefix KV), with a P-MTP medusa head drafting tokens inside each branch. Its
-output carries a type, a bbox and reading order for every block; this recipe keeps
-them in an `hpd_blocks` column next to the markdown.
-
-The server half is the vendor's own `vllm serve` command, started in the job. The
-driver half (concurrency, retries, output, resume) is the `saturate` library:
-adaptive concurrency, resumable parquet output and durable error rows.
-
-NEEDS PADDLE'S vLLM FORK. Forking is a scheduler feature of Paddle's vLLM fork
-(`0.17.1+hpdparsing`), which ships in their registry image. The [tool.hf-jobs]
-header above names `cr.hf.co/davanstrien/hpd-parsing-vllm`: Paddle's image
-(`latest-nvidia-gpu`, pinned by digest, built 2026-07-16) plus `uv`, which their
-image lacks. Build script and digest: images/hpd-parsing/ in the uv-scripts repo.
-Run on HF Jobs (`hf` CLI 1.32+ reads image, flavor, timeout and secrets from the
-header):
-
-  hf jobs uv run --detach \\
-      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/hpd-parsing-saturate.py \\
-      <input-dataset> <output-dataset>
-
-Smoke test first with --max-samples 5. Budget for an ~11 GB image pull on a cold
-node before anything runs. requires-python includes 3.10 so that uv uses the
-image's own Python (3.10) instead of downloading one.
-
-On Paddle's image directly (no uv in it), install uv in the job command:
-
-  hf jobs run --detach --flavor l4x1 -s HF_TOKEN --timeout 2h \\
-      ccr-2vdh3abv-pub.cnc.bj.baidubce.com/paddlepaddle/hpd-parsing-vllm@sha256:87496aa5dd702a7df6c70bb00c29d5bf8d1a0f0505d66b613fafa6f71cd72de2 \\
-      -- bash -lc 'pip install -q uv==0.13.6 && uv run \\
-          https://huggingface.co/datasets/uv-scripts/ocr/raw/main/hpd-parsing-saturate.py \\
-          <input-dataset> <output-dataset>'
-
-Output: the output repo (created private if missing) holds `data/part-*.parquet`
-with rows `{id, markdown, hpd_blocks, raw, looped_blocks, finish_reason, model,
-prompt_tokens, completion_tokens, error}` keyed by the input row id
-(`--id-column`, or `<repo>:<config>:<split>:<000000000>` by default). Read it with
-`saturate.read_output`, which keeps one row per id (a success over an earlier
-error). `datasets.load_dataset(<output>, data_dir="data")` returns every record,
-so after a --retry-errors run it also holds the old error rows: drop rows with an
-`error` before you join back to the input on id. Re-running the same command
-skips finished rows; --retry-errors re-admits failed ones.
-
-- `hpd_blocks`: JSON list, one entry per region in the model's reading order:
-  `{"type": "text|title|table|formula|figure|...", "bbox": [x1, y1, x2, y2], "text": "..."}`.
-  BBOX SPACE: 0-1000 **normalized**, not pixels. Convert with
-  `px = value / 1000 * width`. Container blocks (`list`, the `table` wrapper)
-  and `chart`/`seal` regions carry a bbox with empty `text`.
-- `raw`: the model's untouched `<BLOCK>/<FORK>/<CHILD>` stream.
-- `looped_blocks`: number of blocks whose text is a repetition loop (see Limits).
-
-Model: PaddlePaddle/HPD-Parsing (Apache-2.0), paper arXiv:2607.18839
-- Card prompt `document parsing with fork.` (hierarchical parallel decoding);
-  --no-fork sends the card's single-trajectory `document parsing.` for an A/B.
-- Image before text, greedy decoding, max_tokens 8000, context 16384: the card's
-  values.
-- Block parsing and formula clean-up adapted from the model repo's Apache-2.0
-  `eval/hpd_to_markdown.py`, via the bbox-preserving `parse_blocks` in
-  multimodalart's demo Space (hugging-apps/hpd-parsing, `hpd_postprocess.py`).
-
-Limits seen in testing:
-- `max_tokens` bounds ONE decoding branch, not the page. A dense page that
-  fragments into hundreds of blocks can loop inside many children at once: on 12
-  Chronicling America pages (1774-1809), 3 pages looped, one emitting 544k
-  characters against 24.9k in LoC's own OCR. Nothing errors. This recipe flags
-  such blocks in `looped_blocks` and leaves the text as the model wrote it.
-  Filter on `looped_blocks == 0`, or drop the looped blocks from `hpd_blocks`
-  yourself. On those 12 pages the 3 looping pages also ended with
-  `finish_reason` "length" and the other 9 with "stop".
-- Card languages are en and zh. A smoke run on degraded French scans produced
-  stray CJK tokens.
-
-The SERVING dict below is the per-model tuning prior. Agents can `ast.literal_eval`
-it without running the script; the script itself consumes it.
-"""
-
-import argparse
-import base64
-import io
-import json
-import math
-import os
-import re
-import shutil
-import subprocess
-import sys
-import zlib
-
-# Serving starting values for PaddlePaddle/HPD-Parsing. Per-value provenance:
-# - serve_args: the vendor image's own /home/hpd/entrypoint.sh, verbatim, except
-#   for the speculative head path (see serve_command) and an added --revision pin.
-#   Two flags look wrong and are not:
-#   * --enable-prefix-caching contradicts the house OCR default (SERVING.md: OCR
-#     never reuses images). Here the forked children share the parent branch's
-#     prefix KV, so the cache is load-bearing (52.9% hit rate measured, 2026-07-27).
-#   * --attention-config use_prefill_query_quantization is a fork-only flag.
-# - served_model_name / port 8118: the entrypoint's values; requests use the name.
-# - max_model_len 16384, max_tokens 8000, temperature 0.0: card values.
-# - max_pixels 0 (no client-side downscale): the model picks its 448 px tile grid
-#   partly from image area (find_closest_aspect_ratio_optim), so pre-shrinking can
-#   land a page on a smaller grid. Set --max-pixels only for huge payloads.
-# - image: Paddle's `latest-nvidia-gpu` tag pinned by digest on 2026-11-05
-#   (base_image), plus uv (image; built by images/hpd-parsing/build.sh).
-SERVING = {
-    "model": "PaddlePaddle/HPD-Parsing",
-    "revision": "91de80054c23ab4238e3d7073fa2b83c2a7e301e",
-    "served_model_name": "HPD-Parsing",
-    "image": "cr.hf.co/davanstrien/hpd-parsing-vllm:87496aa5-uv0.13.6",
-    "base_image": (
-        "ccr-2vdh3abv-pub.cnc.bj.baidubce.com/paddlepaddle/hpd-parsing-vllm"
-        "@sha256:87496aa5dd702a7df6c70bb00c29d5bf8d1a0f0505d66b613fafa6f71cd72de2"
-    ),
-    "port": 8118,
-    "max_model_len": 16384,
-    "serve_args": [
-        "--trust-remote-code",
-        "--host", "0.0.0.0",
-        "--limit-mm-per-prompt", '{"image": 1}',
-        "--gpu-memory-utilization", "0.9",
-        "--attention-backend", "FLASHINFER",
-        "--attention-config", '{"use_prefill_query_quantization":true}',
-        "--enable-chunked-prefill",
-        "--enable-prefix-caching",
-    ],
-    "num_speculative_tokens": 6,
-    "max_tokens": 8000,
-    "temperature": 0.0,
-    "max_pixels": 0,
-}  # fmt: skip
-assert SERVING["max_tokens"] < SERVING["max_model_len"], (
-    "context math: max_tokens must leave room for the image tokens "
-    "(input + output <= max_model_len, or every request 400s)"
-)
-
-# Card-verbatim prompts. Do not "improve" either.
-FORK_PROMPT = "document parsing with fork."
-PLAIN_PROMPT = "document parsing."
-
-RUN_COMMAND = (
-    f"hf jobs uv run --detach --image {SERVING['image']} --flavor l4x1 -s HF_TOKEN \\\n"
-    "    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/hpd-parsing-saturate.py \\\n"
-    "    <input-dataset> <output-dataset>"
-)
-
-
-def to_pil(value):
-    from PIL import Image
-
-    if isinstance(value, Image.Image):
-        return value
-    if isinstance(value, dict) and value.get("bytes"):
-        return Image.open(io.BytesIO(value["bytes"]))
-    if isinstance(value, (bytes, bytearray)):
-        return Image.open(io.BytesIO(value))
-    raise ValueError(f"unsupported image value: {type(value)}")
-
-
-def encode_image(value, max_pixels: int) -> str:
-    """RGB-convert, downscale only if max_pixels is set, return base64 JPEG q95."""
-    from PIL import Image
-
-    img = to_pil(value).convert("RGB")
-    w, h = img.size
-    if max_pixels and w * h > max_pixels:
-        scale = math.sqrt(max_pixels / (w * h))
-        img = img.resize((max(1, int(w * scale)), max(1, int(h * scale))), Image.LANCZOS)
-    buf = io.BytesIO()
-    img.save(buf, format="JPEG", quality=95)
-    return base64.b64encode(buf.getvalue()).decode()
-
-
-# --- Formula cleaning (verbatim from the model repo's eval/hpd_to_markdown.py) ---
-
-_TALL = re.compile(
-    r'\\d?frac|\\tfrac|\\cfrac|\\binom|\\sqrt'
-    r'|\\sum|\\prod|\\coprod|\\int|\\iint|\\iiint|\\oint'
-    r'|\\bigcup|\\bigcap|\\bigoplus|\\bigotimes|\\bigsqcup'
-    r'|\\begin\{'
-    r'|\\overbrace|\\underbrace|\\overset|\\underset|\\stackrel'
-    r'|\\substack|\\atop|\\\\'
-)
-
-
-def _scan_delims(s):
-    out = []
-    for m in re.finditer(r'\\(left|right)\s*', s):
-        dm = re.match(r'\\[a-zA-Z]+|\\.|.', s[m.end():])
-        if not dm:
-            continue
-        out.append({'kind': m.group(1), 'delim': dm.group(0),
-                    'start': m.start(), 'end': m.end() + dm.end()})
-    return out
-
-
-def simplify_left_right(s: str) -> str:
-    """Downgrade `\\left( ... \\right)` with no tall inner structure to plain `( )`."""
-    if '\\left' not in s:
-        return s
-    stack, pairs = [], []
-    for d in _scan_delims(s):
-        if d['kind'] == 'left':
-            stack.append(d)
-        elif stack:
-            pairs.append((stack.pop(), d))
-    edits = []
-    for L, R in pairs:
-        if L['delim'] == '(' and R['delim'] == ')' and not _TALL.search(s[L['end']:R['start']]):
-            edits.append((L['start'], L['end'], '('))
-            edits.append((R['start'], R['end'], ')'))
-    for st, en, rep in sorted(edits, key=lambda x: x[0], reverse=True):
-        s = s[:st] + rep + s[en:]
-    return s
-
-
-_ELLIPSIS = r'(?:\\dots|\\cdots|\\ldots|\\dotsb|\\dotsc)'
-_CLOSER = r'(?:\\right\s*[.\}\]\)]|\\end\s*\{(?:array|matrix|cases|bmatrix|pmatrix|vmatrix|smallmatrix)\})'
-_TAIL_WRAP = re.compile(r'^(?P<core>.*?)(?P<wrap>\s*(?:\\\]|\\\)|\$\$))?\s*$', re.DOTALL)
-
-
-def clean_formula_tail(s: str) -> str:
-    """Strip degenerate formula tails (repeated/dangling ellipses, stray `\\quad`)."""
-    if not s:
-        return s
-    m = _TAIL_WRAP.match(s)
-    core, wrap = m.group('core'), m.group('wrap') or ''
-    prev = None
-    while prev != core:
-        prev = core
-        core = re.sub(r'(' + _ELLIPSIS + r')(?:\s*' + _ELLIPSIS + r')+', r'\1', core)
-        core = re.sub(r'(?P<keep>' + _CLOSER + r')\s*(?:\\q?quad\s*)*' + _ELLIPSIS + r'\s*$',
-                      lambda mm: mm.group('keep'), core)
-        core = re.sub(r'(?:\s*\\q?quad)+\s*' + _ELLIPSIS + r'\s*$', '', core)
-        core = re.sub(r'(?:\s*\\q?quad)+\s*$', '', core)
-        core = core.rstrip()
-    return core + wrap
-
-
-_OP_MAP = {
-    '≈': r'\approx', '≠': r'\neq', '≤': r'\leq', '≥': r'\geq', '×': r'\times',
-    '÷': r'\div', '±': r'\pm', '∓': r'\mp', '·': r'\cdot', '∙': r'\cdot',
-    '⋅': r'\cdot', '∗': '*', '−': '-', '≡': r'\equiv', '∝': r'\propto',
-    '∞': r'\infty', '√': r'\sqrt', '→': r'\to', '≪': r'\ll', '≫': r'\gg',
-}
-_ARITH_ALLOWED = re.compile(r'^[0-9A-Za-z\s=+\-*/^_().,:;<>|%!\u4e00-\u9fff' + ''.join(_OP_MAP.keys()) + r']+$')
-_ARITH_HASOP = re.compile(r'[=+\-*/' + ''.join(_OP_MAP.keys()) + r']')
-_KNOWN_FUNCS = {'sin', 'cos', 'tan', 'cot', 'sec', 'csc', 'log', 'ln', 'exp',
-                'lim', 'max', 'min', 'det', 'mod', 'arcsin', 'arccos', 'arctan', 'sqrt'}
-_CJK_RUN = re.compile(r'[\u4e00-\u9fff]+')
-_MATH_SPAN = re.compile(r'(\\\[.*?\\\]|\$\$.*?\$\$|\\\(.*?\\\)|\$.*?\$)', re.DOTALL)
-
-WRAP_CJK_IN_ARITH = True
-
-
-def _convert_unicode_ops(s: str) -> str:
-    for k, v in _OP_MAP.items():
-        s = s.replace(k, (v + ' ') if v.startswith('\\') else v)
-    if WRAP_CJK_IN_ARITH:
-        s = _CJK_RUN.sub(lambda m: r'\text{' + m.group(0) + '}', s)
-    return re.sub(r'[ \t]{2,}', ' ', s)
-
-
-def _is_pure_arith_line(line: str) -> bool:
-    t = line.strip()
-    if not t or '\\(' in t or '\\[' in t or '$' in t or '<' in t:
-        return False
-    if not WRAP_CJK_IN_ARITH and re.search(r'[\u4e00-\u9fff]', t):
-        return False
-    if not _ARITH_ALLOWED.match(t) or not _ARITH_HASOP.search(t):
-        return False
-    return all(w.lower() in _KNOWN_FUNCS for w in re.findall(r'[A-Za-z]{2,}', t))
-
-
-def normalize_arith(text: str) -> str:
-    """Normalize Unicode operators to LaTeX and wrap pure-arithmetic lines as `\\( .. \\)`."""
-    if not text:
-        return text
-    text = _MATH_SPAN.sub(lambda m: _convert_unicode_ops(m.group(0)), text)
-    out = []
-    for line in text.split('\n'):
-        if _is_pure_arith_line(line):
-            out.append('\\( ' + _convert_unicode_ops(line.strip()) + ' \\)')
-        else:
-            out.append(line)
-    return '\n'.join(out)
-
-
-def clean_text(text: str) -> str:
-    """Per-block cleaning, matching the official hpd_to_markdown.py steps."""
-    text = text.strip()
-    text = text.replace('The image is too blurry to recognize any text content.', '').strip()
-    text = text.replace(
-        "The image contains no text or characters. It is a graphical element (a horizontal "
-        "line with a vertical line) and does not contain any chart, graph, or data points "
-        "that can be extracted. Therefore, the correct OCR output is an empty string.", ""
-    ).strip()
-    if not text or text == '[Non-Text]':
-        return ''
-    if text.startswith('\\[') and not text.endswith('\n\\]'):
-        text += '\n\\]'
-    if text.startswith('<table>') and not text.endswith('</table>'):
-        text += '</table>'
-    if '\\[\n' in text and '\\\\' not in text:
-        text = text.replace('\\[\n', '\\(').replace('\n\\]', '\\)')
-    text = text.replace('\\) \\(', '\\)\n\n\\(')
-    if '÷' in text and '\\(' not in text:
-        text = '\\( ' + text + ' \\)'
-    text = re.sub(r'\\tag\s*\{[^{}]*\}', '', text)
-    text = text.replace('\\supset', '\\sqsupset')
-    text = simplify_left_right(text)
-    text = clean_formula_tail(text)
-    return normalize_arith(text)
-
-
-# --- Block parsing (bbox-preserving; the official script discards bboxes) ---
-
-# type + [bbox], usually followed by <FORK|CHILD|BLOCK>. Container blocks such as
-# `list [x1,y1,x2,y2]` may have no trailing tag at all, so the tag is optional.
-_BLOCK_HEADER = re.compile(r'([a-zA-Z_]+)\s*\[\s*([-\d.,\s]+)\]\s*(?:<(?:FORK|CHILD|BLOCK)>)?')
-_NO_CONTENT_TYPES = {'chart', 'seal'}
-
-
-def parse_blocks(raw_text: str) -> list[dict]:
-    """Parse the `<BLOCK> <type> [bbox] <CHILD> <content>` stream.
-
-    Returns `[{"type": str, "bbox": [x1,y1,x2,y2] | None, "text": str}, ...]` in the
-    model's own reading order. `bbox` is in the model's native 0-1000 NORMALIZED
-    coordinate space, not pixels. `text` is empty for container blocks (e.g. `list`,
-    the `table` wrapper) and for `chart`/`seal`, matching the official export.
-    """
-    blocks = []
-    for seg in raw_text.split('<BLOCK>')[1:]:
-        header_m = _BLOCK_HEADER.match(seg.strip())
-        type_m = re.match(r'\s*([a-zA-Z_]+)', seg)
-        block_type = type_m.group(1) if type_m else 'unknown'
-
-        bbox = None
-        if header_m:
-            block_type = header_m.group(1)
-            nums = [float(x) for x in re.split(r'[,\s]+', header_m.group(2).strip()) if x]
-            if len(nums) == 4:
-                bbox = nums
-
-        text = ''
-        if block_type.lower() not in _NO_CONTENT_TYPES:
-            content_m = re.search(r'<CHILD>(.*)', seg, re.DOTALL)
-            if content_m:
-                # stop at the next control tag if any leaked through
-                raw_content = re.split(r'<(?:FORK|CHILD|BLOCK)>', content_m.group(1))[0]
-                text = clean_text(raw_content)
-
-        blocks.append({'type': block_type, 'bbox': bbox, 'text': text})
-    return blocks
-
-
-def blocks_to_markdown(blocks: list[dict]) -> str:
-    """Join the non-empty block texts in reading order into one markdown string."""
-    return '\n\n'.join(b['text'] for b in blocks if b['text']).strip()
-
-
-# --- Loop flag ---
-
-# Calibrated on the 2026-07-27 test outputs (ChronAm, OmniDocBench, UFO; 345 blocks of
-# 200+ bytes). Ordinary text blocks of 2000+ bytes compress about 2x with zlib; looping
-# blocks compressed 6x (a counting loop: "of the 860th of the 861th ...") to 330x. The
-# most compressible real block was a 1.5 KB table at 5.3x, so tables get a higher bar.
-LOOP_MIN_BYTES = 2000
-LOOP_MIN_RATIO = 4.0
-LOOP_MIN_RATIO_TABLE = 10.0
-
-
-def is_looped(block: dict) -> bool:
-    """True when a block's text is long and highly repetitive (a decoding loop)."""
-    data = block["text"].encode()
-    if len(data) < LOOP_MIN_BYTES:
-        return False
-    ratio = len(data) / len(zlib.compress(data))
-    threshold = LOOP_MIN_RATIO_TABLE if block["type"] == "table" else LOOP_MIN_RATIO
-    return ratio >= threshold
-
-
-# --- Server ---
-
-
-def vendor_vllm() -> str:
-    """Return the vendor fork's `vllm` binary, or exit with the command that provides it."""
-    vllm = shutil.which("vllm")
-    version = ""
-    if vllm:
-        out = subprocess.run([vllm, "--version"], capture_output=True, text=True, check=False)
-        lines = out.stdout.strip().splitlines()
-        version = lines[-1] if lines else ""
-    if "hpdparsing" not in version:
-        found = f"found vllm {version!r} at {vllm}" if vllm else "no `vllm` on PATH"
-        sys.exit(
-            f"HPD-Parsing needs Paddle's vLLM fork (0.17.1+hpdparsing); {found}. "
-            f"Run the job on an image that has it:\n\n{RUN_COMMAND}"
-        )
-    print(f"vendor vllm {version} at {vllm}", file=sys.stderr)
-    return vllm
-
-
-def resolve_spec_model() -> str:
-    """Download the P-MTP speculative head and return its local directory.
-
-    The vendor entrypoint passes `PaddlePaddle/HPD-Parsing/P-MTP`, a local directory in
-    the image's offline variant (weights baked in). This image has no weights, so pull
-    that subfolder (~644 MB) into the normal HF cache and pass its path.
-    """
-    from huggingface_hub import snapshot_download
-
-    snapshot = snapshot_download(
-        SERVING["model"], revision=SERVING["revision"], allow_patterns=["P-MTP/*"]
-    )
-    spec_dir = os.path.join(snapshot, "P-MTP")
-    if not os.path.isfile(os.path.join(spec_dir, "config.json")):
-        sys.exit(f"P-MTP head has no config.json under {spec_dir}")
-    return spec_dir
-
-
-def serve_command(vllm: str, max_model_len: int) -> list[str]:
-    """The vendor entrypoint's `vllm serve` command, with a local speculative head."""
-    speculative = {
-        "method": "medusa",
-        "model": resolve_spec_model(),
-        "num_speculative_tokens": SERVING["num_speculative_tokens"],
-    }
-    return [
-        vllm, "serve", SERVING["model"],
-        "--revision", SERVING["revision"],
-        "--served-model-name", SERVING["served_model_name"],
-        "--port", str(SERVING["port"]),
-        "--max-model-len", str(max_model_len),
-        *SERVING["serve_args"],
-        "--speculative-config", json.dumps(speculative),
-    ]  # fmt: skip
-
-
-def main():
-    ap = argparse.ArgumentParser(
-        description="HPD-Parsing document parsing via saturate (vendor vLLM fork image only)"
-    )
-    ap.add_argument("input_dataset", help="Input dataset repo id (rows with an image column)")
-    ap.add_argument("output_dataset", help="Output dataset repo id (created private if missing)")
-    ap.add_argument("--image-column", default="image")
-    ap.add_argument("--config", default=None, help="Dataset config name")
-    ap.add_argument("--split", default="train")
-    ap.add_argument("--id-column", default=None,
-                    help="Column to use as row id (default: split-index ids)")
-    ap.add_argument("--max-samples", "--limit", dest="limit", type=int, default=None,
-                    help="Process only the first N rows (smoke test)")
-    ap.add_argument("--max-tokens", type=int, default=SERVING["max_tokens"],
-                    help="Output cap PER DECODING BRANCH, not per page (card: 8000)")
-    ap.add_argument("--max-pixels", type=int, default=SERVING["max_pixels"],
-                    help="Downscale images above this pixel count before upload (default 0 = off)")
-    ap.add_argument("--no-fork", action="store_true",
-                    help="Send the single-trajectory prompt ('document parsing.') instead of "
-                         "hierarchical parallel decoding; for an A/B only")
-    ap.add_argument("--retry-errors", action="store_true",
-                    help="Re-admit rows whose only record is an error row")
-    args = ap.parse_args()
-
-    if not 1 <= args.max_tokens < SERVING["max_model_len"]:
-        ap.error(f"--max-tokens must be between 1 and {SERVING['max_model_len'] - 1}")
-
-    vllm = vendor_vllm()  # fail before the dataset is touched if this is the wrong image
-
-    import pyarrow as pa
-    from saturate import Engine, dataset_rows, pump
-
-    if args.id_column is None:
-        ids = "index"
-    elif args.id_column in ("index", "content"):
-        # saturate reads these two names as id strategies, so a column with one of them
-        # needs a callable. It returns the raw value, so saturate still refuses a null id.
-        ids = lambda example: example[args.id_column]
-    else:
-        ids = args.id_column
-
-    rows = dataset_rows(
-        args.input_dataset, config=args.config, split=args.split,
-        columns=[args.image_column], ids=ids, limit=args.limit,
-    )
-    prompt = PLAIN_PROMPT if args.no_fork else FORK_PROMPT
-
-    def to_request(row):
-        b64 = encode_image(row[args.image_column], args.max_pixels)
-        return {
-            "model": SERVING["served_model_name"],
-            "messages": [{"role": "user", "content": [
-                # Image first, then text: the order of the card's example.
-                {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b64}"}},
-                {"type": "text", "text": prompt},
-            ]}],
-            "temperature": SERVING["temperature"],
-            "max_tokens": args.max_tokens,
-        }
-
-    # Declared, so a part holding only error rows has the same columns as the rest
-    # (datasets.load_dataset reads every part with one schema).
-    schema = pa.schema([
-        ("id", pa.string()), ("error", pa.string()), ("markdown", pa.string()),
-        ("hpd_blocks", pa.string()), ("raw", pa.string()), ("looped_blocks", pa.int64()),
-        ("finish_reason", pa.string()), ("model", pa.string()),
-        ("prompt_tokens", pa.int64()), ("completion_tokens", pa.int64()),
-    ])  # fmt: skip
-
-    def parse(row, body):
-        choice = body["choices"][0]
-        raw = choice["message"]["content"] or ""
-        blocks = parse_blocks(raw)
-        usage = body.get("usage") or {}
-        return {
-            "markdown": blocks_to_markdown(blocks),
-            "hpd_blocks": json.dumps(blocks, ensure_ascii=False),
-            "raw": raw,
-            "looped_blocks": sum(is_looped(b) for b in blocks),
-            "finish_reason": choice.get("finish_reason"),
-            "model": SERVING["model"],
-            "prompt_tokens": usage.get("prompt_tokens"),
-            "completion_tokens": usage.get("completion_tokens"),
-        }
-
-    engine = Engine(
-        SERVING["model"],
-        port=SERVING["port"],
-        cmd=serve_command(vllm, SERVING["max_model_len"]),
-    )
-    output = f"hf://datasets/{args.output_dataset}/data"
-    with engine as endpoint:
-        stats = pump(rows, to_request, parse, endpoint, output,
-                     prepare_workers=int(float(os.environ.get("CPU_CORES") or "4")),
-                     retry_errors=args.retry_errors, schema=schema)
-
-    print(f"https://huggingface.co/datasets/{args.output_dataset} "
-          f"({stats.rows_processed} ok, {stats.rows_failed} error rows)", file=sys.stderr)
-    print("HPD_PARSING_SATURATE " + stats.to_json(), flush=True)
-
-
-if __name__ == "__main__":
-    main()

hunyuan-ocr-1.5.py

@@ -1,890 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "datasets>=4.0.0,<5.1",  # 5.1 needs huggingface_hub>=1.31; the image ships an older 1.x on PYTHONPATH, which wins
-#     "huggingface-hub",
-#     "pillow",
-#     "tqdm",
-#     "toolz",
-# ]
-#
-# [tool.hf-jobs]
-# image = "vllm/vllm-openai:v0.24.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 using HunyuanOCR-1.5 with vLLM.
-
-HunyuanOCR-1.5 is a lightweight ~1B-parameter, end-to-end OCR-specialized VLM
-from Tencent. It keeps the validated 1.0 backbone but extends the max image
-resolution to 4K and the context window to 128K, and adds targeted long-tail
-capabilities (low-resource / ancient-script OCR, multi-image text QA). Per the
-technical report (arXiv:2607.04884) it is faster than dots.ocr / DeepSeek-OCR-2
-and top-tier on OmniDocBench v1.6. This script runs it offline via vLLM.
-
-Features:
-- 📝 End-to-end document parsing to markdown (tables → HTML, formulas → LaTeX)
-- 🧩 Structured / layout-aware parsing
-- 📍 Text spotting with coordinates (JSON or Hunyuan format)
-- 📐 Formula (LaTeX) and 📊 table (HTML) recognition
-- 📈 Chart parsing (Mermaid / Markdown)
-- 🌐 Document + general-scene translation (→ zh / → en)
-- 🎯 Compact model (~1B parameters)
-
-Model: tencent/HunyuanOCR
-  On 2026-07-06 Tencent replaced the repo root in-place with HunyuanOCR-1.5
-  (1.0 archived under `v1.0/`, no git tag). So the repo *root* — the default
-  here — is now 1.5. The sibling recipe `hunyuan-ocr.py` pins the last 1.0
-  commit by revision to keep the 1.0 behavior; this script deliberately tracks
-  root (1.5).
-
-vLLM: 0.18.1 (release) is the first stable wheel with native
-  `HunYuanVLForConditionalGeneration` support for autoregressive decoding — no
-  nightly or patch needed for batch OCR. The [tool.hf-jobs] header pins the
-  vllm/vllm-openai:v0.24.0 image (`hf` CLI 1.32+), which also sets the hardware
-  and the HF_TOKEN secret. Newer stacks fail: unpinned vLLM with transformers
-  >=5.13 does not recognise `hunyuan_vl`, and the v0.29.0 image fails at engine
-  start ("Expected 4 multimodal RoPE channels"). To run on your own GPU:
-  `uv run --with vllm==0.24.0 --with "transformers<5.13" ...`. The DFlash
-  speculative-decoding draft (a per-request *latency* win that needs a vLLM
-  nightly) is intentionally NOT implemented: it does not change offline batch
-  throughput or output distribution.
-
-trust_remote_code=True per the model card (the processor ships custom code).
-
-License: Tencent Hunyuan Community License (territory excludes EU/UK/South Korea)
-https://huggingface.co/tencent/HunyuanOCR/blob/main/LICENSE
-
-Note: batch_size defaults to 16 (untested on this arch as of writing — 1.5 on
-vLLM ≥0.18.1 should batch fine, unlike the 1.0 V1 batching issue; will be
-smoke-tested). Lower it if you hit engine errors.
-
-Post-processing note: only the shared tail-repetition cleanup
-(`clean_repeated_substrings`, byte-for-byte from the official toolkit) is
-ported. The upstream doc_parse-only markdown normalization (10 OmniDocBench
-GT-alignment regex passes in `hunyuan_utils.process_one`) is intentionally NOT
-ported — it is benchmark-GT alignment, not general OCR, and would bloat this
-self-contained recipe. For bench-exact output, use Tencent's toolkit directly.
-"""
-
-import argparse
-import base64
-import io
-import json
-import logging
-import os
-import sys
-import time
-from datetime import datetime
-from typing import Any, Dict, List, Union
-
-import torch
-from datasets import load_dataset
-from huggingface_hub import DatasetCard, login
-from PIL import Image
-from toolz import partition_all
-from tqdm.auto import tqdm
-
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
-from vllm import LLM, SamplingParams
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-
-# ────────────────────────────────────────────────────────────────
-# HunyuanOCR-1.5 official task prompts.
-# Reproduced VERBATIM from the shipped client's `hunyuan_tasks.py`:
-#   https://github.com/Tencent-Hunyuan/HunyuanOCR (inference/*/hunyuan_tasks.py)
-# The model card only prints the `doc_parse` prompt; the other 11 live only in
-# the client. Prompts are FIXED per task type — upstream deliberately does NOT
-# expose free-form prompt editing because hand-tweaked instructions were
-# observed to silently degrade quality (users pick a *task*, not a prompt).
-# All prompts are Chinese-language, including for English documents — this is
-# the officially recommended wording; the card provides no English variants.
-# ────────────────────────────────────────────────────────────────
-
-TASK_PROMPTS = {
-    # 端到端文档解析
-    "doc_parse": "提取文档图片中正文的所有信息用markdown格式表示，其中页眉、页脚部分忽略，"
-    "表格用html格式表达，文档中公式用latex格式表示，按照阅读顺序组织进行解析。",
-    # 结构化解析（古文、街景等非文档结构化场景）
-    "structured_parse": "提取图中的文字。",
-    # Spotting — JSON 格式
-    "spotting_json": "检测并识别图中所有的文字行，请按从上到下、从左到右的阅读顺序进行识别。 "
-    "输出格式为 JSON 数组，每个元素必须包含："
-    '"box": [xmin, ymin, xmax, ymax]（坐标需归一化到 [0, 1000] 范围内）；'
-    '"text": "识别出的文字内容"。 '
-    "注意：请直接输出 JSON 数组，不要包含任何多余的描述性文字。",
-    # Spotting — Hunyuan 模式
-    "spotting_hunyuan": "检测并识别图片中的文字，将文本坐标格式化输出。",
-    # 版式分析
-    "layout": "按照阅读顺序解析图中的版式信息。",
-    # 版式分析 + 解析
-    "layout_parse": "提取文档图片中所有内容用markdown格式表示，表格用html格式表达，"
-    "文档中公式用latex格式表示，请按照阅读顺序组织进行全文解析，并输出版式分析信息。",
-    # 图表解析
-    "chart_parse": "解析图中的图表，对于流程图使用Mermaid格式表示，其他图表使用Markdown格式表示。",
-    # 公式解析
-    "formula": "识别图片中的公式，用LaTeX格式表示。",
-    # 表格解析
-    "table": "把图中的表格解析为HTML。",
-    # 文档英译中
-    "doc_trans_en2zh": "先解析文档，再将文档内容翻译为中文，其中页眉、页脚忽略，"
-    "公式用latex格式表示，表格用html格式表示。",
-    # 通用场景翻译 other2en
-    "trans_other2en": "按照阅读顺序，提取图中文字，公式用latex格式表示，表格用markdown格式表示，"
-    "再将文字内容翻译为英文。",
-    # 通用场景翻译 other2zh
-    "trans_other2zh": "按照阅读顺序，提取图中文字，公式用latex格式表示，表格用markdown格式表示，"
-    "再将文字内容翻译为中文。",
-}
-
-# English glosses for --help / the no-args banner (upstream ships Chinese ones).
-TASK_DESCRIPTIONS = {
-    "doc_parse": "End-to-end doc parse (body→markdown, tables→HTML, formulas→LaTeX, headers/footers ignored). Default.",
-    "structured_parse": "Structured parse for non-document scenes (ancient scripts, street signs) — extract all text.",
-    "spotting_json": "Text detect+recognize as a JSON array (box normalized to 0-1000 + text).",
-    "spotting_hunyuan": "Text detect+recognize in Hunyuan coordinate format.",
-    "layout": "Layout analysis in reading order.",
-    "layout_parse": "Layout analysis + full-document parse (markdown/HTML/LaTeX).",
-    "chart_parse": "Chart parsing (flowcharts→Mermaid, other charts→Markdown).",
-    "formula": "Formula recognition → LaTeX.",
-    "table": "Table parsing → HTML.",
-    "doc_trans_en2zh": "Document translation to Chinese (parse then translate; formulas LaTeX, tables HTML).",
-    "trans_other2en": "General-scene extraction + translation to English.",
-    "trans_other2zh": "General-scene extraction + translation to Chinese.",
-}
-
-DEFAULT_TASK = "doc_parse"
-
-# Sampling params LOCKED by the model card across all official setups so outputs
-# are comparable: temperature=0.0, top_p=1.0, top_k=-1, repetition_penalty=1.08.
-# Only repetition_penalty is exposed as a flag (the others are fixed for
-# deterministic OCR); repetition_penalty is the model's built-in anti-repeat.
-DEFAULT_REPETITION_PENALTY = 1.08
-
-
-def clean_repeated_substrings(text: str, min_repeats: int = 10) -> str:
-    """Trim a long repeated suffix as a final safety net against greedy-decoding
-    degeneration. Byte-for-byte from the official `hunyuan_utils.py`.
-    """
-    n = len(text)
-    if n < 2000:
-        return text
-    for length in range(2, n // min_repeats + 1):
-        candidate = text[-length:]
-        count = 0
-        i = n - length
-        while i >= 0 and text[i : i + length] == candidate:
-            count += 1
-            i -= length
-        if count >= min_repeats:
-            return text[: n - length * (count - 1)]
-    return text
-
-
-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 get_prompt(task_type: str) -> str:
-    """Return the official prompt for a task type."""
-    if task_type not in TASK_PROMPTS:
-        raise ValueError(
-            f"Unknown task type: {task_type}. Available: {list(TASK_PROMPTS.keys())}"
-        )
-    return TASK_PROMPTS[task_type]
-
-
-def make_ocr_message(
-    image: Union[Image.Image, Dict[str, Any], str],
-    prompt: str,
-) -> List[Dict]:
-    """Create the chat messages for one image + prompt.
-
-    Mirrors the official client: an empty system message followed by a user turn
-    with the image *before* the text. The empty system content pins "no system
-    prompt" (matching how the model is served) rather than letting the chat
-    template inject a default.
-    """
-    # Convert to PIL Image if needed
-    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)}")
-
-    # Convert to RGB
-    pil_img = pil_img.convert("RGB")
-
-    # Convert to base64 data URI
-    buf = io.BytesIO()
-    pil_img.save(buf, format="PNG")
-    data_uri = f"data:image/png;base64,{base64.b64encode(buf.getvalue()).decode()}"
-
-    return [
-        {"role": "system", "content": ""},
-        {
-            "role": "user",
-            "content": [
-                {"type": "image_url", "image_url": {"url": data_uri}},
-                {"type": "text", "text": prompt},
-            ],
-        },
-    ]
-
-
-def create_dataset_card(
-    source_dataset: str,
-    model: str,
-    num_samples: int,
-    processing_time: str,
-    batch_size: int,
-    max_model_len: int,
-    max_tokens: int,
-    repetition_penalty: float,
-    gpu_memory_utilization: float,
-    image_column: str = "image",
-    output_column: str = "markdown",
-    split: str = "train",
-    task_type: str = "doc_parse",
-) -> str:
-    """Create a dataset card documenting the OCR process."""
-    model_name = model.split("/")[-1]
-
-    return f"""---
-tags:
-- ocr
-- document-processing
-- hunyuan-ocr-1.5
-- multilingual
-- markdown
-- uv-script
-- generated
----
-
-# Document OCR using {model_name} (HunyuanOCR-1.5)
-
-This dataset contains OCR results from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using HunyuanOCR-1.5, a lightweight ~1B end-to-end OCR VLM from Tencent (128K context, 4K max image resolution).
-
-Model license: [Tencent Hunyuan Community License](https://huggingface.co/tencent/HunyuanOCR/blob/main/LICENSE) (territory excludes EU/UK/South Korea).
-
-## Processing Details
-
-- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
-- **Model**: [{model}](https://huggingface.co/{model})
-- **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}`
-- **Output Column**: `{output_column}`
-- **Dataset Split**: `{split}`
-- **Task Type**: `{task_type}`
-- **Batch Size**: {batch_size}
-- **Max Model Length**: {max_model_len:,} tokens
-- **Max Output Tokens**: {max_tokens:,}
-- **Repetition Penalty**: {repetition_penalty}
-- **GPU Memory Utilization**: {gpu_memory_utilization:.1%}
-
-## Model Information
-
-HunyuanOCR-1.5 is a lightweight end-to-end OCR VLM that excels at:
-- 📝 **Document Parsing** - Full markdown extraction in reading order
-- 🧩 **Structured / Layout Parsing** - Layout-aware full-document parse
-- 📊 **Table Extraction** - HTML format tables
-- 📐 **Formula Recognition** - LaTeX format formulas
-- 📈 **Chart Parsing** - Mermaid / Markdown format
-- 📍 **Text Spotting** - Detection with coordinates (JSON / Hunyuan)
-- 🌐 **Translation** - Document and general-scene translation (→ zh / → en)
-
-Per the technical report ([arXiv:2607.04884](https://arxiv.org/pdf/2607.04884)),
-1.5 is faster than dots.ocr / DeepSeek-OCR-2 and top-tier on OmniDocBench v1.6.
-
-## Task Types Available
-
-- `doc_parse` - End-to-end document parsing (default)
-- `structured_parse` - Non-document structured scenes (ancient scripts, street signs)
-- `spotting_json` - Text detection + recognition as JSON array (box 0-1000 + text)
-- `spotting_hunyuan` - Text detection + recognition, Hunyuan coordinate format
-- `layout` - Layout analysis in reading order
-- `layout_parse` - Layout analysis + full-document parse
-- `chart_parse` - Chart parsing (flowcharts → Mermaid, others → Markdown)
-- `formula` - Formula recognition → LaTeX
-- `table` - Table parsing → HTML
-- `doc_trans_en2zh` - Document translation to Chinese
-- `trans_other2en` - General-scene extraction + translation to English
-- `trans_other2zh` - General-scene extraction + translation to Chinese
-
-## Dataset Structure
-
-The dataset contains all original columns plus:
-- `{output_column}`: The extracted text (markdown for `doc_parse`, else the task's format)
-- `inference_info`: JSON list tracking all OCR models applied to this dataset
-
-## Usage
-
-```python
-from datasets import load_dataset
-import json
-
-# Load the dataset
-dataset = load_dataset("{{output_dataset_id}}", split="{split}")
-
-# Access the extracted text
-for example in dataset:
-    print(example["{output_column}"])
-    break
-
-# View all OCR models applied to this dataset
-inference_info = json.loads(dataset[0]["inference_info"])
-for info in inference_info:
-    print(f"Column: {{info['column_name']}} - Model: {{info['model_id']}}")
-```
-
-## Reproduction
-
-This dataset was generated using the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) HunyuanOCR-1.5 script:
-
-```bash
-uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/hunyuan-ocr-1.5.py \\
-    {source_dataset} \\
-    <output-dataset> \\
-    --image-column {image_column} \\
-    --batch-size {batch_size} \\
-    --task-type {task_type} \\
-    --max-model-len {max_model_len} \\
-    --max-tokens {max_tokens} \\
-    --gpu-memory-utilization {gpu_memory_utilization}
-```
-
-Generated with [UV Scripts](https://huggingface.co/uv-scripts)
-"""
-
-
-def main(
-    input_dataset: str,
-    output_dataset: str,
-    image_column: str = "image",
-    batch_size: int = 16,
-    model: str = "tencent/HunyuanOCR",
-    revision: str = None,
-    max_model_len: int = 32768,
-    max_tokens: int = 8192,
-    repetition_penalty: float = DEFAULT_REPETITION_PENALTY,
-    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,
-    task_type: str = DEFAULT_TASK,
-    custom_prompt: str = None,
-    output_column: str = "markdown",
-    overwrite: bool = False,
-    clean_output: bool = True,
-    config: str = None,
-    create_pr: bool = False,
-    verbose: bool = False,
-):
-    """Process images from an HF dataset through HunyuanOCR-1.5."""
-
-    # Check CUDA availability first
-    check_cuda_availability()
-
-    # Context-length invariant (config.json): text max_position_embeddings=131072;
-    # the vision processor caps a single image at img_max_token_num=16384. So the
-    # default budget holds without resizing: 16384 (image) + prompt + 8192 (output)
-    # ≈ 25k ≤ 32768 (default max_model_len). Enforce max_tokens ≤ max_model_len ≤ 131072.
-    if max_model_len > 131072:
-        logger.error(
-            f"--max-model-len {max_model_len} exceeds the model's max context (131072)."
-        )
-        sys.exit(1)
-    if max_tokens > max_model_len:
-        logger.error(
-            f"--max-tokens ({max_tokens}) cannot exceed --max-model-len ({max_model_len})."
-        )
-        sys.exit(1)
-
-    # Track processing start time
-    start_time = datetime.now()
-
-    # Login to HF if token provided
-    HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
-    if HF_TOKEN:
-        login(token=HF_TOKEN)
-
-    # Determine prompt to use
-    if custom_prompt:
-        prompt = custom_prompt
-        logger.warning(
-            "Using --custom-prompt. Note: upstream deliberately locks prompts per "
-            "task type — hand-tweaked instructions can silently degrade quality."
-        )
-        logger.info(f"Custom prompt: {prompt[:60]}...")
-    else:
-        prompt = get_prompt(task_type)
-        logger.info(f"Using task type: {task_type}")
-
-    # Load dataset
-    logger.info(f"Loading dataset: {input_dataset}")
-    dataset = load_dataset(input_dataset, split=split)
-
-    # Validate image column
-    if image_column not in dataset.column_names:
-        raise ValueError(
-            f"Column '{image_column}' not found. Available: {dataset.column_names}"
-        )
-
-    # Fail fast if the output column would collide with an existing input column
-    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
-
-    # Shuffle if requested
-    if shuffle:
-        logger.info(f"Shuffling dataset with seed {seed}")
-        dataset = dataset.shuffle(seed=seed)
-
-    # Limit samples if requested
-    if max_samples:
-        dataset = dataset.select(range(min(max_samples, len(dataset))))
-        logger.info(f"Limited to {len(dataset)} samples")
-
-    # Initialize vLLM model
-    logger.info(f"Initializing vLLM with model: {model}")
-    logger.info("This may take a few minutes on first run...")
-
-    llm = LLM(
-        model=model,
-        revision=revision,
-        trust_remote_code=True,
-        max_model_len=max_model_len,
-        gpu_memory_utilization=gpu_memory_utilization,
-        limit_mm_per_prompt={"image": 1},
-        # The encoder cache is sized from max_num_batched_tokens (8192 by default), but one
-        # image can reach img_max_token_num=16384 tokens; a 2000 px scan already needs ~8.6k.
-        max_num_batched_tokens=16384,
-    )
-
-    # Locked sampling per the model card (deterministic OCR); only repetition_penalty
-    # is user-tunable.
-    sampling_params = SamplingParams(
-        temperature=0.0,
-        top_p=1.0,
-        top_k=-1,
-        repetition_penalty=repetition_penalty,
-        max_tokens=max_tokens,
-        skip_special_tokens=True,
-    )
-
-    logger.info(f"Processing {len(dataset)} images in batches of {batch_size}")
-    logger.info(f"Output will be written to column: {output_column}")
-
-    # Process images in batches
-    all_outputs = []
-
-    for batch_indices in tqdm(
-        partition_all(batch_size, range(len(dataset))),
-        total=(len(dataset) + batch_size - 1) // batch_size,
-        desc="HunyuanOCR-1.5 processing",
-    ):
-        batch_indices = list(batch_indices)
-        batch_images = [dataset[i][image_column] for i in batch_indices]
-
-        try:
-            # Create messages for batch
-            batch_messages = [make_ocr_message(img, prompt) for img in batch_images]
-
-            # Process with vLLM
-            outputs = llm.chat(batch_messages, sampling_params)
-
-            # Extract outputs
-            for output in outputs:
-                text = output.outputs[0].text.strip()
-                # Clean repeated substrings if enabled
-                if clean_output:
-                    text = clean_repeated_substrings(text)
-                all_outputs.append(text)
-
-        except Exception as e:
-            logger.error(f"Error processing batch: {e}")
-            # Add error placeholders for failed batch
-            all_outputs.extend(["[OCR ERROR]"] * len(batch_images))
-
-    # Calculate processing time
-    processing_duration = datetime.now() - start_time
-    processing_time_str = f"{processing_duration.total_seconds() / 60:.1f} min"
-
-    # Add output column to dataset
-    logger.info(f"Adding '{output_column}' column to dataset")
-    dataset = dataset.add_column(output_column, all_outputs)
-
-    # Handle inference_info tracking (for multi-model comparisons)
-    inference_entry = {
-        "model_id": model,
-        "model_name": "HunyuanOCR-1.5",
-        "model_revision": revision or "main",
-        "column_name": output_column,
-        "timestamp": datetime.now().isoformat(),
-        "task_type": task_type if not custom_prompt else "custom",
-        "repetition_penalty": repetition_penalty,
-    }
-
-    if "inference_info" in dataset.column_names:
-        # Append to existing inference info
-        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:
-        # Create new inference_info column
-        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}")
-    commit_msg = f"Add HunyuanOCR-1.5 OCR results ({len(dataset)} samples)" + (
-        f" [{config}]" if config else ""
-    )
-    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"
-            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=commit_msg,
-            )
-            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 (skip when creating PR to avoid conflicts)
-    if not create_pr:
-        logger.info("Creating dataset card")
-        card_content = create_dataset_card(
-            source_dataset=input_dataset,
-            model=model,
-            num_samples=len(dataset),
-            processing_time=processing_time_str,
-            batch_size=batch_size,
-            max_model_len=max_model_len,
-            max_tokens=max_tokens,
-            repetition_penalty=repetition_penalty,
-            gpu_memory_utilization=gpu_memory_utilization,
-            image_column=image_column,
-            output_column=output_column,
-            split=split,
-            task_type=task_type if not custom_prompt else "custom",
-        )
-
-        card = DatasetCard(card_content)
-        card.push_to_hub(output_dataset, token=HF_TOKEN)
-
-    logger.info("HunyuanOCR-1.5 processing complete!")
-    logger.info(
-        f"Dataset available at: https://huggingface.co/datasets/{output_dataset}"
-    )
-    logger.info(f"Processing time: {processing_time_str}")
-
-    if verbose:
-        import importlib.metadata
-
-        logger.info("--- Resolved package versions ---")
-        for pkg in [
-            "vllm",
-            "transformers",
-            "torch",
-            "datasets",
-            "pyarrow",
-            "pillow",
-        ]:
-            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__":
-    # Show example usage if no arguments
-    if len(sys.argv) == 1:
-        print("=" * 80)
-        print("HunyuanOCR-1.5 Document Processing")
-        print("=" * 80)
-        print(
-            "\nLightweight ~1B end-to-end OCR VLM from Tencent (128K context, 4K images)"
-        )
-        print("\nFeatures:")
-        print("- 📝 End-to-end document parsing to markdown")
-        print("- 📊 Table extraction (HTML format)")
-        print("- 📐 Formula recognition (LaTeX format)")
-        print("- 📍 Text spotting with coordinates (JSON / Hunyuan)")
-        print("- 📈 Chart parsing (Mermaid / Markdown)")
-        print("- 🌐 Document + general-scene translation (→ zh / → en)")
-        print("\nExample usage:")
-        print("\n1. Basic document parsing:")
-        print("   uv run hunyuan-ocr-1.5.py input-dataset output-dataset")
-        print("\n2. Formula extraction:")
-        print("   uv run hunyuan-ocr-1.5.py math-docs formulas --task-type formula")
-        print("\n3. Table extraction:")
-        print("   uv run hunyuan-ocr-1.5.py docs tables --task-type table")
-        print("\n4. Text spotting as JSON (box + text):")
-        print("   uv run hunyuan-ocr-1.5.py images spotted --task-type spotting_json")
-        print("\n5. Translate a document to Chinese:")
-        print(
-            "   uv run hunyuan-ocr-1.5.py en-docs zh-docs --task-type doc_trans_en2zh"
-        )
-        print("\n6. Running on HF Jobs:")
-        print("   (image, hardware and HF_TOKEN come from the script's [tool.hf-jobs] header)")
-        print("   hf jobs uv run \\")
-        print(
-            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/hunyuan-ocr-1.5.py \\"
-        )
-        print("       input-dataset output-dataset")
-        print("\n" + "=" * 80)
-        print("\nFor full help, run: uv run hunyuan-ocr-1.5.py --help")
-        sys.exit(0)
-
-    task_help = "\n".join(f"  {k:18s}- {TASK_DESCRIPTIONS[k]}" for k in TASK_PROMPTS)
-    parser = argparse.ArgumentParser(
-        description="Document OCR using HunyuanOCR-1.5 (lightweight ~1B end-to-end OCR VLM)",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog=f"""
-Task Types (official HunyuanOCR-1.5 prompts, all Chinese-language):
-{task_help}
-
-Examples:
-  # Basic document OCR (default)
-  uv run hunyuan-ocr-1.5.py my-docs analyzed-docs
-
-  # Extract formulas as LaTeX
-  uv run hunyuan-ocr-1.5.py math-papers formulas --task-type formula
-
-  # Extract tables as HTML
-  uv run hunyuan-ocr-1.5.py reports tables --task-type table
-
-  # Text spotting as JSON (box normalized 0-1000 + text)
-  uv run hunyuan-ocr-1.5.py images spotted --task-type spotting_json
-
-  # Translate documents to Chinese
-  uv run hunyuan-ocr-1.5.py en-docs translated --task-type doc_trans_en2zh
-
-  # Random sampling for testing
-  uv run hunyuan-ocr-1.5.py large-dataset test --max-samples 50 --shuffle
-        """,
-    )
-
-    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(
-        "--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; lower it if you hit engine errors)",
-    )
-    parser.add_argument(
-        "--model",
-        default="tencent/HunyuanOCR",
-        help="Model to use (default: tencent/HunyuanOCR — repo root is 1.5)",
-    )
-    parser.add_argument(
-        "--revision",
-        default=None,
-        help="Model repo revision (default: main). Tencent has replaced this repo's "
-        "root in-place before (1.0 → 1.5); pin a commit hash for reproducible runs.",
-    )
-    parser.add_argument(
-        "--max-model-len",
-        type=int,
-        default=32768,
-        help="Maximum model context length (default: 32768; max 131072). A single "
-        "image is capped at ~16384 tokens by the vision processor, so 32768 fits "
-        "image + 8192 output; raise for very long outputs.",
-    )
-    parser.add_argument(
-        "--max-tokens",
-        type=int,
-        default=8192,
-        help="Maximum tokens to generate (default: 8192; must be ≤ --max-model-len). "
-        "Dense pages may need more — raise toward 32768.",
-    )
-    parser.add_argument(
-        "--repetition-penalty",
-        type=float,
-        default=DEFAULT_REPETITION_PENALTY,
-        help=f"Repetition penalty (default: {DEFAULT_REPETITION_PENALTY}, the model card's locked value)",
-    )
-    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(
-        "--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(
-        "--task-type",
-        choices=list(TASK_PROMPTS.keys()),
-        default=DEFAULT_TASK,
-        metavar="TASK",
-        help=f"Official task type (default: {DEFAULT_TASK}). See the epilog for all types.",
-    )
-    parser.add_argument(
-        "--custom-prompt",
-        help="Custom prompt text (overrides --task-type; may degrade quality — upstream "
-        "locks prompts per task)",
-    )
-    parser.add_argument(
-        "--output-column",
-        default="markdown",
-        help="Column name for output text (default: markdown)",
-    )
-    parser.add_argument(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists in the input dataset "
-        "(default: error out to avoid clobbering an existing column).",
-    )
-    parser.add_argument(
-        "--no-clean-output",
-        action="store_true",
-        help="Disable cleaning of repeated substrings in output",
-    )
-    parser.add_argument(
-        "--config",
-        help="Dataset config name for multi-model benchmarks",
-    )
-    parser.add_argument(
-        "--create-pr",
-        action="store_true",
-        help="Push results as a pull request instead of direct commit",
-    )
-    parser.add_argument(
-        "--verbose",
-        action="store_true",
-        help="Log resolved package versions at the end of the run",
-    )
-
-    args = parser.parse_args()
-
-    main(
-        input_dataset=args.input_dataset,
-        output_dataset=args.output_dataset,
-        image_column=args.image_column,
-        batch_size=args.batch_size,
-        model=args.model,
-        revision=args.revision,
-        max_model_len=args.max_model_len,
-        max_tokens=args.max_tokens,
-        repetition_penalty=args.repetition_penalty,
-        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,
-        task_type=args.task_type,
-        custom_prompt=args.custom_prompt,
-        output_column=args.output_column,
-        overwrite=args.overwrite,
-        clean_output=not args.no_clean_output,
-        config=args.config,
-        create_pr=args.create_pr,
-        verbose=args.verbose,
-    )

hunyuan-ocr.py

@@ -5,9 +5,6 @@
 #     "huggingface-hub",
 #     "pillow",
 #     "vllm>=0.15.1",
-#     "transformers<5.13",  # vLLM ≤0.24.0's HunyuanVL processor breaks on transformers 5.13
-#                           # (string-key AutoImageProcessor.register; fixed in vllm#47872).
-#                           # Drop this cap once that fix ships in a stable vLLM release.
 #     "tqdm",
 #     "toolz",
 #     "torch",
@@ -15,20 +12,11 @@
 # ///
 
 """
-UNSUPPORTED: Broken (2026-09-23): the pinned 1.0 revision fails on current vLLM/transformers. Use hunyuan-ocr-1.5.py. See models.json (`support`).
-
-Convert document images to markdown using HunyuanOCR (v1.0) with vLLM.
+Convert document images to markdown using HunyuanOCR with vLLM.
 
 HunyuanOCR is a lightweight 1B parameter VLM from Tencent designed for complex
 multilingual document parsing. This script uses vLLM for processing.
 
-⚠️ This recipe targets HunyuanOCR **1.0**. On 2026-07-06 Tencent pushed
-HunyuanOCR-1.5 into the *same* repo (new weights at root, 1.0 archived under
-`v1.0/`, no git tag), so loading `tencent/HunyuanOCR@main` now yields 1.5 —
-different context length, prompts, and transformers/vLLM requirements. We pin
-the last 1.0 commit by revision to keep this script's validated behavior.
-For 1.5, use the sibling `hunyuan-ocr-1.5.py`.
-
 Features:
 - 📝 Full document parsing to markdown
 - 📊 Table extraction (HTML format)
@@ -38,10 +26,8 @@ Features:
 - 🌐 Photo translation
 - 🎯 Compact model (1B parameters)
 
-Model: tencent/HunyuanOCR (pinned to the last 1.0 revision)
-
-License: Tencent Hunyuan Community License (territory excludes EU/UK/South Korea)
-https://huggingface.co/tencent/HunyuanOCR/blob/main/LICENSE
+Model: tencent/HunyuanOCR
+vLLM: Requires nightly build (trust_remote_code=True)
 
 Note: Due to vLLM V1 engine batching issues with HunyuanOCR, batch_size defaults to 1.
 """
@@ -63,21 +49,11 @@ from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Last commit where the repo root held the 1.0 weights (2026-01-13). Not a temporary
-# workaround pin: upstream replaced root with 1.5 in-place (2026-07-06) and left no
-# 1.0 tag/branch, so this revision IS the 1.0 identity. Never loosen to "main" here —
-# 1.5 lives in hunyuan-ocr-1.5.py. Override with --revision only to reproduce old runs.
-DEFAULT_REVISION = "f6af82ee007fe6091b29fb3bb287b491ead41c82"
-
 
 # ────────────────────────────────────────────────────────────────
 # HunyuanOCR Prompt Templates (from official README)
@@ -170,28 +146,6 @@ def check_cuda_availability():
         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 get_prompt(
     prompt_mode: str,
     use_chinese: bool = False,
@@ -268,7 +222,6 @@ def make_ocr_message(
 def create_dataset_card(
     source_dataset: str,
     model: str,
-    revision: str,
     num_samples: int,
     processing_time: str,
     batch_size: int,
@@ -298,13 +251,10 @@ tags:
 
 This dataset contains OCR results from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using HunyuanOCR, a lightweight 1B VLM from Tencent.
 
-Model license: [Tencent Hunyuan Community License](https://huggingface.co/tencent/HunyuanOCR/blob/main/LICENSE) (territory excludes EU/UK/South Korea).
-
 ## Processing Details
 
 - **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
 - **Model**: [{model}](https://huggingface.co/{model})
-- **Model Revision**: `{revision}` (HunyuanOCR 1.0 — the repo root holds 1.5 since 2026-07-06)
 - **Number of Samples**: {num_samples:,}
 - **Processing Time**: {processing_time}
 - **Processing Date**: {datetime.now().strftime("%Y-%m-%d %H:%M UTC")}
@@ -396,7 +346,6 @@ def main(
     image_column: str = "image",
     batch_size: int = 1,  # Default to 1 due to vLLM V1 batching issues with HunyuanOCR
     model: str = "tencent/HunyuanOCR",
-    revision: str = None,
     max_model_len: int = 16384,
     max_tokens: int = 16384,
     gpu_memory_utilization: float = 0.8,
@@ -413,7 +362,6 @@ def main(
     use_chinese: bool = False,
     custom_prompt: str = None,
     output_column: str = "markdown",
-    overwrite: bool = False,
     clean_output: bool = True,
     config: str = None,
     create_pr: bool = False,
@@ -457,9 +405,6 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
-    # Fail fast if the output column would collide with an existing input column
-    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
-
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -470,21 +415,14 @@ def main(
         dataset = dataset.select(range(min(max_samples, len(dataset))))
         logger.info(f"Limited to {len(dataset)} samples")
 
-    # Pin the 1.0 revision only for the default repo — a user-supplied --model
-    # must not inherit a foreign commit hash.
-    if revision is None and model == "tencent/HunyuanOCR":
-        revision = DEFAULT_REVISION
-        logger.info(f"Pinning tencent/HunyuanOCR to 1.0 revision {revision[:8]}")
-
     # Initialize vLLM model
-    logger.info(f"Initializing vLLM: {model} (revision: {revision or 'main'})")
+    logger.info(f"Initializing vLLM with model: {model}")
     logger.info("This may take a few minutes on first run...")
 
     # Note: HunyuanOCR has batching issues with vLLM V1 engine when batch_size > 1
     # Using limit_mm_per_prompt for stability
     llm = LLM(
         model=model,
-        revision=revision,
         trust_remote_code=True,
         max_model_len=max_model_len,
         gpu_memory_utilization=gpu_memory_utilization,
@@ -543,7 +481,6 @@ def main(
     inference_entry = {
         "model_id": model,
         "model_name": "HunyuanOCR",
-        "model_revision": revision or "main",
         "column_name": output_column,
         "timestamp": datetime.now().isoformat(),
         "prompt_mode": prompt_mode if not custom_prompt else "custom",
@@ -611,7 +548,6 @@ def main(
         card_content = create_dataset_card(
             source_dataset=input_dataset,
             model=model,
-            revision=revision or "main",
             num_samples=len(dataset),
             processing_time=processing_time_str,
             batch_size=batch_size,
@@ -765,13 +701,6 @@ Examples:
         default="tencent/HunyuanOCR",
         help="Model to use (default: tencent/HunyuanOCR)",
     )
-    parser.add_argument(
-        "--revision",
-        default=None,
-        help="Model repo revision. Defaults to the last 1.0 commit when --model is "
-        "tencent/HunyuanOCR (the repo root now holds 1.5 — see hunyuan-ocr-1.5.py); "
-        "defaults to main for any other model.",
-    )
     parser.add_argument(
         "--max-model-len",
         type=int,
@@ -853,12 +782,6 @@ Examples:
         default="markdown",
         help="Column name for output text (default: markdown)",
     )
-    parser.add_argument(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists in the input dataset "
-        "(default: error out to avoid clobbering an existing column).",
-    )
     parser.add_argument(
         "--no-clean-output",
         action="store_true",
@@ -892,7 +815,6 @@ Examples:
         image_column=args.image_column,
         batch_size=args.batch_size,
         model=args.model,
-        revision=args.revision,
         max_model_len=args.max_model_len,
         max_tokens=args.max_tokens,
         gpu_memory_utilization=args.gpu_memory_utilization,
@@ -909,7 +831,6 @@ Examples:
         use_chinese=args.use_chinese_prompts,
         custom_prompt=args.custom_prompt,
         output_column=args.output_column,
-        overwrite=args.overwrite,
         clean_output=not args.no_clean_output,
         config=args.config,
         create_pr=args.create_pr,

images/hpd-parsing/README.md

@@ -1,18 +0,0 @@
-# cr.hf.co/davanstrien/hpd-parsing-vllm
-
-Public. Built 2026-11-05. Public page: https://huggingface.co/containers/davanstrien/hpd-parsing-vllm
-
-Runtime image for [`../../hpd-parsing-saturate.py`](../../hpd-parsing-saturate.py): Paddle's
-HPD-Parsing image with `uv` added, so the recipe runs with `hf jobs uv run`.
-
-| Tag | Base (Paddle, pinned) | Digest |
-|---|---|---|
-| `87496aa5-uv0.13.6` (also `latest`) | `ccr-2vdh3abv-pub.cnc.bj.baidubce.com/paddlepaddle/hpd-parsing-vllm@sha256:87496aa5…` (`latest-nvidia-gpu`, built 2026-07-16) | `sha256:b7d3c561cc245572b11ec3bce0739fd359c564b890d8e848b53b1a8346a573c5` |
-
-Why a custom image: HPD-Parsing runs on Paddle's vLLM fork (`0.17.1+hpdparsing`, request
-forking + P-MTP speculative decoding), which ships in their registry image. That image has no
-`uv`, which `hf jobs uv run --image <image>` needs. This image adds one layer, `uv` and `uvx` (0.13.6, checksum-verified)
-in `/usr/local/bin`. User, venv, environment and entrypoint are unchanged.
-
-Built with [`build.sh`](build.sh) and `crane append` on an HF CPU Job (`cpu-upgrade`); no Docker
-daemon. Drop it when Paddle's image ships `uv`, or when request forking lands in an upstream vLLM release.

images/hpd-parsing/build.sh

@@ -1,42 +0,0 @@
-#!/usr/bin/env bash
-# Build cr.hf.co/<namespace>/hpd-parsing-vllm: Paddle's HPD-Parsing image plus uv.
-#
-# Paddle's image (vendor vLLM fork 0.17.1+hpdparsing) has no `uv`, which
-# `hf jobs uv run --image <image>` needs. This adds one layer, the uv and uvx binaries in /usr/local/bin, to the
-# vendor image pinned by digest. Nothing else changes: same user (hpd), same venv,
-# same entrypoint. No Docker daemon is needed: `crane append` adds the layer and
-# pushes. Runs on a CPU Job (the base layers stream from Baidu's registry to cr.hf.co).
-#
-# Run (the container repo must exist; HF_TOKEN needs write on its namespace):
-#
-#   hf jobs run --flavor cpu-upgrade -s HF_TOKEN --timeout 1h \
-#       -v hf://datasets/uv-scripts/ocr:/recipe:ro \
-#       python:3.12 -- bash /recipe/images/hpd-parsing/build.sh cr.hf.co/<namespace>/hpd-parsing-vllm
-set -euo pipefail
-
-REPO="${1:?usage: build.sh <cr.hf.co/namespace/name>}"
-BASE_DIGEST="sha256:87496aa5dd702a7df6c70bb00c29d5bf8d1a0f0505d66b613fafa6f71cd72de2"
-BASE="ccr-2vdh3abv-pub.cnc.bj.baidubce.com/paddlepaddle/hpd-parsing-vllm@${BASE_DIGEST}"
-UV_VERSION="0.13.6"
-CRANE_VERSION="v0.22.1"
-TAG="${BASE_DIGEST:7:8}-uv${UV_VERSION}"
-
-# 1. The layer: uv + uvx from the official release, checksum-verified.
-cd /tmp
-UV_TGZ="uv-x86_64-unknown-linux-gnu.tar.gz"
-curl -sSfLO "https://github.com/astral-sh/uv/releases/download/${UV_VERSION}/${UV_TGZ}"
-curl -sSfLO "https://github.com/astral-sh/uv/releases/download/${UV_VERSION}/${UV_TGZ}.sha256"
-sha256sum -c "${UV_TGZ}.sha256"
-tar -xzf "$UV_TGZ"
-mkdir -p layer/usr/local/bin
-install -m 755 uv-x86_64-unknown-linux-gnu/uv uv-x86_64-unknown-linux-gnu/uvx layer/usr/local/bin/
-tar -C layer --owner=0 --group=0 -cf layer.tar usr
-tar -tvf layer.tar
-
-# 2. Append it to the vendor image and push.
-curl -sSfL "https://github.com/google/go-containerregistry/releases/download/${CRANE_VERSION}/go-containerregistry_Linux_x86_64.tar.gz" \
-    | tar -xz -C /usr/local/bin crane
-crane auth login cr.hf.co -u "${HF_USER:-user}" -p "$HF_TOKEN"
-crane append --platform linux/amd64 -b "$BASE" -f layer.tar -t "$REPO:$TAG"
-crane tag "$REPO:$TAG" latest
-echo "PUSHED $REPO:$TAG $(crane digest "$REPO:$TAG")"

images/minicpm-ocr/Dockerfile

@@ -1,44 +0,0 @@
-# MiniCPM-OCR 1.0 runtime for Hugging Face Jobs: cr.hf.co/davanstrien/minicpm-ocr
-#
-# - vLLM nightly 5d35ce3 (27 Oct 2026). MiniCPMOcrForConditionalGeneration landed in vLLM main on
-#   23 Oct (18343393b4, the commit OpenBMB's install.sh builds from source) and is not in a
-#   release yet; this nightly is newer and also has DSpark speculative decoding.
-# - transformers at OpenBMB's pin (549e5b4, "5.21.0.dev0"). pip reports it as outside the nightly's
-#   transformers>=5.16.1,<5.21.0 (a pre-release of 5.21.0 is excluded by <5.21.0); vLLM serves the
-#   model with it (smoke test, 27 Oct 2026).
-# - The minicpm-ocr SDK (layout, crops, assembly) in its own venv at /opt/sdk, as OpenBMB's docs
-#   require (SDK and inference service in separate environments), with PaddlePaddle GPU for the
-#   PP-DocLayoutV3 layout model.
-# - The layout model is baked in (sha256-checked) at $OCR_ASSETS_DIR, so a run never fetches it
-#   from Paddle's CDN. Model weights are not baked in: pull a pinned revision at run time.
-FROM vllm/vllm-openai:nightly-5d35ce3934a7804b298559d2d99eec33792e1eb9@sha256:3431ebee919296f7a5f3604db353f639e1474a4c7ef37595e31de6699fd831a7
-
-ARG TRANSFORMERS_COMMIT=549e5b410733fb50e8efbbe4aa585cb89f6478ea
-ARG LAYOUT_URL=https://paddle-model-ecology.bj.bcebos.com/paddlex/official_inference_model/paddle3.0.0/PP-DocLayoutV3_infer.tar
-ARG LAYOUT_SHA256=98b9bac88c80f6bc0fda7e0bfc2cae180020371c0b2edbb1eb498a70ace751b1
-
-RUN python3 -m pip install --no-cache-dir \
-      "transformers @ https://github.com/huggingface/transformers/archive/${TRANSFORMERS_COMMIT}.tar.gz"
-
-# sdk-requirements.lock is `uv pip freeze` of /opt/sdk in the published image (digest in README.md),
-# so a rebuild installs the tested SDK environment rather than resolving it afresh.
-COPY sdk-requirements.lock /tmp/sdk-requirements.lock
-RUN python3 -m pip install --no-cache-dir uv==0.13.6 \
- && uv venv /opt/sdk --python 3.12 \
- && uv pip install --python /opt/sdk/bin/python --no-cache \
-      --extra-index-url https://www.paddlepaddle.org.cn/packages/stable/cu129/ --index-strategy unsafe-best-match \
-      -r /tmp/sdk-requirements.lock
-
-ENV OCR_ASSETS_DIR=/opt/minicpm-ocr-assets
-RUN mkdir -p ${OCR_ASSETS_DIR}/models \
- && curl -fsSL -o /tmp/layout.tar "${LAYOUT_URL}" \
- && echo "${LAYOUT_SHA256}  /tmp/layout.tar" | sha256sum -c - \
- && tar -xf /tmp/layout.tar -C ${OCR_ASSETS_DIR}/models \
- && rm /tmp/layout.tar
-
-# The SDK CLI is on PATH as `minicpmvocr`; vLLM stays the image's `vllm`.
-RUN ln -s /opt/sdk/bin/minicpmvocr /usr/local/bin/minicpmvocr \
- && minicpmvocr --help > /dev/null
-
-ENTRYPOINT []
-CMD ["bash"]

images/minicpm-ocr/README.md

@@ -1,18 +0,0 @@
-# cr.hf.co/davanstrien/minicpm-ocr
-
-Runtime image for [`../../minicpm-ocr.py`](../../minicpm-ocr.py), public on the Hugging Face
-container registry: https://huggingface.co/containers/davanstrien/minicpm-ocr
-
-| Tag | Digest |
-|---|---|
-| `1.0-vllm-5d35ce3` (also `latest`) | `sha256:2fb9a09980abecb3102b99b0685b57b4ecde22702b3a441c03fab22e30239aea` |
-
-Built with kaniko on an HF CPU Job (`cpu-upgrade`, about 20 minutes),
-pushed to `cr.hf.co`. The published digest was built before `sdk-requirements.lock` existed;
-the lock is that image's `/opt/sdk` environment (`uv pip freeze`), so a rebuild reproduces it. Why a custom image: MiniCPM-OCR's architecture is in vLLM main but not in a
-vLLM release yet, and the SDK needs PaddlePaddle in its own environment. Drop it for a stock
-`vllm/vllm-openai` tag plus a pip-installed SDK once a vLLM release has the architecture.
-
-Build note: pip warns that `transformers 5.21.0.dev0` does not satisfy vLLM's
-`transformers<5.21.0` (a pre-release of 5.21.0 is excluded by `<5.21.0`). This is OpenBMB's pin;
-vLLM serves the model with it (smoke test, 27 Oct 2026).

images/minicpm-ocr/sdk-requirements.lock

@@ -1,90 +0,0 @@
-aistudio-sdk==0.3.9
-annotated-types==0.8.0
-anyio==4.15.1
-bce-python-sdk==0.9.79
-beautifulsoup4==4.15.0
-certifi==2026.10.23
-cffi==2.1.1
-chardet==7.7.0
-charset-normalizer==3.5.2
-click==8.5.0
-colorlog==6.12.0
-crc32c==2.9.post0
-cryptography==50.0.2
-cuda-bindings==12.9.5
-cuda-pathfinder==1.3.3
-cuda-python==12.9.4
-filelock==4.2.4
-flatbuffers==25.12.19
-fsspec==2026.9.0
-future==1.0.0
-h11==0.16.0
-hf-xet==1.7.0
-httpcore==1.0.9
-httpcore2==2.16.0
-httpx==0.28.1
-httpx2==2.16.0
-huggingface-hub==2.3.0
-idna==3.20
-imagesize==2.0.1
-minicpm-ocr==1.0.1
-modelscope==1.40.2
-modelscope-hub==0.5.1
-networkx==3.7
-numpy==2.5.4
-nvidia-cublas-cu12==12.9.0.13
-nvidia-cuda-cccl-cu12==12.9.27
-nvidia-cuda-cupti-cu12==12.9.19
-nvidia-cuda-nvrtc-cu12==12.9.41
-nvidia-cuda-runtime-cu12==12.9.37
-nvidia-cudnn-cu12==9.9.0.52
-nvidia-cufft-cu12==11.4.0.6
-nvidia-cufile-cu12==1.14.0.30
-nvidia-curand-cu12==10.3.10.19
-nvidia-cusolver-cu12==11.7.4.40
-nvidia-cusparse-cu12==12.5.9.5
-nvidia-cusparselt-cu12==0.7.1
-nvidia-nccl-cu12==2.27.3
-nvidia-nvjitlink-cu12==12.9.41
-nvidia-nvtx-cu12==12.9.19
-onnxruntime==1.31.1
-opencv-contrib-python==4.10.0.84
-opt-einsum==3.3.0
-packaging==26.3
-paddleocr==3.4.1
-paddlepaddle-gpu==3.3.0
-paddlex==3.4.2
-pandas==3.1.0
-pillow==13.0.0
-prettytable==3.18.0
-protobuf==7.36.2
-psutil==7.2.2
-py-cpuinfo==9.0.0
-pyclipper==1.4.0
-pycparser==3.12
-pycryptodome==4.2.0
-pydantic==2.14.1
-pydantic-core==2.50.1
-pymupdf==2.0
-pymupdf-layout==2.0
-pymupdf4llm==2.0
-pypdfium2==5.14.0
-python-bidi==0.6.12
-python-dateutil==3.0.0
-pyyaml==6.0.2
-requests==2.34.2
-ruamel-yaml==0.19.1
-safetensors==0.7.0
-setuptools==84.2.1
-shapely==2.2.0
-six==1.17.0
-soupsieve==3.0.4
-tabulate==0.10.0
-tqdm==4.70.1
-truststore==0.10.5
-typing-extensions==4.16.0
-typing-inspection==0.4.4
-tzdata==2026.5
-ujson==6.0.0
-urllib3==2.8.0
-wcwidth==0.9.4

jina-ocr-v1.py

@@ -1,448 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "datasets>=4.0.0",
-#     "huggingface-hub",
-#     "pillow",
-#     "vllm>=0.21",
-#     "tqdm",
-#     "toolz",
-#     "torch",
-# ]
-#
-# [tool.hf-jobs]
-# flavor = "a10g-small"
-# secrets = ["HF_TOKEN"]
-# env = { UV_TORCH_BACKEND = "auto" }
-# ///
-
-"""
-UNSUPPORTED: Broken (2026-09-23): vLLM 0.30 DeepEncoder kernel error; pinning vllm/vllm-openai:v0.29.0 likely fixes it (as for deepseek-ocr-vllm.py). CC-BY-NC-4.0 model. See models.json (`support`).
-
-Convert document images to markdown using jina-ocr-v1 with vLLM (offline batch).
-
-jina-ocr-v1 (Jina AI, 2026-09) is a DeepSeek-OCR fine-tune: the DeepEncoder vision
-tower plus a 3B mixture-of-experts decoder with ~570M active parameters, and a
-FastMTP speculative-decoding head (one draft block reused for K=3 steps). The
-card reports 91.14 on OmniDocBench v1.6 and 83.4 on olmOCR-Bench. Licence:
-CC-BY-NC-4.0 (non-commercial).
-
-The model ships its own vLLM glue in the checkpoint (`deepseek_ocr_mtp.py`):
-architecture registration, the speculative config, and an n-gram repetition
-stop built on vLLM's own `repetition_detection`. This recipe follows the card's
-offline pattern exactly: put the snapshot on the import path, `register()`
-once, then `LLM(**vllm_llm_kwargs(...))` and `llm.chat(...)`.
-
-Run on HF Jobs (hardware and the HF_TOKEN secret come from the script's
-[tool.hf-jobs] header; `hf` CLI 1.32+):
-
-  hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/jina-ocr-v1.py \\
-      <input-dataset> <output-dataset>
-
-Notes:
-- `--spec 0` disables speculative decoding (A/B it: FastMTP is a latency trick
-  that helps most at low concurrency; at batch 16 the gain may be small).
-- `--no-repetition-stop` disables the card's n-gram stop.
-- Uses vLLM from PyPI on the default uv image; the first run spends a few
-  minutes installing it. `--image vllm/vllm-openai:<tag>` skips that.
-
-Model: jinaai/jina-ocr-v1
-"""
-
-import argparse
-import io
-import json
-import logging
-import os
-import sys
-from datetime import datetime
-from typing import Any, Dict, Union
-
-from datasets import load_dataset
-from huggingface_hub import DatasetCard, login, snapshot_download
-from PIL import Image
-from toolz import partition_all
-from tqdm.auto import tqdm
-
-# The default uv-script image has no nvcc; vLLM's FlashInfer sampler would JIT a
-# kernel and crash engine init. Greedy OCR does not need it. No-op on vllm images.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
-# register() adds architectures to this process's ModelRegistry; the engine worker only
-# sees them if it is forked, not spawned. Nothing below initialises CUDA before LLM().
-os.environ.setdefault("VLLM_WORKER_MULTIPROC_METHOD", "fork")
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-MODEL_ID = "jinaai/jina-ocr-v1"
-SCRIPT_NAME = "jina-ocr-v1.py"
-SCRIPT_URL = f"https://huggingface.co/datasets/uv-scripts/ocr/raw/main/{SCRIPT_NAME}"
-
-
-def check_cuda_availability():
-    """GPU check WITHOUT initialising CUDA in this process.
-
-    torch.cuda.is_available() would initialise CUDA here, and vLLM then forces the
-    `spawn` start method for its engine worker. A spawned worker does not inherit the
-    ModelRegistry entries that register() adds in this process, so the custom
-    architecture is "not supported" in the worker (seen on the first smoke run).
-    nvidia-smi answers the same question with no CUDA context.
-    """
-    import shutil
-    import subprocess
-
-    if shutil.which("nvidia-smi") is None:
-        logger.error("nvidia-smi not found. This script requires a GPU.")
-        sys.exit(1)
-    try:
-        out = subprocess.run(["nvidia-smi", "--query-gpu=name", "--format=csv,noheader"],
-                             capture_output=True, text=True, timeout=30, check=True).stdout.strip()
-    except (subprocess.CalledProcessError, subprocess.TimeoutExpired) as e:
-        logger.error(f"nvidia-smi failed: {e}. This script requires a GPU.")
-        sys.exit(1)
-    logger.info(f"GPU: {out.splitlines()[0] if out else 'unknown'}")
-
-
-def ensure_output_columns_free(dataset, columns, overwrite=False):
-    """Fail fast if an output column would overwrite an existing input column."""
-    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 (columns: {dataset.column_names}).")
-    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
-    sys.exit(1)
-
-
-def to_pil(image: Union[Image.Image, Dict[str, Any], str]) -> Image.Image:
-    if isinstance(image, Image.Image):
-        return image
-    if isinstance(image, dict) and "bytes" in image:
-        return Image.open(io.BytesIO(image["bytes"]))
-    if isinstance(image, str):
-        return Image.open(image)
-    raise ValueError(f"Unsupported image type: {type(image)}")
-
-
-def load_model_glue(revision: str | None):
-    """Download the checkpoint and import its vLLM helpers.
-
-    vLLM v1 starts its engine core as a *spawned* process, which does not inherit
-    sys.path edits, so the snapshot directory also goes into PYTHONPATH before LLM()
-    is created. The architecture override points at `deepseek_ocr_mtp`, which the
-    worker must be able to import.
-    """
-    snapshot = snapshot_download(MODEL_ID, revision=revision)
-    os.environ["PYTHONPATH"] = snapshot + os.pathsep + os.environ.get("PYTHONPATH", "")
-    sys.path.insert(0, snapshot)
-    import deepseek_ocr_mtp  # noqa: E402  (lives in the checkpoint)
-
-    return snapshot, deepseek_ocr_mtp
-
-
-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,
-    num_samples: int,
-    processing_time: str,
-    batch_size: int,
-    max_model_len: int,
-    max_tokens: int,
-    spec: int,
-    repetition_stop: bool,
-    image_column: str,
-    output_column: str,
-    split: str,
-    image_count_per_sec: float,
-) -> str:
-    on_jobs = os.environ.get("JOB_ID") is not None
-    hw = jobs_flavor()  # flavor name, e.g. "a10g-small"; "" on CPU
-    origin = (
-        "Produced on [Hugging Face Jobs](https://huggingface.co/docs/huggingface_hub/guides/jobs)"
-        + (f" (`{hw}`)" if hw else "")
-    ) if on_jobs else "Generated"
-    tags = ["ocr", "document-processing", "jina-ocr", "markdown", "uv-script", "generated"]
-    if on_jobs:
-        tags.append("hf-jobs")
-    tag_lines = "\n".join(f"- {t}" for t in tags)
-
-    return f"""---
-tags:
-{tag_lines}
----
-
-# Document OCR using jina-ocr-v1
-
-Markdown OCR of the images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
-using [{MODEL_ID}](https://huggingface.co/{MODEL_ID}) (DeepSeek-OCR fine-tune, ~570M active parameters,
-FastMTP speculative decoding). The model is released under CC-BY-NC-4.0; check that licence before
-reusing these outputs commercially.
-
-## Processing Details
-
-- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
-- **Model**: [{MODEL_ID}](https://huggingface.co/{MODEL_ID})
-- **Number of Samples**: {num_samples:,}
-- **Processing Time**: {processing_time} (~{image_count_per_sec:.2f} images/second including model load)
-- **Processing Date**: {datetime.now().strftime("%Y-%m-%d %H:%M UTC")}
-
-### Configuration
-
-- **Image Column**: `{image_column}`
-- **Output Column**: `{output_column}`
-- **Dataset Split**: `{split}`
-- **Batch Size**: {batch_size}
-- **Max Model Length**: {max_model_len:,} tokens
-- **Max Output Tokens**: {max_tokens:,}
-- **Speculative decoding (FastMTP draft depth)**: {spec}
-- **N-gram repetition stop**: {"on" if repetition_stop else "off"}
-
-## Dataset Structure
-
-All original columns plus:
-- `{output_column}`: the extracted text as markdown (HTML tables, LaTeX math)
-- `inference_info`: JSON list tracking the OCR models applied to this dataset
-
-## Reproduction
-
-{origin} with the [`{SCRIPT_NAME}`]({SCRIPT_URL}) recipe from [uv-scripts](https://huggingface.co/uv-scripts). Run it yourself:
-
-```bash
-hf jobs uv run {SCRIPT_URL} \\
-    {source_dataset} \\
-    <output-dataset> \\
-    --image-column {image_column} \\
-    --batch-size {batch_size} \\
-    --spec {spec}
-```
-"""
-
-
-def main():
-    ap = argparse.ArgumentParser(description="jina-ocr-v1 batch OCR with vLLM (offline)")
-    ap.add_argument("input_dataset")
-    ap.add_argument("output_dataset")
-    ap.add_argument("--image-column", default="image")
-    ap.add_argument("--output-column", default="markdown")
-    ap.add_argument("--overwrite", action="store_true", help="Replace an existing output column")
-    ap.add_argument("--split", default="train")
-    ap.add_argument("--input-config", default=None, help="Config (subset) name of the input dataset")
-    ap.add_argument("--config", default=None, help="Config name for the output dataset")
-    ap.add_argument("--max-samples", type=int, default=None)
-    ap.add_argument("--shuffle", action="store_true")
-    ap.add_argument("--seed", type=int, default=42)
-    ap.add_argument("--batch-size", type=int, default=16)
-    ap.add_argument("--max-tokens", type=int, default=4096)
-    ap.add_argument("--max-model-len", type=int, default=8192)
-    ap.add_argument("--gpu-memory-utilization", type=float, default=0.85)
-    ap.add_argument("--spec", type=int, default=3, help="FastMTP draft depth K; 0 disables speculative decoding")
-    ap.add_argument("--no-repetition-stop", action="store_true", help="Disable the card's n-gram repetition stop")
-    ap.add_argument("--prompt", default=None, help="Override the model's default OCR prompt")
-    ap.add_argument("--revision", default=None, help="Model revision to pin")
-    ap.add_argument("--private", action="store_true")
-    ap.add_argument("--create-pr", action="store_true")
-    ap.add_argument("--hf-token", default=None)
-    ap.add_argument("--verbose", action="store_true", help="Log resolved package versions after the run")
-    args = ap.parse_args()
-
-    check_cuda_availability()
-    start_time = datetime.now()
-
-    hf_token = args.hf_token or os.environ.get("HF_TOKEN")
-    if hf_token:
-        login(token=hf_token)
-
-    logger.info(f"Loading dataset: {args.input_dataset}")
-    dataset = load_dataset(args.input_dataset, name=args.input_config, split=args.split)
-    if args.image_column not in dataset.column_names:
-        raise ValueError(f"Column '{args.image_column}' not found. Available: {dataset.column_names}")
-    dataset = ensure_output_columns_free(dataset, [args.output_column], overwrite=args.overwrite)
-    if args.shuffle:
-        dataset = dataset.shuffle(seed=args.seed)
-    if args.max_samples:
-        dataset = dataset.select(range(min(args.max_samples, len(dataset))))
-        logger.info(f"Limited to {len(dataset)} samples")
-
-    # --- model: the checkpoint's own vLLM glue, in the card's order ---------------
-    snapshot, glue = load_model_glue(args.revision)
-    from vllm import LLM
-
-    glue.register()
-    llm_kwargs = glue.vllm_llm_kwargs(
-        snapshot, num_speculative_tokens=args.spec, mtp_heads=1, mtp_recursive=True,
-    )
-    llm_kwargs.setdefault("max_model_len", args.max_model_len)
-    llm_kwargs.setdefault("gpu_memory_utilization", args.gpu_memory_utilization)
-    llm_kwargs.setdefault("enable_prefix_caching", False)
-    llm_kwargs.setdefault("mm_processor_cache_gb", 0)
-    llm_kwargs.setdefault("limit_mm_per_prompt", {"image": 1})
-    logger.info(f"Initializing vLLM with {MODEL_ID} (spec={args.spec}); this can take a few minutes")
-    llm = LLM(**llm_kwargs)
-
-    sampling_kwargs = {"max_tokens": args.max_tokens}
-    if args.no_repetition_stop:
-        sampling_kwargs["repetition_detection"] = None
-    sampling_params = glue.vllm_sampling_params(**sampling_kwargs)
-    prompt = args.prompt or glue.DEFAULT_OCR_PROMPT
-    logger.info(f"Prompt: {prompt}")
-
-    # --- inference ------------------------------------------------------------------
-    all_markdown = []
-    n_batches = (len(dataset) + args.batch_size - 1) // args.batch_size
-    for batch_indices in tqdm(partition_all(args.batch_size, range(len(dataset))), total=n_batches, desc="jina-ocr-v1"):
-        batch_indices = list(batch_indices)
-        batch_images = [dataset[i][args.image_column] for i in batch_indices]
-        try:
-            messages = []
-            for img in batch_images:
-                pil_img = to_pil(img).convert("RGB")
-                messages.append([{"role": "user", "content": [
-                    {"type": "image_pil", "image_pil": pil_img},
-                    {"type": "text", "text": prompt},
-                ]}])
-            outputs = llm.chat(messages, sampling_params=sampling_params, use_tqdm=False)
-            for output in outputs:
-                all_markdown.append(output.outputs[0].text.strip())
-        except Exception as e:
-            logger.error(f"Error processing batch: {e}")
-            all_markdown.extend(["[OCR FAILED]"] * len(batch_images))
-
-    if args.spec > 0:
-        glue.log_spec_stats(llm)
-
-    processing_duration = datetime.now() - start_time
-    processing_time_str = f"{processing_duration.total_seconds() / 60:.1f} min"
-    images_per_sec = len(dataset) / max(1.0, processing_duration.total_seconds())
-
-    # --- output dataset ---------------------------------------------------------------
-    dataset = dataset.add_column(args.output_column, all_markdown)
-    inference_entry = {
-        "model_id": MODEL_ID,
-        "model_name": "jina-ocr-v1",
-        "column_name": args.output_column,
-        "timestamp": datetime.now().isoformat(),
-        "prompt": "custom" if args.prompt else "default",
-        "batch_size": args.batch_size,
-        "max_tokens": args.max_tokens,
-        "max_model_len": args.max_model_len,
-        "speculative_tokens": args.spec,
-        "repetition_stop": not args.no_repetition_stop,
-        "script": SCRIPT_NAME,
-        "script_url": SCRIPT_URL,
-    }
-    if "inference_info" in dataset.column_names:
-        def update_inference_info(example):
-            try:
-                existing = json.loads(example["inference_info"]) if example["inference_info"] else []
-            except (json.JSONDecodeError, TypeError):
-                existing = []
-            existing.append(inference_entry)
-            return {"inference_info": json.dumps(existing)}
-        dataset = dataset.map(update_inference_info)
-    else:
-        dataset = dataset.add_column("inference_info", [json.dumps([inference_entry])] * len(dataset))
-
-    logger.info(f"Pushing to {args.output_dataset}")
-    dataset.push_to_hub(
-        args.output_dataset,
-        private=args.private,
-        token=hf_token,
-        **({"config_name": args.config} if args.config else {}),
-        create_pr=args.create_pr,
-        commit_message=f"Add {MODEL_ID} OCR results ({len(dataset)} samples)" + (f" [{args.config}]" if args.config else ""),
-    )
-    card = DatasetCard(create_dataset_card(
-        source_dataset=args.input_dataset, num_samples=len(dataset), processing_time=processing_time_str,
-        batch_size=args.batch_size, max_model_len=args.max_model_len, max_tokens=args.max_tokens,
-        spec=args.spec, repetition_stop=not args.no_repetition_stop, image_column=args.image_column,
-        output_column=args.output_column, split=args.split, image_count_per_sec=images_per_sec,
-    ))
-    card.push_to_hub(args.output_dataset, token=hf_token)
-    logger.info(f"Dataset available at: https://huggingface.co/datasets/{args.output_dataset}")
-    logger.info(f"Processing time: {processing_time_str}")
-
-    failed = sum(1 for m in all_markdown if m == "[OCR FAILED]")
-    if failed:
-        logger.warning(f"{failed} of {len(all_markdown)} rows are [OCR FAILED] (a whole batch fails together in offline mode)")
-
-    if args.verbose:
-        import importlib.metadata
-        for pkg in ["vllm", "transformers", "torch", "datasets", "pillow"]:
-            try:
-                logger.info(f"{pkg}=={importlib.metadata.version(pkg)}")
-            except importlib.metadata.PackageNotFoundError:
-                logger.info(f"{pkg}: not installed")
-
-
-if __name__ == "__main__":
-    main()

lfm2-extract.py

@@ -1,336 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "datasets>=4.0.0,<5.1",  # 5.1 needs huggingface_hub>=1.31; the image ships an older 1.x on PYTHONPATH, which wins
-#     "huggingface-hub",
-#     "transformers",
-#     "tqdm",
-#     "toolz",
-# ]
-#
-# [tool.hf-jobs]
-# image = "vllm/vllm-openai:v0.29.0"
-# python = "/usr/bin/python3"
-# env = { PYTHONPATH = "/usr/local/lib/python3.12/dist-packages" }
-# flavor = "a10g-small"
-# secrets = ["HF_TOKEN"]
-# ///
-"""
-Extract structured data (JSON / XML / YAML) from text using LiquidAI's LFM2-1.2B-Extract.
-
-LFM2-1.2B-Extract is a compact 1.2B text-only model purpose-built for turning unstructured
-documents into structured data: give it a schema, it returns JSON, XML, or YAML. It reports
-beating Gemma 3 27B (22x larger) on syntax validity / format accuracy / faithfulness, and
-is multilingual (en, ar, zh, fr, de, ja, ko, pt, es).
-
-This is the *text* counterpart to `lfm2-vl-extract.py` (which extracts from images). Pair them:
-OCR a page to markdown with one of the OCR recipes, then extract fields from that text here.
-
-Pass `--schema` as inline text/JSON, a URL, or a file path describing the structure to extract:
-
-    --schema '{"invoice_number": "string", "total": "number", "line_items": "array"}'
-
-Model:  https://huggingface.co/LiquidAI/LFM2-1.2B-Extract
-Docs:   https://docs.liquid.ai/deployment/gpu-inference/vllm
-
-HF Jobs: the `[tool.hf-jobs]` header above pins the vLLM image (vLLM + torch come from the
-image, not the deps), the GPU flavor and the HF_TOKEN secret, so no flags are needed
-(requires `hf` CLI 1.32+):
-
-    hf jobs uv run \
-        https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lfm2-extract.py \
-        INPUT OUTPUT --text-column text --schema '{"field": "description"}'
-
-On your own GPU, supply vLLM yourself:
-
-    uv run --with vllm==0.29.0 lfm2-extract.py INPUT OUTPUT --schema '{"field": "description"}'
-
-FlashInfer sampling is disabled (see below) so the engine never JIT-compiles a kernel that
-needs nvcc.
-"""
-
-import argparse
-import json
-import logging
-import os
-import sys
-from datetime import datetime, timezone
-from typing import List, Optional
-from urllib.request import urlopen
-
-# Disable vLLM's FlashInfer sampler before the engine starts: it JIT-compiles at warmup and
-# needs nvcc (absent from the default uv image). Harmless for greedy decoding.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
-
-import torch
-from datasets import load_dataset
-from huggingface_hub import DatasetCard, login
-from toolz import partition_all
-from tqdm import tqdm
-from vllm import LLM, SamplingParams
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-DEFAULT_MODEL = "LiquidAI/LFM2-1.2B-Extract"
-FORMATS = {"json": "JSON", "xml": "XML", "yaml": "YAML"}
-
-
-def check_cuda_availability() -> None:
-    if not torch.cuda.is_available():
-        logger.error("CUDA is not available. This script requires a GPU.")
-        logger.error("Run on Hugging Face Jobs with: hf jobs uv run lfm2-extract.py ...")
-        sys.exit(1)
-    logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name()}")
-
-
-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 load_text_arg(value: str) -> str:
-    """Resolve --schema (inline text/JSON, URL, or file path) into a string."""
-    text = value.strip()
-    if text.startswith("http://") or text.startswith("https://"):
-        logger.info(f"Loading schema from URL: {text}")
-        return urlopen(text).read().decode("utf-8").strip()
-    if os.path.exists(text):
-        logger.info(f"Loading schema from file: {text}")
-        with open(text) as f:
-            return f.read().strip()
-    return text
-
-
-def build_system_prompt(schema_text: str, fmt: str) -> str:
-    return f"Return data as a {FORMATS[fmt]} object with the following schema:\n\n{schema_text}"
-
-
-def parse_output(text: str, fmt: str) -> tuple[str, bool]:
-    """Strip code fences; for JSON, validate. Returns (cleaned_text, is_valid)."""
-    stripped = text.strip()
-    if stripped.startswith("```"):
-        stripped = stripped.split("\n", 1)[-1]
-        if stripped.endswith("```"):
-            stripped = stripped.rsplit("```", 1)[0]
-    stripped = stripped.strip()
-    if fmt == "json":
-        try:
-            return json.dumps(json.loads(stripped), ensure_ascii=False), True
-        except (json.JSONDecodeError, ValueError):
-            return stripped, False
-    return stripped, True  # xml/yaml: store as-is (no strict validator)
-
-
-def main(
-    input_dataset: str,
-    output_dataset: str,
-    schema: str,
-    text_column: str = "text",
-    output_column: str = "extraction",
-    overwrite: bool = False,
-    output_format: str = "json",
-    split: str = "train",
-    max_samples: Optional[int] = None,
-    shuffle: bool = False,
-    seed: int = 42,
-    batch_size: int = 32,
-    model: str = DEFAULT_MODEL,
-    max_model_len: int = 8192,
-    max_tokens: int = 4096,
-    private: bool = False,
-    hf_token: Optional[str] = None,
-) -> None:
-    check_cuda_availability()
-    if output_format not in FORMATS:
-        logger.error(f"--format must be one of {list(FORMATS)}; got {output_format}")
-        sys.exit(1)
-
-    HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
-    if HF_TOKEN:
-        login(token=HF_TOKEN)
-
-    schema_text = load_text_arg(schema)
-    system_prompt = build_system_prompt(schema_text, output_format)
-
-    logger.info(f"Loading dataset: {input_dataset} (split={split})")
-    dataset = load_dataset(input_dataset, split=split)
-
-    # Fail fast if the output column would collide with an existing input column
-    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
-
-    if shuffle:
-        dataset = dataset.shuffle(seed=seed)
-    if max_samples:
-        dataset = dataset.select(range(min(max_samples, len(dataset))))
-    logger.info(f"Processing {len(dataset)} examples; format={output_format}")
-
-    if text_column not in dataset.column_names:
-        logger.error(f"Text column '{text_column}' not found. Columns: {dataset.column_names}")
-        sys.exit(1)
-
-    logger.info(f"Loading model: {model}")
-    llm = LLM(model=model, max_model_len=max_model_len, enforce_eager=True)
-    sampling_params = SamplingParams(temperature=0.0, max_tokens=max_tokens)
-
-    all_outputs: List[str] = []
-    n_valid = 0
-    texts = dataset[text_column]
-    for batch in tqdm(list(partition_all(batch_size, texts)), desc="Extracting"):
-        batch_messages = [
-            [
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": str(doc)},
-            ]
-            for doc in batch
-        ]
-        outputs = llm.chat(batch_messages, sampling_params)
-        for out in outputs:
-            cleaned, ok = parse_output(out.outputs[0].text, output_format)
-            n_valid += int(ok)
-            all_outputs.append(cleaned)
-
-    logger.info(f"Valid {output_format.upper()}: {n_valid}/{len(all_outputs)}")
-    dataset = dataset.add_column(output_column, all_outputs)
-
-    inference_entry = {
-        "model": model,
-        "column_name": output_column,
-        "task": "structured extraction",
-        "format": output_format,
-        "timestamp": datetime.now(timezone.utc).isoformat(),
-        "script": "lfm2-extract.py",
-    }
-    if "inference_info" in dataset.column_names:
-        def update_info(example):
-            try:
-                existing = json.loads(example["inference_info"]) if example["inference_info"] else []
-            except (json.JSONDecodeError, TypeError):
-                existing = []
-            existing.append(inference_entry)
-            return {"inference_info": json.dumps(existing)}
-        dataset = dataset.map(update_info)
-    else:
-        dataset = dataset.add_column(
-            "inference_info", [json.dumps([inference_entry])] * len(dataset)
-        )
-
-    logger.info(f"Pushing to {output_dataset}")
-    dataset.push_to_hub(output_dataset, private=private, token=HF_TOKEN)
-
-    card_text = f"""---
-tags:
-- uv-script
-- extraction
-- lfm2
-- {output_format}
----
-
-# Structured extraction with LFM2-1.2B-Extract
-
-`{output_format.upper()}` extracted from the `{text_column}` column of
-[{input_dataset}](https://huggingface.co/datasets/{input_dataset})
-using [{model}](https://huggingface.co/{model}).
-
-- **Source**: `{input_dataset}` (split `{split}`, column `{text_column}`)
-- **Model**: `{model}`
-- **Format**: `{output_format}`
-- **Output column**: `{output_column}`
-- **Valid {output_format.upper()}**: {n_valid}/{len(all_outputs)}
-- **Date**: {datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")}
-
-Generated with the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) `lfm2-extract.py` script.
-"""
-    try:
-        DatasetCard(card_text).push_to_hub(output_dataset, token=HF_TOKEN)
-    except Exception as e:
-        logger.warning(f"Could not push dataset card: {e}")
-
-    logger.info("Done! Extraction complete.")
-    logger.info(f"Dataset: https://huggingface.co/datasets/{output_dataset}")
-
-
-if __name__ == "__main__":
-    if len(sys.argv) == 1:
-        print("LFM2-1.2B-Extract — structured extraction (JSON/XML/YAML) from text")
-        print("\nUsage:")
-        print("  uv run --with vllm==0.29.0 lfm2-extract.py INPUT OUTPUT --schema SCHEMA [--text-column text] [--format json]")
-        print("\nExample:")
-        print('  uv run --with vllm==0.29.0 lfm2-extract.py my-docs my-fields \\')
-        print('    --text-column markdown \\')
-        print('    --schema \'{"title": "the title", "date": "any date", "summary": "one sentence"}\'')
-        print("\n  --schema accepts inline text/JSON, a URL, or a file path.")
-        print("\nOn HF Jobs (hf CLI 1.32+; image/flavor/secrets come from the script header):")
-        print("  hf jobs uv run lfm2-extract.py INPUT OUTPUT --schema SCHEMA")
-        print("\nFor full help: uv run --with vllm==0.29.0 lfm2-extract.py --help")
-        sys.exit(0)
-
-    parser = argparse.ArgumentParser(
-        description="Structured extraction (JSON/XML/YAML) from text using LFM2-1.2B-Extract",
-    )
-    parser.add_argument("input_dataset", help="Input dataset ID (with a text column)")
-    parser.add_argument("output_dataset", help="Output dataset ID")
-    parser.add_argument(
-        "--schema", required=True,
-        help="Structure to extract: inline text/JSON, a URL, or a file path",
-    )
-    parser.add_argument("--text-column", default="text", help="Text column (default: text)")
-    parser.add_argument("--output-column", default="extraction", help="Output column (default: extraction)")
-    parser.add_argument(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists in the input dataset "
-        "(default: error out to avoid clobbering an existing column).",
-    )
-    parser.add_argument(
-        "--format", dest="output_format", default="json", choices=list(FORMATS),
-        help="Output format (default: json)",
-    )
-    parser.add_argument("--split", default="train", help="Dataset split (default: train)")
-    parser.add_argument("--max-samples", type=int, help="Limit number of samples")
-    parser.add_argument("--shuffle", action="store_true", help="Shuffle before sampling")
-    parser.add_argument("--seed", type=int, default=42, help="Shuffle seed (default: 42)")
-    parser.add_argument("--batch-size", type=int, default=32, help="Batch size (default: 32)")
-    parser.add_argument("--model", default=DEFAULT_MODEL, help=f"Model (default: {DEFAULT_MODEL})")
-    parser.add_argument("--max-model-len", type=int, default=8192, help="Max context length (default: 8192)")
-    parser.add_argument("--max-tokens", type=int, default=4096, help="Max output tokens (default: 4096)")
-    parser.add_argument("--private", action="store_true", help="Make output dataset private")
-    parser.add_argument("--hf-token", help="HF token (or set HF_TOKEN)")
-    args = parser.parse_args()
-
-    main(
-        input_dataset=args.input_dataset,
-        output_dataset=args.output_dataset,
-        schema=args.schema,
-        text_column=args.text_column,
-        output_column=args.output_column,
-        overwrite=args.overwrite,
-        output_format=args.output_format,
-        split=args.split,
-        max_samples=args.max_samples,
-        shuffle=args.shuffle,
-        seed=args.seed,
-        batch_size=args.batch_size,
-        model=args.model,
-        max_model_len=args.max_model_len,
-        max_tokens=args.max_tokens,
-        private=args.private,
-        hf_token=args.hf_token,
-    )

lfm2-vl-extract.py

@@ -1,358 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "datasets>=4.0.0",
-#     "huggingface-hub",
-#     "pillow",
-#     "vllm",
-#     "transformers",
-#     "tqdm",
-#     "toolz",
-#     "torch",
-# ]
-# ///
-"""
-Extract structured JSON from images using LiquidAI's LFM2.5-VL-1.6B-Extract with vLLM.
-
-LFM2.5-VL-1.6B-Extract (1.6B = LFM2 1.2B LM + SigLIP2 0.4B vision) is a compact
-vision-language model purpose-built for *schema-guided* extraction: you give it a
-list of fields, it returns a flat JSON object with those fields filled from the image.
-It reports 99.6 JSON-validity / F1 on its benchmark, beating similarly-sized VLMs.
-
-Unlike the markdown-OCR scripts here, this one needs a SCHEMA (a field list). Pass
-`--schema` as inline JSON, a URL, or a file path, mapping field names to short
-descriptions:
-
-    --schema '{"invoice_number": "the invoice number", "total": "the total amount"}'
-
-Model:  https://huggingface.co/LiquidAI/LFM2.5-VL-1.6B-Extract
-Docs:   https://docs.liquid.ai/deployment/gpu-inference/vllm
-
-HF Jobs note: run on the vLLM image so the CUDA toolkit + prebuilt FlashInfer kernels
-are present and startup is fast (it reuses the image's CUDA-matched vLLM build):
-
-    hf jobs uv run --flavor l4x1 --secrets HF_TOKEN \
-        --image vllm/vllm-openai --python /usr/bin/python3 \
-        -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages \
-        https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lfm2-vl-extract.py \
-        INPUT OUTPUT --schema '{"title": "the document title", "date": "any date shown"}'
-
-It also runs on the default uv image, just with a slower first-time vLLM build. Deps are
-left unpinned so uv resolves a vLLM that supports the LFM2-VL (transformers 5) architecture,
-and FlashInfer sampling is disabled (VLLM_USE_FLASHINFER_SAMPLER=0, see below) so the engine
-never JIT-compiles a kernel that needs nvcc — absent from the default image.
-"""
-
-import argparse
-import base64
-import io
-import json
-import logging
-import os
-import sys
-from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional, Union
-from urllib.request import urlopen
-
-# Disable vLLM's FlashInfer top-k/top-p sampler before the engine starts: it JIT-compiles
-# at warmup and needs nvcc (absent from the default uv image). Harmless for greedy decoding.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
-
-import torch
-from datasets import load_dataset
-from huggingface_hub import DatasetCard, login
-from PIL import Image
-from toolz import partition_all
-from tqdm import tqdm
-from vllm import LLM, SamplingParams
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-DEFAULT_MODEL = "LiquidAI/LFM2.5-VL-1.6B-Extract"
-
-
-def check_cuda_availability() -> None:
-    if not torch.cuda.is_available():
-        logger.error("CUDA is not available. This script requires a GPU.")
-        logger.error("Run on Hugging Face Jobs with: hf jobs uv run --flavor l4x1 ...")
-        sys.exit(1)
-    logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name()}")
-
-
-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 load_schema_arg(value: str) -> Dict[str, str]:
-    """Resolve --schema (inline JSON, URL, or file path) into a {field: description} dict."""
-    text = value.strip()
-    if text.startswith("http://") or text.startswith("https://"):
-        logger.info(f"Loading schema from URL: {text}")
-        text = urlopen(text).read().decode("utf-8")
-    elif not text.startswith("{") and not text.startswith("["):
-        if os.path.exists(text):
-            logger.info(f"Loading schema from file: {text}")
-            with open(text) as f:
-                text = f.read()
-    parsed = json.loads(text)
-    # Accept {"field": "description"} or ["field1", "field2"]
-    if isinstance(parsed, list):
-        return {str(field): "" for field in parsed}
-    if isinstance(parsed, dict):
-        return {str(k): str(v) for k, v in parsed.items()}
-    raise ValueError("--schema must be a JSON object {field: description} or a JSON list of field names.")
-
-
-def build_system_prompt(schema: Dict[str, str]) -> str:
-    """LFM2.5-VL-Extract prompt: a field list in the system message → flat JSON out."""
-    lines = []
-    for field, desc in schema.items():
-        lines.append(f"{field}: {desc}" if desc else field)
-    fields_block = "\n".join(lines)
-    return (
-        f"Extract the following from the image:\n\n{fields_block}\n\n"
-        "Respond with only a JSON object."
-    )
-
-
-def image_to_data_uri(image: Union[Image.Image, Dict[str, Any], str]) -> str:
-    if isinstance(image, dict) and "bytes" in image:
-        image = Image.open(io.BytesIO(image["bytes"]))
-    elif isinstance(image, str):
-        image = Image.open(image)
-    if image.mode != "RGB":
-        image = image.convert("RGB")
-    buf = io.BytesIO()
-    image.save(buf, format="PNG")
-    return f"data:image/png;base64,{base64.b64encode(buf.getvalue()).decode()}"
-
-
-def make_message(image: Any, system_prompt: str) -> List[Dict]:
-    data_uri = image_to_data_uri(image)
-    return [
-        {"role": "system", "content": system_prompt},
-        {"role": "user", "content": [{"type": "image_url", "image_url": {"url": data_uri}}]},
-    ]
-
-
-def parse_json_output(text: str) -> tuple[Optional[Any], bool]:
-    """Return (parsed, ok). Strips ```json fences if present."""
-    stripped = text.strip()
-    if stripped.startswith("```"):
-        stripped = stripped.split("\n", 1)[-1]
-        if stripped.endswith("```"):
-            stripped = stripped.rsplit("```", 1)[0]
-    stripped = stripped.strip()
-    try:
-        return json.loads(stripped), True
-    except (json.JSONDecodeError, ValueError):
-        return None, False
-
-
-def main(
-    input_dataset: str,
-    output_dataset: str,
-    schema: str,
-    image_column: str = "image",
-    output_column: str = "extraction",
-    overwrite: bool = False,
-    split: str = "train",
-    max_samples: Optional[int] = None,
-    shuffle: bool = False,
-    seed: int = 42,
-    batch_size: int = 16,
-    model: str = DEFAULT_MODEL,
-    max_model_len: int = 4096,
-    max_tokens: int = 1024,
-    private: bool = False,
-    hf_token: Optional[str] = None,
-) -> None:
-    check_cuda_availability()
-
-    HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
-    if HF_TOKEN:
-        login(token=HF_TOKEN)
-
-    schema_dict = load_schema_arg(schema)
-    system_prompt = build_system_prompt(schema_dict)
-    logger.info(f"Extraction fields: {list(schema_dict.keys())}")
-
-    logger.info(f"Loading dataset: {input_dataset} (split={split})")
-    dataset = load_dataset(input_dataset, split=split)
-
-    # Fail fast if the output column would collide with an existing input column
-    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
-
-    if shuffle:
-        dataset = dataset.shuffle(seed=seed)
-    if max_samples:
-        dataset = dataset.select(range(min(max_samples, len(dataset))))
-    logger.info(f"Processing {len(dataset)} examples")
-
-    if image_column not in dataset.column_names:
-        logger.error(f"Image column '{image_column}' not found. Columns: {dataset.column_names}")
-        sys.exit(1)
-
-    logger.info(f"Loading model: {model}")
-    llm = LLM(
-        model=model,
-        max_model_len=max_model_len,
-        limit_mm_per_prompt={"image": 1},
-        enforce_eager=True,
-    )
-    sampling_params = SamplingParams(temperature=0.0, max_tokens=max_tokens)
-
-    all_outputs: List[str] = []
-    n_valid = 0
-    images = dataset[image_column]
-    for batch in tqdm(list(partition_all(batch_size, images)), desc="Extracting"):
-        batch_messages = [make_message(img, system_prompt) for img in batch]
-        outputs = llm.chat(batch_messages, sampling_params)
-        for out in outputs:
-            text = out.outputs[0].text.strip()
-            parsed, ok = parse_json_output(text)
-            if ok:
-                n_valid += 1
-                all_outputs.append(json.dumps(parsed, ensure_ascii=False))
-            else:
-                all_outputs.append(text)  # keep raw on parse failure
-
-    logger.info(f"Valid JSON: {n_valid}/{len(all_outputs)}")
-
-    dataset = dataset.add_column(output_column, all_outputs)
-
-    inference_entry = {
-        "model": model,
-        "column_name": output_column,
-        "task": "schema-guided extraction",
-        "fields": list(schema_dict.keys()),
-        "timestamp": datetime.now(timezone.utc).isoformat(),
-        "script": "lfm2-vl-extract.py",
-    }
-    if "inference_info" in dataset.column_names:
-        def update_info(example):
-            try:
-                existing = json.loads(example["inference_info"]) if example["inference_info"] else []
-            except (json.JSONDecodeError, TypeError):
-                existing = []
-            existing.append(inference_entry)
-            return {"inference_info": json.dumps(existing)}
-        dataset = dataset.map(update_info)
-    else:
-        dataset = dataset.add_column(
-            "inference_info", [json.dumps([inference_entry])] * len(dataset)
-        )
-
-    logger.info(f"Pushing to {output_dataset}")
-    dataset.push_to_hub(output_dataset, private=private, token=HF_TOKEN)
-
-    card_text = f"""---
-tags:
-- uv-script
-- extraction
-- lfm2-vl
-- json
----
-
-# Structured extraction with LFM2.5-VL-1.6B-Extract
-
-JSON fields extracted from images in [{input_dataset}](https://huggingface.co/datasets/{input_dataset})
-using [{model}](https://huggingface.co/{model}).
-
-- **Source**: `{input_dataset}` (split `{split}`)
-- **Model**: `{model}`
-- **Fields**: {", ".join(f"`{k}`" for k in schema_dict.keys())}
-- **Output column**: `{output_column}` (JSON string per row)
-- **Valid JSON**: {n_valid}/{len(all_outputs)}
-- **Date**: {datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")}
-
-Generated with the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) `lfm2-vl-extract.py` script.
-"""
-    try:
-        card = DatasetCard(card_text)
-        card.push_to_hub(output_dataset, token=HF_TOKEN)
-    except Exception as e:
-        logger.warning(f"Could not push dataset card: {e}")
-
-    logger.info("Done! Extraction complete.")
-    logger.info(f"Dataset: https://huggingface.co/datasets/{output_dataset}")
-
-
-if __name__ == "__main__":
-    if len(sys.argv) == 1:
-        print("LFM2.5-VL-1.6B-Extract — schema-guided JSON extraction from images")
-        print("\nUsage:")
-        print("  uv run lfm2-vl-extract.py INPUT OUTPUT --schema SCHEMA [options]")
-        print("\nExample:")
-        print('  uv run lfm2-vl-extract.py my-images my-extractions \\')
-        print('    --schema \'{"title": "the document title", "date": "any date shown"}\'')
-        print("\n  --schema accepts inline JSON, a URL, or a file path.")
-        print("\nFor full help: uv run lfm2-vl-extract.py --help")
-        sys.exit(0)
-
-    parser = argparse.ArgumentParser(
-        description="Schema-guided JSON extraction from images using LFM2.5-VL-1.6B-Extract",
-    )
-    parser.add_argument("input_dataset", help="Input dataset ID (with images)")
-    parser.add_argument("output_dataset", help="Output dataset ID")
-    parser.add_argument(
-        "--schema", required=True,
-        help="Fields to extract: inline JSON {field: description}, a URL, or a file path",
-    )
-    parser.add_argument("--image-column", default="image", help="Image column (default: image)")
-    parser.add_argument("--output-column", default="extraction", help="Output column (default: extraction)")
-    parser.add_argument(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists in the input dataset "
-        "(default: error out to avoid clobbering an existing column).",
-    )
-    parser.add_argument("--split", default="train", help="Dataset split (default: train)")
-    parser.add_argument("--max-samples", type=int, help="Limit number of samples")
-    parser.add_argument("--shuffle", action="store_true", help="Shuffle before sampling")
-    parser.add_argument("--seed", type=int, default=42, help="Shuffle seed (default: 42)")
-    parser.add_argument("--batch-size", type=int, default=16, help="Batch size (default: 16)")
-    parser.add_argument("--model", default=DEFAULT_MODEL, help=f"Model (default: {DEFAULT_MODEL})")
-    parser.add_argument("--max-model-len", type=int, default=4096, help="Max context length (default: 4096)")
-    parser.add_argument("--max-tokens", type=int, default=1024, help="Max output tokens (default: 1024)")
-    parser.add_argument("--private", action="store_true", help="Make output dataset private")
-    parser.add_argument("--hf-token", help="HF token (or set HF_TOKEN)")
-    args = parser.parse_args()
-
-    main(
-        input_dataset=args.input_dataset,
-        output_dataset=args.output_dataset,
-        schema=args.schema,
-        image_column=args.image_column,
-        output_column=args.output_column,
-        overwrite=args.overwrite,
-        split=args.split,
-        max_samples=args.max_samples,
-        shuffle=args.shuffle,
-        seed=args.seed,
-        batch_size=args.batch_size,
-        model=args.model,
-        max_model_len=args.max_model_len,
-        max_tokens=args.max_tokens,
-        private=args.private,
-        hf_token=args.hf_token,
-    )

lift-extract.py

@@ -1,855 +0,0 @@
-# /// script
-# requires-python = ">=3.12"
-# dependencies = [
-#     "lift-pdf[hf]",
-#     "datasets>=3.1.0",
-#     "huggingface-hub",
-#     "pillow",
-#     "toolz",
-#     "tqdm",
-# ]
-#
-# [tool.hf-jobs]
-# flavor = "a100-large"
-# secrets = ["HF_TOKEN"]
-# ///
-"""
-Extract structured JSON from document images OR multi-page PDFs using Datalab's
-`lift` model (`datalab-to/lift`, 9B, Qwen3.5-based).
-
-Unlike the markdown-OCR scripts here, lift does *schema-constrained* extraction:
-you give it a JSON Schema, it returns a JSON object matching that schema. It
-natively handles multi-page documents — a whole PDF is collapsed into a single
-extraction.
-
-Two in-process backends, selected with `--method` (no server, single command):
-
-  --method hf    (default)  Transformers via the `lift-pdf` package. Runs on the
-                            default uv image. Simplest path; best for small jobs.
-  --method vllm             vLLM's offline `LLM()` engine (`llm.chat`) with
-                            structured-output decoding — the fast batched path the
-                            other vLLM OCR scripts here use. Needs the
-                            `vllm/vllm-openai` image (which ships vLLM). Reproduces
-                            lift's own prompt + guided-JSON recipe against the
-                            offline engine. Wins on large jobs via continuous batching.
-
-Benchmark the two by pushing each to one repo with `--config hf` / `--config vllm`.
-
-Input is one document per row:
-  --image-column COL   (default `image`)  one image per row  -> one extraction
-  --pdf-column COL                        PDF bytes per row -> one extraction
-                                          (multi-page; respects --page-range)
-
-Pass `--schema` as inline JSON, a URL, or a file path (standard JSON Schema):
-
-    --schema '{"type":"object","properties":{"invoice_number":{"type":"string"},
-               "total":{"type":"number"}},"required":["invoice_number"]}'
-
-LICENSE NOTE: lift's *code* is Apache-2.0 but the *weights* are a modified
-OpenRAIL-M license — free for research, personal use, and startups under $5M
-funding/revenue, but restricted from competitive use against Datalab's API.
-Confirm you are within those terms before using it. https://huggingface.co/datalab-to/lift
-
-HF Jobs — HF backend. The [tool.hf-jobs] header above sets the flavor
-(a100-large; 9B needs a roomy GPU) and the HF_TOKEN secret, so no flags are
-needed (requires `hf` CLI 1.32+):
-
-    hf jobs uv run \\
-        https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lift-extract.py \\
-        INPUT_DATASET OUTPUT_DATASET \\
-        --schema '{"type":"object","properties":{"title":{"type":"string"}}}' \\
-        --max-samples 5 --shuffle --seed 42
-
-HF Jobs — vLLM offline backend (use the vllm image so vLLM is present). The
-header does not cover this path: pass the image flags explicitly. This path is
-not tested with the header; treat it as unsupported for now:
-
-    hf jobs uv run --flavor a100-large -s HF_TOKEN \\
-        --image vllm/vllm-openai --python /usr/bin/python3 \\
-        -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages \\
-        https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lift-extract.py \\
-        INPUT_DATASET OUTPUT_DATASET --method vllm \\
-        --schema '{"type":"object","properties":{"title":{"type":"string"}}}' \\
-        --max-samples 5
-
-Model: datalab-to/lift  (package: lift-pdf, https://github.com/datalab-to/lift)
-"""
-
-import argparse
-import base64
-import io
-import json
-import logging
-import os
-import sys
-import tempfile
-import time
-from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional, Tuple
-from urllib.request import urlopen
-
-from datasets import load_dataset
-from huggingface_hub import DatasetCard, login
-from PIL import Image
-from toolz import partition_all
-from tqdm import tqdm
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# The package default checkpoint drifts between releases (e.g. "datalab-to/lift-extract");
-# pin to the canonical card repo so the script is stable across lift-pdf versions.
-DEFAULT_MODEL = "datalab-to/lift"
-DEFAULT_MAX_TOKENS = 12384  # lift-pdf's own MAX_OUTPUT_TOKENS default
-
-# A processed document: (parsed JSON or None, error flag, raw model text).
-DocResult = Tuple[Optional[Any], bool, str]
-
-
-def check_cuda_availability() -> None:
-    """Exit early with a clear message if there's no GPU."""
-    import torch
-
-    if not torch.cuda.is_available():
-        logger.error("CUDA is not available. This script requires a GPU.")
-        logger.error(
-            "Run on Hugging Face Jobs with: hf jobs uv run lift-extract.py ... "
-            "(the script header sets flavor a100-large; hf CLI 1.32+)"
-        )
-        sys.exit(1)
-    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 load_schema_arg(value: str) -> Dict[str, Any]:
-    """Resolve --schema (inline JSON, a URL, or a file path) into a JSON Schema dict."""
-    text = value.strip()
-    if text.startswith(("http://", "https://")):
-        logger.info(f"Loading schema from URL: {text}")
-        text = urlopen(text).read().decode("utf-8")  # noqa: S310
-    elif not text.startswith("{"):
-        # Looks like a path (inline JSON would start with "{"); read it if it exists.
-        if os.path.isfile(text):
-            logger.info(f"Loading schema from file: {text}")
-            with open(text) as f:
-                text = f.read()
-    try:
-        parsed = json.loads(text)
-    except json.JSONDecodeError as e:
-        raise ValueError(
-            f"Could not parse --schema as JSON (tried URL/path/inline): {e}"
-        ) from e
-    if not isinstance(parsed, dict):
-        raise ValueError("--schema must be a JSON object (a JSON Schema).")
-    return parsed
-
-
-def cell_to_bytes(cell: Any) -> bytes:
-    """Normalize an HF dataset cell (image or document) to raw file bytes.
-
-    Handles decoded PIL images (Image feature), {"bytes"/"path"} dicts, raw bytes
-    (e.g. a binary PDF column), and string paths/URLs.
-    """
-    if isinstance(cell, Image.Image):
-        buf = io.BytesIO()
-        cell.convert("RGB").save(buf, format="PNG")
-        return buf.getvalue()
-    if isinstance(cell, dict):
-        if cell.get("bytes"):
-            return cell["bytes"]
-        if cell.get("path"):
-            with open(cell["path"], "rb") as f:
-                return f.read()
-        raise ValueError(
-            f"Unsupported image/document dict (no bytes/path): {list(cell)}"
-        )
-    if isinstance(cell, (bytes, bytearray)):
-        return bytes(cell)
-    if isinstance(cell, str):
-        if cell.startswith(("http://", "https://")):
-            return urlopen(cell).read()  # noqa: S310
-        with open(cell, "rb") as f:
-            return f.read()
-    raise ValueError(f"Unsupported cell type: {type(cell)}")
-
-
-def load_document_images(
-    load_file, cell: Any, page_range: Optional[str]
-) -> List[Image.Image]:
-    """Render one dataset cell into the page images lift expects.
-
-    Reuses lift's own `load_file`, which auto-detects PDF vs image by content
-    (pypdfium2 for PDFs, with the model's DPI/min-dim and page-range handling).
-    """
-    data = cell_to_bytes(cell)
-    # load_file detects type from content, so the temp file needs no extension.
-    with tempfile.NamedTemporaryFile(delete=False) as tmp:
-        tmp.write(data)
-        path = tmp.name
-    try:
-        config = {"page_range": page_range} if page_range else {}
-        return load_file(path, config)
-    finally:
-        os.unlink(path)
-
-
-def pil_to_data_uri(img: Image.Image) -> str:
-    """PNG data URI for an OpenAI-format image content block."""
-    if img.mode != "RGB":
-        img = img.convert("RGB")
-    buf = io.BytesIO()
-    img.save(buf, format="PNG")
-    return f"data:image/png;base64,{base64.b64encode(buf.getvalue()).decode()}"
-
-
-def parse_json_output(text: str) -> Tuple[Optional[Any], bool]:
-    """Return (parsed, ok). Strips ```json fences if present."""
-    stripped = text.strip()
-    if stripped.startswith("```"):
-        stripped = stripped.split("\n", 1)[-1] if "\n" in stripped else stripped[3:]
-        if stripped.endswith("```"):
-            stripped = stripped[:-3].rstrip()
-    try:
-        return json.loads(stripped), True
-    except (json.JSONDecodeError, ValueError):
-        return None, False
-
-
-# --- HF backend (lift-pdf package, in-process Transformers) ---
-def make_hf_processor(schema: Dict[str, Any], max_tokens: Optional[int]):
-    """Load lift via the package's HF backend; return a batch-processing closure."""
-    from lift.model import InferenceManager
-    from lift.model.schema import BatchInputItem
-
-    logger.info("Loading lift via Transformers (method=hf)...")
-    manager = InferenceManager(method="hf")
-
-    def process(image_lists: List[List[Image.Image]]) -> List[DocResult]:
-        items = [
-            BatchInputItem(images=imgs, schema=schema, prompt_type="direct")
-            for imgs in image_lists
-        ]
-        results = manager.generate(items, max_output_tokens=max_tokens)
-        return [(r.extraction, bool(r.error), r.raw) for r in results]
-
-    return process
-
-
-# --- vLLM backend (offline LLM() engine + structured outputs) ---
-def build_guided_schema(schema: Dict[str, Any]) -> Dict[str, Any]:
-    """Reproduce lift's vLLM guided-decoding schema: JSON Schema -> pydantic ->
-    json_schema with every leaf made nullable (so absent fields can be null,
-    matching lift's own server-side behavior)."""
-    from json_schema_to_pydantic import create_model
-    from lift.model.vllm import make_properties_nullable
-
-    schema_model = create_model(schema)
-    json_schema = schema_model.model_json_schema()
-    make_properties_nullable(json_schema)
-    return json_schema
-
-
-def make_sampling_params(json_schema: Dict[str, Any], max_tokens: int):
-    """SamplingParams with structured JSON output, across vLLM API versions.
-
-    lift uses greedy-ish decoding (temperature 0.0, top_p 0.1).
-    """
-    from vllm import SamplingParams
-
-    # vLLM >= 0.12
-    try:
-        from vllm.sampling_params import StructuredOutputsParams
-
-        return SamplingParams(
-            temperature=0.0,
-            top_p=0.1,
-            max_tokens=max_tokens,
-            structured_outputs=StructuredOutputsParams(json=json_schema),
-        )
-    except (ImportError, TypeError):
-        pass
-    # Older vLLM
-    try:
-        from vllm.sampling_params import GuidedDecodingParams
-
-        return SamplingParams(
-            temperature=0.0,
-            top_p=0.1,
-            max_tokens=max_tokens,
-            guided_decoding=GuidedDecodingParams(json=json_schema),
-        )
-    except (ImportError, TypeError):
-        pass
-    logger.warning(
-        "Structured output unavailable in this vLLM version; relying on lift's "
-        "training to emit valid JSON."
-    )
-    return SamplingParams(temperature=0.0, top_p=0.1, max_tokens=max_tokens)
-
-
-def make_vllm_processor(
-    schema: Dict[str, Any],
-    model: str,
-    max_tokens: Optional[int],
-    max_model_len: int,
-    gpu_memory_utilization: float,
-    max_images_per_doc: int,
-):
-    """Load lift into vLLM's offline engine; return a batch-processing closure."""
-    try:
-        from vllm import LLM
-    except ImportError as e:
-        raise RuntimeError(
-            "--method vllm needs vLLM. Run on the vllm/vllm-openai image: "
-            "--image vllm/vllm-openai --python /usr/bin/python3 "
-            "-e PYTHONPATH=/usr/local/lib/python3.12/dist-packages"
-        ) from e
-    from lift.model.util import scale_to_fit
-    from lift.prompts import PROMPT_MAPPING
-
-    json_schema = build_guided_schema(schema)
-    prompt = PROMPT_MAPPING["direct"].replace("{schema}", json.dumps(schema, indent=2))
-
-    logger.info("Loading lift via vLLM offline engine (method=vllm)...")
-    llm = LLM(
-        model=model,
-        trust_remote_code=True,
-        max_model_len=max_model_len,
-        gpu_memory_utilization=gpu_memory_utilization,
-        limit_mm_per_prompt={"image": max_images_per_doc},
-        # lift's own server-side image bounds, applied by the offline processor too.
-        mm_processor_kwargs={"min_pixels": 3136, "max_pixels": 861696},
-    )
-    sampling_params = make_sampling_params(
-        json_schema, max_tokens or DEFAULT_MAX_TOKENS
-    )
-
-    def process(image_lists: List[List[Image.Image]]) -> List[DocResult]:
-        messages = []
-        for imgs in image_lists:
-            content = [
-                {
-                    "type": "image_url",
-                    "image_url": {"url": pil_to_data_uri(scale_to_fit(img))},
-                }
-                for img in imgs
-            ]
-            content.append({"type": "text", "text": prompt})
-            messages.append([{"role": "user", "content": content}])
-        outputs = llm.chat(
-            messages, sampling_params, chat_template_content_format="openai"
-        )
-        results: List[DocResult] = []
-        for o in outputs:
-            raw = o.outputs[0].text
-            parsed, ok = parse_json_output(raw)
-            results.append((parsed if ok else None, not ok, raw))
-        return results
-
-    return process
-
-
-def create_dataset_card(
-    source_dataset: str,
-    model: str,
-    method: str,
-    schema: Dict[str, Any],
-    num_samples: int,
-    n_valid: int,
-    source_column: str,
-    is_pdf: bool,
-    page_range: Optional[str],
-    output_column: str,
-    split: str,
-    processing_time: str,
-) -> str:
-    """Build the output dataset card documenting the lift run."""
-    schema_block = json.dumps(schema, indent=2)
-    input_kind = "PDF documents" if is_pdf else "images"
-    col_desc = "PDF" if is_pdf else "image"
-    if page_range:
-        col_desc += f", pages {page_range}"
-    backend_desc = (
-        "vLLM offline engine" if method == "vllm" else "Transformers (lift-pdf)"
-    )
-    return f"""---
-tags:
-- ocr
-- structured-extraction
-- document-processing
-- lift
-- json
-- uv-script
-- generated
----
-
-# lift structured extraction on {source_dataset}
-
-Schema-constrained JSON extracted from {input_kind} in
-[{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using
-[lift](https://huggingface.co/{model}) (9B, Qwen3.5-based) by Datalab, via the
-[`lift-pdf`](https://github.com/datalab-to/lift) package.
-
-## Processing Details
-
-- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
-- **Model**: [{model}](https://huggingface.co/{model})
-- **Backend**: `{method}` ({backend_desc})
-- **Input column**: `{source_column}` ({col_desc})
-- **Output column**: `{output_column}` (JSON string per row)
-- **Split**: `{split}`
-- **Samples**: {num_samples:,}
-- **Valid JSON**: {n_valid:,} / {num_samples:,}
-- **Processing time**: {processing_time}
-- **Date**: {datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")}
-
-### Extraction Schema
-
-```json
-{schema_block}
-```
-
-## License note
-
-lift's code is Apache-2.0, but the model **weights** use a modified OpenRAIL-M
-license: free for research, personal use, and startups under $5M funding/revenue,
-restricted from competitive use against Datalab's API. See the
-[model card](https://huggingface.co/{model}).
-
-## Dataset Structure
-
-Original columns plus:
-- `{output_column}`: lift output (JSON string; raw text kept on parse failure)
-- `inference_info`: JSON list tracking models applied to this dataset
-
-Generated with [UV Scripts](https://huggingface.co/uv-scripts).
-"""
-
-
-def main(
-    input_dataset: str,
-    output_dataset: str,
-    schema_arg: str,
-    image_column: str = "image",
-    pdf_column: Optional[str] = None,
-    output_column: str = "extraction",
-    overwrite: bool = False,
-    method: str = "hf",
-    page_range: Optional[str] = None,
-    split: str = "train",
-    max_samples: Optional[int] = None,
-    shuffle: bool = False,
-    seed: int = 42,
-    batch_size: int = 8,
-    max_tokens: Optional[int] = None,
-    max_model_len: int = 32768,
-    gpu_memory_utilization: float = 0.9,
-    max_images_per_doc: Optional[int] = None,
-    model: str = DEFAULT_MODEL,
-    private: bool = False,
-    config: Optional[str] = None,
-    create_pr: bool = False,
-    hf_token: Optional[str] = None,
-    verbose: bool = False,
-) -> None:
-    # Unlock full Xet bandwidth for the 9B (~19GB) model download (repo convention).
-    os.environ["HF_XET_HIGH_PERFORMANCE"] = "1"
-    check_cuda_availability()
-    start_time = datetime.now(timezone.utc)
-
-    HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
-    if HF_TOKEN:
-        login(token=HF_TOKEN)
-
-    schema = load_schema_arg(schema_arg)
-
-    # lift reads the checkpoint from env (pydantic-settings) at import time; set it first.
-    os.environ["MODEL_CHECKPOINT"] = model
-
-    # Import lift only after env is set so settings pick up the right checkpoint.
-    from lift import resolve_schema
-    from lift.input import load_file
-
-    schema = resolve_schema(schema)  # validates and normalizes
-    fields = list(schema.get("properties", {}).keys())
-
-    source_column = pdf_column or image_column
-    is_pdf = pdf_column is not None
-    # vLLM caps images per prompt at init; PDFs need headroom for multiple pages.
-    if max_images_per_doc is None:
-        max_images_per_doc = 30 if is_pdf else 1
-
-    logger.info(f"Model: {model}  Backend: {method}")
-    logger.info(f"Schema top-level fields: {fields}")
-
-    logger.info(f"Loading dataset: {input_dataset} (split={split})")
-    dataset = load_dataset(input_dataset, split=split)
-    if source_column not in dataset.column_names:
-        logger.error(
-            f"Column '{source_column}' not found. Available: {dataset.column_names}"
-        )
-        sys.exit(1)
-
-    # Fail fast if the output column would collide with an existing input column
-    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
-
-    if shuffle:
-        dataset = dataset.shuffle(seed=seed)
-    if max_samples:
-        dataset = dataset.select(range(min(max_samples, len(dataset))))
-    logger.info(f"Processing {len(dataset)} documents from column '{source_column}'")
-
-    if method == "vllm":
-        process_batch = make_vllm_processor(
-            schema,
-            model,
-            max_tokens,
-            max_model_len,
-            gpu_memory_utilization,
-            max_images_per_doc,
-        )
-    else:
-        process_batch = make_hf_processor(schema, max_tokens)
-
-    extractions: List[Optional[str]] = [None] * len(dataset)
-    error_flags: List[bool] = [True] * len(dataset)
-
-    chunks = list(partition_all(batch_size, range(len(dataset))))
-    for chunk in tqdm(chunks, desc="Extracting"):
-        chunk = list(chunk)
-        rendered: Dict[int, List[Image.Image]] = {}
-        for i in chunk:
-            try:
-                rendered[i] = load_document_images(
-                    load_file, dataset[i][source_column], page_range
-                )
-            except Exception as e:
-                logger.warning(f"Row {i}: failed to load document: {e}")
-                extractions[i] = f"[LIFT LOAD ERROR] {e}"
-                error_flags[i] = True
-        if not rendered:
-            continue
-
-        idxs = list(rendered.keys())
-        try:
-            results = process_batch([rendered[i] for i in idxs])
-        except Exception as e:
-            logger.error(f"Batch generate failed: {e}")
-            for i in idxs:
-                extractions[i] = "[LIFT GENERATE ERROR]"
-                error_flags[i] = True
-            continue
-
-        for i, (parsed, err, raw) in zip(idxs, results):
-            if parsed is not None and not err:
-                extractions[i] = json.dumps(parsed, ensure_ascii=False)
-                error_flags[i] = False
-            else:
-                extractions[i] = raw if raw else "[LIFT EMPTY OUTPUT]"
-                error_flags[i] = True
-
-    n_valid = sum(not f for f in error_flags)
-    logger.info(f"Valid JSON: {n_valid}/{len(dataset)}")
-
-    dataset = dataset.add_column(output_column, extractions)
-
-    inference_entry = {
-        "model": model,
-        "model_name": "lift",
-        "column_name": output_column,
-        "task": "schema-constrained extraction",
-        "backend": method,
-        "fields": fields,
-        "page_range": page_range,
-        "parse_error_rate": (len(dataset) - n_valid) / len(dataset)
-        if len(dataset)
-        else 0.0,
-        "timestamp": datetime.now(timezone.utc).isoformat(),
-        "script": "lift-extract.py",
-    }
-    if "inference_info" in dataset.column_names:
-
-        def update_info(example):
-            try:
-                existing = (
-                    json.loads(example["inference_info"])
-                    if example["inference_info"]
-                    else []
-                )
-            except (json.JSONDecodeError, TypeError):
-                existing = []
-            existing.append(inference_entry)
-            return {"inference_info": json.dumps(existing)}
-
-        dataset = dataset.map(update_info)
-    else:
-        dataset = dataset.add_column(
-            "inference_info", [json.dumps([inference_entry])] * len(dataset)
-        )
-
-    processing_time = (
-        f"{(datetime.now(timezone.utc) - start_time).total_seconds() / 60:.1f} min"
-    )
-
-    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"
-            dataset.push_to_hub(
-                output_dataset,
-                private=private,
-                token=HF_TOKEN,
-                max_shard_size="500MB",
-                create_pr=create_pr,
-                **({"config_name": config} if config else {}),
-                commit_message=f"Add lift extraction 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. Results are lost.")
-                sys.exit(1)
-
-    try:
-        card = DatasetCard(
-            create_dataset_card(
-                source_dataset=input_dataset,
-                model=model,
-                method=method,
-                schema=schema,
-                num_samples=len(dataset),
-                n_valid=n_valid,
-                source_column=source_column,
-                is_pdf=is_pdf,
-                page_range=page_range,
-                output_column=output_column,
-                split=split,
-                processing_time=processing_time,
-            )
-        )
-        card.push_to_hub(output_dataset, token=HF_TOKEN)
-    except Exception as e:
-        logger.warning(f"Could not push dataset card: {e}")
-
-    logger.info("Done! lift extraction complete.")
-    logger.info(f"Dataset: https://huggingface.co/datasets/{output_dataset}")
-    logger.info(f"Processing time: {processing_time}")
-
-    if verbose:
-        import importlib.metadata
-
-        logger.info("--- Resolved package versions ---")
-        pkgs = ["lift-pdf", "transformers", "torch", "datasets", "pillow", "openai"]
-        if method == "vllm":
-            pkgs.append("vllm")
-        for pkg in pkgs:
-            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("lift — schema-constrained JSON extraction from images & PDFs (9B)")
-        print("\nUsage:")
-        print("  uv run lift-extract.py INPUT OUTPUT --schema SCHEMA [options]")
-        print("\nExamples:")
-        print("  # image column -> JSON")
-        print("  uv run lift-extract.py my-images my-fields \\")
-        print(
-            '    --schema \'{"type":"object","properties":{"title":{"type":"string"}}}\''
-        )
-        print("\n  # multi-page PDFs -> JSON (one extraction per document)")
-        print(
-            "  uv run lift-extract.py my-pdfs my-fields --pdf-column pdf --page-range 0-5 \\"
-        )
-        print("    --schema schema.json")
-        print("\n  --schema accepts inline JSON, a URL, or a file path.")
-        print(
-            "  --method hf (default) | vllm (offline LLM engine; needs the vllm image)"
-        )
-        print("\nFor full help: uv run lift-extract.py --help")
-        sys.exit(0)
-
-    parser = argparse.ArgumentParser(
-        description="Schema-constrained JSON extraction from images & PDFs using datalab-to/lift",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Backends (both in-process, single command):
-  --method hf     Transformers via lift-pdf (default). Simplest; default image.
-  --method vllm   vLLM offline LLM() engine with structured outputs. Faster on
-                  large jobs. Needs the vllm/vllm-openai image.
-
-Input (one document per row):
-  --image-column COL   one image per row   (default: image)
-  --pdf-column COL     PDF bytes per row    (multi-page; honors --page-range)
-""",
-    )
-    parser.add_argument(
-        "input_dataset", help="Input dataset ID from the Hugging Face Hub"
-    )
-    parser.add_argument(
-        "output_dataset", help="Output dataset ID for the Hugging Face Hub"
-    )
-    parser.add_argument(
-        "--schema",
-        required=True,
-        help="JSON Schema: inline JSON, a URL, or a file path",
-    )
-    parser.add_argument(
-        "--image-column", default="image", help="Image column (default: image)"
-    )
-    parser.add_argument(
-        "--pdf-column",
-        default=None,
-        help="PDF column (bytes/path). Mutually exclusive with --image-column.",
-    )
-    parser.add_argument(
-        "--output-column",
-        default="extraction",
-        help="Output column (default: extraction)",
-    )
-    parser.add_argument(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists in the input dataset "
-        "(default: error out to avoid clobbering an existing column).",
-    )
-    parser.add_argument(
-        "--method",
-        choices=["hf", "vllm"],
-        default="hf",
-        help="Inference backend (default: hf)",
-    )
-    parser.add_argument(
-        "--page-range",
-        default=None,
-        help="Pages to extract from PDFs, e.g. '0-5,7' (PDF column only)",
-    )
-    parser.add_argument(
-        "--split", default="train", help="Dataset split (default: train)"
-    )
-    parser.add_argument(
-        "--max-samples", type=int, help="Limit number of documents (for testing)"
-    )
-    parser.add_argument(
-        "--shuffle", action="store_true", help="Shuffle before sampling"
-    )
-    parser.add_argument(
-        "--seed", type=int, default=42, help="Shuffle seed (default: 42)"
-    )
-    parser.add_argument(
-        "--batch-size",
-        type=int,
-        default=8,
-        help="Documents per generate() call (default: 8; lower for big multi-page PDFs)",
-    )
-    parser.add_argument(
-        "--max-tokens",
-        type=int,
-        default=None,
-        help=f"Max output tokens (default: lift's {DEFAULT_MAX_TOKENS})",
-    )
-    parser.add_argument(
-        "--max-model-len",
-        type=int,
-        default=32768,
-        help="vLLM context length (default: 32768; raise for long multi-page PDFs)",
-    )
-    parser.add_argument(
-        "--gpu-memory-utilization",
-        type=float,
-        default=0.9,
-        help="vLLM GPU memory fraction (default: 0.9)",
-    )
-    parser.add_argument(
-        "--max-images-per-doc",
-        type=int,
-        default=None,
-        help="vLLM images-per-prompt cap (default: 1 for images, 30 for PDFs)",
-    )
-    parser.add_argument(
-        "--model", default=DEFAULT_MODEL, help=f"Model ID (default: {DEFAULT_MODEL})"
-    )
-    parser.add_argument(
-        "--private", action="store_true", help="Make output dataset private"
-    )
-    parser.add_argument(
-        "--config",
-        default=None,
-        help="Config/subset name when pushing (for benchmarking backends in one repo)",
-    )
-    parser.add_argument(
-        "--create-pr",
-        action="store_true",
-        help="Push as a pull request instead of directly (for parallel benchmarking)",
-    )
-    parser.add_argument("--hf-token", help="Hugging Face API token (or set HF_TOKEN)")
-    parser.add_argument(
-        "--verbose",
-        action="store_true",
-        help="Log resolved package versions after processing",
-    )
-
-    args = parser.parse_args()
-
-    if args.pdf_column and args.image_column != "image":
-        parser.error("--image-column and --pdf-column are mutually exclusive.")
-
-    main(
-        input_dataset=args.input_dataset,
-        output_dataset=args.output_dataset,
-        schema_arg=args.schema,
-        image_column=args.image_column,
-        pdf_column=args.pdf_column,
-        output_column=args.output_column,
-        overwrite=args.overwrite,
-        method=args.method,
-        page_range=args.page_range,
-        split=args.split,
-        max_samples=args.max_samples,
-        shuffle=args.shuffle,
-        seed=args.seed,
-        batch_size=args.batch_size,
-        max_tokens=args.max_tokens,
-        max_model_len=args.max_model_len,
-        gpu_memory_utilization=args.gpu_memory_utilization,
-        max_images_per_doc=args.max_images_per_doc,
-        model=args.model,
-        private=args.private,
-        config=args.config,
-        create_pr=args.create_pr,
-        hf_token=args.hf_token,
-        verbose=args.verbose,
-    )

lighton-ocr.py

@@ -1,7 +1,7 @@
 # /// script
 # requires-python = ">=3.11"
 # dependencies = [
-#     "datasets>=4.0.0",
+#     "datasets",
 #     "huggingface-hub",
 #     "pillow",
 #     "vllm",
@@ -57,10 +57,6 @@ from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)
@@ -85,28 +81,6 @@ def check_cuda_availability():
         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 resize_image_to_target(image: Image.Image, target_size: int = 1540) -> Image.Image:
     """
     Resize image so longest dimension is target_size while maintaining aspect ratio.
@@ -317,7 +291,6 @@ def main(
     shuffle: bool = False,
     seed: int = 42,
     output_column: str = "markdown",
-    overwrite: bool = False,
 ):
     """Process images from HF dataset through LightOnOCR model."""
 
@@ -350,9 +323,6 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
-    # Fail fast if the output column would collide with an existing input column
-    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
-
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -651,12 +621,6 @@ Examples:
         default="markdown",
         help="Column name for output text (default: markdown)",
     )
-    parser.add_argument(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists in the input dataset "
-        "(default: error out to avoid clobbering an existing column).",
-    )
 
     args = parser.parse_args()
 
@@ -680,5 +644,4 @@ Examples:
         shuffle=args.shuffle,
         seed=args.seed,
         output_column=args.output_column,
-        overwrite=args.overwrite,
     )

lighton-ocr2-saturate.py

@@ -1,189 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "saturate[hf]==0.3.0",
-#     "pillow>=10",
-# ]
-#
-# [tool.hf-jobs]
-# image = "vllm/vllm-openai:v0.22.1"
-# flavor = "a10g-small"
-# timeout = "4h"
-# secrets = ["HF_TOKEN"]
-# ///
-"""
-Convert document images to markdown using LightOnOCR-2 via saturate.
-
-Companion to `lighton-ocr2-server.py`: same model, same message shape, same
-sampling, same in-job `vllm serve` — but the driver half (concurrency, retries,
-output, resume) is the `saturate` library instead of hand-rolled code. What that
-buys over the -server recipe:
-
-- **Adaptive concurrency** — the window sizes itself from live engine signals
-  (no `--concurrency` flag to tune).
-- **Crash-safe, resumable output** — results stream to the output repo as
-  parquet parts while the run is hot; re-running the same command skips
-  everything already done (exact anti-join on id). A 10k-page job that dies at
-  9k resumes at 9k.
-- **Durable error rows** — a failed page is recorded as `{id, error}` instead of
-  an `[OCR ERROR]` string in the text column; `--retry-errors` re-admits only
-  those rows on a later run.
-
-Run on HF Jobs. The script starts `vllm serve` itself; its [tool.hf-jobs] header
-declares the image that provides the `vllm` binary, the hardware and the HF_TOKEN
-secret (`hf` CLI 1.32+). Pass --timeout for a long run; flags override the header:
-
-  hf jobs uv run --detach --timeout 4h \\
-      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr2-saturate.py \\
-      <input-dataset> <output-dataset>
-
-Output layout (differs from the -server recipe, which pushes input+markdown):
-the output repo holds `data/part-*.parquet` with rows
-`{id, markdown, model, prompt_tokens, completion_tokens, error}` keyed by the
-input row id (`--id-column`, or `<split>-<index>` by default). Read it with
-`datasets.load_dataset(<output>, data_dir="data")` or `saturate.read_output`;
-join back to the input on id. Run metadata lands in `data/completions/`.
-
-Model: lightonai/LightOnOCR-2-1B (1B, Apache-2.0)
-- Message is the image ONLY (no text prompt) — LightOnOCR-2's trained format.
-- Images resized client-side so the longest dimension is 1540px (training
-  resolution at 200 DPI), same as the offline recipe.
-- Sampling per the card: temperature 0.2, top_p 0.9, max_tokens 4096.
-
-The SERVING dict below is the per-model tuning prior (serve flags + client
-sampling + context math). Agents can `ast.literal_eval` it without running
-the script; the script itself consumes it, so it cannot drift from reality.
-"""
-
-import argparse
-import base64
-import io
-import sys
-
-# Serving starting values for lightonai/LightOnOCR-2-1B. Per-value provenance:
-# - serve_args: the model card's own `vllm serve` command, verbatim (the three
-#   cache/mm flags; OCR never reuses images, so those caches only cost memory).
-# - max_model_len 8192: NOT in the card's serve command (card default = native
-#   16384). House choice inherited from lighton-ocr2-server.py: halves the KV
-#   allocation on 24GB and still fits a 1540px page (~2.5k image tokens) + 4096
-#   output with headroom.
-# - max_tokens/temperature/top_p: card's sampling example, verbatim.
-# - target_size 1540: card's stated training resolution (200 DPI longest side).
-# Throughput receipt (a10g-small): 0.955 img/s at 1k pages incl. streaming.
-SERVING = {
-    "model": "lightonai/LightOnOCR-2-1B",
-    "image": "vllm/vllm-openai:v0.22.1",
-    "max_model_len": 8192,
-    "serve_args": [
-        "--limit-mm-per-prompt", '{"image": 1}',
-        "--mm-processor-cache-gb", "0",
-        "--no-enable-prefix-caching",
-    ],
-    "max_tokens": 4096,
-    "temperature": 0.2,
-    "top_p": 0.9,
-    "target_size": 1540,
-}
-assert SERVING["max_tokens"] < SERVING["max_model_len"], (
-    "context math: max_tokens must leave room for the image tokens "
-    "(input + output <= max_model_len, or every request 400s)"
-)
-
-
-def to_pil(value):
-    from PIL import Image
-
-    if isinstance(value, Image.Image):
-        return value
-    if isinstance(value, dict) and value.get("bytes"):
-        return Image.open(io.BytesIO(value["bytes"]))
-    if isinstance(value, (bytes, bytearray)):
-        return Image.open(io.BytesIO(value))
-    raise ValueError(f"unsupported image value: {type(value)}")
-
-
-def encode_image(value, target_size: int) -> str:
-    """RGB-convert, resize longest dimension to target_size, return base64 PNG."""
-    from PIL import Image
-
-    img = to_pil(value).convert("RGB")
-    if target_size:
-        w, h = img.size
-        if max(w, h) != target_size:
-            scale = target_size / max(w, h)
-            img = img.resize((round(w * scale), round(h * scale)), Image.LANCZOS)
-    buf = io.BytesIO()
-    img.save(buf, format="PNG")
-    return base64.b64encode(buf.getvalue()).decode()
-
-
-def main():
-    ap = argparse.ArgumentParser(description="LightOnOCR-2 batch OCR via saturate")
-    ap.add_argument("input_dataset", help="Input dataset repo id (rows with an image column)")
-    ap.add_argument("output_dataset", help="Output dataset repo id (created if missing)")
-    ap.add_argument("--image-column", default="image")
-    ap.add_argument("--config", default=None, help="Dataset config name")
-    ap.add_argument("--split", default="train")
-    ap.add_argument("--id-column", default=None,
-                    help="Column to use as row id (default: split-index ids)")
-    ap.add_argument("--max-samples", "--limit", dest="limit", type=int, default=None,
-                    help="Process at most N rows (same name as the other OCR recipes; --limit still works)")
-    ap.add_argument("--max-tokens", type=int, default=SERVING["max_tokens"])
-    ap.add_argument("--temperature", type=float, default=SERVING["temperature"])
-    ap.add_argument("--target-size", type=int, default=SERVING["target_size"])
-    ap.add_argument("--no-resize", action="store_true")
-    ap.add_argument("--retry-errors", action="store_true",
-                    help="Re-admit rows whose only record is an error row")
-    args = ap.parse_args()
-
-    import pyarrow as pa
-    from saturate import Auto, Engine, dataset_rows, pump
-
-    target_size = 0 if args.no_resize else args.target_size
-    rows = dataset_rows(
-        args.input_dataset, config=args.config, split=args.split,
-        columns=[args.image_column], ids=args.id_column or "index", limit=args.limit,
-    )
-
-    def to_request(row):
-        b64 = encode_image(row[args.image_column], target_size)
-        return {
-            "model": SERVING["model"],
-            "messages": [{"role": "user", "content": [
-                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}},
-            ]}],
-            "temperature": args.temperature,
-            "top_p": SERVING["top_p"],
-            "max_tokens": args.max_tokens,
-        }
-
-    # Declared, so a part holding only error rows has the same columns as the rest
-    # (datasets.load_dataset reads every part with one schema).
-    schema = pa.schema([
-        ("id", pa.string()), ("error", pa.string()), ("markdown", pa.string()),
-        ("model", pa.string()), ("prompt_tokens", pa.int64()), ("completion_tokens", pa.int64()),
-    ])  # fmt: skip
-
-    def parse(row, body):
-        usage = body.get("usage") or {}
-        return {
-            "markdown": body["choices"][0]["message"]["content"].strip(),
-            "model": SERVING["model"],
-            "prompt_tokens": usage.get("prompt_tokens"),
-            "completion_tokens": usage.get("completion_tokens"),
-        }
-
-    extra = ["--max-model-len", str(SERVING["max_model_len"]), *SERVING["serve_args"]]
-    output = f"hf://datasets/{args.output_dataset}/data"
-    with Engine(SERVING["model"], engine="vllm", extra_args=extra) as endpoint:
-        stats = pump(rows, to_request, parse, endpoint, output,
-                     window=Auto(initial=8, max_limit=48),
-                     retry_errors=args.retry_errors, schema=schema)
-
-    print(f"https://huggingface.co/datasets/{args.output_dataset} "
-          f"({stats.rows_processed} ok, {stats.rows_failed} error rows)", file=sys.stderr)
-    print("LIGHTON_OCR2_SATURATE " + stats.to_json(), flush=True)
-
-
-if __name__ == "__main__":
-    main()

lighton-ocr2-server.py

@@ -1,720 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "datasets>=4.0.0",
-#     "huggingface-hub",
-#     "pillow",
-#     "requests",
-# ]
-# ///
-
-"""
-Convert document images to markdown using LightOnOCR-2 via an in-job vLLM server.
-
-Same model, message shape, and sampling as lighton-ocr2.py, but serves the
-model behind `vllm serve` inside the job (the model card's own documented
-path) and posts images concurrently — continuous batching stays fed instead
-of draining at each offline batch barrier, and a bad image fails one request
-instead of a whole batch. Measured ~1.8x the offline recipe's inference
-throughput on a 100-page historical-scan smoke test (l4x1, concurrency 32).
-
-This script is the *driver* half: it expects the server on localhost
-(started by the job command below), loads the input dataset, posts images
-concurrently, and pushes the result dataset. The driver has no torch/vllm
-deps, so `uv run` starts in seconds while the server warms up in parallel.
-
-Run on HF Jobs (standard uv-run shape — the script starts `vllm serve` itself
-as a subprocess when no server is already reachable; the only thing to get
-right is the --image flag, which provides the `vllm` binary):
-
-  hf jobs uv run --detach --flavor l4x1 -s HF_TOKEN --timeout 4h \\
-      --image vllm/vllm-openai:v0.22.1 \\
-      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr2-server.py \\
-      <input-dataset> <output-dataset>
-
-To use an already-running or remote endpoint instead, pass --server URL — the
-script only spawns a server when the (default localhost) URL is unreachable.
-The serve flags live in SERVE_ARGS below (the model card's own recommended
-command: `--limit-mm-per-prompt`, `--mm-processor-cache-gb 0`,
-`--no-enable-prefix-caching` — OCR never reuses images, so the caches only
-cost memory).
-
-Model: lightonai/LightOnOCR-2-1B (1B, Apache-2.0)
-- Message is the image ONLY (no text prompt) — LightOnOCR-2's trained format.
-- Images resized client-side so the longest dimension is 1540px (training
-  resolution at 200 DPI), same as the offline recipe.
-- Sampling per the card: temperature 0.2, top_p 0.9, max_tokens 4096.
-"""
-
-import argparse
-import atexit
-import base64
-import concurrent.futures
-import io
-import json
-import logging
-import os
-import shutil
-import subprocess
-import sys
-import threading
-import time
-from datetime import datetime
-from typing import Any, Dict, Union
-from urllib.parse import urlparse
-
-import requests
-from datasets import load_dataset
-from huggingface_hub import DatasetCard, login
-from PIL import Image
-
-logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
-logger = logging.getLogger(__name__)
-
-MODEL = "lightonai/LightOnOCR-2-1B"
-
-DEFAULT_TARGET_SIZE = 1540  # longest dimension; LightOnOCR-2 training resolution
-
-# The serve command this script spawns when no server is reachable — the model
-# card's own recommended flags; single source of truth for the serving config.
-SERVE_ARGS = [
-    "vllm", "serve", MODEL,
-    "--limit-mm-per-prompt", '{"image": 1}',
-    "--mm-processor-cache-gb", "0",
-    "--no-enable-prefix-caching",
-    "--max-model-len", "8192",
-    "--gpu-memory-utilization", "0.8",
-    "--port", "8000",
-]
-
-RUN_COMMAND = (
-    "hf jobs uv run --detach --flavor l4x1 -s HF_TOKEN --timeout 4h \\\n"
-    "    --image vllm/vllm-openai:v0.22.1 \\\n"
-    "    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr2-server.py \\\n"
-    "    <input-dataset> <output-dataset>"
-)
-
-
-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 encode_image(image, target_size: int) -> str:
-    """RGB-convert, resize longest dimension to target_size, return base64 PNG."""
-    img = to_pil_image(image)
-    if target_size:
-        w, h = img.size
-        if max(w, h) != target_size:
-            scale = target_size / max(w, h)
-            img = img.resize(
-                (max(1, int(w * scale)), max(1, int(h * scale))),
-                Image.Resampling.LANCZOS,
-            )
-    buf = io.BytesIO()
-    img.save(buf, format="PNG")
-    return base64.b64encode(buf.getvalue()).decode()
-
-
-def server_alive(server: str) -> bool:
-    try:
-        return requests.get(f"{server}/health", timeout=5).status_code == 200
-    except requests.RequestException:
-        return False
-
-
-def wait_for_server(server: str, timeout_s: int, proc: "subprocess.Popen | None" = None):
-    logger.info(f"Waiting for server at {server}...")
-    deadline = time.time() + timeout_s
-    while time.time() < deadline:
-        if server_alive(server):
-            logger.info("Server is ready")
-            return
-        if proc is not None and proc.poll() is not None:
-            logger.error(f"Spawned vllm serve exited with code {proc.returncode} before becoming ready")
-            sys.exit(1)
-        time.sleep(10)
-    logger.error(f"Server did not become ready within {timeout_s}s")
-    sys.exit(1)
-
-
-def ensure_server(server: str, timeout_s: int = 1800):
-    """Use a reachable server; otherwise spawn `vllm serve` ourselves; else fail fast.
-
-    Spawning is only attempted for a localhost URL — a remote --server that is
-    down is the user's to fix, not ours to shadow with a local model.
-    """
-    if server_alive(server):
-        logger.info(f"Using already-running server at {server}")
-        return
-
-    host = urlparse(server).hostname or ""
-    if host not in ("127.0.0.1", "localhost", "0.0.0.0"):
-        logger.info(f"Remote server {server} not up yet — waiting for it")
-        wait_for_server(server, timeout_s)
-        return
-
-    if shutil.which("vllm") is None:
-        logger.error("No server is running and the `vllm` binary is not on PATH.")
-        logger.error("Run this script on a vLLM image so it can start the server itself:\n")
-        logger.error(RUN_COMMAND)
-        logger.error("\n(or start `vllm serve` yourself / pass --server URL of a running endpoint)")
-        sys.exit(1)
-
-    logger.info(f"Starting server: {' '.join(SERVE_ARGS)}")
-    proc = subprocess.Popen(SERVE_ARGS)  # logs interleave with ours on stdout/stderr
-    atexit.register(proc.terminate)  # don't leave a GPU server behind on local runs
-    wait_for_server(server, timeout_s, proc=proc)
-
-
-def ocr_one(
-    server: str,
-    image,
-    target_size: int,
-    max_tokens: int,
-    temperature: float,
-    top_p: float,
-    timeout_s: int,
-    retries: int = 2,
-) -> str:
-    """OCR a single image via the chat completions API. Returns raw model text."""
-    b64 = encode_image(image, target_size)
-    payload = {
-        "model": MODEL,
-        "messages": [
-            {
-                "role": "user",
-                "content": [
-                    # Image ONLY — LightOnOCR-2 uses no text prompt.
-                    {
-                        "type": "image_url",
-                        "image_url": {"url": f"data:image/png;base64,{b64}"},
-                    },
-                ],
-            }
-        ],
-        "temperature": temperature,
-        "top_p": top_p,
-        "max_tokens": max_tokens,
-    }
-    last_err = None
-    for attempt in range(retries + 1):
-        try:
-            resp = requests.post(
-                f"{server}/v1/chat/completions", json=payload, timeout=timeout_s
-            )
-            resp.raise_for_status()
-            return resp.json()["choices"][0]["message"]["content"]
-        except Exception as e:
-            last_err = e
-            if attempt < retries:
-                time.sleep(10 * (attempt + 1))
-    raise RuntimeError(f"request failed after {retries + 1} attempts: {last_err}")
-
-
-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,
-    num_samples: int,
-    num_errors: int,
-    processing_time: str,
-    images_per_sec: float,
-    concurrency: int,
-    max_tokens: int,
-    temperature: float,
-    target_size: int,
-    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"; "" on CPU
-    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 ""
-
-    return f"""---
-tags:
-- ocr
-- document-processing
-- lighton-ocr
-- markdown
-- uv-script
-- generated{jobs_tag}
----
-
-# Document OCR using {model_name} (server mode)
-
-This dataset contains OCR results from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using LightOnOCR-2 (1B), served behind an in-job vLLM server with concurrent requests (continuous batching).
-
-## Processing Details
-
-- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
-- **Model**: [{model}](https://huggingface.co/{model})
-- **Number of Samples**: {num_samples:,}
-- **Failed Requests**: {num_errors:,} (marked `[OCR ERROR]`)
-- **Processing Time**: {processing_time}
-- **Throughput**: {images_per_sec:.2f} images/sec
-- **Processing Date**: {datetime.now().strftime("%Y-%m-%d %H:%M UTC")}
-
-### Configuration
-
-- **Mode**: vLLM server (`vllm serve`) + concurrent driver, {concurrency} concurrent requests
-- **Image Column**: `{image_column}`
-- **Dataset Split**: `{split}`
-- **Target Image Size**: {target_size}px (longest dimension)
-- **Max Output Tokens**: {max_tokens:,}
-- **Temperature**: {temperature}
-
-## Dataset Structure
-
-The dataset contains all original columns plus:
-- `markdown`: The extracted text in markdown format
-- `inference_info`: JSON list tracking all OCR models applied to this dataset
-
-## Reproduction
-
-{origin} with the [`lighton-ocr2-server.py`](https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr2-server.py) recipe from [uv-scripts](https://huggingface.co/uv-scripts) — see the script docstring for the single `hf jobs run` command that starts the server and driver together. The offline-vLLM sibling recipe is [`lighton-ocr2.py`](https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr2.py).
-"""
-
-
-def main(
-    input_dataset: str,
-    output_dataset: str,
-    image_column: str = "image",
-    server: str = "http://127.0.0.1:8000",
-    concurrency: int = 32,
-    max_tokens: int = 4096,
-    temperature: float = 0.2,
-    top_p: float = 0.9,
-    target_size: int = DEFAULT_TARGET_SIZE,
-    request_timeout: int = 1800,
-    hf_token: str = None,
-    split: str = "train",
-    max_samples: int = None,
-    private: bool = False,
-    shuffle: bool = False,
-    seed: int = 42,
-    output_column: str = "markdown",
-    overwrite: bool = False,
-    config: str = None,
-    create_pr: bool = False,
-):
-    """Process images from HF dataset through a LightOnOCR-2 vLLM server."""
-
-    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} via server {server}")
-
-    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}"
-        )
-
-    dataset = ensure_output_columns_free(dataset, [output_column], 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")
-
-    # Reuse a reachable server, else spawn `vllm serve` (needs the vllm binary,
-    # i.e. a vllm/vllm-openai image), else fail fast with the correct command.
-    ensure_server(server)
-
-    n = len(dataset)
-    logger.info(f"Processing {n} images, concurrency {concurrency}")
-    all_outputs = [None] * n
-    errors = 0
-    done = 0
-    inference_start = time.time()
-    lock = threading.Lock()
-
-    def worker(i: int) -> None:
-        nonlocal errors, done
-        try:
-            text = ocr_one(
-                server,
-                dataset[i][image_column],
-                target_size,
-                max_tokens,
-                temperature,
-                top_p,
-                request_timeout,
-            )
-            all_outputs[i] = text.strip()
-        except Exception as e:
-            logger.error(f"Image {i} failed: {e}")
-            all_outputs[i] = "[OCR ERROR]"
-            with lock:
-                errors += 1
-        with lock:
-            done += 1
-            if done % 25 == 0 or done == n:
-                rate = done / max(time.time() - inference_start, 1e-9)
-                logger.info(f"{done}/{n} done ({rate:.2f} img/s, {errors} errors)")
-
-    with concurrent.futures.ThreadPoolExecutor(max_workers=concurrency) as pool:
-        list(pool.map(worker, range(n)))
-
-    inference_secs = time.time() - inference_start
-    processing_duration = datetime.now() - start_time
-    processing_time_str = f"{processing_duration.total_seconds() / 60:.1f} min"
-    images_per_sec = n / inference_secs if inference_secs else 0.0
-
-    logger.info(f"Adding '{output_column}' column to dataset")
-    dataset = dataset.add_column(output_column, all_outputs)
-
-    # Inference info tracking
-    inference_entry = {
-        "model_id": MODEL,
-        "model_name": "LightOnOCR-2-1B",
-        "column_name": output_column,
-        "timestamp": datetime.now().isoformat(),
-        "temperature": temperature,
-        "top_p": top_p,
-        "max_tokens": max_tokens,
-        "target_size": target_size,
-        "mode": "vllm-server",
-        "concurrency": concurrency,
-    }
-
-    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"
-            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, server mode)"
-                + (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)
-
-    logger.info("Creating dataset card")
-    card_content = create_dataset_card(
-        source_dataset=input_dataset,
-        model=MODEL,
-        num_samples=len(dataset),
-        num_errors=errors,
-        processing_time=processing_time_str,
-        images_per_sec=images_per_sec,
-        concurrency=concurrency,
-        max_tokens=max_tokens,
-        temperature=temperature,
-        target_size=target_size,
-        image_column=image_column,
-        split=split,
-    )
-
-    card = DatasetCard(card_content)
-    card.push_to_hub(output_dataset, token=HF_TOKEN)
-
-    logger.info("Done! LightOnOCR-2 server-mode 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"Throughput: {images_per_sec:.2f} images/sec "
-        f"(inference only, excl. dataset load/push; {errors} errors)"
-    )
-
-
-if __name__ == "__main__":
-    if len(sys.argv) == 1:
-        print("=" * 70)
-        print("LightOnOCR-2 Document Processing (vLLM server mode)")
-        print("=" * 70)
-        print("\nSame model + outputs as lighton-ocr2.py, but drives an in-job")
-        print("`vllm serve` with concurrent requests — no batch barriers,")
-        print("per-image (not per-batch) failure isolation.")
-        print("\nThe server must already be running (the job command starts")
-        print("both — see the module docstring for the full `hf jobs run`).")
-        print("\nExamples:")
-        print("\n1. Basic OCR (server on localhost:8000):")
-        print("   uv run lighton-ocr2-server.py input-dataset output-dataset")
-        print("\n2. Test with a small sample:")
-        print("   uv run lighton-ocr2-server.py large-dataset test --max-samples 10 --shuffle")
-        print("\nFor full help: uv run lighton-ocr2-server.py --help")
-        sys.exit(0)
-
-    parser = argparse.ArgumentParser(
-        description="Document OCR using LightOnOCR-2 via an in-job vLLM server",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  uv run lighton-ocr2-server.py my-docs analyzed-docs
-  uv run lighton-ocr2-server.py large-dataset test --max-samples 50 --shuffle
-See the module docstring for the full `hf jobs run` command (server + driver in one job).
-        """,
-    )
-
-    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(
-        "--image-column",
-        default="image",
-        help="Column containing images (default: image)",
-    )
-    parser.add_argument(
-        "--server",
-        default="http://127.0.0.1:8000",
-        help="vLLM server base URL (default: in-job localhost:8000)",
-    )
-    parser.add_argument(
-        "--concurrency",
-        type=int,
-        default=32,
-        help="Concurrent OCR requests (default: 32; vLLM queues excess internally, "
-        "so this mainly needs to be high enough to keep continuous batching fed)",
-    )
-    parser.add_argument(
-        "--max-tokens",
-        type=int,
-        default=4096,
-        help="Maximum tokens to generate (default: 4096, the model card value)",
-    )
-    parser.add_argument(
-        "--temperature",
-        type=float,
-        default=0.2,
-        help="Sampling temperature (default: 0.2, the model card value)",
-    )
-    parser.add_argument(
-        "--top-p",
-        type=float,
-        default=0.9,
-        help="Top-p sampling (default: 0.9, the model card value)",
-    )
-    parser.add_argument(
-        "--target-size",
-        type=int,
-        default=DEFAULT_TARGET_SIZE,
-        help=f"Resize images so the longest dimension is this many pixels before upload "
-        f"(default: {DEFAULT_TARGET_SIZE}, the model's training resolution); 0 disables",
-    )
-    parser.add_argument(
-        "--request-timeout",
-        type=int,
-        default=1800,
-        help="Per-request timeout in seconds (default: 1800)",
-    )
-    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(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists in the input dataset "
-        "(default: error out to avoid clobbering an existing column).",
-    )
-
-    args = parser.parse_args()
-
-    main(
-        input_dataset=args.input_dataset,
-        output_dataset=args.output_dataset,
-        image_column=args.image_column,
-        server=args.server,
-        concurrency=args.concurrency,
-        max_tokens=args.max_tokens,
-        temperature=args.temperature,
-        top_p=args.top_p,
-        target_size=args.target_size,
-        request_timeout=args.request_timeout,
-        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,
-        overwrite=args.overwrite,
-        config=args.config,
-        create_pr=args.create_pr,
-    )

lighton-ocr2.py

@@ -1,28 +1,14 @@
 # /// script
 # requires-python = ">=3.11"
 # dependencies = [
-#     "datasets>=4.0.0,<5.1",  # 5.1 needs huggingface_hub>=1.31; the image ships an older 1.x on PYTHONPATH, which wins
+#     "datasets>=4.0.0",
 #     "huggingface-hub",
 #     "pillow",
+#     "vllm>=0.15.1",
 #     "tqdm",
 #     "toolz",
+#     "torch",
 # ]
-#
-# [tool.uv]
-# exclude-newer = "2026-10-01T00:00:00Z"  # frozen: resolve packages as on this date
-#
-# [tool.uv-scripts]
-# maintenance = "frozen"
-# frozen_on = "2026-11-06"
-# superseded_by = "lighton-ocr3.py"
-#
-# [tool.hf-jobs]
-# image = "vllm/vllm-openai@sha256:953d3a06d5e64ab582985cd7401289d3abf2a2c14ef2158e9a84313daeec77d7"  # v0.22.1
-# python = "/usr/bin/python3"
-# env = { PYTHONPATH = "/usr/local/lib/python3.12/dist-packages" }
-# flavor = "a10g-small"
-# timeout = "1h"
-# secrets = ["HF_TOKEN"]
 # ///
 
 """
@@ -32,20 +18,8 @@ LightOnOCR-2 is a compact 1B multilingual OCR model optimized for production spe
 Combines Pixtral ViT encoder with Qwen3 language model for efficient document parsing.
 Uses Reinforcement Learning with Verifiable Rewards (RLVR) for improved quality.
 
-Run on HF Jobs. vLLM and torch come from the vllm/vllm-openai:v0.22.1 image declared
-in the [tool.hf-jobs] header (`hf` CLI 1.32+), which also sets the hardware and the
-HF_TOKEN secret. The tag is pinned: unpinned vLLM 0.29/0.30 with current transformers
-fails to import LightOnOCR-2 (PixtralRotaryEmbedding). Pass --timeout for a long run:
-
-  hf jobs uv run --timeout 1h \\
-      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr2.py \\
-      <input-dataset> <output-dataset>
-
-To run on your own GPU, add the engine: `uv run --with vllm==0.22.1 lighton-ocr2.py ...`.
-
-Frozen on 2026-11-06 (superseded by lighton-ocr3.py): the image digest, the package
-resolution date and the model revision are pinned, and it gets fixes only when it breaks.
-See MAINTAINING.md in https://github.com/davanstrien/uv-scripts.
+NOTE: Requires vLLM nightly wheels for LightOnOCR-2 support. First run may take
+a few minutes to download and install dependencies.
 
 Features:
 - ⚡ Fastest: 42.8 pages/sec on H100 GPU (7× faster than v1)
@@ -59,7 +33,7 @@ Features:
 - 💪 Production-ready: Outperforms models 9× larger
 
 Model: lightonai/LightOnOCR-2-1B
-vLLM: vllm/vllm-openai:v0.22.1 image (see the header)
+vLLM: Requires vLLM nightly build
 Performance: 83.2 ± 0.9% on OlmOCR-Bench
 """
 
@@ -75,14 +49,10 @@ from datetime import datetime
 
 import torch
 from datasets import load_dataset
-from huggingface_hub import DatasetCard
+from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)
@@ -91,8 +61,6 @@ logger = logging.getLogger(__name__)
 
 # LightOnOCR-2 model (single variant)
 MODEL = "lightonai/LightOnOCR-2-1B"
-# Frozen: the revision tested on 2026-11-06 (main at that date).
-MODEL_REVISION = "be7c41313c30e940fe5571de59e5fabc779e00c8"
 
 
 def check_cuda_availability():
@@ -105,28 +73,6 @@ def check_cuda_availability():
         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 resize_image_to_target(image: Image.Image, target_size: int = 1540) -> Image.Image:
     """
     Resize image so longest dimension is target_size while maintaining aspect ratio.
@@ -336,7 +282,6 @@ def main(
     shuffle: bool = False,
     seed: int = 42,
     output_column: str = "markdown",
-    overwrite: bool = False,
     config: str = None,
     create_pr: bool = False,
     verbose: bool = False,
@@ -349,11 +294,10 @@ def main(
     # Track processing start time
     start_time = datetime.now()
 
-    # Set the env var instead of login(): the old huggingface_hub in this image
-    # raises KeyError on a Jobs token in login(). Hub calls read HF_TOKEN.
+    # Login to HF if token provided
     HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
     if HF_TOKEN:
-        os.environ["HF_TOKEN"] = HF_TOKEN
+        login(token=HF_TOKEN)
 
     logger.info(f"Using model: {MODEL}")
 
@@ -367,9 +311,6 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
-    # Fail fast if the output column would collide with an existing input column
-    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
-
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -385,9 +326,6 @@ def main(
     logger.info("This may take a few minutes on first run...")
     llm = LLM(
         model=MODEL,
-        revision=MODEL_REVISION,
-        code_revision=MODEL_REVISION,
-        tokenizer_revision=MODEL_REVISION,
         trust_remote_code=True,
         max_model_len=max_model_len,
         gpu_memory_utilization=gpu_memory_utilization,
@@ -562,8 +500,8 @@ if __name__ == "__main__":
         print("\n4. Original image size (no resize):")
         print("   uv run lighton-ocr2.py docs output --no-resize")
         print("\n5. Running on HF Jobs:")
-        print("   (image, hardware and HF_TOKEN come from the script's [tool.hf-jobs] header)")
-        print("   hf jobs uv run \\")
+        print("   hf jobs uv run --flavor l4x1 \\")
+        print("     -s HF_TOKEN \\")
         print(
             "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr2.py \\"
         )
@@ -616,12 +554,8 @@ Examples:
     parser.add_argument(
         "--max-model-len",
         type=int,
-        default=16384,
-        help=(
-            "Maximum model context length (default: 16384). A full page resized to "
-            "1540px is ~6k image tokens; with --max-tokens 4096 output that overflows "
-            "the old 8192 default at admission and vLLM rejects the request."
-        ),
+        default=8192,
+        help="Maximum model context length (default: 8192)",
     )
     parser.add_argument(
         "--max-tokens",
@@ -693,12 +627,6 @@ Examples:
         default="markdown",
         help="Column name for output text (default: markdown)",
     )
-    parser.add_argument(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists in the input dataset "
-        "(default: error out to avoid clobbering an existing column).",
-    )
     parser.add_argument(
         "--verbose",
         action="store_true",
@@ -726,7 +654,6 @@ Examples:
         shuffle=args.shuffle,
         seed=args.seed,
         output_column=args.output_column,
-        overwrite=args.overwrite,
         config=args.config,
         create_pr=args.create_pr,
         verbose=args.verbose,

lighton-ocr3-bucket.py

@@ -1,528 +0,0 @@
-# /// 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-saturate.py

@@ -1,475 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "saturate[hf]==0.3.0",
-#     "pillow>=10",
-#     # LightOn's official client, pinned to a commit (not on PyPI). Used for its page
-#     # resize, grounding parser 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"
-# flavor = "a10g-small"
-# timeout = "4h"
-# secrets = ["HF_TOKEN"]
-# ///
-"""
-Convert document images to markdown (or layout blocks) using LightOnOCR-3 via saturate.
-
-Same model, prompt modes, sampling and page preparation as `lighton-ocr3.py`, but the
-script starts `vllm serve` in the Job and the `saturate` library sends the pages to it:
-many pages in flight, resumable parquet output and durable error rows. Use this recipe
-for large runs.
-
-Run on HF Jobs. The script starts the server itself; its [tool.hf-jobs] header declares
-the image that provides `vllm`, the hardware and the HF_TOKEN secret (`hf` CLI 1.32+).
-Flags on the command line override the header:
-
-  hf jobs uv run --detach \\
-      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr3-saturate.py \\
-      <input-dataset> <output-dataset>
-
-Smoke test first with --max-samples 10. Layout blocks with labels and boxes:
-
-  hf jobs uv run --detach \\
-      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr3-saturate.py \\
-      <input-dataset> <output-dataset> --mode grounding
-
-Output: the output repo holds `data/part-*.parquet` with rows
-`{id, markdown, raw, finish_reason, layout_blocks, model, prompt_tokens, completion_tokens,
-error}` keyed by the input row id (`--id-column`, or `<repo>:<config>:<split>:<000000000>`
-by default). Read it with `saturate.read_output`, which keeps one row per id (a success
-over an earlier error). `datasets.load_dataset(<output>, data_dir="data")` returns every
-record, so after a --retry-errors run it also holds the old error rows: drop rows with an
-`error` before you join back to the input on id. Re-running the same command skips
-finished rows; --retry-errors re-admits failed ones.
-
-`finish_reason` = "length" marks a page that hit --max-tokens (long tables, or the model
-repeating a line). --repair-max-tokens N sends those pages once more, at the end of the
-run, with a cap of N tokens and temperature 0.1, and writes the results to `repair/`
-(`load_dataset(<output>, data_dir="repair")`); join on id and prefer the repair row where
-its finish_reason is "stop". A restarted run also repairs the pages that an earlier,
-interrupted run saved as truncated.
-
-Models (Apache-2.0):
-  lightonai/LightOnOCR-3-0.8B  (default)  85.5 olmOCR-Bench, 74.6 ParseBench
-  lightonai/LightOnOCR-3-4B               86.3 olmOCR-Bench, 75.1 ParseBench
-LightOnOCR-3-1B is not supported: it keeps the LightOnOCR-2 (Pixtral) architecture, and
-LightOn reports that transformers 5.17 (the version in the vLLM 0.30.0 image) breaks it.
-
-Upstream settings kept:
-- Serve flags: the LightOnOCR README's flags for the 0.8B and 4B (`--max-model-len 18000`,
-  thinking off, `--mm-processor-cache-gb 0`, `--no-enable-prefix-caching`,
-  `--limit-mm-per-prompt '{"image": 1}'`). vLLM 0.30.0, the version LightOn tests.
-- Prompt modes: plain sends the image alone; grounding adds the text "grounding". The card
-  says other instructions are out of distribution.
-- Sampling: the model card's vLLM example (temperature 0.2, top_p 0.9, max_tokens 4096).
-- Pages: downscaled to 2048 px on the longest edge with LightOn's own resize (never
-  upscaled), sent as PNG, as the official client does. The PNG uses a fast compression
-  level; PNG is lossless, so the server decodes the same pixels.
-- Escaped dollar delimiters are repaired (`\\$x\\$` -> `$x$`) as the client does; `raw`
-  keeps the model's text.
-
-Speed settings: pages are prepared in `--prepare-workers` threads (default: the CPU_CORES
-that HF Jobs sets), and saturate's adaptive window sets how many pages are in flight, up to
-a cap that fits the Job's memory (window_cap below). `--window N` pins it instead. The
-server also gets `--max-num-batched-tokens 16384`, and 4 API server processes on flavors
-with 12 or more CPU cores (see SERVING). Pass --serve-args "--api-server-count N" to choose.
-
-Measured speed, LightOnOCR-3-0.8B (2026-11-05, vLLM 0.30.0). 600 pages: 350 book pages from
-finebooks/bhl-impact-gt and 250 pages of typed industry documents, all fitted to 2048 px.
-Steady state, excluding the server start (about 4 min, also paid by lighton-ocr3.py):
-
-  flavor          pages/s   $ per 1,000 pages   lighton-ocr3.py (offline batches)
-  a10g-small        2.2         0.12                0.90 pages/s, $0.31
-  l4x1              1.6         0.14
-  a10g-large        2.7         0.15
-  a100-large        7.2         0.10                1.27 pages/s, $0.55
-  rtx-pro-6000     10.0         0.08
-
-The 4B on a100-large (one API server): 2.7 pages/s, $0.26 per 1,000 pages; on these book
-pages its character error rate was higher than the 0.8B's (0.10 mean, 0.023 median, one
-run), so check a sample before paying for it. The header's a10g-small is a good default
-for small and medium runs; for large runs add --flavor rtx-pro-6000 (or a100-large). In
-every run the outputs differed from lighton-ocr3.py's no more than two runs of this recipe
-differ from each other (sampling at temperature 0.2). The character error rate on the 282
-book pages with at least 20 characters of ground truth was 0.077 to 0.083 mean and 0.020
-median in every 0.8B run.
-
-Truncation and repair: 9 to 12 of the 600 pages stopped at max_tokens 4096 in each run,
-most of them typed tables. With --repair-max-tokens 12000, 8 of 12 such pages finished:
-3 in fewer than 4,096 tokens on the second try, and 5 long pages that needed 4,900 to
-6,100 tokens. The other 4 hit the cap again. The pass added 22% to the run's output
-tokens. With --repair-max-tokens 8192 (suggested), 5 of 9 such pages finished, the same 4
-hit the cap again, and the pass added 16%. Pages that hit the cap on both tries keep
-their first output in data/.
-
-The SERVING dict below is the per-model tuning prior. Agents can `ast.literal_eval` it
-without running the script; the script itself consumes it.
-"""
-
-import argparse
-import base64
-import hashlib
-import io
-import json
-import os
-import shlex
-import sys
-import tempfile
-
-# Serving starting values for LightOnOCR-3 (0.8B and 4B). Per-value provenance:
-# - image: vLLM 0.30.0, the version LightOn's client pins and tests (0.27.1 makes the
-#   models loop, per the LightOnOCR README).
-# - context 18000 and serve_args: the LightOnOCR README "Models" table for the 0.8B and 4B,
-#   plus its `--limit-mm-per-prompt '{"image": 1}'`.
-# - max_tokens/temperature/top_p: the model card's vLLM example, verbatim.
-# - longest_edge 2048: the card's rendering tip and the client's page size for these models.
-# - patch 32: 16 px patches with a 2x2 merge, so a 2048x2048 page is at most 64x64 = 4,096
-#   image tokens (used for the context check).
-# - --max-num-batched-tokens 16384: speed only. vLLM 0.30 serves with 2048 on A10G, L4 and
-#   A100 (8192 on other GPUs of 70 GB or more), less than one page's image tokens. Measured on a100-large:
-#   6.20 and 6.30 pages/s against 5.83 without it, outputs within the run-to-run noise.
-# - pages_per_gib: see window_cap().
-# - api_servers 4 when CPU_CORES >= 12: speed only. With one vLLM API server, a100-large and
-#   rtx-pro-6000 had 128-256 pages in flight but only 36-60 running in the engine and none
-#   waiting: the rest queued for image preprocessing in the API process. Measured, 4 API
-#   servers against one: a100-large 7.29 and 7.18 against 6.20 and 6.30 pages/s,
-#   rtx-pro-6000 10.0 against 9.15, a10g-large 2.74 against 2.49; outputs within the
-#   run-to-run noise. Small flavors (a10g-small 3 cores, l4x1 8) keep one, to leave CPU
-#   for page preparation.
-SERVING = {
-    "models": ["lightonai/LightOnOCR-3-0.8B", "lightonai/LightOnOCR-3-4B"],
-    "image": "vllm/vllm-openai:v0.30.0",
-    "context": 18000,
-    "serve_args": [
-        "--default-chat-template-kwargs", '{"enable_thinking": false}',
-        "--limit-mm-per-prompt", '{"image": 1}',
-        "--mm-processor-cache-gb", "0",
-        "--no-enable-prefix-caching",
-        "--max-num-batched-tokens", "16384",
-    ],
-    "pages_per_gib": 6,
-    "api_servers": 4,
-    "api_servers_min_cores": 12,
-    "max_tokens": 4096,
-    "temperature": 0.2,
-    "top_p": 0.9,
-    "repair_temperature": 0.1,
-    "longest_edge": 2048,
-    "patch": 32,
-}
-
-
-def window_cap() -> int:
-    """Most pages in flight that this machine's memory allows.
-
-    Every page in flight holds about 0.1 GiB of image data on the host (the client's copy and
-    the server's preprocessed image), on top of 7 to 9 GiB for the engine itself. On
-    a10g-small (14.9 GiB limit), 64 pages in flight reached the limit and the Job stopped
-    making progress; 32 peaked at 12.0 GiB, and up to 39 peaked at 13.0 and 14.8 GiB on two
-    runs. So the window may grow by SERVING "pages_per_gib" pages per GiB above 10 GiB: 29 on
-    a10g-small (which is GPU-bound from about 20 pages in flight), about 100 on l4x1, the full
-    512 on a100-large. The limit is read from the container (cgroup v2), then from the MEMORY
-    variable that HF Jobs sets.
-    """
-    limit_gib = None
-    try:
-        with open("/sys/fs/cgroup/memory.max") as handle:
-            value = handle.read().strip()
-        if value != "max":
-            limit_gib = int(value) / 2**30
-    except (OSError, ValueError):
-        pass
-    if limit_gib is None and os.environ.get("MEMORY"):
-        try:  # e.g. "16.0G" (decimal gigabytes)
-            limit_gib = float(os.environ["MEMORY"].upper().rstrip("GIB ")) * 1e9 / 2**30
-        except ValueError:
-            pass
-    if limit_gib is None:
-        return 512
-    return max(8, min(512, int((limit_gib - 10) * SERVING["pages_per_gib"])))
-
-
-def flag_value(tokens: list[str], name: str):
-    """Last value given for `name` in a `vllm serve` argument list (`--x v` or `--x=v`), else None."""
-    value = None
-    for index, token in enumerate(tokens):
-        if token == name and index + 1 < len(tokens):
-            value = tokens[index + 1]
-        elif token.startswith(name + "="):
-            value = token.split("=", 1)[1]
-    return value
-
-
-def saved_truncations(output_dataset: str) -> set:
-    """Ids whose saved result in data/ stopped at max_tokens and that have no saved repair.
-
-    A restarted run skips rows already in data/, so without this the pages truncated
-    before the restart would never reach the repair pass. Reads only three columns.
-    """
-    import fsspec
-    import pyarrow.parquet as pq
-
-    def records(subdir, columns):
-        fs, root = fsspec.core.url_to_fs(f"hf://datasets/{output_dataset}/{subdir}")
-        if not fs.exists(root):
-            return
-        for path in fs.glob(f"{root}/part-*.parquet"):
-            with fs.open(path, "rb") as handle:
-                yield from pq.read_table(handle, columns=columns).to_pylist()
-
-    finish = {}
-    for record in records("data", ["id", "error", "finish_reason"]):
-        if record["error"] is None:
-            finish[record["id"]] = record["finish_reason"]
-    repaired = {r["id"] for r in records("repair", ["id", "error"]) if r["error"] is None}
-    return {row_id for row_id, reason in finish.items() if reason == "length" and row_id not in repaired}
-
-
-def max_image_tokens(longest_edge: int) -> int:
-    """Upper bound on the image tokens of a page fitted to longest_edge (square page)."""
-    side = -(-longest_edge // SERVING["patch"])
-    return side * side
-
-
-def to_pil(value):
-    from PIL import Image
-
-    if isinstance(value, Image.Image):
-        return value
-    if isinstance(value, dict) and value.get("bytes"):
-        return Image.open(io.BytesIO(value["bytes"]))
-    if isinstance(value, dict) and value.get("path"):
-        return Image.open(value["path"])
-    if isinstance(value, (bytes, bytearray)):
-        return Image.open(io.BytesIO(value))
-    raise ValueError(f"unsupported image value: {type(value)}")
-
-
-def page_png(value, longest_edge: int) -> bytes:
-    """RGB page fitted to longest_edge with LightOn's resize, as PNG bytes.
-
-    compress_level=1 instead of Pillow's default 6: PNG is lossless at every level, so the
-    pixels are identical, and level 1 encodes several times faster (CPU is the limit on
-    small flavors).
-    """
-    from lightonocr import fit
-
-    image = fit(to_pil(value).convert("RGB"), longest_edge)
-    buffer = io.BytesIO()
-    image.save(buffer, format="PNG", compress_level=1)
-    return buffer.getvalue()
-
-
-def chat_request(model: str, png: bytes, mode: str, max_tokens: int, temperature: float, top_p: float) -> dict:
-    """One page as the client sends it: the image, plus the word "grounding" in grounding mode."""
-    from lightonocr import GROUNDING_PROMPT
-
-    url = "data:image/png;base64," + base64.b64encode(png).decode()
-    content = [{"type": "image_url", "image_url": {"url": url}}]
-    if mode == "grounding":
-        content.append({"type": "text", "text": GROUNDING_PROMPT})
-    return {
-        "model": model,
-        "messages": [{"role": "user", "content": content}],
-        "max_tokens": max_tokens,
-        "temperature": temperature,
-        "top_p": top_p,
-        "chat_template_kwargs": {"enable_thinking": False},
-    }
-
-
-def postprocess(raw: str, mode: str, fix_dollars: bool):
-    """Return (markdown, layout_blocks JSON or None) for one model output, as lighton-ocr3.py."""
-    from lightonocr import fix_escaped_dollars, parse_blocks, to_markdown
-
-    text = fix_escaped_dollars(raw) if fix_dollars else raw
-    if mode != "grounding":
-        return text, None
-    blocks = parse_blocks(text)
-    if not blocks:
-        return text, json.dumps([])  # no markers parsed: keep the text so nothing is lost
-    return to_markdown(blocks), json.dumps([b.to_dict() for b in blocks], ensure_ascii=False)
-
-
-def main():
-    ap = argparse.ArgumentParser(description="LightOnOCR-3 batch OCR via saturate")
-    ap.add_argument("input_dataset", help="Input dataset repo id (rows with an image column)")
-    ap.add_argument("output_dataset", help="Output dataset repo id (created private if missing)")
-    ap.add_argument("--model", default=SERVING["models"][0], choices=SERVING["models"])
-    ap.add_argument("--mode", default="plain", choices=["plain", "grounding"],
-                    help="plain = markdown; grounding = labelled layout blocks with 0-1000 boxes")
-    ap.add_argument("--image-column", default="image")
-    ap.add_argument("--config", default=None, help="Dataset config name")
-    ap.add_argument("--split", default="train")
-    ap.add_argument("--id-column", default=None,
-                    help="Column to use as row id (default: split-index ids)")
-    ap.add_argument("--max-samples", "--limit", dest="limit", type=int, default=None,
-                    help="Process only the first N rows (smoke test)")
-    ap.add_argument("--max-tokens", type=int, default=SERVING["max_tokens"],
-                    help="Output cap per page (default 4096, the model card's)")
-    ap.add_argument("--temperature", type=float, default=SERVING["temperature"])
-    ap.add_argument("--top-p", type=float, default=SERVING["top_p"],
-                    help="Default 0.9, the model card's; LightOn's client uses 1.0")
-    ap.add_argument("--longest-edge", type=int, default=SERVING["longest_edge"],
-                    help="Downscale pages to at most this many pixels on the longest edge")
-    ap.add_argument("--no-fix-dollars", action="store_true",
-                    help="Keep the model's text in `markdown` without repairing escaped dollars")
-    ap.add_argument("--repair-max-tokens", type=int, default=0,
-                    help="Re-send pages that hit --max-tokens once, with this cap and "
-                         "temperature 0.1, into repair/ (default 0: off; 8192 suggested)")
-    ap.add_argument("--window", default="auto",
-                    help="Pages in flight: 'auto' (saturate adapts it) or a fixed number")
-    ap.add_argument("--prepare-workers", type=int, default=None,
-                    help="Threads that decode, resize and encode pages (default: CPU_CORES)")
-    ap.add_argument("--serve-args", default="",
-                    help="Extra `vllm serve` flags, one quoted string, e.g. "
-                         "\"--max-num-batched-tokens 16384\"")
-    ap.add_argument("--retry-errors", action="store_true",
-                    help="Re-admit rows whose only record is an error row")
-    args = ap.parse_args()
-
-    user_serve_args = shlex.split(args.serve_args)
-    if args.longest_edge < 1:
-        ap.error("--longest-edge must be at least 1")
-    try:  # --serve-args may set its own --max-model-len; vLLM uses the last one given
-        context = int(flag_value(user_serve_args, "--max-model-len") or SERVING["context"])
-    except ValueError:
-        ap.error("--max-model-len in --serve-args must be a whole number of tokens")
-    room = context - max_image_tokens(args.longest_edge) - 64
-    for flag, value in (("--max-tokens", args.max_tokens), ("--repair-max-tokens", args.repair_max_tokens)):
-        if value > room:
-            ap.error(f"{flag} {value} can overflow the {context}-token context with a "
-                     f"{args.longest_edge} px page; use at most {room}")
-    if args.max_tokens < 1:
-        ap.error("--max-tokens must be at least 1")
-    if args.repair_max_tokens and args.repair_max_tokens <= args.max_tokens:
-        ap.error("--repair-max-tokens must be larger than --max-tokens")
-    if args.window != "auto" and not (args.window.isdigit() and int(args.window) >= 1):
-        ap.error("--window must be 'auto' or a number of at least 1")
-
-    import pyarrow as pa
-    from saturate import Auto, Engine, Fixed, dataset_rows, pump
-
-    if args.id_column is None:
-        ids = "index"
-    elif args.id_column in ("index", "content"):
-        # saturate reads these two names as id strategies, so a column with one of them
-        # needs a callable. It returns the raw value, so saturate still refuses a null id.
-        def ids(example):
-            return example[args.id_column]
-    else:
-        ids = args.id_column
-
-    rows = dataset_rows(
-        args.input_dataset, config=args.config, split=args.split,
-        columns=[args.image_column], ids=ids, limit=args.limit,
-    )
-
-    # Declared, so a part holding only error rows has the same columns as the rest
-    # (datasets.load_dataset reads every part with one schema).
-    schema = pa.schema([
-        ("id", pa.string()), ("error", pa.string()), ("markdown", pa.string()), ("raw", pa.string()),
-        ("finish_reason", pa.string()), ("layout_blocks", pa.string()), ("model", pa.string()),
-        ("prompt_tokens", pa.int64()), ("completion_tokens", pa.int64()),
-    ])  # fmt: skip
-
-    # Pages that hit --max-tokens, kept on local disk for the repair pass: those truncated
-    # in this run (stashed in parse) and those saved as truncated by an earlier, interrupted
-    # run (stashed as the stream passes them; the main pass skips them).
-    repair_dir = tempfile.mkdtemp(prefix="lighton-ocr3-repair-") if args.repair_max_tokens else None
-    earlier = saved_truncations(args.output_dataset) if repair_dir else set()
-    truncated = []
-
-    def stash(row_id, image):
-        path = os.path.join(repair_dir, hashlib.sha1(row_id.encode()).hexdigest() + ".png")
-        with open(path, "wb") as handle:
-            handle.write(page_png(image, args.longest_edge))
-        truncated.append((row_id, path))
-
-    def to_request(row):
-        png = page_png(row[args.image_column], args.longest_edge)
-        return chat_request(args.model, png, args.mode, args.max_tokens, args.temperature, args.top_p)
-
-    def make_parse(stash_truncated: bool):
-        def parse(row, body):
-            choice = body["choices"][0]
-            raw = (choice["message"].get("content") or "").strip()
-            markdown, blocks = postprocess(raw, args.mode, fix_dollars=not args.no_fix_dollars)
-            usage = body.get("usage") or {}
-            if stash_truncated and choice.get("finish_reason") == "length":
-                stash(row["__id"], row[args.image_column])
-            return {
-                "markdown": markdown,
-                "raw": raw,
-                "finish_reason": choice.get("finish_reason"),
-                "layout_blocks": blocks,
-                "model": args.model,
-                "prompt_tokens": usage.get("prompt_tokens"),
-                "completion_tokens": usage.get("completion_tokens"),
-            }
-        return parse
-
-    def with_ids(source):
-        # Keep each row's id on the row, so parse can name the page it stashes for repair.
-        for row_id, row in source:
-            if row_id in earlier:
-                stash(row_id, row[args.image_column])
-            yield row_id, {**row, "__id": row_id}
-
-    cap = window_cap()
-    if args.window == "auto":
-        window = Auto(initial=min(64, cap), max_limit=cap)
-        print(f"window: auto, at most {cap} pages in flight (host memory)", file=sys.stderr)
-    else:
-        window = Fixed(int(args.window))
-        if int(args.window) > cap:
-            print(f"warning: --window {args.window} is above the {cap} pages this machine's "
-                  "memory allows; the Job may run out of memory", file=sys.stderr)
-    cores = max(1, int(float(os.environ.get("CPU_CORES") or "4")))
-    workers = args.prepare_workers if args.prepare_workers is not None else cores
-    extra = [
-        "--max-model-len", str(SERVING["context"]),
-        *SERVING["serve_args"],
-        *user_serve_args,
-    ]
-    # Several API server processes share the image decoding and preprocessing, which one
-    # process cannot keep up with on a fast GPU. Only where there are cores to spare.
-    if cores >= SERVING["api_servers_min_cores"] and flag_value(extra, "--api-server-count") is None:
-        extra += ["--api-server-count", str(SERVING["api_servers"])]
-        print(f"server: --api-server-count {SERVING['api_servers']} ({cores} CPU cores)", file=sys.stderr)
-
-    output = f"hf://datasets/{args.output_dataset}/data"
-    with Engine(args.model, engine="vllm", extra_args=extra) as endpoint:
-        stats = pump(with_ids(rows) if repair_dir else rows, to_request, make_parse(bool(repair_dir)),
-                     endpoint, output, window=window, prepare_workers=workers,
-                     retry_errors=args.retry_errors, schema=schema)
-        print("LIGHTON_OCR3_SATURATE " + stats.to_json(), flush=True)
-
-        if repair_dir and truncated:
-            print(f"repair: re-sending {len(truncated)} pages that hit --max-tokens "
-                  f"with a cap of {args.repair_max_tokens}", file=sys.stderr, flush=True)
-
-            def repair_rows():
-                for row_id, path in truncated:
-                    with open(path, "rb") as handle:
-                        yield row_id, {"png": handle.read()}
-
-            def repair_request(row):
-                return chat_request(args.model, row["png"], args.mode, args.repair_max_tokens,
-                                    SERVING["repair_temperature"], args.top_p)
-
-            repair_stats = pump(repair_rows(), repair_request, make_parse(False), endpoint,
-                                f"hf://datasets/{args.output_dataset}/repair", window=window,
-                                retry_errors=args.retry_errors, schema=schema)
-            print("LIGHTON_OCR3_SATURATE_REPAIR " + repair_stats.to_json(), flush=True)
-
-    print(f"https://huggingface.co/datasets/{args.output_dataset} "
-          f"({stats.rows_processed} ok, {stats.rows_failed} error rows, "
-          f"{len(truncated) if repair_dir else 'n/a'} truncated pages re-sent to repair/)", file=sys.stderr)
-
-
-if __name__ == "__main__":
-    main()

lighton-ocr3.py

@@ -1,810 +0,0 @@
-# /// 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.
-
-For large runs use lighton-ocr3-saturate.py: same model, prompts and sampling, served by
-vLLM with many pages in flight (measured 2.4x the pages per second on a10g-small, 5.7x on
-a100-large), with resumable output.
-
-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,
-    )

minicpm-ocr.py

@@ -1,644 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "datasets>=3.1.0",
-#     "huggingface-hub>=1.0",
-#     "pillow",
-#     "bucketbag @ https://github.com/davanstrien/bucketbag/archive/refs/tags/v0.3.1.tar.gz",
-# ]
-#
-# [tool.hf-jobs]
-# image = "cr.hf.co/davanstrien/minicpm-ocr:1.0-vllm-5d35ce3"
-# flavor = "a10g-large"
-# timeout = "2h"
-# secrets = ["HF_TOKEN"]
-# ///
-
-"""
-Convert document images to markdown with OpenBMB's MiniCPM-OCR 1.0 pipeline.
-
-MiniCPM-OCR 1.0 (1.3B, Apache-2.0) is a region reader: the official SDK finds layout regions
-with PP-DocLayoutV3, crops them, sends each crop to the model with the prompt for its type
-(`Text Recognition:`, `Table Recognition:`, `Formula Recognition:`, ...) and assembles the page
-as Markdown (tables as HTML, formulas as LaTeX). This script runs that pipeline unchanged.
-
-Two ways in and out:
-
-  # Hub dataset -> Hub dataset (adds `markdown` and `markdown_status` columns)
-  hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/minicpm-ocr.py \\
-      input-dataset output-dataset --max-samples 20
-
-  # Bucket (or folder) of page images -> one .md per image in a Bucket (or folder)
-  hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/minicpm-ocr.py \\
-      hf://buckets/<ns>/<bucket>/pages hf://buckets/<ns>/<bucket>/minicpm-ocr
-
-Bucket input is listed and downloaded in batches with bucketbag (no mount); `x/y.jp2` becomes
-`x/y.md` under the output prefix. A page whose regions all read cleanly is written; a page with
-failed regions is not, and is listed at the end, so re-running the same command retries it (pages
-with a `.md` already are skipped). In dataset mode every row gets a `markdown_status`: `ok`,
-`partial_failed` (some regions failed; the text is kept), `failed` or `error: ...` (no text).
-
-Runtime image (from the [tool.hf-jobs] header): cr.hf.co/davanstrien/minicpm-ocr, built from
-images/minicpm-ocr/Dockerfile. It holds:
-- vLLM nightly 5d35ce3. MiniCPMOcrForConditionalGeneration landed in vLLM main on 23 Oct 2026
-  and is not in a release yet. Drop the custom image for a stock vllm/vllm-openai tag once a
-  release has the architecture.
-- transformers at OpenBMB's pin (549e5b4).
-- The minicpm-ocr SDK 1.0.1 in its own venv (/opt/sdk) with PaddlePaddle GPU, as OpenBMB's docs
-  require (SDK and inference service in separate environments), and the PP-DocLayoutV3 layout
-  model baked in at /opt/minicpm-ocr-assets.
-
-Server settings follow OpenBMB's SDK tutorial (docs/minicpmvocr_tutorial_en.md): max-model-len
-40960, 32 sequences, image limit 36, `downsample_mode` 4x, thinking off, DSpark speculative
-decoding with the matching draft model (`--no-dspark` for plain decoding). The SDK's bundled
-config sets sampling and per-region prompts; nothing here overrides them. The SDK reads page
-numbers, headers, footers, footnotes and side notes but leaves them out of the Markdown;
-`--keep-labels footnote aside_text` puts those region types back.
-
-Model: https://huggingface.co/openbmb/MiniCPM-OCR-1.0
-SDK: https://github.com/OpenBMB/MiniCPM-OCR
-Image: https://huggingface.co/containers/davanstrien/minicpm-ocr
-"""
-
-import argparse
-import contextlib
-import json
-import logging
-import os
-import shlex
-import shutil
-import signal
-import subprocess
-import sys
-import tempfile
-import time
-import urllib.request
-from datetime import datetime
-from pathlib import Path
-
-logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
-logger = logging.getLogger(__name__)
-
-SCRIPT_URL = "https://huggingface.co/datasets/uv-scripts/ocr/raw/main/minicpm-ocr.py"
-MODEL = "openbmb/MiniCPM-OCR-1.0"
-MODEL_REVISION = "a59a4acf215e34c6d73149e9eafdb88ed2086e39"
-DRAFT_MODEL = "openbmb/MiniCPM-OCR-1.0-DSpark"  # must come from the same release as MODEL
-DRAFT_REVISION = "31e3feaf80e0061cd6aa73db23480d2d691d6452"
-SERVED_NAME = "minicpm-ocr"
-PORT = 18499
-SDK_PYTHON = "/opt/sdk/bin/python"
-LAYOUT_MODEL_DIR = "/opt/minicpm-ocr-assets/models/PP-DocLayoutV3_infer"
-# minicpm-ocr SDK 1.0.1 markdown_assembly.ignore_labels: read by the model, left out of the Markdown
-SDK_IGNORED_LABELS = ["number", "footnote", "header", "footer", "aside_text"]
-IMAGE_TAG = "cr.hf.co/davanstrien/minicpm-ocr:1.0-vllm-5d35ce3"
-BUCKET_SCHEME = "hf://buckets/"
-IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".tif", ".tiff", ".bmp", ".webp", ".jp2"}
-
-# Runs inside the SDK venv: the SDK's documented Python API (docs/minicpmvocr_api_en.md),
-# with the bundled config and only the input, server and layout path filled in.
-SDK_RUNNER = """
-import json, sys
-from importlib.resources import files
-from pathlib import Path
-from minicpmvocr import load_config, pipelined_run
-from minicpmvocr.prompts import DEFAULT_PROMPT_MAP
-args = json.loads(sys.argv[1])
-prompt = {}
-if args["keep_labels"]:
-    # A prompt-map file replaces whole top-level sections, so write the full assembly section.
-    assembly = dict(DEFAULT_PROMPT_MAP["markdown_assembly"])
-    assembly["ignore_labels"] = [l for l in assembly["ignore_labels"] if l not in args["keep_labels"]]
-    prompt_map = Path(args["run_root"]) / "prompt_map.json"
-    prompt_map.parent.mkdir(parents=True, exist_ok=True)
-    prompt_map.write_text(json.dumps({"markdown_assembly": assembly}))
-    prompt = {"prompt_map": str(prompt_map)}
-cfg = load_config(str(files("minicpmvocr").joinpath("configs/minicpmvocr.yaml")), overrides={
-    "input": {"image_dir": args["image_dir"]},
-    "run": {"run_root": args["run_root"], "run_tag": args["run_tag"]},
-    "engine": {"server_url": args["server_url"], "model_name": args["model_name"], "max_model_len": 40960},
-    "layout": {"model_dir": args["layout_dir"], "device": "cuda:0"},
-    "pipeline": {"overlap_layout": True},
-    "prompt": prompt,
-})
-pipelined_run(cfg)
-print(json.dumps({"run_dir": cfg["_meta"]["run_dir"]}))
-"""
-
-
-def image_python() -> str | None:
-    """The image's own python3 (the one with vLLM and torch), looking past this script's venv."""
-    own_bin = os.path.realpath(os.path.join(sys.prefix, "bin"))
-    path = os.pathsep.join(p for p in os.environ.get("PATH", "").split(os.pathsep)
-                           if os.path.realpath(p) != own_bin)
-    return shutil.which("python3", path=path)
-
-
-def check_runtime():
-    """Fail fast, naming the fix, when not on the MiniCPM-OCR image or without a CUDA GPU."""
-    py = image_python()
-    if not (py and shutil.which("vllm") and Path(SDK_PYTHON).exists() and Path(LAYOUT_MODEL_DIR).exists()):
-        logger.error("This script needs the %s image (vLLM with MiniCPM-OCR support, the "
-                     "minicpm-ocr SDK and the layout model).", IMAGE_TAG)
-        logger.error("Run it with `hf jobs uv run`, which reads the image from the script header, "
-                     "or pass --image %s.", IMAGE_TAG)
-        sys.exit(1)
-    probe = subprocess.run([py, "-c", "import torch; print(torch.cuda.is_available())"],
-                           capture_output=True, text=True)
-    if probe.stdout.strip() != "True":
-        logger.error("CUDA is not available to the image's torch. This script needs a GPU "
-                     "(e.g. --flavor a10g-large). %s", probe.stderr.strip()[-300:])
-        sys.exit(1)
-
-
-@contextlib.contextmanager
-def vllm_server(dspark: bool):
-    """Run vLLM with OpenBMB's tutorial settings for the duration of the block.
-
-    The server gets its own process group, and is terminated, then killed, then reaped, on every
-    exit path, including a failed or interrupted startup.
-    """
-    from huggingface_hub import snapshot_download
-
-    model_dir = snapshot_download(MODEL, revision=MODEL_REVISION)
-    cmd = [
-        "vllm", "serve", model_dir, "--served-model-name", SERVED_NAME,
-        "--host", "127.0.0.1", "--port", str(PORT),
-        "--max-model-len", "40960", "--max-num-batched-tokens", "40960", "--max-num-seqs", "32",
-        "--limit-mm-per-prompt", '{"image":36,"video":0}',
-        "--mm-processor-kwargs", '{"downsample_mode":"4x"}',
-        "--gpu-memory-utilization", "0.85", "--trust-request-mm-kwargs",
-        "--default-chat-template-kwargs", '{"enable_thinking":false}',
-    ]
-    if dspark:
-        draft_dir = snapshot_download(DRAFT_MODEL, revision=DRAFT_REVISION)
-        cmd += ["--speculative-config", json.dumps({
-            "method": "dspark", "model": draft_dir, "num_speculative_tokens": 15,
-            "enable_adaptive_verification": False})]
-    # This script's VIRTUAL_ENV must not leak into the image's vLLM.
-    env = {k: v for k, v in os.environ.items() if k != "VIRTUAL_ENV"}
-    logger.info("Starting vLLM: %s", shlex.join(cmd))
-    proc = subprocess.Popen(cmd, env=env, start_new_session=True)
-    try:
-        deadline = time.time() + 1800
-        while True:
-            if proc.poll() is not None:
-                sys.exit(f"vLLM exited during startup (code {proc.returncode})")
-            try:
-                with urllib.request.urlopen(f"http://127.0.0.1:{PORT}/v1/models", timeout=5) as r:
-                    if SERVED_NAME in r.read().decode():
-                        break
-            except OSError:
-                pass
-            if time.time() > deadline:
-                sys.exit("vLLM did not become ready within 30 minutes")
-            time.sleep(5)
-        logger.info("vLLM ready")
-        yield
-    finally:
-        stop_process_group(proc)
-
-
-def group_alive(pgid: int) -> bool:
-    try:
-        os.killpg(pgid, 0)
-        return True
-    except (ProcessLookupError, PermissionError):
-        return False
-
-
-def stop_process_group(proc: subprocess.Popen):
-    """SIGTERM the whole group, wait up to 60 s for it to empty, then SIGKILL; always reap the
-    parent. Checks the group, not just the parent, since vLLM's workers can outlive it."""
-    pgid = proc.pid  # start_new_session=True: the server leads its own group
-    for sig, wait in ((signal.SIGTERM, 60), (signal.SIGKILL, 30)):
-        if not group_alive(pgid):
-            break
-        with contextlib.suppress(ProcessLookupError):
-            os.killpg(pgid, sig)
-        deadline = time.time() + wait
-        while group_alive(pgid) and time.time() < deadline:
-            with contextlib.suppress(subprocess.TimeoutExpired):
-                proc.wait(timeout=1)
-    with contextlib.suppress(subprocess.TimeoutExpired):
-        proc.wait(timeout=5)
-
-
-def parse_batch(images: dict, work: Path, tag: str, keep_labels: list[str]) -> dict:
-    """OCR one batch of pages with the SDK.
-
-    `images` maps a key to a PIL image, a path, or an undecoded datasets image dict. Returns
-    key -> (status, markdown or None). A page that cannot be read gets an `error: ...` status and
-    does not stop the batch; if the SDK run itself fails, every page in the batch gets one.
-    """
-    from datasets import Image as ImageFeature
-    from PIL import Image, ImageOps
-
-    decoder = ImageFeature()
-    image_dir = work / tag / "images"
-    image_dir.mkdir(parents=True)
-    results, ids = {}, {}
-    for i, (key, source) in enumerate(images.items()):
-        try:
-            if isinstance(source, dict):
-                # datasets Image(decode=False): {"bytes", "path"}. The datasets decoder handles
-                # remote paths and auth, and turns EXIF-rotated photos upright.
-                img = decoder.decode_example(source)
-            else:
-                img = source if isinstance(source, Image.Image) else Image.open(source)
-                img = ImageOps.exif_transpose(img)
-            img.convert("RGB").save(image_dir / f"{i:06d}.png")
-            ids[f"{i:06d}"] = key
-        except Exception as e:  # one unreadable page must not lose the batch
-            logger.warning("Cannot read %s: %s", key, e)
-            results[key] = (f"error: unreadable image ({type(e).__name__})", None)
-    if ids:
-        args = {"image_dir": str(image_dir), "run_root": str(work / tag / "runs"), "run_tag": tag,
-                "server_url": f"http://127.0.0.1:{PORT}", "model_name": SERVED_NAME,
-                "layout_dir": LAYOUT_MODEL_DIR, "keep_labels": keep_labels}
-        run = subprocess.run([SDK_PYTHON, "-c", SDK_RUNNER, json.dumps(args)],
-                             capture_output=True, text=True)
-        if run.returncode != 0:
-            logger.error("SDK run failed for %s (exit %d):\n%s", tag, run.returncode, run.stderr[-3000:])
-            results.update({key: (f"error: SDK exit {run.returncode}", None) for key in ids.values()})
-        else:
-            run_dir = Path(json.loads(run.stdout.strip().splitlines()[-1])["run_dir"])
-            status = {}
-            metrics = run_dir / "per_page_metrics.jsonl"
-            if metrics.exists():
-                for line in metrics.read_text(encoding="utf-8").splitlines():
-                    row = json.loads(line)
-                    status[row["image_id"]] = row.get("status") or "unknown"
-            for image_id, key in ids.items():
-                md = run_dir / "output" / f"{image_id}.md"
-                page_status = status.get(image_id, "failed" if not md.exists() else "unknown")
-                text = md.read_text(encoding="utf-8").strip() if md.exists() else None
-                results[key] = (page_status, text if page_status in ("ok", "partial_failed") else None)
-    shutil.rmtree(work / tag, ignore_errors=True)
-    return results
-
-
-# --- Bucket / folder mode ------------------------------------------------------------------
-
-
-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 "/").
-
-    The prefix goes to bucketbag explicitly: it matches prefixes as strings, so `.../vol`
-    would also list `.../vol2/...`.
-    """
-    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 md_rel(rel: str) -> str:
-    return str(Path(rel).with_suffix(".md"))
-
-
-def list_rels(location: str) -> list[str]:
-    """Relative paths of every file under a bucket prefix or folder, sorted."""
-    if is_bucket(location):
-        from bucketbag import iter_keys
-
-        url, prefix = as_bucket_dir(location)
-        return sorted(k[len(prefix):] for k in iter_keys(url, prefix=prefix))
-    root = Path(location)
-    return sorted(str(p.relative_to(root)) for p in root.rglob("*") if p.is_file()) if root.is_dir() else []
-
-
-def iter_local_batches(source: str, rels: list[str], n: int):
-    """Yield batches of (rel, local path): from disk, or downloaded by bucketbag to scratch."""
-    if not is_bucket(source):
-        for i in range(0, len(rels), n):
-            yield [(rel, Path(source) / rel) for rel in rels[i: i + n]]
-        return
-    from bucketbag import batched_files
-
-    url, prefix = as_bucket_dir(source)
-    for batch in batched_files(url, keys=[prefix + rel for rel in rels], n=n, prefetch=2):
-        yield [(item.key[len(prefix):], item.path) for item in batch]
-
-
-def write_outputs(dest: str, pairs: list[tuple[str, str]]):
-    if not pairs:
-        return
-    if is_bucket(dest):
-        from bucketbag import put_files
-
-        url, prefix = as_bucket_dir(dest)
-        put_files([(prefix + rel, content) for rel, content in pairs], url)
-        return
-    for rel, content in pairs:
-        # Temp file + rename: a stopped job never leaves a partial .md that a re-run counts 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 run_files(args):
-    inputs = [r for r in list_rels(args.input) if Path(r).suffix.lower() in IMAGE_EXTENSIONS]
-    owners: dict[str, list[str]] = {}
-    for rel in inputs:
-        owners.setdefault(md_rel(rel), []).append(rel)
-    clashes = [" + ".join(group) for group in owners.values() if len(group) > 1]
-    if clashes:
-        sys.exit("These inputs would write the same .md file; rename or move them first:\n  "
-                 + "\n  ".join(clashes))
-    if args.max_samples:
-        inputs = inputs[: args.max_samples]  # the same pages on every run, so a re-run resumes them
-    done = {r for r in list_rels(args.output) if r.endswith(".md")}
-    todo = [r for r in inputs if args.overwrite or md_rel(r) not in done]
-    already = sum(md_rel(r) in done for r in inputs)
-    logger.info("%d images under %s, %d already have a .md, %d to OCR", len(inputs), args.input,
-                already, len(todo))
-    if not todo:
-        return
-    failed = []
-    with vllm_server(dspark=not args.no_dspark), tempfile.TemporaryDirectory() as work:
-        for b, batch in enumerate(iter_local_batches(args.input, todo, args.batch_size)):
-            results = parse_batch(dict(batch), Path(work), f"batch{b:06d}", args.keep_labels)
-            write_outputs(args.output, [(md_rel(rel), text) for rel, (status, text) in results.items()
-                                        if status == "ok"])
-            failed += [f"{rel} ({status})" for rel, (status, _) in results.items() if status != "ok"]
-            logger.info("%d/%d images", min((b + 1) * args.batch_size, len(todo)), len(todo))
-    if failed:
-        logger.warning("%d pages not written (re-run the same command to retry them):\n  %s",
-                       len(failed), "\n  ".join(failed))
-        stale = [f for f in failed if md_rel(f.rsplit(" (", 1)[0]) in done]
-        if args.overwrite and stale:
-            logger.warning("%d of them still have a .md from an earlier run, which a re-run without "
-                           "--overwrite will skip; delete those files to retry them:\n  %s",
-                           len(stale), "\n  ".join(stale))
-
-
-# --- Dataset mode ----------------------------------------------------------------------------
-
-
-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(args, num_samples: int, counts: dict, processing_time: str) -> str:
-    # 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()
-    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 ""
-    status_col = f"{args.output_column}_status"
-    flags = [f"--flavor {hw or 'a10g-large'}"]
-    for flag, value, default in (("--split", args.split, "train"), ("--image-column", args.image_column, "image"),
-                                 ("--output-column", args.output_column, "markdown"),
-                                 ("--batch-size", args.batch_size, 64)):
-        if value != default:
-            flags.append(f"{flag} {shlex.quote(str(value))}")
-    if args.max_samples:
-        flags.append(f"--max-samples {args.max_samples}")
-    if args.shuffle:
-        flags.append(f"--shuffle --seed {args.seed}")
-    if args.no_dspark:
-        flags.append("--no-dspark")
-    if args.keep_labels:
-        flags.append("--keep-labels " + " ".join(args.keep_labels))
-    if args.overwrite:
-        flags.append("--overwrite")
-    command = f"hf jobs uv run {' '.join(flags[:1])} \\\n    {SCRIPT_URL} \\\n    {args.input} <output-dataset>"
-    if flags[1:]:
-        command += " \\\n    " + " ".join(flags[1:])
-    counts_line = ", ".join(f"`{k}` {v:,}" for k, v in sorted(counts.items()))
-    return f"""---
-tags:
-- ocr
-- document-processing
-- minicpm-ocr
-- markdown
-- uv-script
-- generated{jobs_tag}
----
-
-# Document OCR using MiniCPM-OCR 1.0
-
-OCR of [{args.input}](https://huggingface.co/datasets/{args.input}) with OpenBMB's
-[MiniCPM-OCR 1.0](https://huggingface.co/{MODEL}) pipeline: PP-DocLayoutV3 layout regions, each
-region read by the model, assembled into Markdown by the official SDK.
-
-## Processing Details
-
-- **Source Dataset**: [{args.input}](https://huggingface.co/datasets/{args.input}) (split `{args.split}`, column `{args.image_column}`)
-- **Model**: [{MODEL}](https://huggingface.co/{MODEL}) @ `{MODEL_REVISION[:7]}`
-- **Decoding**: {"standard" if args.no_dspark else "DSpark speculative decoding"}
-- **Region types left out of the Markdown**: {", ".join(f"`{l}`" for l in SDK_IGNORED_LABELS if l not in args.keep_labels) or "none"}
-- **Number of Samples**: {num_samples:,}
-- **Page status**: {counts_line}
-- **Processing Time**: {processing_time}
-- **Processing Date**: {datetime.now().strftime("%Y-%m-%d %H:%M UTC")}
-
-## Columns
-
-- `{args.output_column}`: the SDK's Markdown for each page (tables as HTML, formulas as LaTeX); empty when
-  the page failed
-- `{status_col}`: `ok`, `partial_failed` (some regions failed; text kept), `failed` or `error: ...`
-- `inference_info`: JSON list tracking all OCR models applied to this dataset
-
-## Reproduction
-
-{origin} with the [`minicpm-ocr.py`]({SCRIPT_URL}) recipe from [uv-scripts](https://huggingface.co/uv-scripts). Run it yourself:
-
-```bash
-{command}
-```
-"""
-
-
-def run_dataset(args):
-    from datasets import load_dataset
-    from huggingface_hub import DatasetCard
-
-    status_col = f"{args.output_column}_status"
-    reserved = {"inference_info", args.image_column}
-    if args.output_column in reserved or status_col in reserved:
-        sys.exit(f"--output-column {args.output_column!r} clashes with {sorted(reserved)}; pick another name")
-
-    dataset = load_dataset(args.input, split=args.split)
-    if args.shuffle:
-        dataset = dataset.shuffle(seed=args.seed)
-    if args.max_samples:
-        dataset = dataset.select(range(min(args.max_samples, len(dataset))))
-    # Undecoded: a corrupt image then fails inside parse_batch's per-page guard, not in the slice.
-    from datasets import Image as ImageFeature
-
-    dataset = dataset.cast_column(args.image_column, ImageFeature(decode=False))
-    clash = [c for c in (args.output_column, status_col) if c in dataset.column_names]
-    if clash and not args.overwrite:
-        sys.exit(f"Output column(s) {clash} already exist; choose another --output-column or pass --overwrite")
-    if clash:
-        logger.warning("--overwrite: replacing existing column(s) %s", clash)
-        dataset = dataset.remove_columns(clash)
-    logger.info("%d pages from %s", len(dataset), args.input)
-
-    # Slice only the image column: slicing the full dataset would decode every other image
-    # column too, outside the per-page guard.
-    image_only = dataset.select_columns([args.image_column])
-    start = datetime.now()
-    texts, statuses = [], []
-    with vllm_server(dspark=not args.no_dspark), tempfile.TemporaryDirectory() as work:
-        for b in range(0, len(dataset), args.batch_size):
-            images = image_only[b: b + args.batch_size][args.image_column]
-            results = parse_batch(dict(enumerate(images)), Path(work), f"batch{b:08d}", args.keep_labels)
-            for i in range(len(images)):
-                status, text = results[i]
-                statuses.append(status)
-                texts.append(text or "")
-            logger.info("%d/%d pages", len(texts), len(dataset))
-    elapsed = datetime.now() - start
-
-    counts = {}
-    for s in statuses:
-        key = "error" if s.startswith("error") else s
-        counts[key] = counts.get(key, 0) + 1
-    logger.info("Page status: %s", counts)
-
-    dataset = dataset.cast_column(args.image_column, ImageFeature())
-    dataset = dataset.add_column(args.output_column, texts).add_column(status_col, statuses)
-    entry = {"model_id": MODEL, "model_name": "MiniCPM-OCR-1.0", "column_name": args.output_column,
-             "timestamp": datetime.now().isoformat(), "model_revision": MODEL_REVISION,
-             "pipeline": "minicpm-ocr SDK 1.0.1 (PP-DocLayoutV3)", "dspark": not args.no_dspark,
-             "keep_labels": args.keep_labels}
-    if "inference_info" in dataset.column_names:
-        def update(example):
-            try:
-                info = json.loads(example["inference_info"]) if example["inference_info"] else []
-            except (json.JSONDecodeError, TypeError):
-                info = []
-            return {"inference_info": json.dumps(info + [entry])}
-        dataset = dataset.map(update)
-    else:
-        dataset = dataset.add_column("inference_info", [json.dumps([entry])] * len(dataset))
-
-    dataset.push_to_hub(args.output, private=args.private)
-    card = create_dataset_card(args, len(dataset), counts, f"{elapsed.total_seconds() / 60:.1f} min")
-    DatasetCard(card).push_to_hub(args.output)
-    logger.info("Done: https://huggingface.co/datasets/%s (%.2f pages/s including startup)",
-                args.output, len(dataset) / elapsed.total_seconds())
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Document OCR with the MiniCPM-OCR 1.0 pipeline",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="Input/output: Hub dataset IDs (dataset mode), or hf://buckets/<ns>/<bucket>[/<prefix>] "
-               "URLs / folders (one .md per image).")
-    parser.add_argument("input", help="Hub dataset ID, or hf://buckets/... URL or folder of page images")
-    parser.add_argument("output", help="Hub dataset ID (dataset input), or hf://buckets/... URL or folder")
-    parser.add_argument("--image-column", default="image", help="Dataset mode: image column")
-    parser.add_argument("--output-column", default="markdown", help="Dataset mode: output column")
-    parser.add_argument("--split", default="train", help="Dataset mode: split")
-    parser.add_argument("--max-samples", type=int, help="Process only the first N pages (for testing)")
-    parser.add_argument("--shuffle", action="store_true", help="Dataset mode: shuffle before --max-samples")
-    parser.add_argument("--seed", type=int, default=42)
-    parser.add_argument("--batch-size", type=int, default=64,
-                        help="Pages handed to the SDK per run (it parallelises regions inside a run)")
-    parser.add_argument("--no-dspark", action="store_true", help="Standard decoding, no draft model")
-    parser.add_argument("--keep-labels", nargs="+", default=[], choices=SDK_IGNORED_LABELS,
-                        help="Region types to keep in the Markdown that the SDK leaves out by default")
-    parser.add_argument("--private", action="store_true", help="Dataset mode: private output dataset")
-    parser.add_argument("--overwrite", action="store_true",
-                        help="Replace an existing output column / re-OCR images that already have a .md")
-    parser.add_argument("--hf-token", help="Hugging Face token (default: HF_TOKEN env var)")
-    args = parser.parse_args()
-
-    if args.hf_token:
-        os.environ["HF_TOKEN"] = args.hf_token
-    if args.max_samples is not None and args.max_samples < 1:
-        sys.exit("--max-samples must be at least 1")
-    if args.batch_size < 1:
-        sys.exit("--batch-size must be at least 1")
-    # The input decides the mode: a Bucket or an existing folder means files, anything else is a
-    # Hub dataset ID. In file mode the output is a Bucket URL or a folder (created if new).
-    file_in = is_bucket(args.input) or Path(args.input).is_dir()
-    if not file_in and (is_bucket(args.output) or Path(args.output).is_dir()):
-        sys.exit("Dataset input writes a Hub dataset; for Bucket output, give a Bucket or folder as input.")
-    check_runtime()
-    if file_in:
-        run_files(args)
-    else:
-        run_dataset(args)
-
-
-if __name__ == "__main__":
-    main()

models.json

@@ -1,1116 +0,0 @@
-{
-  "_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-11-06",
-    "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`.",
-      "tool": "Maintained companion (judge, layout, text extraction), not a page-OCR recipe.",
-      "legacy": "Works (smoke-tested 2026-09-23) but superseded or little used; no header yet. See support_note for the alternative.",
-      "unsupported": "Known broken as of 2026-09-23; kept in the repo for now. See support_note.",
-      "experimental": "Works in testing on HF Jobs with the launch config in `jobs`, but changes often and may break. See support_note for the stable alternative."
-    }
-  },
-  "tesseract-ocr.py": {
-    "model_id": null,
-    "model_name": "Tesseract 5",
-    "params": null,
-    "backend": "pytesseract (CPU)",
-    "task": "ocr",
-    "output": "plain text",
-    "license": "apache-2.0",
-    "languages": {
-      "evidence": "named-list",
-      "count": "125 traineddata packs (~100+ languages + script models)",
-      "list_url": "https://github.com/tesseract-ocr/tessdata_best",
-      "notes": "Broadest named coverage; script models (Latin, Cyrillic, Devanagari, ...) cover languages without a dedicated pack. Legacy baseline quality."
-    },
-    "support": "core",
-    "jobs": {
-      "flavor": "cpu-upgrade",
-      "secrets": [
-        "HF_TOKEN"
-      ]
-    }
-  },
-  "pp-ocrv6.py": {
-    "model_id": "PaddlePaddle/PP-OCRv6",
-    "params": "1.5M-34.5M",
-    "backend": "paddleocr",
-    "task": "ocr",
-    "output": "plain text",
-    "license": "apache-2.0",
-    "languages": {
-      "evidence": "count-claim",
-      "count": 48
-    },
-    "support": "core",
-    "jobs": {
-      "flavor": "t4-small",
-      "secrets": [
-        "HF_TOKEN"
-      ]
-    }
-  },
-  "falcon-ocr.py": {
-    "model_id": "tiiuae/Falcon-OCR",
-    "params": "0.3B",
-    "backend": "falcon-perception",
-    "task": "ocr",
-    "output": "markdown",
-    "license": "apache-2.0",
-    "languages": {
-      "evidence": "not-stated"
-    },
-    "support": "legacy",
-    "support_note": "Falcon-OCR v1; v1.5 work is in PR #110."
-  },
-  "smoldocling-ocr.py": {
-    "model_id": "ds4sd/SmolDocling-256M-preview",
-    "params": "256M",
-    "backend": "transformers",
-    "task": "ocr",
-    "output": "DocTags",
-    "languages": {
-      "evidence": "english-only"
-    },
-    "support": "unsupported",
-    "support_note": "Broken (2026-09-23): the DocTags-to-markdown converter is a stub, so rows are raw DocTags."
-  },
-  "surya-ocr.py": {
-    "model_id": "datalab-to/surya-ocr-2",
-    "params": "0.65B",
-    "backend": "vllm",
-    "image": "vllm/vllm-openai:v0.20.1",
-    "task": "ocr | layout | table",
-    "output": "markdown + surya_blocks (per-block HTML, bboxes, reading order)",
-    "license": "modified OpenRAIL-M",
-    "languages": {
-      "evidence": "per-language-benchmark",
-      "count": 91,
-      "benchmark_url": "https://github.com/datalab-to/surya/blob/master/static/docs/multilingual.md",
-      "notes": "38/91 languages score >=90%, 76/91 >=80%; weakest of top-15: Arabic 72.7%, Vietnamese 73.2%."
-    },
-    "support": "core",
-    "jobs": {
-      "image": "vllm/vllm-openai:v0.20.1",
-      "python": "/usr/local/bin/python3",
-      "env": {
-        "PYTHONPATH": "/usr/local/lib/python3.12/site-packages"
-      },
-      "flavor": "a10g-small",
-      "secrets": [
-        "HF_TOKEN"
-      ]
-    }
-  },
-  "glm-ocr.py": {
-    "model_id": "zai-org/GLM-OCR",
-    "params": "0.9B",
-    "backend": "vllm",
-    "task": "ocr",
-    "output": "markdown",
-    "languages": {
-      "evidence": "named-list",
-      "count": 8,
-      "named": [
-        "zh",
-        "en",
-        "fr",
-        "es",
-        "ru",
-        "de",
-        "ja",
-        "ko"
-      ],
-      "notes": "Declared in card metadata only; no per-language evidence in the card body."
-    },
-    "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"
-  },
-  "paddleocr-vl.py": {
-    "model_id": "PaddlePaddle/PaddleOCR-VL",
-    "params": "0.9B",
-    "backend": "vllm",
-    "task": "ocr | table | formula | chart",
-    "output": "markdown",
-    "languages": {
-      "evidence": "count-claim",
-      "count": 109,
-      "notes": "Names scripts (Cyrillic, Arabic, Devanagari, Thai); claims handwriting + historical documents; no per-language numbers."
-    },
-    "support": "legacy",
-    "support_note": "PaddleOCR-VL 1.0; use paddleocr-vl-1.6.py."
-  },
-  "paddleocr-vl-1.5.py": {
-    "model_id": "PaddlePaddle/PaddleOCR-VL-1.5",
-    "params": "0.9B",
-    "backend": "transformers",
-    "task": "ocr (6 modes)",
-    "output": "markdown",
-    "languages": {
-      "evidence": "count-claim",
-      "count": "109+ (adds Tibetan, Bengali)",
-      "notes": "Claims improved rare-character and ancient-text recognition."
-    },
-    "support": "unsupported",
-    "support_note": "Broken (2026-09-23): every row is an [OCR ERROR] ('min_pixels' attribute removed in transformers 5). Use paddleocr-vl-1.6.py."
-  },
-  "paddleocr-vl-1.6.py": {
-    "model_id": "PaddlePaddle/PaddleOCR-VL-1.6",
-    "params": "0.9B",
-    "backend": "vllm",
-    "task": "ocr",
-    "output": "markdown",
-    "languages": {
-      "evidence": "count-claim",
-      "count": "109+ (inherited from 1.5, not restated)",
-      "notes": "Upgrade-focused card; language-specific claims are Chinese ancient documents and rare characters."
-    },
-    "support": "core",
-    "jobs": {
-      "image": "vllm/vllm-openai:v0.29.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.29.0"
-  },
-  "ovis-ocr2.py": {
-    "model_id": "ATH-MaaS/OvisOCR2",
-    "params": "0.9B",
-    "backend": "vllm",
-    "task": "ocr",
-    "output": "markdown + LaTeX + HTML tables",
-    "license": "apache-2.0",
-    "languages": {
-      "evidence": "not-stated"
-    },
-    "support": "core",
-    "jobs": {
-      "image": "vllm/vllm-openai:v0.29.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.29.0"
-  },
-  "ovis-ocr2-server.py": {
-    "model_id": "ATH-MaaS/OvisOCR2",
-    "params": "0.9B",
-    "backend": "vllm-server (in-job vllm serve + concurrent driver)",
-    "image": "vllm/vllm-openai:v0.22.1",
-    "task": "ocr",
-    "output": "markdown + LaTeX + HTML tables",
-    "license": "apache-2.0",
-    "notes": "Server-mode sibling of ovis-ocr2.py: ~1.7x its inference throughput, per-request failure isolation. See SERVING.md.",
-    "languages": {
-      "evidence": "not-stated"
-    },
-    "support": "legacy",
-    "support_note": "Use ovis-ocr2-saturate.py (same model and server, adaptive concurrency, resumable)."
-  },
-  "ovis-ocr2-saturate.py": {
-    "model_id": "ATH-MaaS/OvisOCR2",
-    "params": "0.9B",
-    "backend": "saturate (in-job vllm serve + saturate pump)",
-    "image": "vllm/vllm-openai:v0.22.1",
-    "task": "ocr",
-    "output": "markdown + LaTeX + HTML tables",
-    "license": "apache-2.0",
-    "notes": "saturate companion of ovis-ocr2-server.py: same model/prompt/sampling/post-processing; the driver half (adaptive concurrency, retries, resumable parquet output, durable error rows) is the saturate library. SERVING dict at the top of the script is the machine-readable tuning prior.",
-    "languages": {
-      "evidence": "not-stated"
-    },
-    "support": "core",
-    "jobs": {
-      "image": "vllm/vllm-openai:v0.22.1",
-      "flavor": "a10g-small",
-      "secrets": [
-        "HF_TOKEN"
-      ]
-    }
-  },
-  "xiaomi-ocr-0-saturate.py": {
-    "model_id": "xiaomi-research/Xiaomi-OCR-0",
-    "params": "0.8B",
-    "backend": "saturate (in-job vllm serve or SGLang + saturate pump)",
-    "image": "vllm/vllm-openai:v0.29.0",
-    "task": "ocr",
-    "output": "markdown + LaTeX + HTML tables",
-    "license": "apache-2.0",
-    "notes": "Single-stage whole-page mode. Card scores (96.83 OmniDocBench v1.6, 95.24 Real5, 87.94 Wild) come from Xiaomi's two-stage pipeline, which this recipe does not run. --engine sglang needs --image lmsysorg/sglang:v0.5.20-cu130. Measured on UFO scans: a10g-small 3.4 pages/s, rtx-pro-6000 9.7 pages/s, both about $0.08 per 1,000 pages excluding boot.",
-    "languages": {
-      "evidence": "not-stated"
-    },
-    "support": "core",
-    "support_note": "Works well on clean print. On small-print historical newspapers it can loop or insert Chinese characters, with finish_reason still stop; check tables for lost items and separators.",
-    "jobs": {
-      "image": "vllm/vllm-openai:v0.29.0",
-      "flavor": "a10g-small",
-      "timeout": "4h",
-      "secrets": [
-        "HF_TOKEN"
-      ]
-    }
-  },
-  "lighton-ocr.py": {
-    "model_id": "lightonai/LightOnOCR-1B-1025",
-    "params": "1B",
-    "backend": "vllm",
-    "task": "ocr",
-    "output": "markdown",
-    "languages": {
-      "evidence": "named-list",
-      "count": 9,
-      "named": [
-        "en",
-        "fr",
-        "de",
-        "es",
-        "it",
-        "nl",
-        "pt",
-        "sv",
-        "da"
-      ],
-      "notes": "Explicitly European / Latin-alphabet focused."
-    },
-    "support": "legacy",
-    "support_note": "LightOnOCR v1; use lighton-ocr2.py."
-  },
-  "lighton-ocr2.py": {
-    "model_id": "lightonai/LightOnOCR-2-1B",
-    "params": "1B",
-    "backend": "vllm",
-    "task": "ocr",
-    "output": "markdown",
-    "languages": {
-      "evidence": "named-list",
-      "count": 11,
-      "named": [
-        "en",
-        "fr",
-        "de",
-        "es",
-        "it",
-        "nl",
-        "pt",
-        "sv",
-        "da",
-        "zh",
-        "ja"
-      ],
-      "notes": "Adds zh/ja over v1; declared, not benchmarked per language."
-    },
-    "support": "core",
-    "support_note": "Frozen 2026-11-06 (superseded by lighton-ocr3.py): image digest, package cutoff and model revision pinned; fixed only when it breaks. Use lighton-ocr3.py for new runs.",
-    "revision": "be7c41313c30e940fe5571de59e5fabc779e00c8",
-    "jobs": {
-      "image": "vllm/vllm-openai@sha256:953d3a06d5e64ab582985cd7401289d3abf2a2c14ef2158e9a84313daeec77d7",
-      "python": "/usr/bin/python3",
-      "env": {
-        "PYTHONPATH": "/usr/local/lib/python3.12/dist-packages"
-      },
-      "flavor": "a10g-small",
-      "secrets": [
-        "HF_TOKEN"
-      ]
-    },
-    "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-ocr3-saturate.py": {
-    "model_id": "lightonai/LightOnOCR-3-0.8B",
-    "params": "0.8B (or 4B via --model)",
-    "backend": "saturate (in-job vllm serve + saturate pump)",
-    "image": "vllm/vllm-openai:v0.30.0",
-    "task": "ocr",
-    "output": "markdown; --mode grounding adds labelled layout blocks with 0-1000 boxes (layout_blocks JSON column)",
-    "license": "apache-2.0",
-    "notes": "Large-run sibling of lighton-ocr3.py: same prompt modes, sampling and page resize; LightOn's serve flags (--max-model-len 18000) plus --max-num-batched-tokens 16384, and 4 vLLM API servers when CPU_CORES >= 12. Window capped by host memory. Measured 2026-11-05 (0.8B, 600 pages, steady state): a10g-small 2.2 pages/s, a100-large 7.2, rtx-pro-6000 10.0 (about $0.08 per 1,000 pages); lighton-ocr3.py: 0.90 and 1.27. Not LightOnOCR-3-1B.",
-    "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",
-      "flavor": "a10g-small",
-      "timeout": "4h",
-      "secrets": [
-        "HF_TOKEN"
-      ]
-    }
-  },
-  "lighton-ocr2-server.py": {
-    "model_id": "lightonai/LightOnOCR-2-1B",
-    "params": "1B",
-    "backend": "vllm-server (in-job vllm serve + concurrent driver)",
-    "image": "vllm/vllm-openai:v0.22.1",
-    "task": "ocr",
-    "output": "markdown",
-    "notes": "Server-mode sibling of lighton-ocr2.py (the model card's own documented path): ~1.8x its inference throughput. See SERVING.md.",
-    "languages": {
-      "evidence": "named-list",
-      "count": 11,
-      "named": [
-        "en",
-        "fr",
-        "de",
-        "es",
-        "it",
-        "nl",
-        "pt",
-        "sv",
-        "da",
-        "zh",
-        "ja"
-      ],
-      "notes": "Adds zh/ja over v1; declared, not benchmarked per language."
-    },
-    "support": "legacy",
-    "support_note": "Use lighton-ocr2-saturate.py (same model and server, adaptive concurrency, resumable)."
-  },
-  "lighton-ocr2-saturate.py": {
-    "model_id": "lightonai/LightOnOCR-2-1B",
-    "params": "1B",
-    "backend": "saturate (in-job vllm serve + saturate pump)",
-    "image": "vllm/vllm-openai:v0.22.1",
-    "task": "ocr",
-    "output": "markdown",
-    "notes": "saturate companion of lighton-ocr2-server.py: same model/message shape/sampling; the driver half (adaptive concurrency, retries, resumable parquet output, durable error rows) is the saturate library. SERVING dict at the top of the script is the machine-readable tuning prior.",
-    "languages": {
-      "evidence": "named-list",
-      "count": 11,
-      "named": [
-        "en",
-        "fr",
-        "de",
-        "es",
-        "it",
-        "nl",
-        "pt",
-        "sv",
-        "da",
-        "zh",
-        "ja"
-      ],
-      "notes": "Adds zh/ja over v1; declared, not benchmarked per language."
-    },
-    "support": "core",
-    "jobs": {
-      "image": "vllm/vllm-openai:v0.22.1",
-      "flavor": "a10g-small",
-      "secrets": [
-        "HF_TOKEN"
-      ]
-    }
-  },
-  "hunyuan-ocr.py": {
-    "model_id": "tencent/HunyuanOCR",
-    "revision": "f6af82ee007fe6091b29fb3bb287b491ead41c82",
-    "params": "1B",
-    "backend": "vllm",
-    "task": "ocr",
-    "output": "markdown",
-    "license": "Hunyuan Community License (excludes EU/UK/KR)",
-    "languages": {
-      "evidence": "multilingual-unspecified"
-    },
-    "support": "unsupported",
-    "support_note": "Broken (2026-09-23): the pinned 1.0 revision fails on current vLLM/transformers. Use hunyuan-ocr-1.5.py."
-  },
-  "hunyuan-ocr-1.5.py": {
-    "model_id": "tencent/HunyuanOCR",
-    "params": "1B",
-    "backend": "vllm",
-    "task": "ocr | 12 task types",
-    "output": "markdown",
-    "license": "Hunyuan Community License (excludes EU/UK/KR)",
-    "languages": {
-      "evidence": "multilingual-unspecified",
-      "notes": "Explicitly targets low-resource + ancient-script OCR as a design goal; nothing enumerated."
-    },
-    "support": "core",
-    "jobs": {
-      "image": "vllm/vllm-openai:v0.24.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.24.0"
-  },
-  "dots-ocr.py": {
-    "model_id": "rednote-hilab/dots.ocr",
-    "params": "1.7B",
-    "backend": "vllm",
-    "task": "ocr + layout",
-    "output": "markdown",
-    "languages": {
-      "evidence": "count-claim",
-      "count": 100,
-      "notes": "Explicit low-resource claim backed by in-house dots.ocr-bench (1,493 PDFs across 100 languages); aggregate scores only."
-    },
-    "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"
-  },
-  "firered-ocr.py": {
-    "model_id": "FireRedTeam/FireRed-OCR",
-    "params": "2.1B",
-    "backend": "vllm",
-    "task": "ocr",
-    "output": "markdown",
-    "license": "apache-2.0",
-    "languages": {
-      "evidence": "not-stated"
-    },
-    "support": "legacy",
-    "support_note": "Works; low adoption."
-  },
-  "abot-ocr.py": {
-    "model_id": "acvlab/ABot-OCR",
-    "params": "2B",
-    "backend": "vllm",
-    "image": "vllm/vllm-openai",
-    "task": "ocr",
-    "output": "markdown (text, LaTeX, HTML tables)",
-    "languages": {
-      "evidence": "not-stated"
-    },
-    "support": "legacy",
-    "support_note": "Works; low adoption and no declared model licence."
-  },
-  "nanonets-ocr.py": {
-    "model_id": "nanonets/Nanonets-OCR-s",
-    "params": "2B",
-    "backend": "vllm",
-    "task": "ocr",
-    "output": "markdown (LaTeX, tables, forms)",
-    "languages": {
-      "evidence": "english-only"
-    },
-    "support": "legacy",
-    "support_note": "Nanonets-OCR-s; use nanonets-ocr2.py."
-  },
-  "dots-mocr.py": {
-    "model_id": "rednote-hilab/dots.mocr",
-    "params": "3B",
-    "backend": "vllm",
-    "task": "ocr | 8 prompt modes incl. SVG, layout + bbox",
-    "output": "markdown",
-    "languages": {
-      "evidence": "multilingual-unspecified"
-    },
-    "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"
-  },
-  "nanonets-ocr2.py": {
-    "model_id": "nanonets/Nanonets-OCR2-3B",
-    "params": "3B",
-    "backend": "vllm",
-    "image": "vllm/vllm-openai:v0.10.2",
-    "task": "ocr",
-    "output": "markdown",
-    "languages": {
-      "evidence": "named-list",
-      "count": "11 named + 'many more'",
-      "named": [
-        "en",
-        "zh",
-        "fr",
-        "es",
-        "pt",
-        "de",
-        "it",
-        "ru",
-        "ja",
-        "ko",
-        "ar"
-      ],
-      "notes": "Only card claiming multilingual handwriting; list illustrative, no per-language benchmark."
-    },
-    "support": "legacy",
-    "support_note": "Works on its pinned vllm/vllm-openai:v0.10.2 image; not header-migrated."
-  },
-  "deepseek-ocr-vllm.py": {
-    "model_id": "deepseek-ai/DeepSeek-OCR",
-    "params": "4B",
-    "backend": "vllm",
-    "task": "ocr | 5 resolution + 5 prompt modes",
-    "output": "markdown",
-    "license": "mit",
-    "languages": {
-      "evidence": "multilingual-unspecified"
-    },
-    "support": "core",
-    "jobs": {
-      "image": "vllm/vllm-openai:v0.29.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.29.0"
-  },
-  "jina-ocr-v1.py": {
-    "model_id": "jinaai/jina-ocr-v1",
-    "model_name": "jina-ocr-v1",
-    "params": "3.4B (MoE, ~570M active)",
-    "backend": "vllm",
-    "task": "ocr",
-    "output": "markdown",
-    "license": "cc-by-nc-4.0",
-    "notes": "DeepSeek-OCR fine-tune with a FastMTP speculative-decoding head; offline vLLM only (the checkpoint's register() must run in-process, no vllm serve path yet). Card: 91.14 OmniDocBench v1.6, 83.4 olmOCR-Bench.",
-    "languages": {
-      "evidence": "multilingual-unspecified",
-      "notes": "Card metadata says multilingual; no per-language list or evidence in the card body."
-    },
-    "support": "unsupported",
-    "support_note": "Broken (2026-09-23): vLLM 0.30 DeepEncoder kernel error; pinning vllm/vllm-openai:v0.29.0 likely fixes it (as for deepseek-ocr-vllm.py). CC-BY-NC-4.0 model.",
-    "jobs": {
-      "flavor": "a10g-small",
-      "secrets": [
-        "HF_TOKEN"
-      ],
-      "env": {
-        "UV_TORCH_BACKEND": "auto"
-      }
-    }
-  },
-  "deepseek-ocr.py": {
-    "model_id": "deepseek-ai/DeepSeek-OCR",
-    "params": "4B",
-    "backend": "transformers",
-    "task": "ocr",
-    "output": "markdown",
-    "license": "mit",
-    "languages": {
-      "evidence": "multilingual-unspecified"
-    },
-    "support": "unsupported",
-    "support_note": "Broken (2026-09-23): every output row is the string 'None' (model.infer returns None). Use deepseek-ocr-vllm.py."
-  },
-  "deepseek-ocr2-vllm.py": {
-    "model_id": "deepseek-ai/DeepSeek-OCR-2",
-    "params": "3B",
-    "backend": "vllm (nightly)",
-    "image": "vllm/vllm-openai:v0.29.0",
-    "task": "ocr",
-    "output": "markdown",
-    "license": "apache-2.0",
-    "languages": {
-      "evidence": "multilingual-unspecified"
-    },
-    "support": "core",
-    "jobs": {
-      "image": "vllm/vllm-openai:v0.29.0",
-      "python": "/usr/bin/python3",
-      "env": {
-        "PYTHONPATH": "/usr/local/lib/python3.12/dist-packages"
-      },
-      "flavor": "a10g-small",
-      "secrets": [
-        "HF_TOKEN"
-      ]
-    }
-  },
-  "unlimited-ocr2.py": {
-    "model_id": "baidu/Unlimited-OCR-2",
-    "params": "3.3B (MoE, 0.5B active)",
-    "backend": "saturate (in-job SGLang from Baidu's wheel + saturate pump)",
-    "image": "lmsysorg/sglang:v0.5.20-cu130",
-    "task": "ocr (multi-page documents: folders of page images; cross-page continuations)",
-    "output": "markdown per page + layout-grounded raw, one row per 16-page window",
-    "license": "mit",
-    "notes": "Sends 16 consecutive pages per request so the model keeps context across page breaks. Needs a >= 48 GB GPU (24 GB cards thrash the KV cache). Measured on 1771 Britannica: rtx-pro-6000 ~1,570 tok/s end to end. About 2% of dense 18th-century pages loop; unlimited-ocr2-saturate.py repairs them.",
-    "languages": {
-      "evidence": "multilingual-unspecified"
-    },
-    "support": "core",
-    "jobs": {
-      "image": "lmsysorg/sglang:v0.5.20-cu130",
-      "flavor": "rtx-pro-6000",
-      "timeout": "4h",
-      "secrets": [
-        "HF_TOKEN"
-      ]
-    }
-  },
-  "unlimited-ocr2-saturate.py": {
-    "model_id": "baidu/Unlimited-OCR-2",
-    "params": "3.3B (MoE, 0.5B active)",
-    "backend": "saturate (in-job SGLang from Baidu's wheel + saturate pump)",
-    "image": "lmsysorg/sglang:v0.5.20-cu130",
-    "task": "ocr (multi-page documents: book volumes, PDFs; cross-page continuations)",
-    "output": "markdown per page and per window + layout-grounded raw",
-    "license": "mit",
-    "notes": "Tuned version of unlimited-ocr2.py: repair pass for looping pages (fixed 28/33 in testing), PDF input, Baidu's own Markdown post-processing, speed flags.",
-    "languages": {
-      "evidence": "multilingual-unspecified"
-    },
-    "support": "experimental",
-    "support_note": "Use unlimited-ocr2.py unless you need the repair pass, PDFs or the extras.",
-    "jobs": {
-      "image": "lmsysorg/sglang:v0.5.20-cu130",
-      "flavor": "rtx-pro-6000",
-      "timeout": "4h",
-      "secrets": [
-        "HF_TOKEN"
-      ]
-    }
-  },
-  "unlimited-ocr2-live.py": {
-    "model_id": "baidu/Unlimited-OCR-2",
-    "params": "3.3B (MoE, 0.5B active)",
-    "backend": "saturate (in-job SGLang from Baidu's wheel + saturate pump)",
-    "image": "lmsysorg/sglang:v0.5.20-cu130",
-    "task": "ocr (multi-page documents) with a live view of the run",
-    "output": "markdown per page + layout-grounded raw, one row per 16-page window",
-    "license": "mit",
-    "notes": "unlimited-ocr2.py plus --live-port: a dashboard served from the Job (start-up steps, the page being read with its text streaming in, finished pages, pages/min, GPU load) for watching or screen-recording a run. Measured on 1,456 Wellcome Library pages: ~130 pages/min on rtx-pro-6000.",
-    "languages": {
-      "evidence": "multilingual-unspecified"
-    },
-    "support": "experimental",
-    "support_note": "Use unlimited-ocr2.py for normal runs; this adds a live view for demos.",
-    "jobs": {
-      "image": "lmsysorg/sglang:v0.5.20-cu130",
-      "flavor": "rtx-pro-6000",
-      "timeout": "4h",
-      "secrets": [
-        "HF_TOKEN"
-      ]
-    }
-  },
-  "minicpm-ocr.py": {
-    "model_id": "openbmb/MiniCPM-OCR-1.0",
-    "params": "1.3B",
-    "backend": "in-job vLLM (nightly) + OpenBMB's minicpm-ocr SDK (PP-DocLayoutV3 layout, per-region prompts, Markdown assembly)",
-    "image": "cr.hf.co/davanstrien/minicpm-ocr:1.0-vllm-5d35ce3",
-    "task": "ocr (page images -> Markdown; tables as HTML, formulas as LaTeX); Hub dataset or Bucket/folder I/O",
-    "output": "dataset mode: markdown + markdown_status columns; Bucket/folder mode: one .md per image (failed pages not written, re-run retries)",
-    "license": "apache-2.0",
-    "notes": "A region reader behind a layout model, run through the vendor SDK unchanged. Custom public image (Dockerfile in images/minicpm-ocr/): the architecture is in vLLM main but not a release, and the SDK needs PaddlePaddle in its own venv. DSpark speculative decoding on by default (--no-dspark). Bucket I/O via bucketbag v0.3.1 (no mount), resume-by-skip. Smoke-tested 2026-10-27 on BHL pages (dataset mode) and 1771 Britannica .jp2 (Bucket mode), a10g-large.",
-    "languages": {
-      "evidence": "named-list",
-      "count": 2,
-      "named": [
-        "zh",
-        "en"
-      ],
-      "notes": "Card: 'Primary languages: Chinese and English'; card metadata lists en, zh. Card examples include historical scans; fine-tuning guide uses French handwriting."
-    },
-    "support": "experimental",
-    "jobs": {
-      "image": "cr.hf.co/davanstrien/minicpm-ocr:1.0-vllm-5d35ce3",
-      "flavor": "a10g-large",
-      "timeout": "2h",
-      "secrets": [
-        "HF_TOKEN"
-      ]
-    }
-  },
-  "unlimited-ocr-vllm.py": {
-    "model_id": "baidu/Unlimited-OCR",
-    "params": "3.3B",
-    "backend": "vllm",
-    "image": "vllm/vllm-openai:unlimited-ocr",
-    "task": "ocr (layout-grounded markdown; single-image batch)",
-    "output": "markdown",
-    "license": "mit",
-    "languages": {
-      "evidence": "multilingual-unspecified"
-    },
-    "support": "core",
-    "jobs": {
-      "image": "vllm/vllm-openai:unlimited-ocr",
-      "python": "/usr/bin/python3",
-      "env": {
-        "PYTHONPATH": "/usr/local/lib/python3.12/dist-packages"
-      },
-      "flavor": "a10g-small",
-      "secrets": [
-        "HF_TOKEN"
-      ]
-    }
-  },
-  "nuextract3.py": {
-    "model_id": "numind/NuExtract3",
-    "params": "4B",
-    "backend": "vllm",
-    "image": "vllm/vllm-openai:v0.29.0",
-    "task": "ocr | schema-guided extraction",
-    "output": "markdown or JSON",
-    "languages": {
-      "evidence": "multilingual-unspecified"
-    },
-    "support": "core",
-    "jobs": {
-      "image": "vllm/vllm-openai:v0.29.0",
-      "python": "/usr/bin/python3",
-      "env": {
-        "PYTHONPATH": "/usr/local/lib/python3.12/dist-packages"
-      },
-      "flavor": "a10g-small",
-      "secrets": [
-        "HF_TOKEN"
-      ]
-    }
-  },
-  "qianfan-ocr.py": {
-    "model_id": "baidu/Qianfan-OCR",
-    "params": "4.7B",
-    "backend": "vllm",
-    "task": "ocr",
-    "output": "markdown",
-    "languages": {
-      "evidence": "count-claim",
-      "count": 192,
-      "notes": "Headline claim; no list or per-language numbers."
-    },
-    "support": "core",
-    "jobs": {
-      "image": "vllm/vllm-openai:v0.29.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.29.0"
-  },
-  "olmocr2-vllm.py": {
-    "model_id": "allenai/olmOCR-2-7B-1025-FP8",
-    "params": "7B",
-    "backend": "vllm",
-    "task": "ocr",
-    "output": "markdown",
-    "languages": {
-      "evidence": "english-only"
-    },
-    "support": "core",
-    "jobs": {
-      "image": "vllm/vllm-openai:v0.29.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.29.0"
-  },
-  "rolm-ocr.py": {
-    "model_id": "reducto/RolmOCR",
-    "params": "7B",
-    "backend": "vllm",
-    "task": "ocr",
-    "output": "plain text",
-    "languages": {
-      "evidence": "not-stated"
-    },
-    "support": "unsupported",
-    "support_note": "Broken (2026-09-23): no KV cache room on a 24 GB L4 with the default settings. Use olmocr2-vllm.py."
-  },
-  "numarkdown-ocr.py": {
-    "model_id": "numind/NuMarkdown-8B-Thinking",
-    "params": "8B",
-    "backend": "vllm",
-    "task": "ocr (reasoning)",
-    "output": "markdown",
-    "languages": {
-      "evidence": "not-stated"
-    },
-    "support": "legacy",
-    "support_note": "8B reasoning model; works, little used."
-  },
-  "lfm2-vl-extract.py": {
-    "model_id": "LiquidAI/LFM2.5-VL-1.6B-Extract",
-    "params": "1.6B",
-    "backend": "vllm",
-    "image": "vllm/vllm-openai",
-    "task": "schema-guided extraction (image -> JSON)",
-    "output": "JSON",
-    "languages": {
-      "evidence": "english-only",
-      "notes": "Vision card declares en only; the text sibling's 9-language list does NOT carry over."
-    },
-    "support": "legacy",
-    "support_note": "Works; nuextract3.py and lift-extract.py cover image-to-JSON extraction."
-  },
-  "lfm2-extract.py": {
-    "model_id": "LiquidAI/LFM2-1.2B-Extract",
-    "params": "1.2B",
-    "backend": "vllm",
-    "image": "vllm/vllm-openai:v0.29.0",
-    "task": "schema-guided extraction (text -> structured); chain after any OCR recipe",
-    "output": "JSON / XML / YAML",
-    "languages": {
-      "evidence": "named-list",
-      "count": 9,
-      "named": [
-        "en",
-        "ar",
-        "zh",
-        "fr",
-        "de",
-        "ja",
-        "ko",
-        "pt",
-        "es"
-      ],
-      "notes": "Text-only model (not OCR). Card prose names 9 incl. Portuguese; card YAML lists 8 (pt missing)."
-    },
-    "support": "tool",
-    "jobs": {
-      "image": "vllm/vllm-openai:v0.29.0",
-      "python": "/usr/bin/python3",
-      "env": {
-        "PYTHONPATH": "/usr/local/lib/python3.12/dist-packages"
-      },
-      "flavor": "a10g-small",
-      "secrets": [
-        "HF_TOKEN"
-      ]
-    }
-  },
-  "lift-extract.py": {
-    "model_id": "datalab-to/lift",
-    "params": "9B",
-    "backend": "transformers | vllm",
-    "task": "schema-guided extraction (image or multi-page PDF -> JSON)",
-    "output": "JSON",
-    "license": "modified OpenRAIL-M",
-    "languages": {
-      "evidence": "not-stated"
-    },
-    "support": "core",
-    "jobs": {
-      "flavor": "a100-large",
-      "secrets": [
-        "HF_TOKEN"
-      ]
-    }
-  },
-  "pp-doclayout.py": {
-    "model_id": "PaddlePaddle/PP-DocLayout-L",
-    "params": "123M",
-    "backend": "paddleocr",
-    "task": "layout detection (no text extraction)",
-    "output": "bounding boxes + region classes",
-    "languages": {
-      "evidence": "not-applicable"
-    },
-    "support": "tool",
-    "jobs": {
-      "flavor": "t4-small",
-      "secrets": [
-        "HF_TOKEN"
-      ]
-    }
-  },
-  "glm-ocr-v2.py": {
-    "variant_of": "glm-ocr.py",
-    "notes": "Adds checkpoint/resume for very large jobs.",
-    "support": "legacy",
-    "support_note": "Superseded by glm-ocr.py for most runs; kept for its resume support."
-  },
-  "glm-ocr-bucket.py": {
-    "variant_of": "glm-ocr.py",
-    "notes": "Reads images/PDFs from a mounted bucket, writes one .md per page.",
-    "support": "core",
-    "jobs": {
-      "image": "vllm/vllm-openai:v0.29.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.29.0"
-  },
-  "falcon-ocr-bucket.py": {
-    "variant_of": "falcon-ocr.py",
-    "notes": "Reads images/PDFs from a mounted bucket, writes one .md per page.",
-    "support": "legacy",
-    "support_note": "Falcon-OCR v1; v1.5 work is in PR #110. --max-samples counts files, not pages."
-  },
-  "surya-ocr-bucket.py": {
-    "variant_of": "surya-ocr.py",
-    "notes": "Bucket-to-bucket structured OCR (--io-mode mount|copy), resumable.",
-    "support": "core",
-    "jobs": {
-      "image": "vllm/vllm-openai:v0.20.1",
-      "python": "/usr/local/bin/python3",
-      "env": {
-        "PYTHONPATH": "/usr/local/lib/python3.12/site-packages"
-      },
-      "flavor": "a10g-small",
-      "secrets": [
-        "HF_TOKEN"
-      ]
-    },
-    "image": "vllm/vllm-openai:v0.20.1"
-  },
-  "ocr-vllm-judge.py": {
-    "model_id": "configurable",
-    "task": "pairwise OCR-quality judging (VLM-as-judge)",
-    "languages": {
-      "evidence": "not-applicable"
-    },
-    "support": "tool",
-    "jobs": {
-      "image": "vllm/vllm-openai:v0.29.0",
-      "python": "/usr/bin/python3",
-      "env": {
-        "PYTHONPATH": "/usr/local/lib/python3.12/dist-packages"
-      },
-      "flavor": "a100-large",
-      "secrets": [
-        "HF_TOKEN"
-      ]
-    },
-    "image": "vllm/vllm-openai:v0.29.0"
-  },
-  "hpd-parsing-saturate.py": {
-    "model_id": "PaddlePaddle/HPD-Parsing",
-    "params": "1B",
-    "backend": "saturate (in-job vllm serve from Paddle's vLLM fork 0.17.1+hpdparsing: request forking + P-MTP speculative decoding)",
-    "image": "cr.hf.co/davanstrien/hpd-parsing-vllm:87496aa5-uv0.13.6",
-    "task": "ocr | layout",
-    "output": "markdown + hpd_blocks (per-block type, bbox, text; bbox 0-1000 NORMALIZED, not pixels) + raw + looped_blocks",
-    "license": "apache-2.0",
-    "notes": "Runs only on Paddle's vLLM fork, shipped in their registry image. The header image is that image (latest-nvidia-gpu, pinned by digest 87496aa5) plus uv, built by images/hpd-parsing/build.sh; the docstring also gives the command for Paddle's image directly. Serve command = the image's own entrypoint, except the P-MTP speculative head path (downloaded locally) and a --revision pin. Keeps --enable-prefix-caching ON: forked children share the parent's prefix KV. max_tokens bounds one decoding branch, not the page, so dense pages can loop in many branches; looped_blocks flags them. 94.91 OmniDocBench v1.6; accuracy below ovis-ocr2 and paddleocr-vl-1.6. ~11 GB image pull on a cold node.",
-    "languages": {
-      "evidence": "named-list",
-      "count": 2,
-      "named": [
-        "en",
-        "zh"
-      ],
-      "notes": "Card metadata lists en + zh only; no per-language numbers. Smoke runs on degraded French scans produced stray Chinese characters - treat other languages as unsupported."
-    },
-    "support": "experimental",
-    "support_note": "Dense pages loop: filter on looped_blocks == 0. Check a sample of your own pages.",
-    "jobs": {
-      "image": "cr.hf.co/davanstrien/hpd-parsing-vllm:87496aa5-uv0.13.6",
-      "flavor": "l4x1",
-      "timeout": "2h",
-      "secrets": [
-        "HF_TOKEN"
-      ]
-    }
-  }
-}

nanonets-ocr.py

@@ -40,10 +40,6 @@ from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 from datetime import datetime
 
@@ -61,28 +57,6 @@ def check_cuda_availability():
         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 make_ocr_message(
     image: Union[Image.Image, Dict[str, Any], str],
     prompt: str = "Extract the text from the above document as if you were reading it naturally. Return the tables in html format. Return the equations in LaTeX representation. If there is an image in the document and image caption is not present, add a small description of the image inside the <img></img> tag; otherwise, add the image caption inside <img></img>. Watermarks should be wrapped in brackets. Ex: <watermark>OFFICIAL COPY</watermark>. Page numbers should be wrapped in brackets. Ex: <page_number>14</page_number> or <page_number>9/22</page_number>. Prefer using ☐ and ☑ for check boxes.",
@@ -115,75 +89,6 @@ def make_ocr_message(
     ]
 
 
-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,
@@ -199,15 +104,6 @@ def create_dataset_card(
     """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"; "" on CPU
-    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 ""
-
     return f"""---
 viewer: false
 tags:
@@ -216,7 +112,7 @@ tags:
 - nanonets
 - markdown
 - uv-script
-- generated{jobs_tag}
+- generated
 ---
 
 # Document OCR using {model_name}
@@ -280,10 +176,10 @@ for info in inference_info:
 
 ## Reproduction
 
-{origin} with the [`nanonets-ocr.py`](https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nanonets-ocr.py) recipe from [uv-scripts](https://huggingface.co/uv-scripts). Run it yourself:
+This dataset was generated using the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) Nanonets OCR script:
 
 ```bash
-hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nanonets-ocr.py \\
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nanonets-ocr.py \\
     {source_dataset} \\
     <output-dataset> \\
     --image-column {image_column} \\
@@ -297,6 +193,8 @@ hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nanonets-
 
 - **Processing Speed**: ~{num_samples / (float(processing_time.split()[0]) * 60):.1f} images/second
 - **GPU Configuration**: vLLM with {gpu_memory_utilization:.0%} GPU memory utilization
+
+Generated with 🤖 [UV Scripts](https://huggingface.co/uv-scripts)
 """
 
 
@@ -306,7 +204,7 @@ def main(
     image_column: str = "image",
     batch_size: int = 32,
     model: str = "nanonets/Nanonets-OCR-s",
-    max_model_len: int = 32768,
+    max_model_len: int = 8192,
     max_tokens: int = 15000,
     gpu_memory_utilization: float = 0.8,
     hf_token: str = None,
@@ -315,8 +213,6 @@ def main(
     private: bool = False,
     shuffle: bool = False,
     seed: int = 42,
-    output_column: str = "markdown",
-    overwrite: bool = False,
     verbose: bool = False,
 ):
     """Process images from HF dataset through OCR model."""
@@ -345,9 +241,6 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
-    # Fail fast if the output column would collide with an existing input column
-    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
-
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -404,9 +297,9 @@ def main(
             # Add error placeholders for failed batch
             all_markdown.extend(["[OCR FAILED]"] * len(batch_images))
 
-    # Add output column to dataset
-    logger.info(f"Adding '{output_column}' column to dataset")
-    dataset = dataset.add_column(output_column, all_markdown)
+    # Add markdown column to dataset
+    logger.info("Adding markdown column to dataset")
+    dataset = dataset.add_column("markdown", all_markdown)
 
     # Handle inference_info tracking
     logger.info("Updating inference_info...")
@@ -414,7 +307,7 @@ def main(
     inference_entry = {
         "model_id": model,
         "model_name": "Nanonets-OCR-s",
-        "column_name": output_column,
+        "column_name": "markdown",
         "timestamp": datetime.now().isoformat(),
         "batch_size": batch_size,
         "max_tokens": max_tokens,
@@ -569,10 +462,8 @@ Examples:
     parser.add_argument(
         "--max-model-len",
         type=int,
-        default=32768,
-        help="Maximum model context length (default: 32768; must exceed --max-tokens "
-        "15000 plus the image/prompt tokens — the old 8192 default couldn't hold the "
-        "output budget). Model max is 128k, so there's ample room.",
+        default=8192,
+        help="Maximum model context length (default: 8192)",
     )
     parser.add_argument(
         "--max-tokens",
@@ -609,17 +500,6 @@ Examples:
         default=42,
         help="Random seed for shuffling (default: 42)",
     )
-    parser.add_argument(
-        "--output-column",
-        default="markdown",
-        help="Column name for the OCR output text (default: markdown)",
-    )
-    parser.add_argument(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists in the input dataset "
-        "(default: error out to avoid clobbering an existing column).",
-    )
     parser.add_argument(
         "--verbose",
         action="store_true",
@@ -643,7 +523,5 @@ Examples:
         private=args.private,
         shuffle=args.shuffle,
         seed=args.seed,
-        output_column=args.output_column,
-        overwrite=args.overwrite,
         verbose=args.verbose,
     )

nanonets-ocr2.py

@@ -4,8 +4,10 @@
 #     "datasets>=4.0.0",
 #     "huggingface-hub",
 #     "pillow",
+#     "vllm>=0.15.1",
 #     "tqdm",
 #     "toolz",
+#     "torch",
 # ]
 #
 # ///
@@ -24,20 +26,6 @@ Features:
 - Signature and watermark detection
 - Checkbox recognition
 - Multilingual support
-
-⚠️ Pinned vLLM image required. Nanonets-OCR2-3B is a Qwen2.5-VL model, and vLLM
->=0.11 regressed Qwen2.5-VL decoding to a stream of "!" (vllm-project/vllm#27775,
-#14126); 0.10.2 is the last known-good. So `vllm` and `torch` are intentionally
-omitted from the deps above and come from the `vllm/vllm-openai:v0.10.2` image at
-runtime via PYTHONPATH. Run it like:
-
-    hf jobs uv run --flavor a10g-small -s HF_TOKEN \
-        --image vllm/vllm-openai:v0.10.2 --python /usr/bin/python3 \
-        -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages \
-        nanonets-ocr2.py INPUT_DATASET OUTPUT_DATASET --max-samples 10 --shuffle
-
-Re-test the pin when a newer vLLM ships a Qwen2.5-VL decode fix; it can then move
-back to a plain `vllm>=...` dep on the default image.
 """
 
 import argparse
@@ -50,33 +38,12 @@ import sys
 from typing import Any, Dict, List, Union
 from datetime import datetime
 
-# Preflight: torch/vllm are deliberately NOT PEP 723 deps (see docstring) — they come from
-# the pinned vllm/vllm-openai:v0.10.2 image. On the bare uv image the imports below would
-# die with a raw ModuleNotFoundError; fail fast naming the exact flags instead.
-import importlib.util
-
-if importlib.util.find_spec("vllm") is None or importlib.util.find_spec("torch") is None:
-    sys.stderr.write(
-        "ERROR: vllm/torch not importable — this recipe cannot run on the bare uv image.\n"
-        "Nanonets-OCR2-3B needs vLLM 0.10.2 (>=0.11 regresses Qwen2.5-VL decoding to '!').\n"
-        "Re-run with the pinned image + interpreter flags:\n"
-        "    hf jobs uv run --flavor a10g-small -s HF_TOKEN \\\n"
-        "        --image vllm/vllm-openai:v0.10.2 --python /usr/bin/python3 \\\n"
-        "        -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages \\\n"
-        "        nanonets-ocr2.py INPUT_DATASET OUTPUT_DATASET ...\n"
-    )
-    sys.exit(1)
-
 import torch
 from datasets import load_dataset
 from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler (JIT-compiles a CUDA kernel; greedy OCR doesn't use it).
-# Harmless no-op on the pinned vllm/vllm-openai image; kept in case the pin is ever relaxed
-# back to an environment without nvcc.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)
@@ -93,28 +60,6 @@ def check_cuda_availability():
         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 make_ocr_message(
     image: Union[Image.Image, Dict[str, Any], str],
     prompt: str = "Extract the text from the above document as if you were reading it naturally. Return the tables in html format. Return the equations in LaTeX representation. If there is an image in the document and image caption is not present, add a small description of the image inside the <img></img> tag; otherwise, add the image caption inside <img></img>. Watermarks should be wrapped in brackets. Ex: <watermark>OFFICIAL COPY</watermark>. Page numbers should be wrapped in brackets. Ex: <page_number>14</page_number> or <page_number>9/22</page_number>. Prefer using ☐ and ☑ for check boxes.",
@@ -265,7 +210,7 @@ def main(
     image_column: str = "image",
     batch_size: int = 16,
     model: str = "nanonets/Nanonets-OCR2-3B",
-    max_model_len: int = 32768,
+    max_model_len: int = 8192,
     max_tokens: int = 15000,
     gpu_memory_utilization: float = 0.8,
     hf_token: str = None,
@@ -274,11 +219,7 @@ def main(
     private: bool = False,
     shuffle: bool = False,
     seed: int = 42,
-    output_column: str = "markdown",
-    overwrite: bool = False,
     verbose: bool = False,
-    config: str = None,
-    create_pr: bool = False,
 ):
     """Process images from HF dataset through Nanonets-OCR2-3B model."""
 
@@ -306,9 +247,6 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
-    # Fail fast if the output column would collide with an existing input column
-    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
-
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -365,9 +303,9 @@ def main(
             # Add error placeholders for failed batch
             all_markdown.extend(["[OCR FAILED]"] * len(batch_images))
 
-    # Add output column to dataset
-    logger.info(f"Adding '{output_column}' column to dataset")
-    dataset = dataset.add_column(output_column, all_markdown)
+    # Add markdown column to dataset
+    logger.info("Adding markdown column to dataset")
+    dataset = dataset.add_column("markdown", all_markdown)
 
     # Handle inference_info tracking
     logger.info("Updating inference_info...")
@@ -375,7 +313,7 @@ def main(
     inference_entry = {
         "model_id": model,
         "model_name": "Nanonets-OCR2-3B",
-        "column_name": output_column,
+        "column_name": "markdown",
         "timestamp": datetime.now().isoformat(),
         "batch_size": batch_size,
         "max_tokens": max_tokens,
@@ -408,15 +346,7 @@ def main(
 
     # Push to hub
     logger.info(f"Pushing to {output_dataset}")
-    commit_info = dataset.push_to_hub(
-        output_dataset,
-        private=private,
-        token=HF_TOKEN,
-        **({"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 ""),
-    )
+    dataset.push_to_hub(output_dataset, private=private, token=HF_TOKEN)
 
     # Calculate processing time
     end_time = datetime.now()
@@ -446,8 +376,6 @@ def main(
     logger.info(
         f"Dataset available at: https://huggingface.co/datasets/{output_dataset}"
     )
-    if create_pr and getattr(commit_info, "pr_url", None):
-        logger.info(f"Pull request created: {commit_info.pr_url}")
 
     if verbose:
         import importlib.metadata
@@ -544,8 +472,8 @@ Examples:
     parser.add_argument(
         "--max-model-len",
         type=int,
-        default=32768,
-        help="Maximum model context length (default: 32768)",
+        default=8192,
+        help="Maximum model context length (default: 8192)",
     )
     parser.add_argument(
         "--max-tokens",
@@ -571,15 +499,6 @@ Examples:
     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",
@@ -591,17 +510,6 @@ Examples:
         default=42,
         help="Random seed for shuffling (default: 42)",
     )
-    parser.add_argument(
-        "--output-column",
-        default="markdown",
-        help="Column name for the OCR output text (default: markdown)",
-    )
-    parser.add_argument(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists in the input dataset "
-        "(default: error out to avoid clobbering an existing column).",
-    )
     parser.add_argument(
         "--verbose",
         action="store_true",
@@ -625,9 +533,5 @@ Examples:
         private=args.private,
         shuffle=args.shuffle,
         seed=args.seed,
-        output_column=args.output_column,
-        overwrite=args.overwrite,
         verbose=args.verbose,
-        config=args.config,
-        create_pr=args.create_pr,
     )

nuextract3.py

@@ -1,784 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "datasets>=3.1.0,<5.1",  # 5.1 needs huggingface_hub>=1.31; the image ships an older 1.x on PYTHONPATH, which wins
-#     "huggingface-hub",
-#     "pillow",
-#     "toolz",
-#     "numind",
-# ]
-#
-# [tool.hf-jobs]
-# image = "vllm/vllm-openai:v0.29.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 extract structured JSON using NuExtract3 with vLLM.
-
-NuExtract3 is a 4B Qwen3.5-based VLM for document understanding. It does two things:
-
-1. Document-to-Markdown OCR (default): images -> clean markdown with HTML tables,
-   LaTeX math, and <figure> tags.
-2. Schema-guided structured extraction: images + a JSON template -> JSON output
-   shaped exactly like the template. Useful for invoices, receipts, forms, contracts.
-
-Modes are selected via flags:
-- (no flags)         -> markdown OCR
-- --mode content     -> plain-content extraction
-- --template SOURCE  -> structured extraction with a NuExtract template
-- --schema SOURCE    -> structured extraction with a JSON Schema
-                        (auto-converted via numind.nuextract_utils)
-- --instructions STR -> free-text guidance passed through to the model
-                        (output-format rules, branch routing, etc.).
-                        Combines with any of the modes above.
-                        See https://huggingface.co/numind/NuExtract3#instructions
-
---template / --schema each accept inline JSON, a URL, or a local file path, so a
-schema can be hosted (e.g. on an HF dataset's raw URL) and reused across jobs:
-    --template https://huggingface.co/datasets/ORG/REPO/raw/main/card.json
-
-HF Jobs invocation: the [tool.hf-jobs] header above sets the vllm/vllm-openai
-image (vLLM + torch come from the image, with pre-built CUDA kernels), the
-flavor and the HF_TOKEN secret. Needs `hf` CLI 1.32+.
-
-    hf jobs uv run \\
-        https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nuextract3.py \\
-        INPUT_DATASET OUTPUT_DATASET --max-samples 5 --shuffle --seed 42
-
-On your own GPU: uv run --with vllm==0.29.0 nuextract3.py INPUT_DATASET OUTPUT_DATASET
-
-Model: numind/NuExtract3
-License: Apache-2.0
-"""
-
-import argparse
-import base64
-import io
-import json
-import logging
-import os
-import sys
-import time
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
-
-import torch
-from datasets import load_dataset
-from huggingface_hub import DatasetCard, login
-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). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
-from vllm import LLM, SamplingParams
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-MODEL_DEFAULT = "numind/NuExtract3"
-MODEL_NAME = "NuExtract3"
-
-
-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 load_template_arg(value: Optional[str]) -> Optional[Dict[str, Any]]:
-    """Load a NuExtract template/JSON Schema from inline JSON, a URL, or a file path."""
-    if value is None:
-        return None
-    text = value
-    if value.startswith(("http://", "https://")):
-        import urllib.request
-
-        with urllib.request.urlopen(value) as resp:  # noqa: S310
-            text = resp.read().decode("utf-8")
-    elif "{" not in value:
-        # Inline JSON often exceeds the OS filename limit, so only probe the
-        # filesystem when the value doesn't look like JSON; treat OSError as
-        # "not a path".
-        try:
-            candidate_path = Path(value)
-            if candidate_path.is_file():
-                text = candidate_path.read_text()
-        except OSError:
-            pass
-    try:
-        return json.loads(text)
-    except json.JSONDecodeError as e:
-        raise ValueError(
-            f"Could not parse template/schema as JSON (tried URL/path/inline): {e}"
-        ) from e
-
-
-def resolve_template(
-    template_arg: Optional[str],
-    schema_arg: Optional[str],
-) -> Optional[Dict[str, Any]]:
-    """Resolve --template / --schema into a NuExtract template dict, or None."""
-    if template_arg and schema_arg:
-        raise ValueError("--template and --schema are mutually exclusive.")
-
-    if template_arg is not None:
-        return load_template_arg(template_arg)
-
-    if schema_arg is not None:
-        schema = load_template_arg(schema_arg)
-        try:
-            from numind.nuextract_utils import convert_json_schema_to_nuextract_template
-        except ImportError as e:
-            raise RuntimeError(
-                "--schema requires the `numind` package. "
-                "It should be listed in this script's PEP 723 dependencies."
-            ) from e
-        template, dropped = convert_json_schema_to_nuextract_template(schema)
-        if dropped:
-            logger.warning(
-                f"numind dropped {len(dropped)} unsupported branches from the JSON Schema: "
-                f"{dropped}"
-            )
-        return template
-
-    return None
-
-
-def image_to_data_uri(image: Union[Image.Image, Dict[str, Any], str]) -> str:
-    """Normalize an HF dataset image cell to a PNG data URI."""
-    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)}")
-
-    pil_img = pil_img.convert("RGB")
-    buf = io.BytesIO()
-    pil_img.save(buf, format="PNG")
-    return f"data:image/png;base64,{base64.b64encode(buf.getvalue()).decode()}"
-
-
-def make_message(image: Union[Image.Image, Dict[str, Any], str]) -> List[Dict]:
-    """Build an OpenAI-format chat message containing one image."""
-    data_uri = image_to_data_uri(image)
-    return [
-        {
-            "role": "user",
-            "content": [
-                {"type": "image_url", "image_url": {"url": data_uri}},
-            ],
-        }
-    ]
-
-
-def split_thinking(text: str) -> tuple[Optional[str], str]:
-    """Return (reasoning, answer) if <think>...</think> is present, else (None, text)."""
-    if "<think>" in text and "</think>" in text:
-        reasoning = text.split("<think>", 1)[1].split("</think>", 1)[0].strip()
-        answer = text.split("</think>", 1)[1].strip()
-        return reasoning, answer
-    return None, text.strip()
-
-
-def parse_json_output(text: str) -> tuple[Optional[Any], bool]:
-    """Parse an extraction output; strip ``` fences as the model card describes.
-
-    Returns (parsed_value, parse_error). On failure, parsed_value is None.
-    """
-    stripped = text.strip()
-    if stripped.startswith("```"):
-        stripped = stripped.split("\n", 1)[-1] if "\n" in stripped else stripped[3:]
-        if stripped.endswith("```"):
-            stripped = stripped[:-3].rstrip()
-    try:
-        return json.loads(stripped), False
-    except json.JSONDecodeError:
-        return None, True
-
-
-def create_dataset_card(
-    source_dataset: str,
-    model: str,
-    num_samples: int,
-    processing_time: str,
-    mode_label: str,
-    template: Optional[Dict[str, Any]],
-    enable_thinking: bool,
-    temperature: float,
-    output_column: str,
-    image_column: str,
-    split: str,
-) -> str:
-    """Create a dataset card documenting the NuExtract3 run."""
-    model_name = model.split("/")[-1]
-    template_block = ""
-    if template is not None:
-        template_block = (
-            "\n### Extraction Template\n\n```json\n"
-            + json.dumps(template, indent=2)
-            + "\n```\n"
-        )
-
-    return f"""---
-tags:
-- ocr
-- structured-extraction
-- document-processing
-- nuextract3
-- markdown
-- uv-script
-- generated
----
-
-# {model_name} on {source_dataset}
-
-This dataset contains outputs from [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) processed with [NuExtract3](https://huggingface.co/{model}), a 4B vision-language model for document understanding.
-
-## Processing Details
-
-- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
-- **Model**: [{model}](https://huggingface.co/{model})
-- **Mode**: {mode_label}
-- **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}`
-- **Output Column**: `{output_column}`
-- **Dataset Split**: `{split}`
-- **Temperature**: {temperature}
-- **Thinking Mode**: {"enabled" if enable_thinking else "disabled"}
-{template_block}
-## Dataset Structure
-
-Original columns plus:
-- `{output_column}`: NuExtract3 output ({"JSON string" if template else "markdown"})
-- `inference_info`: JSON list tracking models applied to this dataset
-{"- `" + output_column + "_reasoning`: model's thinking trace (when enabled)" if enable_thinking else ""}
-
-Generated with [UV Scripts](https://huggingface.co/uv-scripts)
-"""
-
-
-def main(
-    input_dataset: str,
-    output_dataset: str,
-    image_column: str = "image",
-    batch_size: int = 16,
-    max_model_len: int = 16384,
-    max_tokens: int = 8192,
-    gpu_memory_utilization: float = 0.8,
-    mode: str = "markdown",
-    template_arg: Optional[str] = None,
-    schema_arg: Optional[str] = None,
-    enable_thinking: bool = False,
-    instructions: Optional[str] = None,
-    temperature: Optional[float] = None,
-    model: str = MODEL_DEFAULT,
-    hf_token: str = None,
-    split: str = "train",
-    max_samples: int = None,
-    private: bool = False,
-    shuffle: bool = False,
-    seed: int = 42,
-    output_column: Optional[str] = None,
-    overwrite: bool = False,
-    verbose: bool = False,
-    config: str = None,
-    create_pr: bool = False,
-):
-    """Process images from an HF dataset through NuExtract3."""
-
-    check_cuda_availability()
-    start_time = datetime.now()
-
-    HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
-    if HF_TOKEN:
-        login(token=HF_TOKEN)
-
-    template = resolve_template(template_arg, schema_arg)
-    extraction_mode = template is not None
-    mode_label = "structured-extraction" if extraction_mode else mode
-
-    if output_column is None:
-        output_column = "extraction" if extraction_mode else "markdown"
-
-    if temperature is None:
-        temperature = 0.6 if enable_thinking else 0.2
-
-    logger.info(f"Using model: {model}")
-    logger.info(f"Mode: {mode_label}")
-    logger.info(f"Thinking: {enable_thinking}  Temperature: {temperature}")
-    if extraction_mode:
-        logger.info(f"Template: {json.dumps(template, indent=2)}")
-
-    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.
-    # With --enable-thinking the script also writes "{output_column}_reasoning".
-    out_cols = [output_column]
-    if enable_thinking:
-        out_cols.append(f"{output_column}_reasoning")
-    dataset = ensure_output_columns_free(dataset, out_cols, 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")
-
-    logger.info("Initializing vLLM with NuExtract3")
-    logger.info("This may take a few minutes on first run...")
-    llm = LLM(
-        model=model,
-        trust_remote_code=True,
-        max_model_len=max_model_len,
-        gpu_memory_utilization=gpu_memory_utilization,
-        limit_mm_per_prompt={"image": 1},
-    )
-
-    sampling_params = SamplingParams(
-        temperature=temperature,
-        max_tokens=max_tokens,
-    )
-
-    chat_template_kwargs: Dict[str, Any] = {"enable_thinking": enable_thinking}
-    if extraction_mode:
-        chat_template_kwargs["template"] = json.dumps(template, indent=4)
-    else:
-        chat_template_kwargs["mode"] = mode
-    if instructions:
-        chat_template_kwargs["instructions"] = instructions
-
-    logger.info(f"Processing {len(dataset)} images in batches of {batch_size}")
-    logger.info(f"Output will be written to column: {output_column}")
-
-    all_outputs: List[str] = []
-    all_reasoning: List[Optional[str]] = []
-    all_parse_errors: List[bool] = []
-    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:
-            batch_messages = [make_message(img) for img in batch_images]
-            outputs = llm.chat(
-                batch_messages,
-                sampling_params,
-                chat_template_kwargs=chat_template_kwargs,
-                chat_template_content_format="openai",
-            )
-
-            for output in outputs:
-                raw_text = output.outputs[0].text
-                reasoning, answer = split_thinking(raw_text)
-
-                if extraction_mode:
-                    parsed, parse_error = parse_json_output(answer)
-                    stored = (
-                        json.dumps(parsed, ensure_ascii=False)
-                        if parsed is not None
-                        else answer
-                    )
-                    all_outputs.append(stored)
-                    all_parse_errors.append(parse_error)
-                else:
-                    all_outputs.append(answer)
-                    all_parse_errors.append(False)
-
-                all_reasoning.append(reasoning)
-
-            processed += len(batch_images)
-
-        except Exception as e:
-            logger.error(f"Error processing batch: {e}")
-            all_outputs.extend(["[NUEXTRACT3 ERROR]"] * len(batch_images))
-            all_reasoning.extend([None] * len(batch_images))
-            all_parse_errors.extend([True] * 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_outputs)
-
-    if enable_thinking and any(r is not None for r in all_reasoning):
-        reasoning_col = f"{output_column}_reasoning"
-        logger.info(f"Adding '{reasoning_col}' column to dataset")
-        dataset = dataset.add_column(reasoning_col, all_reasoning)
-
-    if extraction_mode:
-        parse_error_count = sum(all_parse_errors)
-        if parse_error_count:
-            logger.warning(
-                f"{parse_error_count}/{len(all_parse_errors)} extractions failed to parse as JSON"
-            )
-
-    inference_entry = {
-        "model_id": model,
-        "model_name": MODEL_NAME,
-        "column_name": output_column,
-        "timestamp": datetime.now().isoformat(),
-        "mode": mode_label,
-        "has_template": extraction_mode,
-        "enable_thinking": enable_thinking,
-        "temperature": temperature,
-        "max_tokens": max_tokens,
-    }
-    if extraction_mode:
-        inference_entry["parse_error_rate"] = (
-            sum(all_parse_errors) / len(all_parse_errors) if all_parse_errors else 0.0
-        )
-
-    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)
-
-    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"
-            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} {mode_label} 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. Results are lost.")
-                sys.exit(1)
-
-    logger.info("Creating dataset card")
-    card_content = create_dataset_card(
-        source_dataset=input_dataset,
-        model=model,
-        num_samples=len(dataset),
-        processing_time=processing_time_str,
-        mode_label=mode_label,
-        template=template,
-        enable_thinking=enable_thinking,
-        temperature=temperature,
-        output_column=output_column,
-        image_column=image_column,
-        split=split,
-    )
-    card = DatasetCard(card_content)
-    card.push_to_hub(output_dataset, token=HF_TOKEN)
-
-    logger.info("Done! NuExtract3 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",
-            "numind",
-        ]:
-            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("NuExtract3 - Document-to-Markdown + Structured Extraction (4B)")
-        print("=" * 70)
-        print("\nModes:")
-        print("  markdown          - Image -> markdown (default)")
-        print("  content           - Image -> plain content")
-        print("  --template / --schema  - Image -> JSON shaped like the template")
-        print("\nExamples:")
-        print("\n1. Markdown OCR:")
-        print("   uv run --with vllm==0.29.0 nuextract3.py input-dataset output-dataset")
-        print("\n2. Structured extraction with an inline template:")
-        print("   uv run --with vllm==0.29.0 nuextract3.py input output \\")
-        print('     --template \'{"title": "verbatim-string", "date": "date"}\'')
-        print("\n3. Structured extraction from a JSON Schema (e.g. Pydantic):")
-        print("   uv run --with vllm==0.29.0 nuextract3.py input output --schema schema.json")
-        print("\n   (--template / --schema also accept a URL or a local file path)")
-        print("\n4. Reasoning mode for harder documents:")
-        print("   uv run --with vllm==0.29.0 nuextract3.py input output --enable-thinking")
-        print("\n5. Test with 10 samples:")
-        print("   uv run --with vllm==0.29.0 nuextract3.py large-ds test --max-samples 10 --shuffle")
-        print("\n6. Running on HF Jobs (image/flavor/secrets from the script header, hf 1.32+):")
-        print("   hf jobs uv run \\")
-        print(
-            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nuextract3.py \\"
-        )
-        print("       input-dataset output-dataset --batch-size 16")
-        print("\nFor full help: uv run --with vllm==0.29.0 nuextract3.py --help")
-        sys.exit(0)
-
-    parser = argparse.ArgumentParser(
-        description="NuExtract3: document-to-markdown + schema-guided JSON extraction (4B VLM)",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Modes:
-  (default)     Markdown OCR (image -> clean markdown)
-  --mode content
-                Plain-content extraction (less structured than markdown)
-  --template PATH_OR_JSON
-                Structured extraction with a NuExtract template
-  --schema PATH_OR_JSON
-                Structured extraction from a JSON Schema
-                (e.g. Pydantic Model.model_json_schema())
-
-Examples:
-  uv run --with vllm==0.29.0 nuextract3.py my-docs analyzed-docs
-  uv run --with vllm==0.29.0 nuextract3.py receipts extracted \\
-      --template '{"store": "verbatim-string", "total": "number"}'
-  uv run --with vllm==0.29.0 nuextract3.py contracts extracted --schema contract_schema.json
-  uv run --with vllm==0.29.0 nuextract3.py hard-docs out --enable-thinking
-        """,
-    )
-
-    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(
-        "--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)",
-    )
-    parser.add_argument(
-        "--max-tokens",
-        type=int,
-        default=8192,
-        help="Maximum tokens to generate (default: 8192)",
-    )
-    parser.add_argument(
-        "--gpu-memory-utilization",
-        type=float,
-        default=0.8,
-        help="GPU memory utilization (default: 0.8)",
-    )
-    parser.add_argument(
-        "--mode",
-        choices=["markdown", "content"],
-        default="markdown",
-        help="OCR mode when no template/schema is given (default: markdown)",
-    )
-    parser.add_argument(
-        "--template",
-        help="NuExtract template: inline JSON, a URL, or a file path",
-    )
-    parser.add_argument(
-        "--schema",
-        help="JSON Schema to auto-convert: inline JSON, a URL, or a file path",
-    )
-    parser.add_argument(
-        "--enable-thinking",
-        action="store_true",
-        help="Enable reasoning mode (slower, better on hard documents)",
-    )
-    parser.add_argument(
-        "--instructions",
-        default=None,
-        help=(
-            "Free-text instructions passed to NuExtract via "
-            "chat_template_kwargs.instructions (e.g. routing guidance across "
-            "optional schema branches, output-format rules). "
-            "See https://huggingface.co/numind/NuExtract3#instructions"
-        ),
-    )
-    parser.add_argument(
-        "--temperature",
-        type=float,
-        default=None,
-        help="Sampling temperature (default: 0.2 non-thinking, 0.6 thinking)",
-    )
-    parser.add_argument(
-        "--model",
-        default=MODEL_DEFAULT,
-        help=f"Model ID (default: {MODEL_DEFAULT})",
-    )
-    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=None,
-        help="Column name for output (default: 'markdown' in OCR mode, 'extraction' in template mode)",
-    )
-    parser.add_argument(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists 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",
-    )
-
-    args = parser.parse_args()
-
-    main(
-        input_dataset=args.input_dataset,
-        output_dataset=args.output_dataset,
-        image_column=args.image_column,
-        batch_size=args.batch_size,
-        max_model_len=args.max_model_len,
-        max_tokens=args.max_tokens,
-        gpu_memory_utilization=args.gpu_memory_utilization,
-        mode=args.mode,
-        template_arg=args.template,
-        schema_arg=args.schema,
-        enable_thinking=args.enable_thinking,
-        instructions=args.instructions,
-        temperature=args.temperature,
-        model=args.model,
-        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,
-        overwrite=args.overwrite,
-        verbose=args.verbose,
-        config=args.config,
-        create_pr=args.create_pr,
-    )

numarkdown-ocr.py

@@ -47,10 +47,6 @@ from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)
@@ -75,28 +71,6 @@ def check_gpu_availability() -> int:
     return num_gpus
 
 
-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 validate_and_resize_image(
     image: Image.Image,
     min_pixels: int = 100 * 28 * 28,
@@ -339,7 +313,6 @@ def main(
     temperature: float = 0.0,
     custom_prompt: Optional[str] = None,
     output_column: str = "markdown",
-    overwrite: bool = False,
     config: str = None,
     create_pr: bool = False,
     verbose: bool = False,
@@ -384,9 +357,6 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
-    # Fail fast if the output column would collide with an existing input column
-    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
-
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -603,7 +573,7 @@ if __name__ == "__main__":
             "   uv run numarkdown-ocr.py large-docs processed-docs --tensor-parallel-size 2"
         )
         print("\n7. Running on HF Jobs:")
-        print("   hf jobs uv run --flavor a100x4 \\")
+        print("   hf jobs uv run --flavor a100x2 \\")
         print(
             '     -e HF_TOKEN=$(python3 -c "from huggingface_hub import get_token; print(get_token())") \\'
         )
@@ -726,12 +696,6 @@ Examples:
         default="markdown",
         help="Column name for output text (default: markdown)",
     )
-    parser.add_argument(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists in the input dataset "
-        "(default: error out to avoid clobbering an existing column).",
-    )
     parser.add_argument(
         "--config",
         help="Config/subset name when pushing to Hub (for benchmarking multiple models in one repo)",
@@ -769,7 +733,6 @@ Examples:
         temperature=args.temperature,
         custom_prompt=args.custom_prompt,
         output_column=args.output_column,
-        overwrite=args.overwrite,
         config=args.config,
         create_pr=args.create_pr,
         verbose=args.verbose,

ocr-vllm-judge.py

@@ -2,20 +2,14 @@
 # /// script
 # requires-python = ">=3.11"
 # dependencies = [
-#     "datasets>=4.0.0,<5.1",  # 5.1 needs huggingface_hub>=1.31; the image ships an older 1.x on PYTHONPATH, which wins
+#     "datasets>=4.0.0",
 #     "huggingface-hub",
 #     "pillow",
+#     "vllm>=0.15.1",
+#     "torch",
 #     "rich",
 #     "tqdm",
 # ]
-#
-# [tool.hf-jobs]
-# image = "vllm/vllm-openai:v0.29.0"
-# python = "/usr/bin/python3"
-# env = { PYTHONPATH = "/usr/local/lib/python3.12/dist-packages" }
-# flavor = "a100-large"
-# timeout = "1h"
-# secrets = ["HF_TOKEN"]
 # ///
 """
 Offline vLLM judge for OCR benchmark evaluation.
@@ -41,10 +35,8 @@ Usage:
         --judge-model Qwen/Qwen2.5-VL-7B-Instruct \\
         --max-samples 50
 
-    # Via HF Job. The [tool.hf-jobs] header pins vllm/vllm-openai:v0.29.0 (the
-    # default uv image has no nvcc, which vLLM needs at warmup) and a100-large
-    # (the default 7B judge does not leave room for the KV cache on a 24 GB L4).
-    hf jobs uv run --timeout 1h \\
+    # Via HF Job
+    hf jobs uv run --flavor l4x1 -s HF_TOKEN \\
         ocr-vllm-judge.py davanstrien/ocr-bench-nls-50 --from-prs \\
         --judge-model Qwen/Qwen3-VL-8B-Instruct --max-samples 50
 """
@@ -644,7 +636,7 @@ Examples:
       --max-samples 50
 
   # Via HF Job
-  hf jobs uv run --timeout 1h \\
+  hf jobs uv run --flavor l4x1 -s HF_TOKEN \\
       ocr-vllm-judge.py my-bench --from-prs \\
       --judge-model Qwen/Qwen3-VL-8B-Instruct
         """,
@@ -703,9 +695,6 @@ Examples:
         default=None,
         help="Push judge results to this HF dataset repo (e.g. davanstrien/ocr-bench-rubenstein-judge)",
     )
-    parser.add_argument(
-        "--private", action="store_true", help="Create the --save-results repo as private"
-    )
     args = parser.parse_args()
 
     # --- CUDA check ---
@@ -787,7 +776,7 @@ Examples:
 
         # Comparisons config
         comp_ds = Dataset.from_list(comparison_log)
-        comp_ds.push_to_hub(args.save_results, config_name="comparisons", private=args.private)
+        comp_ds.push_to_hub(args.save_results, config_name="comparisons")
         console.print(f"  Pushed [cyan]comparisons[/cyan] ({len(comparison_log)} rows)")
 
         # Leaderboard config
@@ -806,7 +795,7 @@ Examples:
                 }
             )
         Dataset.from_list(leaderboard_rows).push_to_hub(
-            args.save_results, config_name="leaderboard", private=args.private
+            args.save_results, config_name="leaderboard"
         )
         console.print(
             f"  Pushed [cyan]leaderboard[/cyan] ({len(leaderboard_rows)} rows)"
@@ -824,7 +813,7 @@ Examples:
             "from_prs": args.from_prs,
         }
         Dataset.from_list([metadata_row]).push_to_hub(
-            args.save_results, config_name="metadata", private=args.private
+            args.save_results, config_name="metadata"
         )
         console.print("  Pushed [cyan]metadata[/cyan]")
         console.print(f"  [green]Results saved to: {args.save_results}[/green]")

olmocr2-vllm.py

@@ -1,21 +1,16 @@
 # /// script
 # requires-python = ">=3.11"
 # dependencies = [
-#     "datasets>=4.0.0,<5.1",  # 5.1 needs huggingface_hub>=1.31; the image ships an older 1.x on PYTHONPATH, which wins
+#     "datasets",
 #     "huggingface-hub",
 #     "pillow",
+#     "vllm",
 #     "tqdm",
 #     "toolz",
+#     "torch",
 #     "pyyaml",  # For parsing YAML front matter
 # ]
 #
-# [tool.hf-jobs]
-# image = "vllm/vllm-openai:v0.29.0"
-# python = "/usr/bin/python3"
-# env = { PYTHONPATH = "/usr/local/lib/python3.12/dist-packages" }
-# flavor = "a10g-small"
-# timeout = "2h"
-# secrets = ["HF_TOKEN"]
 # ///
 
 """
@@ -35,13 +30,6 @@ Features:
 
 Model: allenai/olmOCR-2-7B-1025-FP8
 Based on: Qwen2.5-VL-7B-Instruct fine-tuned on olmOCR-mix
-
-Run on HF Jobs (the [tool.hf-jobs] header sets image, flavor and secrets;
-needs `hf` CLI 1.32+):
-    hf jobs uv run olmocr2-vllm.py input-dataset output-dataset
-
-Run on your own GPU (vLLM and torch come from the Jobs image, so add vLLM):
-    uv run --with vllm==0.29.0 olmocr2-vllm.py input-dataset output-dataset
 """
 
 import argparse
@@ -62,11 +50,8 @@ from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
+from vllm.sampling_params import GuidedDecodingParams
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -93,28 +78,6 @@ def check_cuda_availability():
         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 parse_yaml_frontmatter(text: str) -> tuple[dict, str]:
     """
     Parse YAML front matter from olmOCR output.
@@ -277,14 +240,15 @@ Each row contains:
 ## Reproduction
 
 ```bash
-# Using HF Jobs (recommended; the script header sets image/flavor/secrets, hf CLI 1.32+)
-hf jobs uv run \\
+# Using HF Jobs (recommended)
+hf jobs uv run --flavor l4x1 \\
+  -s HF_TOKEN \\
   https://huggingface.co/datasets/uv-scripts/ocr/raw/main/olmocr2-vllm.py \\
   {source_dataset} \\
   your-username/output-dataset
 
 # Local with GPU
-uv run --with vllm==0.29.0 https://huggingface.co/datasets/uv-scripts/ocr/raw/main/olmocr2-vllm.py \\
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/olmocr2-vllm.py \\
   {source_dataset} \\
   your-username/output-dataset
 ```
@@ -313,7 +277,6 @@ def main(
     output_dataset: str,
     image_column: str = "image",
     output_column: str = "markdown",
-    overwrite: bool = False,
     batch_size: int = 16,
     model: str = "allenai/olmOCR-2-7B-1025-FP8",
     max_model_len: int = 16384,
@@ -327,8 +290,6 @@ def main(
     private: bool = False,
     shuffle: bool = False,
     seed: int = 42,
-    config: str = None,
-    create_pr: bool = False,
 ):
     """
     Process a dataset of document images through olmOCR-2 to extract markdown.
@@ -369,9 +330,6 @@ def main(
     logger.info(f"Loading dataset: {input_dataset}")
     ds = load_dataset(input_dataset, split=split)
 
-    # Fail fast if the output column would collide with an existing input column
-    ds = ensure_output_columns_free(ds, [output_column], overwrite=overwrite)
-
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -407,25 +365,13 @@ def main(
         "stop": ["<|im_end|>", "<|endoftext|>"],
     }
 
-    # Add guided decoding if requested (enforces YAML front matter structure).
-    # vLLM 0.22.x renamed this API: GuidedDecodingParams (guided_decoding=) →
-    # StructuredOutputsParams (structured_outputs=). Import lazily + shim so the
-    # default path (guided_decoding=False) never touches the moved symbol.
+    # Add guided decoding if requested (enforces YAML front matter structure)
     if guided_decoding:
         logger.info("Enabling guided decoding with YAML front matter regex")
-        front_matter_regex = r"---\nprimary_language: (?:[a-z]{2}|null)\nis_rotation_valid: (?:True|False|true|false)\nrotation_correction: (?:0|90|180|270)\nis_table: (?:True|False|true|false)\nis_diagram: (?:True|False|true|false)\n(?:---|---\n[\s\S]+)"
-        try:
-            from vllm.sampling_params import StructuredOutputsParams
-
-            sampling_params_kwargs["structured_outputs"] = StructuredOutputsParams(
-                regex=front_matter_regex
-            )
-        except ImportError:
-            from vllm.sampling_params import GuidedDecodingParams
-
-            sampling_params_kwargs["guided_decoding"] = GuidedDecodingParams(
-                regex=front_matter_regex
-            )
+        guided_params = GuidedDecodingParams(
+            regex=r"---\nprimary_language: (?:[a-z]{2}|null)\nis_rotation_valid: (?:True|False|true|false)\nrotation_correction: (?:0|90|180|270)\nis_table: (?:True|False|true|false)\nis_diagram: (?:True|False|true|false)\n(?:---|---\n[\s\S]+)"
+        )
+        sampling_params_kwargs["guided_decoding"] = guided_params
 
     sampling_params = SamplingParams(**sampling_params_kwargs)
 
@@ -474,41 +420,36 @@ def main(
         ds = ds.remove_columns([metadata_column_name])
     ds = ds.add_column(metadata_column_name, all_metadata)
 
-    # Add inference information — standard schema: a JSON-string LIST of entries, each carrying
-    # model_id (used as the leaderboard label) and column_name (the output text column). The
-    # script's own extras (version, timestamp, sampling params) ride along as extra keys.
-    inference_entry = {
-        "model_id": model,
-        "column_name": output_column,
-        "script": "olmocr2-vllm.py",
-        "version": "1.0.0",
-        "timestamp": datetime.now().isoformat(),
-        "batch_size": batch_size,
-        "max_tokens": max_tokens,
-        "temperature": temperature,
-    }
+    # Add inference information
+    inference_info = json.dumps(
+        {
+            "model": model,
+            "script": "olmocr2-vllm.py",
+            "version": "1.0.0",
+            "timestamp": datetime.now().isoformat(),
+            "batch_size": batch_size,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+        }
+    )
 
-    # Handle existing inference_info column (append to the list; create a fresh list otherwise)
+    # Handle existing inference_info column
     if inference_info_column in ds.column_names:
-        logger.info("Updating existing inference_info column")
-
+        # Parse existing, append new model info
         def update_inference_info(example):
             try:
-                existing_info = (
-                    json.loads(example[inference_info_column])
-                    if example[inference_info_column]
-                    else []
-                )
-            except (json.JSONDecodeError, TypeError):
-                existing_info = []
-            existing_info.append(inference_entry)
-            return {inference_info_column: json.dumps(existing_info)}
+                existing = json.loads(example[inference_info_column])
+                if not isinstance(existing, list):
+                    existing = [existing]
+            except (json.JSONDecodeError, KeyError):
+                existing = []
+
+            existing.append(json.loads(inference_info))
+            return {inference_info_column: json.dumps(existing)}
 
         ds = ds.map(update_inference_info)
     else:
-        logger.info("Creating new inference_info column")
-        inference_list = [json.dumps([inference_entry])] * len(ds)
-        ds = ds.add_column(inference_info_column, inference_list)
+        ds = ds.add_column(inference_info_column, [inference_info] * len(ds))
 
     # Calculate processing time
     elapsed_time = time.time() - start_time
@@ -533,13 +474,9 @@ def main(
 
     # Push to hub
     logger.info(f"Pushing to HuggingFace Hub: {output_dataset}")
-    commit_info = ds.push_to_hub(
+    ds.push_to_hub(
         output_dataset,
         private=private,
-        **({"config_name": config} if config else {}),
-        create_pr=create_pr,
-        commit_message=f"Add {model} OCR results ({len(ds)} samples)"
-        + (f" [{config}]" if config else ""),
     )
 
     # Update dataset card
@@ -550,8 +487,6 @@ def main(
     logger.info(f"✓ Dataset: https://huggingface.co/datasets/{output_dataset}")
     logger.info(f"✓ Processing time: {processing_time}")
     logger.info(f"✓ Samples processed: {len(ds):,}")
-    if create_pr and getattr(commit_info, "pr_url", None):
-        logger.info(f"✓ Pull request created: {commit_info.pr_url}")
 
 
 if __name__ == "__main__":
@@ -562,30 +497,32 @@ if __name__ == "__main__":
 Examples:
 
 1. Basic OCR on a dataset:
-   uv run --with vllm==0.29.0 olmocr2-vllm.py input-dataset output-dataset
+   uv run olmocr2-vllm.py input-dataset output-dataset
 
 2. Test with first 10 samples:
-   uv run --with vllm==0.29.0 olmocr2-vllm.py input-dataset output-dataset --max-samples 10
+   uv run olmocr2-vllm.py input-dataset output-dataset --max-samples 10
 
 3. Process with custom batch size:
-   uv run --with vllm==0.29.0 olmocr2-vllm.py input-dataset output-dataset --batch-size 8
+   uv run olmocr2-vllm.py input-dataset output-dataset --batch-size 8
 
 4. Custom image column:
-   uv run --with vllm==0.29.0 olmocr2-vllm.py input-dataset output-dataset --image-column page_image
+   uv run olmocr2-vllm.py input-dataset output-dataset --image-column page_image
 
 5. Private output dataset:
-   uv run --with vllm==0.29.0 olmocr2-vllm.py input-dataset output-dataset --private
+   uv run olmocr2-vllm.py input-dataset output-dataset --private
 
 6. Random sampling:
-   uv run --with vllm==0.29.0 olmocr2-vllm.py input-dataset output-dataset --max-samples 100 --shuffle
+   uv run olmocr2-vllm.py input-dataset output-dataset --max-samples 100 --shuffle
 
-7. Running on HuggingFace Jobs (header sets image/flavor/secrets; hf CLI 1.32+):
-   hf jobs uv run \\
+7. Running on HuggingFace Jobs:
+   hf jobs uv run --flavor l4x1 \\
+     -s HF_TOKEN \\
      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/olmocr2-vllm.py \\
      input-dataset output-dataset
 
 8. Real example with historical documents:
-   hf jobs uv run --timeout 2h \\
+   hf jobs uv run --flavor l4x1 \\
+     -s HF_TOKEN \\
      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/olmocr2-vllm.py \\
      NationalLibraryOfScotland/Britain-and-UK-Handbooks-Dataset \\
      your-username/handbooks-olmocr \\
@@ -606,12 +543,6 @@ Examples:
         default="markdown",
         help="Column name for markdown output (default: markdown)",
     )
-    parser.add_argument(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists in the input dataset "
-        "(default: error out to avoid clobbering an existing column).",
-    )
     parser.add_argument(
         "--batch-size",
         type=int,
@@ -671,15 +602,6 @@ Examples:
         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",
@@ -698,7 +620,6 @@ Examples:
         output_dataset=args.output_dataset,
         image_column=args.image_column,
         output_column=args.output_column,
-        overwrite=args.overwrite,
         batch_size=args.batch_size,
         model=args.model,
         max_model_len=args.max_model_len,
@@ -712,6 +633,4 @@ Examples:
         private=args.private,
         shuffle=args.shuffle,
         seed=args.seed,
-        config=args.config,
-        create_pr=args.create_pr,
     )

ovis-ocr2-saturate.py

@@ -1,254 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "saturate[hf]==0.3.0",
-#     "pillow>=10",
-# ]
-#
-# [tool.hf-jobs]
-# image = "vllm/vllm-openai:v0.22.1"
-# flavor = "a10g-small"
-# timeout = "4h"
-# secrets = ["HF_TOKEN"]
-# ///
-"""
-Convert document images to markdown using OvisOCR2 via saturate.
-
-Companion to `ovis-ocr2-server.py`: same model, prompt, message shape, sampling,
-and post-processing, same in-job `vllm serve` — but the driver half (concurrency,
-retries, output, resume) is the `saturate` library instead of hand-rolled code.
-What that buys over the -server recipe:
-
-- **Adaptive concurrency** — the window sizes itself from live engine signals
-  (no `--concurrency` flag to tune).
-- **Crash-safe, resumable output** — results stream to the output repo as
-  parquet parts while the run is hot; re-running the same command skips
-  everything already done (exact anti-join on id).
-- **Durable error rows** — a failed page is recorded as `{id, error}` instead of
-  an `[OCR ERROR]` string in the text column; `--retry-errors` re-admits only
-  those rows on a later run.
-
-Run on HF Jobs. The script starts `vllm serve` itself; its [tool.hf-jobs] header
-declares the image that provides the `vllm` binary, the hardware and the HF_TOKEN
-secret (`hf` CLI 1.32+). Pass --timeout for a long run; flags override the header:
-
-  hf jobs uv run --detach --timeout 4h \\
-      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/ovis-ocr2-saturate.py \\
-      <input-dataset> <output-dataset>
-
-Smoke test first with --max-samples 3. On your own GPU (vllm on PATH):
-
-  uv run --with vllm==0.22.1 ovis-ocr2-saturate.py <input-dataset> <output-dataset>
-
-Output layout (differs from the -server recipe, which pushes input+markdown):
-the output repo holds `data/part-*.parquet` with rows
-`{id, markdown, model, prompt_tokens, completion_tokens, error}` keyed by the
-input row id (`--id-column`, or `<split>-<index>` by default). Read it with
-`datasets.load_dataset(<output>, data_dir="data")` or `saturate.read_output`;
-join back to the input on id. Run metadata lands in `data/completions/`.
-
-Model: ATH-MaaS/OvisOCR2 (0.9B, Apache-2.0, 96.58 OmniDocBench)
-- The card's exact OCR prompt (leading newline included — outputs are tuned to
-  this wording), image before text, `enable_thinking=False` via
-  chat_template_kwargs (the Qwen3.5 template otherwise injects a thinking
-  preamble).
-- Images downscaled client-side to the processor's max_pixels bound (8.3MP) and
-  sent as JPEG q95 — the same clamp the server would apply, moved client-side to
-  shrink the payload; min/max pixel bounds ride on the engine boot flag.
-- Post-processing per the card: bbox `<img>` placeholder blocks dropped (keep
-  with --keep-image-tags) and degenerate trailing repeats trimmed.
-
-The SERVING dict below is the per-model tuning prior (serve flags + client
-sampling + context math). Agents can `ast.literal_eval` it without running
-the script; the script itself consumes it, so it cannot drift from reality.
-"""
-
-import argparse
-import base64
-import io
-import math
-import sys
-
-# Serving starting values for ATH-MaaS/OvisOCR2. Per-value provenance:
-# - The card documents OFFLINE inference only — no `vllm serve` command exists
-#   upstream. The whole server arrangement here (incl. serve_args) is the
-#   uv-scripts construction inherited from ovis-ocr2-server.py.
-# - max_model_len 32768: house choice (card sets none; native ctx is 262144 —
-#   NEVER boot without a cap on 24GB, the full-context KV profile kills boot).
-# - cache/mm flags: house OCR defaults (OCR never reuses images, so prefix/
-#   processor caches only cost memory).
-# - mm-processor-kwargs pixel bounds: card's offline example, verbatim
-#   (min 448*448=200704, max 2880*2880=8294400), moved to the engine flag.
-# - max_tokens 16384 / temperature 0.0: card's sampling, verbatim.
-# Throughput receipt (a10g-small, 20 pages): 4,057 tok/s, window ramped to 32.
-SERVING = {
-    "model": "ATH-MaaS/OvisOCR2",
-    "image": "vllm/vllm-openai:v0.22.1",
-    "max_model_len": 32768,
-    "serve_args": [
-        "--limit-mm-per-prompt", '{"image": 1}',
-        "--mm-processor-cache-gb", "0",
-        "--no-enable-prefix-caching",
-        "--mm-processor-kwargs",
-        '{"images_kwargs": {"min_pixels": 200704, "max_pixels": 8294400}}',
-    ],
-    "max_tokens": 16384,
-    "temperature": 0.0,
-    "max_pixels": 8294400,
-}
-assert SERVING["max_tokens"] < SERVING["max_model_len"], (
-    "context math: max_tokens must leave room for the image tokens "
-    "(input + output <= max_model_len, or every request 400s)"
-)
-
-OCR_PROMPT = (
-    "\nExtract all readable content from the image in natural human reading order "
-    "and output the result as a single Markdown document. For charts or images, "
-    'represent them using an HTML image tag: <img src="images/bbox_{left}_{top}_{right}_{bottom}.jpg" />, '
-    "where left, top, right, bottom are bounding box coordinates scaled to [0, 1000). "
-    "Format formulas as LaTeX. Format tables as HTML: <table>...</table>. "
-    "Transcribe all other text as standard Markdown. Preserve the original text "
-    "without translation or paraphrasing."
-)
-
-
-def to_pil(value):
-    from PIL import Image
-
-    if isinstance(value, Image.Image):
-        return value
-    if isinstance(value, dict) and value.get("bytes"):
-        return Image.open(io.BytesIO(value["bytes"]))
-    if isinstance(value, (bytes, bytearray)):
-        return Image.open(io.BytesIO(value))
-    raise ValueError(f"unsupported image value: {type(value)}")
-
-
-def encode_image(value, max_pixels: int) -> str:
-    """RGB-convert, downscale to max_pixels if needed, return base64 JPEG q95."""
-    from PIL import Image
-
-    img = to_pil(value).convert("RGB")
-    w, h = img.size
-    if w * h > max_pixels:
-        scale = math.sqrt(max_pixels / (w * h))
-        img = img.resize((int(w * scale), int(h * scale)), Image.LANCZOS)
-    buf = io.BytesIO()
-    img.save(buf, format="JPEG", quality=95)
-    return base64.b64encode(buf.getvalue()).decode()
-
-
-def clean_truncated_repeats(
-    text: str,
-    min_text_len: int = 8000,
-    max_period: int = 200,
-    min_period: int = 1,
-    min_repeat_chars: int = 100,
-    min_repeat_times: int = 5,
-) -> str:
-    """Trim degenerate trailing repetition (verbatim port of the model card's cleanup)."""
-    n = len(text)
-    if n < min_text_len:
-        return text
-
-    max_period = min(max_period, n - 1)
-    for unit_len in range(min_period, max_period + 1):
-        if text[n - 1] != text[n - 1 - unit_len]:
-            continue
-
-        match_len = 1
-        idx = n - 2
-        while idx >= unit_len and text[idx] == text[idx - unit_len]:
-            match_len += 1
-            idx -= 1
-
-        total_len = match_len + unit_len
-        repeat_times = total_len // unit_len
-        tail_len = total_len % unit_len
-
-        if repeat_times >= min_repeat_times and total_len >= min_repeat_chars:
-            return text[: n - total_len + unit_len] + text[n - tail_len:]
-
-    return text
-
-
-def filter_image_tags(text: str) -> str:
-    blocks = text.split("\n\n")
-    return "\n\n".join(
-        b for b in blocks if not b.strip().startswith('<img src="images/bbox_')
-    )
-
-
-def main():
-    ap = argparse.ArgumentParser(description="OvisOCR2 batch OCR via saturate")
-    ap.add_argument("input_dataset", help="Input dataset repo id (rows with an image column)")
-    ap.add_argument("output_dataset", help="Output dataset repo id (created if missing)")
-    ap.add_argument("--image-column", default="image")
-    ap.add_argument("--config", default=None, help="Dataset config name")
-    ap.add_argument("--split", default="train")
-    ap.add_argument("--id-column", default=None,
-                    help="Column to use as row id (default: split-index ids)")
-    ap.add_argument("--max-samples", "--limit", dest="limit", type=int, default=None,
-                    help="Process only the first N rows (smoke test)")
-    ap.add_argument("--max-tokens", type=int, default=SERVING["max_tokens"])
-    ap.add_argument("--keep-image-tags", action="store_true",
-                    help="Keep the bbox <img> placeholder blocks in the output")
-    ap.add_argument("--retry-errors", action="store_true",
-                    help="Re-admit rows whose only record is an error row")
-    args = ap.parse_args()
-
-    import pyarrow as pa
-    from saturate import Auto, Engine, dataset_rows, pump
-
-    rows = dataset_rows(
-        args.input_dataset, config=args.config, split=args.split,
-        columns=[args.image_column], ids=args.id_column or "index", limit=args.limit,
-    )
-
-    def to_request(row):
-        b64 = encode_image(row[args.image_column], SERVING["max_pixels"])
-        return {
-            "model": SERVING["model"],
-            "messages": [{"role": "user", "content": [
-                {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b64}"}},
-                {"type": "text", "text": OCR_PROMPT},
-            ]}],
-            "temperature": SERVING["temperature"],
-            "max_tokens": args.max_tokens,
-            "chat_template_kwargs": {"enable_thinking": False},
-        }
-
-    # Declared, so a part holding only error rows has the same columns as the rest
-    # (datasets.load_dataset reads every part with one schema).
-    schema = pa.schema([
-        ("id", pa.string()), ("error", pa.string()), ("markdown", pa.string()),
-        ("model", pa.string()), ("prompt_tokens", pa.int64()), ("completion_tokens", pa.int64()),
-    ])  # fmt: skip
-
-    def parse(row, body):
-        text = body["choices"][0]["message"]["content"].strip()
-        if not args.keep_image_tags:
-            text = filter_image_tags(text)
-        text = clean_truncated_repeats(text)
-        usage = body.get("usage") or {}
-        return {
-            "markdown": text,
-            "model": SERVING["model"],
-            "prompt_tokens": usage.get("prompt_tokens"),
-            "completion_tokens": usage.get("completion_tokens"),
-        }
-
-    extra = ["--max-model-len", str(SERVING["max_model_len"]), *SERVING["serve_args"]]
-    output = f"hf://datasets/{args.output_dataset}/data"
-    with Engine(SERVING["model"], engine="vllm", extra_args=extra) as endpoint:
-        stats = pump(rows, to_request, parse, endpoint, output,
-                     window=Auto(initial=8, max_limit=48),
-                     retry_errors=args.retry_errors, schema=schema)
-
-    print(f"https://huggingface.co/datasets/{args.output_dataset} "
-          f"({stats.rows_processed} ok, {stats.rows_failed} error rows)", file=sys.stderr)
-    print("OVIS_OCR2_SATURATE " + stats.to_json(), flush=True)
-
-
-if __name__ == "__main__":
-    main()

ovis-ocr2-server.py

@@ -1,794 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "datasets>=4.0.0",
-#     "huggingface-hub",
-#     "pillow",
-#     "requests",
-# ]
-# ///
-
-"""
-Convert document images to markdown using OvisOCR2 via an in-job vLLM server.
-
-Same model, prompt, and outputs as ovis-ocr2.py, but serves the model behind
-`vllm serve` inside the job and posts images concurrently — continuous batching
-stays fed instead of draining at each offline `llm.generate()` batch barrier,
-and a bad image fails one request instead of a whole batch of 16.
-
-This script is the *driver* half: it expects the server on localhost (started
-by the job command below), loads the input dataset, posts images concurrently,
-postprocesses (repeat-trim + img-tag filter, as in ovis-ocr2.py), and pushes
-the result dataset. The driver has no torch/vllm deps, so `uv run` starts in
-seconds while the server warms up in parallel.
-
-NOTE: OvisOCR2's card documents offline vLLM only (checked 2026-07-16) — this
-server translation is ours, not the authors'. The serve flags below mirror the
-card's offline args; treat A/B output parity with ovis-ocr2.py as part of any
-benchmark run (same --max-samples slice, diff the markdown columns).
-
-Run on HF Jobs (standard uv-run shape — the script starts `vllm serve` itself
-as a subprocess when no server is already reachable; the only thing to get
-right is the --image flag, which provides the `vllm` binary):
-
-  hf jobs uv run --detach --flavor l4x1 -s HF_TOKEN --timeout 4h \\
-      --image vllm/vllm-openai:v0.22.1 \\
-      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/ovis-ocr2-server.py \\
-      <input-dataset> <output-dataset>
-
-To use an already-running or remote endpoint instead, pass --server URL — the
-script only spawns a server when the (default localhost) URL is unreachable.
-The serve flags live in SERVE_ARGS below, the single source of truth.
-
-Serve-flag provenance (the card only shows offline `LLM(...)` args):
-- `--no-enable-prefix-caching --mm-processor-cache-gb 0`: the recurring official
-  OCR-serving pattern (DeepSeek-OCR vLLM recipe, LightOnOCR, PaddleOCR-VL recipe)
-  — OCR never reuses images, the caches only cost memory.
-- `--mm-processor-kwargs`: server-side equivalent of the card's per-request
-  `images_kwargs` pixel bounds. The driver ALSO downscales oversized images
-  client-side to the same max_pixels, so outputs match even if the server flag
-  is dropped.
-- The card's offline `gdn_prefill_backend="triton"` (JIT/nvcc workaround for the
-  bare uv image) is NOT needed here: the vllm-openai image ships the full CUDA
-  toolchain. Add `--gdn-prefill-backend triton` to the serve command if the
-  default backend misbehaves.
-- `enable_thinking=False` (card-mandated, Qwen3.5 templates can inject a
-  thinking preamble) is passed per-request via `chat_template_kwargs`.
-
-Model: ATH-MaaS/OvisOCR2 (0.9B, Apache-2.0, 96.58 OmniDocBench v1.6)
-vLLM: stock Qwen3_5ForConditionalGeneration arch, needs vllm >= 0.22.1.
-"""
-
-import argparse
-import atexit
-import base64
-import concurrent.futures
-import io
-import json
-import logging
-import math
-import os
-import shutil
-import subprocess
-import sys
-import threading
-import time
-from datetime import datetime
-from typing import Any, Dict, Union
-from urllib.parse import urlparse
-
-import requests
-from datasets import load_dataset
-from huggingface_hub import DatasetCard, login
-from PIL import Image
-
-logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
-logger = logging.getLogger(__name__)
-
-MODEL = "ATH-MaaS/OvisOCR2"
-
-# Fixed instruction prompt, verbatim from the model card (including the leading newline).
-# The card warns outputs are tuned to this exact wording — don't "improve" it.
-OCR_PROMPT = (
-    "\nExtract all readable content from the image in natural human reading order "
-    "and output the result as a single Markdown document. For charts or images, "
-    'represent them using an HTML image tag: <img src="images/bbox_{left}_{top}_'
-    '{right}_{bottom}.jpg" />, where left, top, right, bottom are bounding box '
-    "coordinates scaled to [0, 1000). Format formulas as LaTeX. Format tables as "
-    "HTML: <table>...</table>. Transcribe all other text as standard Markdown. "
-    "Preserve the original text without translation or paraphrasing."
-)
-
-# Image bounds from the model card's parser.
-DEFAULT_MIN_PIXELS = 448 * 448  # 200,704
-DEFAULT_MAX_PIXELS = 2880 * 2880  # 8,294,400
-
-# The serve command this script spawns when no server is reachable — single
-# source of truth for the serving configuration (see docstring for provenance).
-SERVE_ARGS = [
-    "vllm", "serve", MODEL,
-    "--max-model-len", "32768",
-    "--gpu-memory-utilization", "0.85",
-    "--limit-mm-per-prompt", '{"image": 1}',
-    "--no-enable-prefix-caching",
-    "--mm-processor-cache-gb", "0",
-    "--mm-processor-kwargs",
-    f'{{"images_kwargs": {{"min_pixels": {DEFAULT_MIN_PIXELS}, "max_pixels": {DEFAULT_MAX_PIXELS}}}}}',
-    "--port", "8000",
-]
-
-RUN_COMMAND = (
-    "hf jobs uv run --detach --flavor l4x1 -s HF_TOKEN --timeout 4h \\\n"
-    "    --image vllm/vllm-openai:v0.22.1 \\\n"
-    "    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/ovis-ocr2-server.py \\\n"
-    "    <input-dataset> <output-dataset>"
-)
-
-
-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 encode_image(image, max_pixels: int) -> str:
-    """RGB-convert, downscale to max_pixels if oversized, return base64 JPEG.
-
-    The server's processor clamps to the same bound, so this only changes where
-    the downscale happens — doing it client-side shrinks the request payload
-    (a 30MP scan is ~4x the bytes of its 8.3MP clamp) and keeps outputs
-    identical even if the serve command omits --mm-processor-kwargs.
-    """
-    img = to_pil_image(image)
-    w, h = img.size
-    if w * h > max_pixels:
-        scale = math.sqrt(max_pixels / (w * h))
-        img = img.resize((max(1, int(w * scale)), max(1, int(h * scale))), Image.LANCZOS)
-    buf = io.BytesIO()
-    img.save(buf, format="JPEG", quality=95)
-    return base64.b64encode(buf.getvalue()).decode()
-
-
-def clean_truncated_repeats(
-    text: str,
-    min_text_len: int = 8000,
-    max_period: int = 200,
-    min_period: int = 1,
-    min_repeat_chars: int = 100,
-    min_repeat_times: int = 5,
-) -> str:
-    """Trim degenerate trailing repetition (verbatim port of the model card's cleanup).
-
-    Long outputs that hit max_tokens can end in a repeated unit (a char, phrase, or
-    table row); this detects the shortest repeating tail unit and keeps one copy.
-    """
-    n = len(text)
-    if n < min_text_len:
-        return text
-
-    max_period = min(max_period, n - 1)
-    for unit_len in range(min_period, max_period + 1):
-        if text[n - 1] != text[n - 1 - unit_len]:
-            continue
-
-        match_len = 1
-        idx = n - 2
-        while idx >= unit_len and text[idx] == text[idx - unit_len]:
-            match_len += 1
-            idx -= 1
-
-        total_len = match_len + unit_len
-        repeat_times = total_len // unit_len
-        tail_len = total_len % unit_len
-
-        if repeat_times >= min_repeat_times and total_len >= min_repeat_chars:
-            return text[: n - total_len + unit_len] + text[n - tail_len :]
-
-    return text
-
-
-def filter_image_tags(text: str) -> str:
-    """Drop visual-region <img> blocks (upstream parser's default behaviour)."""
-    return "\n\n".join(
-        block
-        for block in text.split("\n\n")
-        if not block.strip().startswith('<img src="images/bbox_')
-    )
-
-
-def postprocess_output(text: str, keep_image_tags: bool) -> str:
-    text = text.strip()
-    if not keep_image_tags:
-        text = filter_image_tags(text)
-    return clean_truncated_repeats(text)
-
-
-def server_alive(server: str) -> bool:
-    try:
-        return requests.get(f"{server}/health", timeout=5).status_code == 200
-    except requests.RequestException:
-        return False
-
-
-def wait_for_server(server: str, timeout_s: int, proc: "subprocess.Popen | None" = None):
-    logger.info(f"Waiting for server at {server}...")
-    deadline = time.time() + timeout_s
-    while time.time() < deadline:
-        if server_alive(server):
-            logger.info("Server is ready")
-            return
-        if proc is not None and proc.poll() is not None:
-            logger.error(f"Spawned vllm serve exited with code {proc.returncode} before becoming ready")
-            sys.exit(1)
-        time.sleep(10)
-    logger.error(f"Server did not become ready within {timeout_s}s")
-    sys.exit(1)
-
-
-def ensure_server(server: str, timeout_s: int = 1800):
-    """Use a reachable server; otherwise spawn `vllm serve` ourselves; else fail fast.
-
-    Spawning is only attempted for a localhost URL — a remote --server that is
-    down is the user's to fix, not ours to shadow with a local model.
-    """
-    if server_alive(server):
-        logger.info(f"Using already-running server at {server}")
-        return
-
-    host = urlparse(server).hostname or ""
-    if host not in ("127.0.0.1", "localhost", "0.0.0.0"):
-        logger.info(f"Remote server {server} not up yet — waiting for it")
-        wait_for_server(server, timeout_s)
-        return
-
-    if shutil.which("vllm") is None:
-        logger.error("No server is running and the `vllm` binary is not on PATH.")
-        logger.error("Run this script on a vLLM image so it can start the server itself:\n")
-        logger.error(RUN_COMMAND)
-        logger.error("\n(or start `vllm serve` yourself / pass --server URL of a running endpoint)")
-        sys.exit(1)
-
-    logger.info(f"Starting server: {' '.join(SERVE_ARGS)}")
-    proc = subprocess.Popen(SERVE_ARGS)  # logs interleave with ours on stdout/stderr
-    atexit.register(proc.terminate)  # don't leave a GPU server behind on local runs
-    wait_for_server(server, timeout_s, proc=proc)
-
-
-def ocr_one(
-    server: str,
-    image,
-    max_pixels: int,
-    max_tokens: int,
-    timeout_s: int,
-    retries: int = 2,
-) -> str:
-    """OCR a single image via the chat completions API. Returns raw model text."""
-    b64 = encode_image(image, max_pixels)
-    payload = {
-        "model": MODEL,
-        "messages": [
-            {
-                "role": "user",
-                "content": [
-                    # Image first, then text — same order the card's chat template uses.
-                    {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b64}"}},
-                    {"type": "text", "text": OCR_PROMPT},
-                ],
-            }
-        ],
-        "temperature": 0.0,
-        "max_tokens": max_tokens,
-        # Card-mandated: Qwen3.5 templates can inject a thinking preamble otherwise.
-        "chat_template_kwargs": {"enable_thinking": False},
-    }
-    last_err = None
-    for attempt in range(retries + 1):
-        try:
-            resp = requests.post(
-                f"{server}/v1/chat/completions", json=payload, timeout=timeout_s
-            )
-            resp.raise_for_status()
-            return resp.json()["choices"][0]["message"]["content"]
-        except Exception as e:
-            last_err = e
-            if attempt < retries:
-                time.sleep(10 * (attempt + 1))
-    raise RuntimeError(f"request failed after {retries + 1} attempts: {last_err}")
-
-
-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,
-    num_samples: int,
-    num_errors: int,
-    processing_time: str,
-    images_per_sec: float,
-    concurrency: int,
-    max_tokens: int,
-    keep_image_tags: bool,
-    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"; "" on CPU
-    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 ""
-
-    return f"""---
-tags:
-- ocr
-- document-processing
-- ovis-ocr2
-- markdown
-- uv-script
-- generated{jobs_tag}
----
-
-# Document OCR using {model_name} (server mode)
-
-This dataset contains OCR results from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using OvisOCR2, a compact 0.9B document parsing model (96.58 on OmniDocBench v1.6), served behind an in-job vLLM server with concurrent requests (continuous batching).
-
-## Processing Details
-
-- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
-- **Model**: [{model}](https://huggingface.co/{model})
-- **Number of Samples**: {num_samples:,}
-- **Failed Requests**: {num_errors:,} (marked `[OCR ERROR]`)
-- **Processing Time**: {processing_time}
-- **Throughput**: {images_per_sec:.2f} images/sec
-- **Processing Date**: {datetime.now().strftime("%Y-%m-%d %H:%M UTC")}
-
-### Configuration
-
-- **Mode**: vLLM server (`vllm serve`) + concurrent driver, {concurrency} concurrent requests
-- **Image Column**: `{image_column}`
-- **Dataset Split**: `{split}`
-- **Max Output Tokens**: {max_tokens:,}
-- **Temperature**: 0.0 (greedy, per model card)
-- **Visual-region image tags**: {"kept" if keep_image_tags else "filtered (default)"}
-
-## Dataset Structure
-
-The dataset contains all original columns plus:
-- `markdown`: The extracted text in markdown format
-- `inference_info`: JSON list tracking all OCR models applied to this dataset
-
-## Reproduction
-
-{origin} with the [`ovis-ocr2-server.py`](https://huggingface.co/datasets/uv-scripts/ocr/raw/main/ovis-ocr2-server.py) recipe from [uv-scripts](https://huggingface.co/uv-scripts) — see the script docstring for the single `hf jobs run` command that starts the server and driver together. The offline-vLLM sibling recipe is [`ovis-ocr2.py`](https://huggingface.co/datasets/uv-scripts/ocr/raw/main/ovis-ocr2.py).
-"""
-
-
-def main(
-    input_dataset: str,
-    output_dataset: str,
-    image_column: str = "image",
-    server: str = "http://127.0.0.1:8000",
-    concurrency: int = 32,
-    max_tokens: int = 16384,
-    max_pixels: int = DEFAULT_MAX_PIXELS,
-    request_timeout: int = 1800,
-    keep_image_tags: bool = False,
-    hf_token: str = None,
-    split: str = "train",
-    max_samples: int = None,
-    private: bool = False,
-    shuffle: bool = False,
-    seed: int = 42,
-    output_column: str = "markdown",
-    overwrite: bool = False,
-    config: str = None,
-    create_pr: bool = False,
-):
-    """Process images from HF dataset through an OvisOCR2 vLLM server."""
-
-    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} via server {server}")
-
-    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}"
-        )
-
-    dataset = ensure_output_columns_free(dataset, [output_column], 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")
-
-    # Reuse a reachable server, else spawn `vllm serve` (needs the vllm binary,
-    # i.e. a vllm/vllm-openai image), else fail fast with the correct command.
-    ensure_server(server)
-
-    n = len(dataset)
-    logger.info(f"Processing {n} images, concurrency {concurrency}")
-    all_outputs = [None] * n
-    errors = 0
-    done = 0
-    inference_start = time.time()
-    lock = threading.Lock()
-
-    def worker(i: int) -> None:
-        nonlocal errors, done
-        try:
-            text = ocr_one(
-                server,
-                dataset[i][image_column],
-                max_pixels,
-                max_tokens,
-                request_timeout,
-            )
-            all_outputs[i] = postprocess_output(text, keep_image_tags)
-        except Exception as e:
-            logger.error(f"Image {i} failed: {e}")
-            all_outputs[i] = "[OCR ERROR]"
-            with lock:
-                errors += 1
-        with lock:
-            done += 1
-            if done % 25 == 0 or done == n:
-                rate = done / max(time.time() - inference_start, 1e-9)
-                logger.info(f"{done}/{n} done ({rate:.2f} img/s, {errors} errors)")
-
-    with concurrent.futures.ThreadPoolExecutor(max_workers=concurrency) as pool:
-        list(pool.map(worker, range(n)))
-
-    inference_secs = time.time() - inference_start
-    processing_duration = datetime.now() - start_time
-    processing_time_str = f"{processing_duration.total_seconds() / 60:.1f} min"
-    images_per_sec = n / inference_secs if inference_secs else 0.0
-
-    logger.info(f"Adding '{output_column}' column to dataset")
-    dataset = dataset.add_column(output_column, all_outputs)
-
-    # Inference info tracking
-    inference_entry = {
-        "model_id": MODEL,
-        "model_name": "OvisOCR2",
-        "column_name": output_column,
-        "timestamp": datetime.now().isoformat(),
-        "temperature": 0.0,
-        "max_tokens": max_tokens,
-        "max_pixels": max_pixels,
-        "keep_image_tags": keep_image_tags,
-        "mode": "vllm-server",
-        "concurrency": concurrency,
-    }
-
-    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"
-            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, server mode)"
-                + (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)
-
-    logger.info("Creating dataset card")
-    card_content = create_dataset_card(
-        source_dataset=input_dataset,
-        model=MODEL,
-        num_samples=len(dataset),
-        num_errors=errors,
-        processing_time=processing_time_str,
-        images_per_sec=images_per_sec,
-        concurrency=concurrency,
-        max_tokens=max_tokens,
-        keep_image_tags=keep_image_tags,
-        image_column=image_column,
-        split=split,
-    )
-
-    card = DatasetCard(card_content)
-    card.push_to_hub(output_dataset, token=HF_TOKEN)
-
-    logger.info("Done! OvisOCR2 server-mode 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"Throughput: {images_per_sec:.2f} images/sec "
-        f"(inference only, excl. dataset load/push; {errors} errors)"
-    )
-
-
-if __name__ == "__main__":
-    if len(sys.argv) == 1:
-        print("=" * 70)
-        print("OvisOCR2 Document Processing (vLLM server mode)")
-        print("=" * 70)
-        print("\nSame model + outputs as ovis-ocr2.py, but drives an in-job")
-        print("`vllm serve` with concurrent requests — no batch barriers,")
-        print("per-image (not per-batch) failure isolation.")
-        print("\nThe server must already be running (the job command starts")
-        print("both — see the module docstring for the full `hf jobs run`).")
-        print("\nExamples:")
-        print("\n1. Basic OCR (server on localhost:8000):")
-        print("   uv run ovis-ocr2-server.py input-dataset output-dataset")
-        print("\n2. Test with a small sample:")
-        print("   uv run ovis-ocr2-server.py large-dataset test --max-samples 10 --shuffle")
-        print("\n3. Throughput A/B vs the offline recipe:")
-        print("   run both scripts on the same --max-samples slice and compare")
-        print("   the images/sec lines + diff the markdown columns")
-        print("\nFor full help: uv run ovis-ocr2-server.py --help")
-        sys.exit(0)
-
-    parser = argparse.ArgumentParser(
-        description="Document OCR using OvisOCR2 via an in-job vLLM server",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  uv run ovis-ocr2-server.py my-docs analyzed-docs
-  uv run ovis-ocr2-server.py large-dataset test --max-samples 50 --shuffle
-See the module docstring for the full `hf jobs run` command (server + driver in one job).
-        """,
-    )
-
-    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(
-        "--image-column",
-        default="image",
-        help="Column containing images (default: image)",
-    )
-    parser.add_argument(
-        "--server",
-        default="http://127.0.0.1:8000",
-        help="vLLM server base URL (default: in-job localhost:8000)",
-    )
-    parser.add_argument(
-        "--concurrency",
-        type=int,
-        default=32,
-        help="Concurrent OCR requests (default: 32; vLLM queues excess internally, "
-        "so this mainly needs to be high enough to keep continuous batching fed)",
-    )
-    parser.add_argument(
-        "--max-tokens",
-        type=int,
-        default=16384,
-        help="Maximum tokens to generate (default: 16384, the model card value)",
-    )
-    parser.add_argument(
-        "--max-pixels",
-        type=int,
-        default=DEFAULT_MAX_PIXELS,
-        help=f"Maximum image pixels; larger images are downscaled client-side before "
-        f"upload (default: {DEFAULT_MAX_PIXELS}, = 2880*2880, the model card value)",
-    )
-    parser.add_argument(
-        "--request-timeout",
-        type=int,
-        default=1800,
-        help="Per-request timeout in seconds (default: 1800)",
-    )
-    parser.add_argument(
-        "--keep-image-tags",
-        action="store_true",
-        help="Keep visual-region <img src=\"images/bbox_...\"> tags in the output "
-        "(default: filtered, matching the upstream parser)",
-    )
-    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(
-        "--overwrite",
-        action="store_true",
-        help="Replace the output column if it already exists in the input dataset "
-        "(default: error out to avoid clobbering an existing column).",
-    )
-
-    args = parser.parse_args()
-
-    main(
-        input_dataset=args.input_dataset,
-        output_dataset=args.output_dataset,
-        image_column=args.image_column,
-        server=args.server,
-        concurrency=args.concurrency,
-        max_tokens=args.max_tokens,
-        max_pixels=args.max_pixels,
-        request_timeout=args.request_timeout,
-        keep_image_tags=args.keep_image_tags,
-        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,
-        overwrite=args.overwrite,
-        config=args.config,
-        create_pr=args.create_pr,
-    )