I need pull

AGENTS.md

@@ -1,92 +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.
-
-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.
-
-## 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

@@ -3,17 +3,10 @@
 ## Active Scripts
 
 ### DeepSeek-OCR v1 (`deepseek-ocr-vllm.py`)
-✅ **Production Ready** (Fixed 2026-02-12)
-- Uses official vLLM offline pattern: `llm.generate()` with PIL images
-- `NGramPerReqLogitsProcessor` prevents repetition on complex documents
-- Resolution modes removed (handled by vLLM's multimodal processor)
-- See: https://docs.vllm.ai/projects/recipes/en/latest/DeepSeek/DeepSeek-OCR.html
-
-**Known issue (vLLM nightly, 2026-02-12):** Some images trigger a crop dimension validation error:
-```
-ValueError: images_crop dim[2] expected 1024, got 640. Expected shape: ('bnp', 3, 1024, 1024), but got torch.Size([0, 3, 640, 640])
-```
-This is a vLLM bug: the preprocessor defaults to gundam mode (image_size=640), but the tensor validator expects 1024x1024 even when the crop batch is empty (dim 0). Hit 2/10 on `davanstrien/ufo-ColPali`, 0/10 on NLS Medical History. Likely depends on image aspect ratios. No upstream issue filed yet. Related feature request: [vllm#28160](https://github.com/vllm-project/vllm/issues/28160) (no way to control resolution mode via mm-processor-kwargs).
+✅ **Production Ready**
+- Fully supported by vLLM
+- Fast batch processing
+- Tested and working on HF Jobs
 
 ### LightOnOCR-2-1B (`lighton-ocr2.py`)
 ✅ **Production Ready** (Fixed 2026-01-29)
@@ -82,117 +75,90 @@ hf jobs uv run --flavor l4x1 \
 - Backend: Transformers (single image processing)
 - Requires: `transformers>=5.0.0`
 
-### DoTS.ocr-1.5 (`dots-ocr-1.5.py`)
-✅ **Production Ready** (Fixed 2026-03-14)
-
-**Status:** Working with vLLM 0.17.1 stable
-
-**Model availability:** The v1.5 model is NOT on HF from the original authors. We mirrored it from ModelScope to `davanstrien/dots.ocr-1.5`. Original: https://modelscope.cn/models/rednote-hilab/dots.ocr-1.5. License: MIT-based (with supplementary terms for responsible use).
-
-**Key fix (2026-03-14):** Must pass `chat_template_content_format="string"` to `llm.chat()`. The model's `tokenizer_config.json` chat template expects string content (not openai-format lists). Without this, the model generates empty output (~1 token then EOS). The separate `chat_template.json` file handles multimodal content but vLLM uses the tokenizer_config template by default.
+## Pending Development
 
-**Bbox coordinate system (layout modes):**
-Bounding boxes from `layout-all` and `layout-only` modes are in the **resized image coordinate space**, not original image coordinates. The model uses `Qwen2VLImageProcessor` which resizes images via `smart_resize()`:
-- `max_pixels=11,289,600`, `factor=28` (patch_size=14 × merge_size=2)
-- Images are scaled down so `w×h ≤ max_pixels`, dims rounded to multiples of 28
-- To map bboxes back to original image coordinates:
-```python
-import math
-
-def smart_resize(height, width, factor=28, min_pixels=3136, max_pixels=11289600):
-    h_bar = max(factor, round(height / factor) * factor)
-    w_bar = max(factor, round(width / factor) * factor)
-    if h_bar * w_bar > max_pixels:
-        beta = math.sqrt((height * width) / max_pixels)
-        h_bar = math.floor(height / beta / factor) * factor
-        w_bar = math.floor(width / beta / factor) * factor
-    elif h_bar * w_bar < min_pixels:
-        beta = math.sqrt(min_pixels / (height * width))
-        h_bar = math.ceil(height * beta / factor) * factor
-        w_bar = math.ceil(width * beta / factor) * factor
-    return h_bar, w_bar
-
-resized_h, resized_w = smart_resize(orig_h, orig_w)
-scale_x = orig_w / resized_w
-scale_y = orig_h / resized_h
-# Then: orig_x = bbox_x * scale_x, orig_y = bbox_y * scale_y
+### 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:
 ```
-
-**Test results (2026-03-14):**
-- 3/3 samples on L4: OCR mode working, ~147 toks/s output
-- 3/3 samples on L4: layout-all mode working, structured JSON with bboxes
-- 10/10 samples on A100: layout-only mode on NLS Highland News, ~670 toks/s output
-- Output datasets: `davanstrien/dots-ocr-1.5-smoke-test-v3`, `davanstrien/dots-ocr-1.5-layout-test`, `davanstrien/dots-ocr-1.5-nls-layout-test`
-
-**Prompt modes:**
-- `ocr` — text extraction (default)
-- `layout-all` — layout + bboxes + categories + text (JSON)
-- `layout-only` — layout + bboxes + categories only (JSON)
-- `web-parsing` — webpage layout analysis (JSON) [new in v1.5]
-- `scene-spotting` — scene text detection [new in v1.5]
-- `grounding-ocr` — text from bounding box region [new in v1.5]
-- `general` — free-form (use with `--custom-prompt`) [new in v1.5]
-
-**Example usage:**
-```bash
-hf jobs uv run --flavor l4x1 \
-    -s HF_TOKEN \
-    /path/to/dots-ocr-1.5.py \
-    davanstrien/ufo-ColPali output-dataset \
-    --model davanstrien/dots.ocr-1.5 \
-    --max-samples 10 --shuffle --seed 42
+ValidationError: Model architectures ['DeepseekOCR2ForCausalLM'] are not supported for now.
+Supported architectures: [...'DeepseekOCRForCausalLM'...]
 ```
 
-**Model Info:**
-- Original: `rednote-hilab/dots.ocr-1.5` (ModelScope only)
-- Mirror: `davanstrien/dots.ocr-1.5` (HF)
-- Parameters: 3B (1.2B vision encoder + 1.7B language model)
-- Architecture: DotsOCRForCausalLM (custom code, trust_remote_code required)
-- Precision: BF16
-- GitHub: https://github.com/rednote-hilab/dots.ocr
+**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
 
----
-
-## Pending Development
-
-### DeepSeek-OCR-2 (`deepseek-ocr2-vllm.py`)
-✅ **Production Ready** (2026-02-12)
-
-**Status:** Working with vLLM nightly (requires nightly for `DeepseekOCR2ForCausalLM` support, not yet in stable 0.15.1)
-
-**What was done:**
-- Rewrote the broken draft script (which used base64/llm.chat/resolution modes)
-- Uses the same proven pattern as v1: `llm.generate()` with PIL images + `NGramPerReqLogitsProcessor`
-- Key v2 addition: `limit_mm_per_prompt={"image": 1}` in LLM init
-- Added `addict` and `matplotlib` as dependencies (required by model's HF custom code)
-
-**Test results (2026-02-12):**
-- 10/10 samples processed successfully on L4 GPU
-- Processing time: 6.4 min (includes model download + warmup)
-- Model: 6.33 GiB, ~475 toks/s input, ~246 toks/s output
-- Output dataset: `davanstrien/deepseek-ocr2-nls-test`
-
-**Example usage:**
-```bash
-hf jobs uv run --flavor l4x1 \
-    -s HF_TOKEN \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/deepseek-ocr2-vllm.py \
-    NationalLibraryOfScotland/medical-history-of-british-india output-dataset \
-    --max-samples 10 --shuffle --seed 42
-```
-
-**Important notes:**
-- Requires vLLM **nightly** (stable 0.15.1 does NOT include DeepSeek-OCR-2 support)
-- The nightly index (`https://wheels.vllm.ai/nightly`) occasionally has transient build issues (e.g., only ARM wheels). If this happens, wait and retry.
-- Uses same API pattern as v1: `NGramPerReqLogitsProcessor`, `SamplingParams(temperature=0, skip_special_tokens=False)`, `extra_args` for ngram settings
+**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
-- Architecture: Visual Causal Flow
-- Resolution: (0-6)x768x768 + 1x1024x1024 patches
+- 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
+}
+```
 
 ## Other OCR Scripts
 
@@ -202,185 +168,6 @@ hf jobs uv run --flavor l4x1 \
 ### PaddleOCR-VL (`paddleocr-vl.py`)
 ✅ Working
 
-### lift (`lift-extract.py`)
-✅ **Both backends validated on Jobs** (added 2026-06-22)
-
-Datalab's `lift` (9B, Qwen3.5-based) for **schema-constrained** structured extraction:
-image *or* multi-page PDF + JSON Schema → JSON. Sits alongside `nuextract3.py` /
-`lfm2-vl-extract.py` in the structured-extraction group, but it's the only one that
-ingests PDFs directly (one row = one document, multi-page collapsed into one extraction).
-
-**Shared rendering** comes from lift: we reuse `lift.input.load_file` (auto-detects PDF vs
-image by content; `pypdfium2`, DPI/min-dim, `--page-range`) via a temp file per row. Each row
-→ a list of page images → one extraction. Both backends share this.
-
-**Backends (`--method`)** — both **in-process, single command** (no server):
-- `hf` (default): drives the `lift-pdf` package directly — `InferenceManager(method="hf")` →
-  `AutoModelForImageTextToText`, bf16, batches a list of `BatchInputItem` conversations with
-  left padding. **No** constrained decoding (plain `model.generate`); trusts lift's training.
-  Runs on the **default** uv image. Simplest path; best for small jobs.
-- `vllm`: vLLM's **offline `LLM()` engine** + `llm.chat()` with structured outputs — the
-  repo's standard fast-batch pattern. We reproduce lift's *own* vLLM recipe (their `generate_vllm`)
-  rather than calling the package: `PROMPT_MAPPING["direct"]`, `scale_to_fit`,
-  `mm_processor_kwargs={min_pixels:3136,max_pixels:861696}`, and the guided JSON schema
-  (`json_schema_to_pydantic.create_model` → `make_properties_nullable` → `StructuredOutputsParams`,
-  with the version shim from `ocr-vllm-judge.py`). Sampling matches lift exactly: `temperature=0.0,
-  top_p=0.1, max_tokens=12384`. Needs the `vllm/vllm-openai` image (vLLM not in our deps; reused
-  from the image via `PYTHONPATH`, which also wins the torch version → no clash). **Not mirrored:**
-  lift's repeat-token retry loop (re-runs looped items at higher temp) — less critical here since
-  the grammar constraint already prevents runaway repetition.
-
-> **History:** the first `--method vllm` used the package's path, which is an OpenAI *client* →
-> server (lift's `lift_vllm` shells out to `sudo docker run`, unusable in a Job). We built+validated
-> an auto-launched `vllm serve` subprocess for it, then replaced the whole thing with the offline
-> `LLM()` engine — cleaner single command, no HTTP, and the repo's established pattern.
-
-**Model id:** card repo is `datalab-to/lift` (9.65B, license `openrail`, not gated). The
-installed package's internal default was `datalab-to/lift-extract`; we pin `--model
-datalab-to/lift` via the `MODEL_CHECKPOINT` env (set *before* importing lift, since settings
-read env at import). Confirmed in the smoke test: `datalab-to/lift` (commit `3129597…`) loads.
-
-**Naming gotcha:** the script must NOT be named `lift.py` — that shadows the installed `lift`
-package (`import lift` resolves to the script itself → `ImportError: cannot import name
-'resolve_schema'`). Hence `lift-extract.py`. Hit this on the first Jobs run.
-
-**License:** code Apache-2.0, **weights modified OpenRAIL-M** (research/personal/<$5M, no
-competitive use vs Datalab API). Surfaced in the docstring, the README entry, and the output
-dataset card.
-
-**Benchmark both backends:** `--config hf --create-pr` vs `--config vllm --create-pr` into one
-repo (same multi-config pattern as the other OCR scripts).
-
-**Smoke-test results (2026-06-22, `davanstrien/ufo-ColPali`, 3 samples, a100-large):**
-- **HF backend** (default image): 3/3 valid JSON, batched (1 chunk of 3 at `--batch-size 8`, no
-  padding/image-count issues), 1.8 min. Output `davanstrien/lift-smoke-hf`. Resolved
-  `lift-pdf==0.1.1, transformers==5.12.1, torch==2.12.1, datasets==5.0.0`.
-- **vLLM offline backend** (`vllm/vllm-openai` image): `LLM()` engine loaded (weights 18 GiB /
-  59s via Xet high-perf), `llm.chat` batched all 3 prompts in one call (538 tok/s in), 3/3 valid
-  JSON via `StructuredOutputsParams`, clean engine shutdown, 5.2 min (engine init + torch.compile
-  warmup dominates at 3 samples; wins at scale). `vllm==0.23.0`, image's `torch==2.11.0+cu130` (no
-  clash). Output `davanstrien/lift-smoke-vllm-offline`.
-  - (The earlier server-subprocess vLLM also passed — `davanstrien/lift-smoke-vllm`, 5.3 min — but
-    was replaced by the offline engine; see History above.)
-- **All paths produce valid schema-shaped JSON**, e.g.
-  `{"title": "OUT OF THIS WORLD UFO FlyBys in Middle Tennessee", "date": "Oct. 26, 1995"}`;
-  absent fields → `null` (nullable-leaf transform). `parse_error_rate: 0.0`. Outputs agree across
-  backends except minor low-temp content drift (offline-vLLM recovered a Spanish title hf left null).
-
-**Still untested (lower risk — reuses lift's `load_file`, exercised on the image path):**
-- PDF column path (`--pdf-column`, `--page-range`) on a real PDF-bytes dataset.
-- `l4x1` for the hf backend (9B bf16 ≈ 19GB; default `a100-large` confirmed comfortable).
-
-Requires Python ≥3.12 (lift-pdf constraint) — fine on the standard images.
-
-### Surya OCR 2 (`surya-ocr.py`)
-✅ **OCR + layout + table validated on Jobs** (added 2026-06-22)
-
-Datalab's **Surya OCR 2** (`datalab-to/surya-ocr-2`, 650M, Qwen3.5-style) for **structured** OCR.
-Unlike the flat-markdown scripts, it returns per-block HTML + bounding boxes + reading order. The
-recipe writes **two columns**: `--output-column` (default `markdown`, flattened reading-order text)
-**and** `surya_blocks` (the full structured result as JSON, one entry per page). `--task` switches
-between `ocr` (RecognitionPredictor, full-page), `layout` (LayoutPredictor), and `table`
-(TableRecPredictor; `--table-mode full` → HTML, `simple` → rows/cols/cells).
-
-**Engine — offline vLLM batch, NO server (the whole trick).** Surya normally runs its VLM through a
-**spawned server**: on GPU it `docker run`s `vllm/vllm-openai`, on CPU a `llama-server` subprocess
-(`surya/inference/backends/{vllm,llamacpp}.py`). Docker-in-Docker isn't available inside a Job, so
-the default path can't work. Instead we subclass Surya's `Backend` ABC
-(`surya/inference/backends/base.py`: `start`/`stop`/`generate(batch)->List[BatchOutputItem]`) with an
-in-process `OfflineVLLMBackend` that runs vLLM's offline `LLM().chat()` and inject it via
-`manager.backend = ...` (bypassing `SuryaInferenceManager.__init__`'s autodetect). **Surya still owns
-everything else** — prompts (`PROMPT_MAPPING`), image scaling (`scale_to_fit`), HTML/bbox parsing, the
-repeat-loop fallback, the 0–1000→pixel bbox rescale, and the layout/table predictors — so we only swap
-the transport. We reuse Surya's own `_build_messages`/`scale_to_fit`/`PROMPT_MAPPING` so the offline
-path matches the server byte-for-byte. `mm_processor_kwargs={min_pixels:3136,max_pixels:6291456}`,
-`dtype=bfloat16`, `max_model_len=18000`, sampling `temperature=0.0/top_p=0.1`, `logprobs=1` →
-`mean_token_prob` → Surya's per-block `confidence`. Guided JSON (layout's `LAYOUT_JSON_SCHEMA`) maps to
-`StructuredOutputsParams`/`GuidedDecodingParams` (same shim as `ocr-vllm-judge.py`). **Not mirrored:**
-Surya's per-item repeat-token retry — its recognition layer already detects loops and falls back to
-layout+block OCR, so the backend stays simple (like lift).
-
-**⚠️ Image gotcha — pin `vllm/vllm-openai:v0.20.1` AND use the `site-packages` path.** Surya-2 is the
-recent, **version-sensitive, hybrid (linear-attention) `qwen3_5`** architecture; v0.20.1 is Surya's
-known-good vLLM. Unlike the other vLLM recipes (which use the unversioned image at
-`/usr/bin/python3` + `dist-packages`), the **`:v0.20.1`** image puts python at `/usr/local/bin/python3`
-and vLLM/torch at **`/usr/local/lib/python3.12/site-packages`**. The first smoke run used the old
-`dist-packages` path → `No module named 'vllm'` → 0/5. Correct flags:
-```bash
-hf jobs uv run --flavor l4x1 -s HF_TOKEN \
-    --image vllm/vllm-openai:v0.20.1 --python /usr/local/bin/python3 \
-    -e PYTHONPATH=/usr/local/lib/python3.12/site-packages \
-    ./ocr/surya-ocr.py davanstrien/ufo-ColPali OUTPUT --max-samples 5
-```
-`PYTHONPATH` is prepended ahead of the uv venv, so the **image's** torch 2.11.0+cu130 / transformers /
-vLLM 0.20.1 win at import even though `surya-ocr` pulls its own torch into the venv (harmless, just a
-wasted download). Confirmed via a probe job: vLLM at `…/site-packages/vllm`, python 3.12.13.
-
-**Naming gotcha:** must be `surya-ocr.py`, never `surya.py` (would shadow the `surya` package on
-import). Checked: no other `surya*` file in the repo.
-
-**Smoke-test results (2026-06-22, `davanstrien/ufo-ColPali`, l4x1, `vllm/vllm-openai:v0.20.1`):**
-- **ocr** (5 samples): 5/5 OK, 3.7 min (vLLM engine init ~113s incl. 34s compile + CUDA-graph capture,
-  then inference). `markdown` clean reading-order text; `surya_blocks` valid JSON with **pixel-space**
-  bboxes (e.g. `[21.6,65.5,30.9,343.4]` within `image_bbox=[0,0,618,1007]`), sequential `reading_order`,
-  canonical labels (PageHeader/SectionHeader/Text/…), `confidence` ~0.94 (logprobs path works), per-block
-  HTML (`<h1>`, `<sup>`, `<br/>`). Output `davanstrien/surya-smoke-ocr`. Resolved `vllm==0.20.1,
-  torch==2.11.0+cu130, transformers==5.7.0, surya-ocr==0.20.0`.
-- **layout** (3 samples): 3/3 OK; `surya_blocks` = `LayoutResult` per page (bboxes with `label`/
-  `position`/`count`/`confidence`, guided-JSON enforced). Output `davanstrien/surya-smoke-layout`.
-- **table** `--table-mode full` (3 samples): 3/3 OK; `TableResult` with `html` populated (rows/cols/cells
-  empty in full mode, by design). ufo-ColPali has no real tables, so use a table dataset for meaningful
-  output — the code path is what's validated. Output `davanstrien/surya-smoke-table`.
-
-- **pdf** (`--pdf-column`/`--page-range`, real 14.8MB arXiv PDF, pages 0–2): 1/1 OK. Text
-  concatenates the 3 pages (title/authors/abstract of arXiv:2606.17162 extracted in reading order);
-  `surya_blocks` has **3 page entries** (`image_bbox=[0,0,1632,2112]` at 192 DPI) with sensible labels
-  (PageHeader/SectionHeader/Text/Picture/Diagram/Caption/ListGroup/…). Source built by wrapping the PDF
-  bytes into a `Value("binary")` column. Output `davanstrien/surya-smoke-pdf`.
-
-**Still untested (low risk):** `--table-mode simple` (rows/cols/cells). Larger GPUs (l4x1 confirmed
-comfortable for 650M).
-
-### Bucket variant (`surya-ocr-bucket.py`) — issue #55 ✅
-✅ **OCR a bucket of files directly, no dataset round-trip** (added 2026-06-22). Reuses the parent's
-`OfflineVLLMBackend` / predictor dispatch / `serialize_pages` **verbatim**; grafts on the bucket I/O
-from `pp-doclayout.py`. Two input strategies via `--io-mode {auto,mount,copy}`: **mount** reads off a
-FUSE-mounted `/in` (`-v hf://buckets/<id>:/in:ro`); **copy** uses `huggingface_hub`
-`list_bucket_tree` + `download_bucket_files` to batch-fetch each `--batch-size` chunk to temp, OCR, then
-`shutil.rmtree` (peak disk = one batch — sidesteps the FUSE bulk-read stall). Two sinks (≥1, both
-allowed): `--output-bucket` writes per-page `<rel>.md` + `<rel>.json` (`surya_blocks`) to a mounted dir
-or `hf://buckets/...` URL (`batch_bucket_files`), **resume-by-skip keyed on the `.json`** (the parent
-bucket recipes have no resume); `--output-dataset` buffers one row per file and `push_to_hub`. `.jp2` is
-first-class (LoC/Chronicling America) with an `imagecodecs` fallback when the image's Pillow lacks
-OpenJPEG.
-
-**⚠️ Dependency gotcha (cost one job):** must pin **`surya-ocr==0.20.0`** in the PEP 723 header. Adding
-`huggingface-hub>=1.6.0` (for the buckets API) loosened the resolve and uv backtracked to an ancient
-surya without the `surya.inference` engine layout → `ModuleNotFoundError: No module named 'surya.inference'`.
-Fix: pin surya, leave `huggingface-hub` unpinned — at runtime `PYTHONPATH` puts the pinned image's hub
-(buckets API present) ahead of the venv, so there's no version tension.
-
-**Smoke-tested on Jobs (2026-06-22, `davanstrien/chronicling-america-mirror-demo`, 1901 *The Commoner*
-`.jp2`, l4x1):** copy→dataset, mount→mounted-bucket-files, copy→API-bucket-files, and resume re-run
-(skip-all, no model load) all 8/8 OK with clean masthead/body OCR + valid pixel-space `surya_blocks`.
-Mount-vs-copy benchmark (32-page seed-42 slice, l4x1, inference identical ~745s — confirms the I/O
-split): **copy wins decisively** — listing **5.1s vs mount 134.2s** (FUSE `rglob` stats all 38k bucket
-files; ~26×), batch-download I/O **57.6s vs FUSE-read 74.6s**. Mount *also* hit a transient
-`Volume mount failed: init container exhausted retries` on the first attempt (needed a cold retry;
-documented fresh-node CSI flake) — copy never mounts. → `auto` defaulting `hf://buckets/...` inputs to
-**copy** is the right call (already the implemented default); mount stays for when the bucket is already
-mounted or zero ephemeral disk is wanted.
-
-**TODO(alto):** ALTO XML export from `surya_blocks` is its own follow-up issue (block-level
-bbox→`HPOS/VPOS/WIDTH/HEIGHT`, label→`TextBlock`/`Illustration`, reading_order→order; line-level needs
-Surya's `DetectionPredictor`; word-level out of scope). The test bucket ships CA's own ALTO `.xml` next
-to each `.jp2` as a ready-made diff target.
-
-**License:** code Apache-2.0, **weights modified OpenRAIL-M** (research/personal/<$5M, no competitive use
-vs Datalab's API). Surfaced in the docstring, README entry, and output dataset card.
-
-**Benchmark/compare:** `--config`/`--create-pr` push the same multi-config pattern as the other scripts.
-
 ---
 
 ## Future: OCR Smoke Test Dataset
@@ -421,314 +208,6 @@ uv run glm-ocr.py uv-scripts/ocr-smoke-test smoke-out --max-samples 5
 
 ---
 
-## OCR Benchmark Coordinator (`ocr-bench-run.py`)
-
-**Status:** Working end-to-end (2026-02-14)
-
-Launches N OCR models on the same dataset via `run_uv_job()`, each pushing to a shared repo as a separate config via `--config/--create-pr`. Eval done separately with `ocr-elo-bench.py`.
-
-### Model Registry (4 models)
-
-| Slug | Model ID | Size | Default GPU | Notes |
-|------|----------|------|-------------|-------|
-| `glm-ocr` | `zai-org/GLM-OCR` | 0.9B | l4x1 | |
-| `deepseek-ocr` | `deepseek-ai/DeepSeek-OCR` | 4B | l4x1 | Auto-passes `--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) |
-
-Each model entry has a `default_args` list for model-specific flags (e.g., DeepSeek uses `["--prompt-mode", "free"]`).
-
-### Workflow
-```bash
-# Launch all 4 models on same data
-uv run ocr-bench-run.py source-dataset --output my-bench --max-samples 50
-
-# Evaluate directly from PRs (no merge needed)
-uv run ocr-elo-bench.py my-bench --from-prs --mode both
-
-# Or merge + evaluate
-uv run ocr-elo-bench.py my-bench --from-prs --merge-prs --mode both
-
-# Other useful flags
-uv run ocr-bench-run.py --list-models          # Show registry table
-uv run ocr-bench-run.py ... --dry-run           # Preview without launching
-uv run ocr-bench-run.py ... --wait              # Poll until complete
-uv run ocr-bench-run.py ... --models glm-ocr dots-ocr  # Subset of models
-```
-
-### Eval script features (`ocr-elo-bench.py`)
-- `--from-prs`: Auto-discovers open PRs on the dataset repo, extracts config names from PR title `[config-name]` suffix, loads data from `refs/pr/N` without merging
-- `--merge-prs`: Auto-merges discovered PRs via `api.merge_pull_request()` before loading
-- `--configs`: Manually specify which configs to load (for merged repos)
-- `--mode both`: Runs pairwise ELO + pointwise scoring
-- Flat mode (original behavior) still works when `--configs`/`--from-prs` not used
-
-### Scripts pushed to Hub
-All 4 scripts have been pushed to `uv-scripts/ocr` on the Hub with `--config`/`--create-pr` support:
-- `glm-ocr.py` ✅
-- `deepseek-ocr-vllm.py` ✅
-- `lighton-ocr2.py` ✅
-- `dots-ocr.py` ✅
-
-### Benchmark Results
-
-#### Run 1: NLS Medical History (2026-02-14) — Pilot
-
-**Dataset:** `NationalLibraryOfScotland/medical-history-of-british-india` (10 samples, shuffled, seed 42)
-**Output repo:** `davanstrien/ocr-bench-test` (4 open PRs)
-**Judge:** `Qwen/Qwen2.5-VL-72B-Instruct` via HF Inference Providers
-**Content:** Historical English, degraded scans of medical texts
-
-**ELO (pairwise, 5 samples evaluated):**
-1. DoTS.ocr — 1540 (67% win rate)
-2. DeepSeek-OCR — 1539 (57%)
-3. LightOnOCR-2 — 1486 (50%)
-4. GLM-OCR — 1436 (29%)
-
-**Pointwise (5 samples):**
-1. DeepSeek-OCR — 5.0/5.0
-2. GLM-OCR — 4.6
-3. LightOnOCR-2 — 4.4
-4. DoTS.ocr — 4.2
-
-**Key finding:** DeepSeek-OCR's `--prompt-mode document` produces grounding tags (`<|ref|>`, `<|det|>`) that the judge penalizes heavily. Switching to `--prompt-mode free` (now the default in the registry) made it jump from last place to top 2.
-
-**Caveat:** 5 samples is far too few for stable rankings. The judge VLM is called once per comparison (pairwise) or once per model-sample (pointwise) via HF Inference Providers API.
-
-#### Run 2: Rubenstein Manuscript Catalog (2026-02-15) — First Full Benchmark
-
-**Dataset:** `biglam/rubenstein-manuscript-catalog` (50 samples, shuffled, seed 42)
-**Output repo:** `davanstrien/ocr-bench-rubenstein` (4 PRs)
-**Judge:** Jury of 2 via `ocr-vllm-judge.py` — `Qwen/Qwen2.5-VL-7B-Instruct` + `Qwen/Qwen3-VL-8B-Instruct` on A100
-**Content:** ~48K typewritten + handwritten manuscript catalog cards from Duke University (CC0)
-
-**ELO (pairwise, 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% |
-
-**OCR job times** (all 50 samples each):
-- dots-ocr: 5.3 min (L4)
-- deepseek-ocr: 5.6 min (L4)
-- glm-ocr: 5.7 min (L4)
-- lighton-ocr-2: 6.4 min (A100)
-
-**Key findings:**
-- **LightOnOCR-2-1B dominates** on manuscript catalog cards (67% win rate, 100-point ELO gap over 2nd place) — a very different result from the NLS pilot where it placed 3rd
-- **Rankings are dataset-dependent**: NLS historical medical texts favored DoTS.ocr and DeepSeek-OCR; Rubenstein typewritten/handwritten cards favor LightOnOCR-2
-- **Jury of small models works well**: 0 parse failures on 300 comparisons thanks to vLLM structured output (xgrammar). Majority voting between 2 judges provides robustness
-- **50 samples gives meaningful separation**: Clear ELO gaps (1595 → 1497 → 1471 → 1437) unlike the noisy 5-sample pilot
-- This validates the multi-dataset benchmark approach — no single dataset tells the whole story
-
-#### Run 3: UFO-ColPali (2026-02-15) — Cross-Dataset Validation
-
-**Dataset:** `davanstrien/ufo-ColPali` (50 samples, shuffled, seed 42)
-**Output repo:** `davanstrien/ocr-bench-ufo` (4 PRs)
-**Judge:** `Qwen/Qwen3-VL-30B-A3B-Instruct` via `ocr-vllm-judge.py` on A100 (updated prompt)
-**Content:** Mixed modern documents (invoices, reports, forms, etc.)
-
-**ELO (pairwise, 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-OCR #1 (same as judge), LightOnOCR-2 #3 (same). Middle pack (GLM-OCR #2 human / #4 judge, dots.ocr #4 human / #2 judge) shuffled.
-
-#### 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 evaluation methods. Middle-pack rankings are dataset-dependent. Updated prompt fixed the LightOnOCR-2 overrating seen with old prompt/small judges.
-
-*Note: NLS pilot results (5 samples, 72B API judge) omitted — not comparable with newer methodology.*
-
-### Known Issues / Next Steps
-
-1. ✅ **More samples needed** — Done. Rubenstein run (2026-02-15) used 50 samples and produced clear ELO separation across all 4 models.
-2. ✅ **Smaller judge model** — Tested with Qwen VL 7B + Qwen3 VL 8B via `ocr-vllm-judge.py`. Works well with structured output (0 parse failures). Jury of small models compensates for individual model weakness. See "Offline vLLM Judge" section below.
-3. **Auto-merge in coordinator** — `--wait` could auto-merge PRs after successful jobs. Not yet implemented.
-4. **Adding more models** — `rolm-ocr.py` exists but needs `--config`/`--create-pr` added. `deepseek-ocr2-vllm.py`, `paddleocr-vl-1.5.py`, etc. could also be added to the registry.
-5. **Leaderboard Space** — See future section below.
-6. ✅ **Result persistence** — `ocr-vllm-judge.py` now has `--save-results REPO_ID` flag. First dataset: `davanstrien/ocr-bench-rubenstein-judge`.
-7. **More diverse datasets** — Rankings are dataset-dependent (LightOnOCR-2 wins on Rubenstein, DoTS.ocr won pilot on NLS). Need benchmarks on tables, formulas, multilingual, and modern documents for a complete picture.
-8. ✅ **Human validation** — `ocr-human-eval.py` completed on Rubenstein (30/30). Tested 3 judge configs. **Kimi K2.5 (170B) via Novita + updated prompt = best human agreement** (only judge to match human's #1). Now default in `ocr-jury-bench.py`. See `OCR-BENCHMARK.md` for full comparison.
-
----
-
-## Offline vLLM Judge (`ocr-vllm-judge.py`)
-
-**Status:** Working end-to-end (2026-02-15)
-
-Runs pairwise OCR quality comparisons using a local VLM judge via vLLM's offline `LLM()` pattern. Supports jury mode (multiple models vote sequentially on the same GPU) with majority voting.
-
-### Why use this over the API judge (`ocr-jury-bench.py`)?
-
-| | API judge (`ocr-jury-bench.py`) | Offline judge (`ocr-vllm-judge.py`) |
-|---|---|---|
-| Parse failures | Needs retries for malformed JSON | 0 failures — vLLM structured output guarantees valid JSON |
-| Network | Rate limits, timeouts, transient errors | Zero network calls |
-| Cost | Per-token API pricing | Just GPU time |
-| Judge models | Limited to Inference Providers catalog | Any vLLM-supported VLM |
-| Jury mode | Sequential API calls per judge | Sequential model loading, batch inference per judge |
-| Best for | Quick spot-checks, access to 72B models | Batch evaluation (50+ samples), reproducibility |
-
-**Pushed to Hub:** `uv-scripts/ocr` as `ocr-vllm-judge.py` (2026-02-15)
-
-### Test Results (2026-02-15)
-
-**Test 1 — Single judge, 1 sample, L4:**
-- Qwen2.5-VL-7B-Instruct, 6/6 comparisons, 0 parse failures
-- Total time: ~3 min (including model download + warmup)
-
-**Test 2 — Jury of 2, 3 samples, A100:**
-- Qwen2.5-VL-7B + Qwen3-VL-8B, 15/15 comparisons, 0 parse failures
-- GPU cleanup between models: successful (nanobind warnings are cosmetic)
-- Majority vote aggregation working (`[2/2]` unanimous, `[1/2]` split)
-- Total time: ~4 min (including both model downloads)
-
-**Test 3 — Full benchmark, 50 samples, A100 (Rubenstein Manuscript Catalog):**
-- Qwen2.5-VL-7B + Qwen3-VL-8B jury, 300/300 comparisons, 0 parse failures
-- Input: `davanstrien/ocr-bench-rubenstein` (4 PRs from `ocr-bench-run.py`)
-- Produced clear ELO rankings with meaningful separation
-- See "Benchmark Results → Run 2" in the OCR Benchmark Coordinator section above
-
-### Usage
-
-```bash
-# Single judge on L4
-hf jobs uv run --flavor l4x1 -s HF_TOKEN \
-    ocr-vllm-judge.py davanstrien/ocr-bench-nls-50 --from-prs \
-    --judge-model Qwen/Qwen2.5-VL-7B-Instruct --max-samples 10
-
-# Jury of 2 on A100 (recommended for jury mode)
-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
-```
-
-### Implementation Notes
-- Comparisons built upfront on CPU as `NamedTuple`s, then batched to vLLM in single `llm.chat()` call
-- Structured output via compatibility shim: `StructuredOutputsParams` (vLLM >= 0.12) → `GuidedDecodingParams` (older) → prompt-based fallback
-- GPU cleanup between jury models: `destroy_model_parallel()` + `gc.collect()` + `torch.cuda.empty_cache()`
-- Position bias mitigation: A/B order randomized per comparison
-- A100 recommended for jury mode; L4 works for single 7B judge
-
-### Next Steps
-1. ✅ **Scale test** — Completed on Rubenstein Manuscript Catalog (50 samples, 300 comparisons, 0 parse failures). Rankings differ from API-based pilot (different dataset + judge), validating multi-dataset approach.
-2. ✅ **Result persistence** — Added `--save-results REPO_ID` flag. Pushes 3 configs to HF Hub: `comparisons` (one row per pairwise comparison), `leaderboard` (ELO + win/loss/tie per model), `metadata` (source dataset, judge models, seed, timestamp). First dataset: `davanstrien/ocr-bench-rubenstein-judge`.
-3. **Integrate into `ocr-bench-run.py`** — Add `--eval` flag that auto-runs vLLM judge after OCR jobs complete
-
----
-
-## Blind Human Eval (`ocr-human-eval.py`)
-
-**Status:** Working (2026-02-15)
-
-Gradio app for blind A/B comparison of OCR outputs. Shows document image + two anonymized OCR outputs, human picks winner or tie. Computes ELO rankings from human annotations and optionally compares against automated judge results.
-
-### Usage
-
-```bash
-# Basic — blind human eval only
-uv run ocr-human-eval.py davanstrien/ocr-bench-rubenstein --from-prs --max-samples 5
-
-# With judge comparison — loads automated judge results for agreement analysis
-uv run ocr-human-eval.py davanstrien/ocr-bench-rubenstein --from-prs \
-    --judge-results davanstrien/ocr-bench-rubenstein-judge --max-samples 5
-```
-
-### Features
-- **Blind evaluation**: Two-tab design — Evaluate tab never shows model names, Results tab reveals rankings
-- **Position bias mitigation**: A/B order randomly swapped per comparison
-- **Resume support**: JSON annotations saved atomically after each vote; restart app to resume where you left off
-- **Live agreement tracking**: Per-vote feedback shows running agreement with automated judge (when `--judge-results` provided)
-- **Split-jury prioritization**: Comparisons where automated judges disagreed ("1/2" agreement) shown first — highest annotation value per vote
-- **Image variety**: Round-robin interleaving by sample so you don't see the same document image repeatedly
-- **Soft/hard disagreement analysis**: Distinguishes between harmless ties-vs-winner disagreements and genuine opposite-winner errors
-
-### First Validation Results (Rubenstein, 30 annotations)
-
-Tested 3 judge configs against 30 human annotations. **Kimi K2.5 (170B) via Novita** is the only judge to match human's #1 pick (DeepSeek-OCR). Small models (7B/8B/30B) all overrate LightOnOCR-2 due to bias toward its commentary style. Updated prompt (prioritized faithfulness > completeness > accuracy) helps but model size is the bigger factor.
-
-Full results and analysis in `OCR-BENCHMARK.md` → "Human Validation" section.
-
-### Next Steps
-1. **Second dataset** — Run on NLS Medical History for cross-dataset human validation
-2. **Multiple annotators** — Currently single-user; could support annotator ID for inter-annotator agreement
-3. **Remaining LightOnOCR-2 gap** — Still #2 (Kimi) vs #4 (human). May need to investigate on more samples or strip commentary in preprocessing
-
----
-
-## Future: Leaderboard HF Space
-
-**Status:** Idea (noted 2026-02-14)
-
-Build a Hugging Face Space with a persistent leaderboard that gets updated after each benchmark run. This would give a public-facing view of OCR model quality.
-
-**Design ideas:**
-- Gradio or static Space displaying ELO ratings + pointwise scores
-- `ocr-elo-bench.py` could push results to a dataset that the Space reads
-- Or the Space itself could run evaluation on demand
-- Show per-document comparisons (image + side-by-side OCR outputs)
-- Historical tracking — how scores change across model versions
-- Filter by document type (historical, modern, tables, formulas, multilingual)
-
-**Open questions:**
-- Should the eval script push structured results to a dataset (e.g., `uv-scripts/ocr-leaderboard-data`)?
-- Static leaderboard (updated by CI/scheduled job) vs interactive (evaluate on demand)?
-- Include sample outputs for qualitative comparison?
-- How to handle different eval datasets (NLS medical history vs UFO vs others)?
-
----
-
-## Incremental Uploads / Checkpoint Strategy — ON HOLD
-
-**Status:** Waiting on HF Hub Buckets (noted 2026-02-20)
-
-**Current state:**
-- `glm-ocr.py` (v1): Simple batch-then-push. Works fine for most jobs.
-- `glm-ocr-v2.py`: Adds CommitScheduler-based incremental uploads + checkpoint/resume. ~400 extra lines. Works but has tradeoffs (commit noise, `--create-pr` incompatible, complex resume metadata).
-
-**Decision: Do NOT port v2 pattern to other scripts.** Wait for HF Hub Buckets instead.
-
-**Why:** Two open PRs will likely make the v2 CommitScheduler approach obsolete:
-- [huggingface_hub#3673](https://github.com/huggingface/huggingface_hub/pull/3673) — Buckets API: S3-like mutable object storage on HF, no git versioning overhead
-- [huggingface_hub#3807](https://github.com/huggingface/huggingface_hub/pull/3807) — HfFileSystem support for buckets: fsspec-compatible, so pyarrow/pandas/datasets can read/write `hf://buckets/` paths directly
-
-**What Buckets would replace:** Once landed, incremental saves become one line per batch:
-```python
-batch_ds.to_parquet(f"hf://buckets/{user}/ocr-scratch/shard-{batch_num:05d}.parquet")
-```
-No CommitScheduler, no CleanupScheduler, no resume metadata, no completed batch scanning. Just write to the bucket path via fsspec. Final step: read back from bucket, `push_to_hub` to a clean dataset repo (compatible with `--create-pr`).
-
-**Action items when Buckets ships:**
-1. Test `hf://buckets/` fsspec writes on one script (glm-ocr is the guinea pig)
-2. Verify: write performance, atomicity (partial writes visible?), auth propagation in HF Jobs
-3. If it works, adopt as the standard pattern for all scripts — simple enough to inline (~20 lines)
-4. Retire `glm-ocr-v2.py` CommitScheduler approach
-
-**Until then:** v1 scripts stay as-is. `glm-ocr-v2.py` exists if someone needs resume on a very large job today.
-
----
-
-**Last Updated:** 2026-02-20
+**Last Updated:** 2026-02-12
 **Watch PRs:**
-- **HF Hub Buckets API** ([#3673](https://github.com/huggingface/huggingface_hub/pull/3673)): Core buckets support. Will enable simpler incremental upload pattern for all scripts.
-- **HfFileSystem Buckets** ([#3807](https://github.com/huggingface/huggingface_hub/pull/3807)): fsspec support for `hf://buckets/` paths. Key for zero-boilerplate writes from scripts.
-- DeepSeek-OCR-2 stable vLLM release: Currently only in nightly. Watch for vLLM 0.16.0 stable release on PyPI to remove nightly dependency.
-- nanobind leak warnings in vLLM structured output (xgrammar): Cosmetic only, does not affect results. May be fixed in future xgrammar release.
+- DeepSeek-OCR-2: https://github.com/vllm-project/vllm/pull/33165

README.md

@@ -1,17 +1,15 @@
 ---
 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.
 
-A model zoo of OCR scripts — one per model — that add a `markdown` column to an image dataset. Pick a model from the table below, point it at your dataset, and run it on a GPU with one command. A few recipes do **structured extraction** instead — image *or* text → JSON given a schema (see [Structured extraction](#structured-extraction-image-or-text--json) below). Two more companions sit alongside: `pp-doclayout.py` detects layout regions (bboxes for text/title/table/figure/…) instead of text, and `ocr-vllm-judge.py` compares model outputs head-to-head.
-
-## Quick Start
+## 🚀 Quick Start
 
 Run OCR on any dataset without needing your own GPU:
 
@@ -24,233 +22,589 @@ hf jobs uv run --flavor l4x1 \
     --max-samples 10
 ```
 
-This will:
+That's it! The script will:
 
-- Process the first 10 images from your dataset
+- 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]`
 
-## Serve a model as a live endpoint
-
-The recipes here run as batch jobs. To call a model interactively, from an agent, or with concurrent ad-hoc requests, you can instead run it as a temporary endpoint: [HF Jobs serving](https://huggingface.co/docs/hub/jobs-serving) exposes a port on a GPU Job, giving an OpenAI-compatible endpoint that runs until the job is cancelled or its `--timeout` is reached. See [serving-unlimited-ocr.md](serving-unlimited-ocr.md) for a worked example serving Baidu's [Unlimited-OCR](https://huggingface.co/baidu/Unlimited-OCR) with SGLang.
-
-## Models at a glance
-
-**Start here:** for a quick first run, try **`lighton-ocr2.py`** (1B, very fast) or **`paddleocr-vl-1.6.py`** (0.9B, current OmniDocBench SOTA); for the smallest footprint, **`falcon-ocr.py`** (0.3B, strong on tables). Reach for a 7–8B model only when quality demands it. Several of these models sit on the public [olmOCR-Bench](https://huggingface.co/datasets/allenai/olmOCR-bench) — pull the live ranking from your terminal in one command:
-
-```bash
-hf datasets leaderboard allenai/olmOCR-bench
-```
-
-But which model wins on *your* documents is still document-dependent — so [ocr-bench](https://github.com/davanstrien/ocr-bench) builds a **per-collection leaderboard** for your own data (pairwise VLM-as-judge, optionally human-validated), using these scripts under the hood.
-
-_Sorted by model size:_
+<details><summary>All scripts at a glance (sorted by model size)</summary>
 
 | Script | Model | Size | Backend | Notes |
 |--------|-------|------|---------|-------|
-| `pp-ocrv6.py` | [PP-OCRv6](https://huggingface.co/collections/PaddlePaddle/pp-ocrv6) | 1.5–34.5M | PaddleOCR (paddle) | **Smallest by far** — classical det+rec pipeline, not a VLM. Three tiers (`--model-tier tiny\|small\|medium`), plain-text output (not markdown). 50 langs. Runs on `t4-small`. Apache 2.0 |
-| `falcon-ocr.py` | [Falcon-OCR](https://huggingface.co/tiiuae/Falcon-OCR) | 0.3B | falcon-perception | Smallest VLM in collection. #1 on multi-column docs and tables (olmOCR), Apache 2.0 |
 | `smoldocling-ocr.py` | [SmolDocling](https://huggingface.co/ds4sd/SmolDocling-256M-preview) | 256M | Transformers | DocTags structured output |
-| `surya-ocr.py` | [Surya OCR 2](https://huggingface.co/datalab-to/surya-ocr-2) | 0.65B | vLLM | **Structured** OCR + `--task layout\|table`: per-block HTML with bboxes & reading order in an extra `surya_blocks` column. 91 langs, top-under-3B on olmOCR-Bench. Modified OpenRAIL-M license. Needs the **pinned** `vllm/vllm-openai:v0.20.1` image |
 | `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 |
-| `paddleocr-vl-1.6.py` | [PaddleOCR-VL-1.6](https://huggingface.co/PaddlePaddle/PaddleOCR-VL-1.6) | 0.9B | vLLM | **96.33% OmniDocBench v1.6** (SOTA), drop-in upgrade of 1.5 |
 | `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 |
-| `abot-ocr.py` | [ABot-OCR](https://huggingface.co/acvlab/ABot-OCR) | 2B | vLLM | Qwen3-VL based, doc→Markdown (text/LaTeX/HTML tables). Needs `vllm/vllm-openai` image. [paper](https://arxiv.org/abs/2605.27978) |
 | `nanonets-ocr.py` | [Nanonets-OCR-s](https://huggingface.co/nanonets/Nanonets-OCR-s) | 2B | vLLM | LaTeX, tables, forms |
-| `dots-mocr.py` | [dots.mocr](https://huggingface.co/rednote-hilab/dots.mocr) | 3B | vLLM | 8 prompt modes incl. SVG generation, layout + bbox, 100+ languages |
+| `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; needs nightly vLLM **+ the `vllm/vllm-openai` image** ([why](#if-a-vllm-script-crashes-at-startup-the-nvcc--nvrtc-error)) |
-| `nuextract3.py` | [NuExtract3](https://huggingface.co/numind/NuExtract3) | 4B | vLLM | Markdown OCR **+ schema-guided JSON extraction** (template/Pydantic). Needs `vllm/vllm-openai` image |
-| `qianfan-ocr.py` | [Qianfan-OCR](https://huggingface.co/baidu/Qianfan-OCR) | 4.7B | vLLM | #1 OmniDocBench v1.5 (93.12), Layout-as-Thought, 192 languages |
+| `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 |
 
-**Variants & tools** (same models, different I/O): `glm-ocr-v2.py` adds checkpoint/resume for very large jobs · `glm-ocr-bucket.py` and `falcon-ocr-bucket.py` read images/PDFs from a mounted bucket and write one `.md` per page · `surya-ocr-bucket.py` is the structured bucket recipe — OCR a bucket of files (no dataset round-trip) via either a FUSE mount **or** `huggingface_hub` batch-copy (`--io-mode mount|copy`), writing per-page `.md` + `.json` (`surya_blocks`) back to a bucket (resumable) and/or a pushed dataset · `ocr-vllm-judge.py` runs pairwise OCR-quality comparisons.
+</details>
 
-`surya-ocr.py` is the structured outlier: besides the flattened text column it writes a `surya_blocks` JSON column (per-block HTML + bounding boxes + reading order), and `--task` switches between OCR, `layout`, and `table`. It runs as **offline vLLM batch** (no server) and must use the **pinned** `vllm/vllm-openai:v0.20.1` image — its `qwen3_5` architecture is recent and version-sensitive, and that image puts vLLM at `/usr/local/lib/python3.12/site-packages` (use `--python /usr/local/bin/python3`; the exact command is in the script's docstring). Weights are **modified OpenRAIL-M**.
+## Common Options
 
-## Structured extraction (image or text → JSON)
+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.
 
-Most scripts here output markdown. These take a **schema** and return **structured data** instead — give them the fields you want, they fill them in:
+| 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 |
 
-| Script | Model | Size | Input | Output |
-|--------|-------|------|-------|--------|
-| `lfm2-vl-extract.py` | [LFM2.5-VL-1.6B-Extract](https://huggingface.co/LiquidAI/LFM2.5-VL-1.6B-Extract) | 1.6B | image | JSON |
-| `nuextract3.py` | [NuExtract3](https://huggingface.co/numind/NuExtract3) | 4B | image | markdown **or** JSON |
-| `lfm2-extract.py` | [LFM2-1.2B-Extract](https://huggingface.co/LiquidAI/LFM2-1.2B-Extract) | 1.2B | **text** | JSON / XML / YAML |
-| `lift-extract.py` | [lift](https://huggingface.co/datalab-to/lift) | 9B | image **or** PDF | JSON |
+Every script supports `--help` to see all available options:
 
-Pass `--schema` (inline JSON, a URL, or a file path). The LFM models are small and fast; run them on the `vllm/vllm-openai` image so the CUDA toolkit is present (each script's docstring has the exact command). Because `lfm2-extract.py` works on a **text** column, you can **chain it after OCR**: a recipe above turns a page into `markdown`, then `lfm2-extract.py` turns that markdown into fields.
+```bash
+uv run glm-ocr.py --help
+```
+
+## Example: GLM-OCR
 
-`lift-extract.py` is the one outlier: a 9B model that also reads **multi-page PDFs** (`--pdf-column`, `--page-range`) and runs on either Transformers (`--method hf`) or vLLM (`--method vllm`). Its weights are **modified OpenRAIL-M** (free for research, personal use, and startups under $5M; no competitive use against Datalab's API) — the only non-permissive license here, so check the terms.
+[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:
 
 ```bash
-# image → JSON directly
-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 \
-    my-images my-fields --schema '{"title": "the document title", "date": "any date shown"}'
+# 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
+
+# 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
+
+# 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
 ```
 
-## Layout detection (not OCR)
+<details><summary>Detailed per-model documentation</summary>
 
-`pp-doclayout.py` runs PaddleOCR's [PP-DocLayout-L](https://huggingface.co/PaddlePaddle/PP-DocLayout-L) (or M / S / plus-L) and emits per-image **bounding boxes + region classes** (text, title, table, figure, formula, list, header, footer, ...) — it does NOT extract text. Useful for filtering pages, cropping regions for downstream OCR, dataset analysis, and training-data prep.
+### PaddleOCR-VL-1.5 (`paddleocr-vl-1.5.py`) — 6 task modes
 
-| Script | Model | Size | Backend | Notes |
-|--------|-------|------|---------|-------|
-| `pp-doclayout.py` | [PP-DocLayout-L](https://huggingface.co/PaddlePaddle/PP-DocLayout-L) | 123M | paddleocr | Layout bboxes (no text). Bucket support: incremental parquet shards, resumable. |
+OCR using [PaddlePaddle/PaddleOCR-VL-1.5](https://huggingface.co/PaddlePaddle/PaddleOCR-VL-1.5) with 94.5% accuracy:
+
+- **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
+
+**Task Modes:**
+
+- `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
-hf jobs uv run --flavor l4x1 -s HF_TOKEN \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/pp-doclayout.py \
-    your-dataset your-layout-output --max-samples 10
+# 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
 ```
 
-Source/sink can be either an HF dataset repo OR an `hf://buckets/...` URL (auto-detected). Bucket output writes incremental zstd parquet shards via the buckets API — resumable across runs (snapshot-backed source listing) and no git/commit overhead. See the script's `--help` for all flags.
+### PaddleOCR-VL (`paddleocr-vl.py`) 🎯 Smallest model with task-specific modes!
 
-## If a vLLM script crashes at startup (the `nvcc` / `nvrtc` error)
+Ultra-compact OCR using [PaddlePaddle/PaddleOCR-VL](https://huggingface.co/PaddlePaddle/PaddleOCR-VL) with only 0.9B parameters:
 
-The vLLM recipes run on the **default** Jobs image and carry a guard (`VLLM_USE_FLASHINFER_SAMPLER=0`) so they work there with the plain command. But some — especially nightly-vLLM ones — JIT-compile a CUDA kernel at engine init and crash on the default image with one of:
+- 🎯 **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
 
-```
-RuntimeError: Could not find nvcc and default cuda_home='/usr/local/cuda' doesn't exist
-nvrtc: error: failed to open libnvrtc-builtins.so...
+**Task Modes:**
+
+- `ocr`: General text extraction (default)
+- `table`: Table extraction to HTML
+- `formula`: Mathematical formula to LaTeX
+- `chart`: Chart and diagram analysis
+
+**Quick start:**
+
+```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
 ```
 
-Run those on the **`vllm/vllm-openai` image**, which ships the full CUDA toolkit. Add these flags to any recipe — they point `import vllm` at the image's CUDA-matched build:
+### GLM-OCR (`glm-ocr.py`) 🏆 SOTA on OmniDocBench V1.5!
+
+Compact high-performance OCR using [zai-org/GLM-OCR](https://huggingface.co/zai-org/GLM-OCR) with 0.9B parameters:
+
+- 🏆 **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
+
+**Task Modes:**
+
+- `ocr`: Text recognition (default)
+- `formula`: LaTeX formula recognition
+- `table`: Table extraction
+
+**Quick start:**
 
 ```bash
-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/<script>.py \
-    INPUT OUTPUT --max-samples 10
+# 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
+
+# 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
+
+# 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
 ```
 
-This is **required** for a few scripts (e.g. `deepseek-ocr2-vllm.py`, `abot-ocr.py`, `nuextract3.py`) and a safe fallback for any vLLM recipe that crashes at startup. (It's also the more robust way to run any vLLM recipe — full CUDA toolkit, ABI-matched build. It isn't a speed-up: uv still reinstalls the script's deps either way.)
+### LightOnOCR (`lighton-ocr.py`) ⚡ Good one to test first since it's small and fast!
 
-## Common Options
+Fast and compact OCR using [lightonai/LightOnOCR-1B-1025](https://huggingface.co/lightonai/LightOnOCR-1B-1025):
 
-The scripts aim to expose a **consistent interface**: every OCR model script takes `input-dataset output-dataset` as positional arguments, accepts the shared core flags below, and writes a `markdown` column — so switching models is usually just swapping the script URL. Models differ where they need to, though: some add their own flags (task modes, resolution presets, `--think`, vocab sizes), a few need a specific Docker image, and per-model defaults (batch size, context length, temperature) are tuned to each model card. Always check a script's `--help` for its specifics.
+- ⚡ **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
 
-| 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 |
+**Vocabulary sizes:**
 
-Every script supports `--help` to see all available options:
+- `151k`: Full vocabulary, all languages (default)
+- `32k`: European languages, ~12% faster decoding
+- `16k`: European languages, ~12% faster decoding
+
+**Quick start:**
 
 ```bash
-uv run glm-ocr.py --help
+# 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
 ```
 
-## NuExtract3: markdown OCR + structured extraction
+### LightOnOCR-2 (`lighton-ocr2.py`) ⚡ Fastest OCR model!
+
+Next-generation fast OCR using [lightonai/LightOnOCR-2-1B](https://huggingface.co/lightonai/LightOnOCR-2-1B) with RLVR training:
 
-[NuExtract3](https://huggingface.co/numind/NuExtract3) (4B, Apache-2.0) is the one script here that does both document-to-markdown OCR *and* schema-guided JSON extraction. Give it a template (or a JSON Schema / Pydantic model) and it returns JSON shaped to match.
+- ⚡ **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
 
-> **Run it with the `vllm/vllm-openai` image.** NuExtract3's Qwen3.5 architecture needs the image's prebuilt CUDA kernels — the default uv-script image lacks `nvcc`, so flashinfer's JIT compile fails at engine warmup. Use `--image vllm/vllm-openai:latest --python /usr/bin/python3 -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages` on `a100-large`.
+**Quick start:**
 
 ```bash
-# Markdown OCR (default mode)
+# Test on 100 samples
 hf jobs uv run --flavor a100-large \
-    --image vllm/vllm-openai:latest \
-    --python /usr/bin/python3 \
-    -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages \
     -s HF_TOKEN \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nuextract3.py \
-    my-documents my-markdown --max-samples 10
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr2.py \
+    your-input-dataset your-output-dataset \
+    --batch-size 32 \
+    --max-samples 100
 
-# Structured extraction with an inline template
+# Full production run
 hf jobs uv run --flavor a100-large \
-    --image vllm/vllm-openai:latest \
-    --python /usr/bin/python3 \
-    -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages \
     -s HF_TOKEN \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nuextract3.py \
-    receipts extracted \
-    --template '{"store": "verbatim-string", "date": "date", "total": "number"}'
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr2.py \
+    your-input-dataset your-output-dataset \
+    --batch-size 32
 ```
 
-**Templates** (`--template`) and **JSON Schemas** (`--schema`) each accept **inline JSON, a URL, or a file path**, so a schema can be hosted once and reused. Add `--enable-thinking` for harder layouts (slower; reasoning trace stored in a `<output-column>_reasoning` column). Template field names act as the model's extraction instructions, so name them descriptively — overly leading names can prompt over-generation, so verify against a few examples.
+### DeepSeek-OCR (`deepseek-ocr-vllm.py`)
+
+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 ☐/☑
+
+### Nanonets OCR2 (`nanonets-ocr2.py`)
+
+Next-generation Nanonets OCR using [nanonets/Nanonets-OCR2-3B](https://huggingface.co/nanonets/Nanonets-OCR2-3B) with improved accuracy:
+
+- 🎯 **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
+
+### 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`)
 
-## Model-specific modes & flags
+Advanced reasoning-based OCR using [numind/NuMarkdown-8B-Thinking](https://huggingface.co/numind/NuMarkdown-8B-Thinking) that analyzes documents before converting to markdown:
 
-Beyond the shared flags, some models add their own. Run `--help` on any script for the full list; the common ones:
+- 🧠 **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`
 
-| Script | Extra options |
-|--------|---------------|
-| `surya-ocr.py` | `--task ocr\|layout\|table`, `--table-mode full\|simple`, `--pdf-column`/`--page-range`, `--blocks-column` |
-| `pp-ocrv6.py` | `--model-tier tiny\|small\|medium` (1.5M–34.5M params) |
-| `glm-ocr.py` | `--task ocr\|formula\|table` |
-| `paddleocr-vl.py` | `--task-mode ocr\|table\|formula\|chart` |
-| `paddleocr-vl-1.5.py` | `--task-mode ocr\|table\|formula\|chart\|spotting\|seal` |
-| `paddleocr-vl-1.6.py` | `--task-mode ocr\|table\|formula` |
-| `lighton-ocr.py` | `--vocab-size 151k\|32k\|16k` (smaller = faster on European languages) |
-| `deepseek-ocr-vllm.py` | `--resolution-mode tiny\|small\|base\|large\|gundam`, `--prompt-mode document\|image\|free\|figure\|describe`; pass `-e UV_TORCH_BACKEND=auto` |
-| `dots-ocr.py` | `--prompt-mode ocr\|layout-all\|layout-only` |
-| `dots-mocr.py` | `--prompt-mode` (8: ocr, layout-all, layout-only, web-parsing, scene-spotting, grounding-ocr, svg, general); SVG: `--model rednote-hilab/dots.mocr-svg --prompt-mode svg` |
-| `qianfan-ocr.py` | `--prompt-mode ocr\|table\|formula\|chart\|scene\|kie`, `--think` (Layout-as-Thought); `kie` needs `--custom-prompt` |
-| `numarkdown-ocr.py` | `--include-thinking` (store the reasoning trace) |
-| `nuextract3.py` | `--template` / `--schema` / `--enable-thinking` — see the NuExtract3 section above |
+### DoTS.ocr (`dots-ocr.py`)
 
-**Image-mode models** — `abot-ocr.py` and `nuextract3.py` (Qwen3.5 architecture) need the `vllm/vllm-openai` image because the default uv-script image lacks `nvcc`. Add `--image vllm/vllm-openai:latest --python /usr/bin/python3 -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages` (see the NuExtract3 example above for the full command).
+Compact multilingual OCR using [rednote-hilab/dots.ocr](https://huggingface.co/rednote-hilab/dots.ocr) with only 1.7B parameters:
 
-## Output & features
+- 🌍 **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
 
-- **Markdown column** — each run adds an `--output-column` (default `markdown`) with the OCR result.
-- **Multi-model comparison** — every script records `inference_info`, so you can run several models into the *same* dataset and compare. Point a second model at the same output repo:
-  ```bash
-  uv run rolm-ocr.py     my-dataset my-dataset --max-samples 100
-  uv run nanonets-ocr.py my-dataset my-dataset --max-samples 100   # appends
-  ```
-- **Reproducible sampling** — `--shuffle` (with `--seed`, default 42) draws a representative sample instead of the first N rows.
-- **Automatic dataset cards** — every run writes a card with the model config, processing stats, column descriptions, and a reproduction command.
+### FireRed-OCR (`firered-ocr.py`)
 
-## More examples
+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 --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
+```
+
+### 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
-# DeepSeek-OCR on historical scans, large resolution mode
-hf jobs uv run --flavor a100-large -s HF_TOKEN -e UV_TORCH_BACKEND=auto \
+# 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']))"
+```
+
+### Random Sampling
+
+Get representative samples with the new `--shuffle` flag:
+
+```bash
+# 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
+```
+
+### Automatic Dataset Cards
+
+Every OCR run now generates comprehensive dataset documentation including:
+
+- Model configuration and parameters
+- Processing statistics
+- Column descriptions
+- Reproduction instructions
+
+## 💻 Usage Examples
+
+### Run on HuggingFace Jobs (Recommended)
+
+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 out \
-    --max-samples 100 --shuffle --resolution-mode large
+    NationalLibraryOfScotland/Britain-and-UK-Handbooks-Dataset \
+    davanstrien/handbooks-deep-ocr \
+    --max-samples 100 \
+    --shuffle \
+    --resolution-mode large
 
-# dots.mocr — SVG generation from charts/figures
-hf jobs uv run --flavor l4x1 -s HF_TOKEN \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-mocr.py \
-    your-charts svg-output --prompt-mode svg --model rednote-hilab/dots.mocr-svg
+# 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
 
-# Qianfan — key-information extraction
-hf jobs uv run --flavor l4x1 -s HF_TOKEN \
-    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."
+# 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
 ```
 
-**Python API:**
+### Python API
 
 ```python
 from huggingface_hub import run_uv_job
@@ -258,17 +612,36 @@ 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",
+    flavor="l4x1"
 )
 ```
 
-**Run locally** (needs your own GPU) — same scripts, run directly from the URL:
+### Run Locally (Requires GPU)
 
 ```bash
-uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py \
+# Clone and run
+git clone https://huggingface.co/datasets/uv-scripts/ocr
+cd ocr
+uv run nanonets-ocr.py input-dataset output-dataset
+
+# Or run directly from URL
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nanonets-ocr.py \
     input-dataset output-dataset
+
+# 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
+
+# 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
+
 ```
 
----
+</details>
 
-Works with any Hugging Face dataset containing images — documents, forms, receipts, books, handwriting.
+Works with any HuggingFace dataset containing images — documents, forms, receipts, books, handwriting.

abot-ocr.py

@@ -1,560 +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 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,
-    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}"
-        )
-
-    # 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 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...")
-
-    inference_entry = {
-        "model_id": model,
-        "model_name": "ABot-OCR",
-        "column_name": "markdown",
-        "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(
-        "--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,
-        verbose=args.verbose,
-    )

deepseek-ocr-vllm.py

@@ -48,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
 

deepseek-ocr.py

@@ -2,7 +2,7 @@
 # requires-python = ">=3.11"
 # dependencies = [
 #     "datasets",
-#     "huggingface-hub",
+#     "huggingface-hub[hf_transfer]",
 #     "pillow",
 #     "torch",
 #     "torchvision",
@@ -252,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")

deepseek-ocr2-vllm.py

@@ -59,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
 

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

@@ -13,27 +13,23 @@
 # ///
 
 """
-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)
-
-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
+- 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.ocr-1.5
+vLLM: Officially supported (same DotsOCRForCausalLM architecture as v1)
 """
 
 import argparse
@@ -50,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)
@@ -64,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 = {
@@ -88,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": """ """,
 }
 
@@ -133,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")
@@ -176,7 +154,7 @@ def create_dataset_card(
 tags:
 - ocr
 - document-processing
-- dots-mocr
+- dots-ocr-1.5
 - multilingual
 - markdown
 - uv-script
@@ -185,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
 
@@ -208,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
 
@@ -245,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} \\
@@ -268,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,
@@ -287,7 +264,7 @@ def main(
     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()
@@ -338,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,
@@ -359,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:
@@ -410,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",
@@ -491,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}"
     )
@@ -513,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 dots-mocr.py input-dataset output-dataset")
-        print("\n2. SVG generation:")
-        print(
-            "   uv run dots-mocr.py charts svg-output --prompt-mode svg --model rednote-hilab/dots.mocr-svg"
-        )
-        print("\n3. Web screen parsing:")
-        print("   uv run 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 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("   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 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 dots-mocr.py my-docs analyzed-docs
-
-  # SVG generation with optimized variant
-  uv run 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 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 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 dots-mocr.py large-dataset test --max-samples 50 --shuffle
+  uv run dots-ocr-1.5.py large-dataset test --max-samples 50 --shuffle
         """,
     )
 
@@ -608,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",

dots-ocr.py

@@ -45,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)

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,433 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "datasets",
-#     "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 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",
-    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}"
-        )
-
-    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(
-        "--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,
-        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

@@ -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)
@@ -108,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 [
@@ -232,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,
@@ -339,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)
 
@@ -487,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",

glm-ocr-bucket.py

@@ -1,369 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "pillow",
-#     "pymupdf",
-#     "vllm",
-#     "torch",
-# ]
-#
-# [[tool.uv.index]]
-# url = "https://wheels.vllm.ai/nightly/cu129"
-#
-# [tool.uv]
-# prerelease = "allow"
-# override-dependencies = ["transformers>=5.1.0"]
-# ///
-
-"""
-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 ...`
-(requires huggingface_hub with PR #3936 volume mounting support).
-
-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 glm-ocr-bucket.py ./test-images ./test-output
-
-  # HF Jobs with bucket volumes (PR #3936)
-  hf jobs uv run --flavor l4x1 \\
-      -s HF_TOKEN \\
-      -v bucket/user/ocr-input:/input:ro \\
-      -v bucket/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) -> list[Path]:
-    """Walk input_dir recursively, returning sorted list of image and PDF files."""
-    files = []
-    for path in sorted(input_dir.rglob("*")):
-        if not path.is_file():
-            continue
-        ext = path.suffix.lower()
-        if ext in IMAGE_EXTENSIONS or ext == ".pdf":
-            files.append(path)
-    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 glm-ocr-bucket.py ./images ./output
-  uv run glm-ocr-bucket.py /input /output --task table --pdf-dpi 200
-
-HF Jobs with bucket volumes (requires huggingface_hub PR #3936):
-  hf jobs uv run --flavor l4x1 -s HF_TOKEN \\
-      -v bucket/user/input-bucket:/input:ro \\
-      -v bucket/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(
-        "--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)
-
-    # Discover and prepare
-    start_time = time.time()
-
-    logger.info(f"Scanning {input_dir} for images and PDFs...")
-    files = discover_files(input_dir)
-    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 (PR #3936).")
-        print()
-        print("Usage:")
-        print("  uv run glm-ocr-bucket.py INPUT_DIR OUTPUT_DIR")
-        print()
-        print("Examples:")
-        print("  uv run glm-ocr-bucket.py ./images ./output")
-        print("  uv run glm-ocr-bucket.py /input /output --task table")
-        print()
-        print("HF Jobs with bucket volumes:")
-        print("  hf jobs uv run --flavor l4x1 -s HF_TOKEN \\")
-        print("      -v bucket/user/ocr-input:/input:ro \\")
-        print("      -v bucket/user/ocr-output:/output \\")
-        print("      glm-ocr-bucket.py /input /output")
-        print()
-        print("For full help: uv run 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)

glm-ocr.py

@@ -60,10 +60,6 @@ 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)

hunyuan-ocr.py

@@ -49,10 +49,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)

lfm2-extract.py

@@ -1,293 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "datasets>=4.0.0",
-#     "huggingface-hub",
-#     "vllm",
-#     "transformers",
-#     "tqdm",
-#     "toolz",
-#     "torch",
-# ]
-# ///
-"""
-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 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-extract.py \
-        INPUT OUTPUT --text-column text --schema '{"field": "description"}'
-
-It also runs on the default uv image, just with a slower first-time vLLM build. Deps are left
-unpinned so uv resolves a recent vLLM; FlashInfer sampling is disabled (see below) so the engine
-never JIT-compiles a kernel that needs nvcc — absent from the default image.
-"""
-
-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 --flavor l4x1 ...")
-        sys.exit(1)
-    logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name()}")
-
-
-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",
-    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)
-    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 lfm2-extract.py INPUT OUTPUT --schema SCHEMA [--text-column text] [--format json]")
-        print("\nExample:")
-        print('  uv run 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("\nFor full help: uv run 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(
-        "--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,
-        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,324 +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 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",
-    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)
-    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("--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,
-        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,812 +0,0 @@
-# /// script
-# requires-python = ">=3.12"
-# dependencies = [
-#     "lift-pdf[hf]",
-#     "datasets>=3.1.0",
-#     "huggingface-hub",
-#     "pillow",
-#     "toolz",
-#     "tqdm",
-# ]
-# ///
-"""
-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 (default image is fine; 9B needs a roomy GPU):
-
-    hf jobs uv run --flavor a100-large -s HF_TOKEN \\
-        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):
-
-    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 --flavor a100-large ..."
-        )
-        sys.exit(1)
-    logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
-
-
-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",
-    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)
-    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(
-        "--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,
-        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

@@ -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)

lighton-ocr2.py

@@ -53,10 +53,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)

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
 

nanonets-ocr2.py

@@ -44,10 +44,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)

nuextract3.py

@@ -1,749 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "datasets>=3.1.0",
-#     "huggingface-hub",
-#     "pillow",
-#     "vllm",
-#     "toolz",
-#     "torch",
-#     "numind",
-# ]
-# ///
-
-"""
-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 (recommended): use the vllm/vllm-openai:latest image so the
-pre-built CUDA kernels (flashinfer etc.) are reused — the default uv-script
-image lacks nvcc and flashinfer's JIT compile fails at engine warmup.
-
-    hf jobs uv run \\
-        --image vllm/vllm-openai:latest \\
-        --flavor a100-large \\
-        --python /usr/bin/python3 \\
-        -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages \\
-        -s HF_TOKEN \\
-        https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nuextract3.py \\
-        INPUT_DATASET OUTPUT_DATASET --max-samples 5 --shuffle --seed 42
-
-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 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,
-    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}"
-        )
-
-    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 nuextract3.py input-dataset output-dataset")
-        print("\n2. Structured extraction with an inline template:")
-        print("   uv run 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 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 nuextract3.py input output --enable-thinking")
-        print("\n5. Test with 10 samples:")
-        print("   uv run nuextract3.py large-ds test --max-samples 10 --shuffle")
-        print("\n6. Running on HF Jobs (use vllm/vllm-openai image for built kernels):")
-        print("   hf jobs uv run --flavor a100-large \\")
-        print("     --image vllm/vllm-openai:latest \\")
-        print("     --python /usr/bin/python3 \\")
-        print("     -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages \\")
-        print("     -s HF_TOKEN \\")
-        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 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 nuextract3.py my-docs analyzed-docs
-  uv run nuextract3.py receipts extracted \\
-      --template '{"store": "verbatim-string", "total": "number"}'
-  uv run nuextract3.py contracts extracted --schema contract_schema.json
-  uv run 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(
-        "--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,
-        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)

olmocr2-vllm.py

@@ -50,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__)
@@ -368,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)
 

paddleocr-vl-1.6.py

@@ -1,798 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "datasets>=4.0.0",
-#     "huggingface-hub",
-#     "pillow",
-#     "vllm>=0.15.1",
-#     "tqdm",
-#     "toolz",
-#     "torch",
-#     "pyarrow",
-#     "transformers",
-# ]
-# ///
-
-"""
-Convert document images to text/tables/formulas using PaddleOCR-VL-1.6 with vLLM.
-
-PaddleOCR-VL-1.6 is a compact 0.9B OCR model that reaches a new SOTA of 96.33% on
-OmniDocBench v1.6. It combines a NaViT-style dynamic resolution visual encoder with
-the ERNIE-4.5-0.3B language model and is a plug-and-play upgrade of PaddleOCR-VL-1.5.
-
-Features:
-- 🎯 SOTA: 96.33% on OmniDocBench v1.6 (0.9B params, smallest top-tier OCR model)
-- 📝 OCR mode: General text extraction to markdown
-- 📊 Table mode: HTML table recognition and extraction
-- 📐 Formula mode: LaTeX mathematical notation
-- 📈 Chart mode: Structured chart analysis
-- 🔍 Spotting mode: Text spotting with localization
-- 🔖 Seal mode: Seal/stamp recognition
-- 🌍 Multilingual support (en/zh + more)
-- 🔧 Based on ERNIE-4.5 (different from Qwen-based models)
-
-Model: PaddlePaddle/PaddleOCR-VL-1.6
-Backend: vLLM offline (batch inference)
-
-HF Jobs note: PaddleOCR-VL-1.6 is supported by stable vLLM, but on HF Jobs you must run
-with the pre-built vLLM image so flashinfer's CUDA kernels are reused. The default
-uv-script image has the CUDA runtime but no `nvcc`, so vLLM's flashinfer sampler crashes
-at warmup with "Could not find nvcc". Use image-mode (see the example at the bottom):
-    --image vllm/vllm-openai:latest --flavor a100-large
-    --python /usr/bin/python3 -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages
-This is the same image-mode pattern as nuextract3.py. Verified end-to-end on a100-large
-(2026-06-01): 5/5 clean markdown on davanstrien/ufo-ColPali, ~194 tok/s, 0 errors.
-"""
-
-import argparse
-import base64
-import io
-import json
-import logging
-import math
-import os
-import sys
-import time
-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__)
-
-MODEL_ID = "PaddlePaddle/PaddleOCR-VL-1.6"
-
-# Task mode configurations from official PaddleOCR-VL documentation
-TASK_MODES = {
-    "ocr": "OCR:",
-    "table": "Table Recognition:",
-    "formula": "Formula Recognition:",
-    "chart": "Chart Recognition:",
-    "spotting": "Spotting:",
-    "seal": "Seal Recognition:",
-}
-
-# Task descriptions for dataset card
-TASK_DESCRIPTIONS = {
-    "ocr": "General text extraction to markdown format",
-    "table": "Table extraction to HTML format",
-    "formula": "Mathematical formula recognition to LaTeX",
-    "chart": "Chart and diagram analysis",
-    "spotting": "Text spotting with localization",
-    "seal": "Seal and stamp recognition",
-}
-
-
-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 smart_resize(
-    height: int,
-    width: int,
-    factor: int = 28,
-    min_pixels: int = 28 * 28 * 130,
-    max_pixels: int = 28 * 28 * 1280,
-) -> tuple[int, int]:
-    """
-    PaddleOCR-VL's intelligent resize logic.
-
-    Rescales the image so that:
-    1. Both dimensions are divisible by 'factor' (28)
-    2. Total pixels are within [min_pixels, max_pixels]
-    3. Aspect ratio is maintained as closely as possible
-
-    Args:
-        height: Original image height
-        width: Original image width
-        factor: Dimension divisibility factor (default: 28)
-        min_pixels: Minimum total pixels (default: 100,880)
-        max_pixels: Maximum total pixels (default: 1,003,520)
-
-    Returns:
-        Tuple of (new_height, new_width)
-    """
-    if height < factor:
-        width = round((width * factor) / height)
-        height = factor
-
-    if width < factor:
-        height = round((height * factor) / width)
-        width = factor
-
-    if max(height, width) / min(height, width) > 200:
-        logger.warning(
-            f"Extreme aspect ratio detected: {max(height, width) / min(height, width):.1f}"
-        )
-        # Continue anyway, but warn about potential issues
-
-    h_bar = round(height / factor) * factor
-    w_bar = round(width / factor) * factor
-
-    if h_bar * w_bar > max_pixels:
-        beta = math.sqrt((height * width) / max_pixels)
-        h_bar = math.floor(height / beta / factor) * factor
-        w_bar = math.floor(width / beta / factor) * factor
-    elif h_bar * w_bar < min_pixels:
-        beta = math.sqrt(min_pixels / (height * width))
-        h_bar = math.ceil(height * beta / factor) * factor
-        w_bar = math.ceil(width * beta / factor) * factor
-
-    return h_bar, w_bar
-
-
-def make_ocr_message(
-    image: Union[Image.Image, Dict[str, Any], str],
-    task_mode: str = "ocr",
-    apply_smart_resize: bool = True,
-) -> List[Dict]:
-    """
-    Create chat message for PaddleOCR-VL processing.
-
-    PaddleOCR-VL expects a specific format with the task prefix after the image.
-    """
-    # 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")
-
-    # Apply smart resize if requested. Spotting benefits from higher resolution
-    # (per the model card), so allow more pixels in that mode.
-    if apply_smart_resize:
-        original_size = pil_img.size
-        max_pixels = 28 * 28 * (2048 if task_mode == "spotting" else 1280)
-        new_height, new_width = smart_resize(
-            pil_img.height, pil_img.width, max_pixels=max_pixels
-        )
-        if (new_width, new_height) != (pil_img.width, pil_img.height):
-            pil_img = pil_img.resize((new_width, new_height), Image.Resampling.LANCZOS)
-            logger.debug(f"Resized image from {original_size} to {pil_img.size}")
-
-    # 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()}"
-
-    # PaddleOCR-VL message format: image first, then task prefix
-    return [
-        {
-            "role": "user",
-            "content": [
-                {"type": "image_url", "image_url": {"url": data_uri}},
-                {"type": "text", "text": TASK_MODES[task_mode]},
-            ],
-        }
-    ]
-
-
-def create_dataset_card(
-    source_dataset: str,
-    model: str,
-    task_mode: str,
-    num_samples: int,
-    processing_time: str,
-    batch_size: int,
-    max_model_len: int,
-    max_tokens: int,
-    gpu_memory_utilization: float,
-    temperature: float,
-    apply_smart_resize: bool,
-    image_column: str = "image",
-    split: str = "train",
-) -> str:
-    """Create a dataset card documenting the OCR process."""
-    task_description = TASK_DESCRIPTIONS[task_mode]
-
-    return f"""---
-tags:
-- ocr
-- document-processing
-- paddleocr-vl
-- paddleocr-vl-1.6
-- {task_mode}
-- uv-script
-- generated
----
-
-# Document Processing using PaddleOCR-VL-1.6 ({task_mode.upper()} mode)
-
-This dataset contains {task_mode.upper()} results from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using PaddleOCR-VL-1.6, an ultra-compact 0.9B OCR model (96.33% SOTA on OmniDocBench v1.6).
-
-## Processing Details
-
-- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
-- **Model**: [{model}](https://huggingface.co/{model})
-- **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")}
-
-### Configuration
-
-- **Image Column**: `{image_column}`
-- **Output Column**: `markdown`
-- **Dataset Split**: `{split}`
-- **Batch Size**: {batch_size}
-- **Smart Resize**: {"Enabled" if apply_smart_resize else "Disabled"}
-- **Max Model Length**: {max_model_len:,} tokens
-- **Max Output Tokens**: {max_tokens:,}
-- **Temperature**: {temperature}
-- **GPU Memory Utilization**: {gpu_memory_utilization:.1%}
-
-## Model Information
-
-PaddleOCR-VL-1.6 is a state-of-the-art, resource-efficient model tailored for document parsing:
-- 🎯 **SOTA** - 96.33% on OmniDocBench v1.6
-- 🧩 **Ultra-compact** - Only 0.9B parameters
-- 📝 **OCR mode** - General text extraction
-- 📊 **Table mode** - HTML table recognition
-- 📐 **Formula mode** - LaTeX mathematical notation
-- 📈 **Chart mode** - Structured chart analysis
-- 🔍 **Spotting mode** - Text spotting with localization
-- 🔖 **Seal mode** - Seal/stamp recognition
-- 🌍 **Multilingual** - Support for multiple languages
-- 🔧 **ERNIE-4.5 based** - Different architecture from Qwen models
-
-### Task Modes
-
-- **OCR**: Extract text content to markdown format
-- **Table Recognition**: Extract tables to HTML format
-- **Formula Recognition**: Extract mathematical formulas to LaTeX
-- **Chart Recognition**: Analyze and describe charts/diagrams
-- **Spotting**: Text spotting with localization
-- **Seal Recognition**: Seal and stamp recognition
-
-## Dataset Structure
-
-The dataset contains all original columns plus:
-- `markdown`: The extracted content based on task mode
-- `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 content
-for example in dataset:
-    print(example["markdown"])
-    break
-
-# View all OCR models applied to this dataset
-inference_info = json.loads(dataset[0]["inference_info"])
-for info in inference_info:
-    print(f"Task: {{info['task_mode']}} - Model: {{info['model_id']}}")
-```
-
-## Reproduction
-
-This dataset was generated using the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) PaddleOCR-VL-1.6 script.
-On HF Jobs, run with the pre-built vLLM image (image-mode) so flashinfer kernels are reused:
-
-```bash
-hf jobs uv run \\
-    --image vllm/vllm-openai:latest --flavor a100-large \\
-    --python /usr/bin/python3 -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages \\
-    -s HF_TOKEN \\
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl-1.6.py \\
-    {source_dataset} \\
-    <output-dataset> \\
-    --task-mode {task_mode} \\
-    --image-column {image_column} \\
-    --batch-size {batch_size} \\
-    --max-model-len {max_model_len} \\
-    --max-tokens {max_tokens} \\
-    --gpu-memory-utilization {gpu_memory_utilization}
-```
-
-## Performance
-
-- **Model Size**: 0.9B parameters (smallest among top-tier OCR models)
-- **Processing Speed**: ~{num_samples / (float(processing_time.split()[0]) * 60):.2f} images/second
-- **Architecture**: NaViT visual encoder + ERNIE-4.5-0.3B language model
-
-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,
-    task_mode: str = "ocr",
-    max_model_len: int = 8192,
-    max_tokens: int = 4096,
-    temperature: float = 0.0,
-    gpu_memory_utilization: float = 0.8,
-    apply_smart_resize: bool = True,
-    hf_token: str = None,
-    split: str = "train",
-    max_samples: int = None,
-    private: bool = False,
-    shuffle: bool = False,
-    seed: int = 42,
-    output_column: str = None,
-    config: str = None,
-    create_pr: bool = False,
-    verbose: bool = False,
-):
-    """Process images from HF dataset through PaddleOCR-VL-1.6 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)
-
-    # Validate task mode
-    if task_mode not in TASK_MODES:
-        raise ValueError(
-            f"Invalid task_mode '{task_mode}'. Choose from: {list(TASK_MODES.keys())}"
-        )
-
-    # Default output column is 'markdown' for consistency across scripts
-    if output_column is None:
-        output_column = "markdown"
-
-    logger.info(f"Using task mode: {task_mode} - {TASK_DESCRIPTIONS[task_mode]}")
-    logger.info(f"Output will be written to column: {output_column}")
-
-    # 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}"
-        )
-
-    # 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_ID}")
-    logger.info("This may take a minute on first run (model is only 0.9B)...")
-
-    try:
-        llm = LLM(
-            model=MODEL_ID,
-            trust_remote_code=True,
-            max_model_len=max_model_len,
-            gpu_memory_utilization=gpu_memory_utilization,
-            limit_mm_per_prompt={"image": 1},
-            max_num_batched_tokens=16384,
-            enable_prefix_caching=False,
-            enforce_eager=True,
-        )
-    except Exception as e:
-        logger.error(f"Failed to initialize PaddleOCR-VL-1.6 with vLLM: {e}")
-        logger.error(
-            "On HF Jobs, run with the pre-built vLLM image so flashinfer kernels are "
-            "reused (the default uv-script image has no nvcc):"
-        )
-        logger.error(
-            "  --image vllm/vllm-openai:latest --flavor a100-large "
-            "--python /usr/bin/python3 -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages"
-        )
-        sys.exit(1)
-
-    # Sampling parameters - deterministic for OCR
-    sampling_params = SamplingParams(
-        temperature=temperature,
-        max_tokens=max_tokens,
-    )
-
-    logger.info(f"Processing {len(dataset)} images in batches of {batch_size}")
-    if apply_smart_resize:
-        logger.info("Smart resize enabled (PaddleOCR-VL's adaptive resolution)")
-
-    # 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=f"PaddleOCR-VL-1.6 {task_mode.upper()} processing",
-    ):
-        batch_indices = list(batch_indices)
-        batch_images = [dataset[i][image_column] for i in batch_indices]
-
-        try:
-            # Create messages for batch with task-specific prefix
-            batch_messages = [
-                make_ocr_message(
-                    img, task_mode=task_mode, apply_smart_resize=apply_smart_resize
-                )
-                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()
-                all_outputs.append(text)
-
-        except Exception as e:
-            logger.error(f"Error processing batch: {e}")
-            # Add error placeholders for failed batch
-            all_outputs.extend([f"[{task_mode.upper()} 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_ID,
-        "model_name": "PaddleOCR-VL-1.6",
-        "model_size": "0.9B",
-        "task_mode": task_mode,
-        "column_name": output_column,
-        "timestamp": datetime.now().isoformat(),
-        "temperature": temperature,
-        "max_tokens": max_tokens,
-        "smart_resize": apply_smart_resize,
-        "backend": "vllm",
-    }
-
-    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}")
-    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 (skip when creating a PR to avoid touching main)
-    if not create_pr:
-        logger.info("Creating dataset card")
-        card_content = create_dataset_card(
-            source_dataset=input_dataset,
-            model=MODEL_ID,
-            task_mode=task_mode,
-            num_samples=len(dataset),
-            processing_time=processing_time_str,
-            batch_size=batch_size,
-            max_model_len=max_model_len,
-            max_tokens=max_tokens,
-            gpu_memory_utilization=gpu_memory_utilization,
-            temperature=temperature,
-            apply_smart_resize=apply_smart_resize,
-            image_column=image_column,
-            split=split,
-        )
-
-        card = DatasetCard(card_content)
-        card.push_to_hub(output_dataset, token=HF_TOKEN)
-
-    logger.info("✅ PaddleOCR-VL-1.6 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"Task mode: {task_mode} - {TASK_DESCRIPTIONS[task_mode]}")
-
-    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("PaddleOCR-VL-1.6 Document Processing")
-        print("=" * 80)
-        print("\nUltra-compact 0.9B OCR model (96.33% SOTA on OmniDocBench v1.6)")
-        print("\nFeatures:")
-        print("- 🎯 SOTA - 96.33% on OmniDocBench v1.6 (0.9B params)")
-        print("- 📝 OCR mode - General text extraction")
-        print("- 📊 Table mode - HTML table recognition")
-        print("- 📐 Formula mode - LaTeX mathematical notation")
-        print("- 📈 Chart mode - Structured chart analysis")
-        print("- 🔍 Spotting mode - Text spotting with localization")
-        print("- 🔖 Seal mode - Seal/stamp recognition")
-        print("- 🌍 Multilingual support")
-        print("- 🔧 Based on ERNIE-4.5 (unique architecture)")
-        print("\nTask Modes:")
-        for mode, description in TASK_DESCRIPTIONS.items():
-            print(f"  {mode:8} - {description}")
-        print("\nExample usage:")
-        print("\n1. Basic OCR (default mode):")
-        print("   uv run paddleocr-vl-1.6.py input-dataset output-dataset")
-        print("\n2. Table extraction:")
-        print("   uv run paddleocr-vl-1.6.py docs tables-extracted --task-mode table")
-        print("\n3. Formula recognition:")
-        print(
-            "   uv run paddleocr-vl-1.6.py papers formulas --task-mode formula --batch-size 32"
-        )
-        print("\n4. Chart analysis:")
-        print("   uv run paddleocr-vl-1.6.py diagrams charts-analyzed --task-mode chart")
-        print("\n5. Test with small sample:")
-        print("   uv run paddleocr-vl-1.6.py dataset test --max-samples 10 --shuffle")
-        print("\n6. Running on HF Jobs (image-mode required — see note below):")
-        print("   hf jobs uv run \\")
-        print("     --image vllm/vllm-openai:latest --flavor a100-large \\")
-        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/paddleocr-vl-1.6.py \\"
-        )
-        print("       input-dataset output-dataset --task-mode ocr")
-        print("\n   NOTE: the default uv-script image has no nvcc, so vLLM's flashinfer")
-        print("   sampler crashes at warmup. The vllm/vllm-openai image ships the kernels.")
-        print("\n" + "=" * 80)
-        print("\nFor full help, run: uv run paddleocr-vl-1.6.py --help")
-        sys.exit(0)
-
-    parser = argparse.ArgumentParser(
-        description="Document processing using PaddleOCR-VL-1.6 (0.9B SOTA OCR model)",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Task Modes:
-  ocr       General text extraction to markdown (default)
-  table     Table extraction to HTML format
-  formula   Mathematical formula recognition to LaTeX
-  chart     Chart and diagram analysis
-  spotting  Text spotting with localization
-  seal      Seal and stamp recognition
-
-Examples:
-  # Basic text OCR
-  uv run paddleocr-vl-1.6.py my-docs analyzed-docs
-
-  # Extract tables from documents
-  uv run paddleocr-vl-1.6.py papers tables --task-mode table
-
-  # Recognize mathematical formulas
-  uv run paddleocr-vl-1.6.py textbooks formulas --task-mode formula
-
-  # Analyze charts and diagrams
-  uv run paddleocr-vl-1.6.py reports charts --task-mode chart
-
-  # Test with random sampling
-  uv run paddleocr-vl-1.6.py large-dataset test --max-samples 50 --shuffle --task-mode ocr
-
-  # Disable smart resize for original resolution
-  uv run paddleocr-vl-1.6.py images output --no-smart-resize
-        """,
-    )
-
-    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(
-        "--task-mode",
-        choices=list(TASK_MODES.keys()),
-        default="ocr",
-        help="Task type: ocr (default), table, formula, chart, spotting, or seal",
-    )
-    parser.add_argument(
-        "--max-model-len",
-        type=int,
-        default=8192,
-        help="Maximum model context length (default: 8192)",
-    )
-    parser.add_argument(
-        "--max-tokens",
-        type=int,
-        default=4096,
-        help="Maximum tokens to generate (default: 4096)",
-    )
-    parser.add_argument(
-        "--temperature",
-        type=float,
-        default=0.0,
-        help="Sampling temperature (default: 0.0 for deterministic)",
-    )
-    parser.add_argument(
-        "--gpu-memory-utilization",
-        type=float,
-        default=0.8,
-        help="GPU memory utilization (default: 0.8)",
-    )
-    parser.add_argument(
-        "--no-smart-resize",
-        action="store_true",
-        help="Disable PaddleOCR-VL's smart resize, use original image size",
-    )
-    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(
-        "--output-column",
-        help="Column name for output (default: markdown)",
-    )
-    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(
-        "--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,
-        task_mode=args.task_mode,
-        max_model_len=args.max_model_len,
-        max_tokens=args.max_tokens,
-        temperature=args.temperature,
-        gpu_memory_utilization=args.gpu_memory_utilization,
-        apply_smart_resize=not args.no_smart_resize,
-        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,
-        config=args.config,
-        create_pr=args.create_pr,
-        verbose=args.verbose,
-    )

paddleocr-vl.py

@@ -56,10 +56,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)

pp-doclayout.py

@@ -1,1197 +0,0 @@
-# /// script
-# requires-python = ">=3.10"
-# dependencies = [
-#     "paddlepaddle-gpu>=3.0.0",
-#     "paddleocr>=3.0.0",
-#     "opencv-contrib-python-headless",
-#     "datasets>=4.0.0",
-#     "huggingface-hub>=1.6.0",
-#     "pyarrow>=15.0",
-#     "pillow",
-#     "numpy",
-#     "tqdm",
-# ]
-#
-# [tool.uv]
-# # PaddleOCR/PaddleX pull in opencv-contrib-python (full) which needs system
-# # libGL.so.1 — not present in the slim uv-on-bookworm image used by HF Jobs.
-# # Swap to the headless cv2 variant (same `import cv2`, no GUI deps).
-# override-dependencies = [
-#     "opencv-contrib-python ; python_version < '0'",
-#     "opencv-python ; python_version < '0'",
-# ]
-#
-# [[tool.uv.index]]
-# name = "paddle"
-# url = "https://www.paddlepaddle.org.cn/packages/stable/cu126/"
-# explicit = true
-#
-# [tool.uv.sources]
-# paddlepaddle-gpu = { index = "paddle" }
-# ///
-
-"""
-Detect document layout regions (text/title/table/figure/formula/...) with PP-DocLayout-L.
-
-Runs PaddleOCR's PP-DocLayout-L (or M / S / plus-L variant) over an image source
-and emits per-image bounding-box predictions. Unlike the OCR scripts in this repo
-this does NOT extract text — it only locates and classifies regions.
-
-Source can be:
-  - HF dataset repo (default): "namespace/dataset"
-  - HF bucket of image files: "hf://buckets/namespace/bucket/optional/prefix"
-
-Sink can be:
-  - HF dataset repo (default): "namespace/dataset" (one push at end + dataset card)
-  - HF bucket: "hf://buckets/namespace/bucket/run-name" (incremental parquet
-    shards, resumable, no git overhead)
-
-Output schema (column `layout` is a JSON string):
-  [{"bbox": [x1, y1, x2, y2], "label": "text", "score": 0.97, "cls_id": 2}, ...]
-
-Coordinates are in the original input-image pixel space.
-
-Example commands:
-
-  # Dataset -> dataset (smoke on L4)
-  hf jobs uv run --flavor l4x1 -s HF_TOKEN https://huggingface.co/datasets/uv-scripts/ocr/raw/main/pp-doclayout.py \\
-      davanstrien/ufo-ColPali pp-doclayout-smoke \\
-      --max-samples 3 --shuffle --seed 42 --private
-
-  # Dataset -> bucket (incremental shards, resumable)
-  hf buckets create davanstrien/pp-doclayout-scratch --exist-ok
-  hf jobs uv run --flavor l4x1 -s HF_TOKEN https://huggingface.co/datasets/uv-scripts/ocr/raw/main/pp-doclayout.py \\
-      davanstrien/ufo-ColPali \\
-      hf://buckets/davanstrien/pp-doclayout-scratch/run1 \\
-      --max-samples 20 --shard-size 5
-
-  # Bucket of images -> dataset
-  hf jobs uv run --flavor l4x1 -s HF_TOKEN https://huggingface.co/datasets/uv-scripts/ocr/raw/main/pp-doclayout.py \\
-      hf://buckets/davanstrien/pp-doclayout-images \\
-      pp-doclayout-from-bucket --private
-"""
-
-import argparse
-import io
-import json
-import logging
-import os
-import sys
-import time
-from dataclasses import dataclass
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
-
-import numpy as np
-from PIL import Image, UnidentifiedImageError
-from tqdm.auto import tqdm
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-
-# ---------------------------------------------------------------------------
-# Constants
-# ---------------------------------------------------------------------------
-
-VALID_MODELS = [
-    "PP-DocLayout-L",
-    "PP-DocLayout-M",
-    "PP-DocLayout-S",
-    "PP-DocLayout_plus-L",
-]
-
-MODEL_SIZES = {
-    "PP-DocLayout-L": "~123M params (RT-DETR-L backbone)",
-    "PP-DocLayout-M": "~22M params (PicoDet-M)",
-    "PP-DocLayout-S": "~4M params (PicoDet-S)",
-    "PP-DocLayout_plus-L": "~123M params, 20-class plus variant",
-}
-
-IMAGE_EXTENSIONS = {
-    ".jpg", ".jpeg", ".png", ".tif", ".tiff", ".webp", ".bmp", ".jp2", ".j2k",
-}
-
-BUCKET_PREFIX = "hf://buckets/"
-
-
-# ---------------------------------------------------------------------------
-# URL helpers
-# ---------------------------------------------------------------------------
-
-
-def is_bucket_url(s: str) -> bool:
-    return s.startswith(BUCKET_PREFIX)
-
-
-def parse_bucket_url(url: str) -> Tuple[str, str]:
-    """Split `hf://buckets/ns/bucket/path/in/bucket` into (`ns/bucket`, `path/in/bucket`)."""
-    if not is_bucket_url(url):
-        raise ValueError(f"Not a bucket URL: {url}")
-    rest = url[len(BUCKET_PREFIX) :].strip("/")
-    parts = rest.split("/", 2)
-    if len(parts) < 2:
-        raise ValueError(
-            f"Bucket URL must include namespace and bucket name: {url}"
-        )
-    bucket_id = f"{parts[0]}/{parts[1]}"
-    prefix = parts[2] if len(parts) > 2 else ""
-    return bucket_id, prefix
-
-
-# ---------------------------------------------------------------------------
-# Image helpers
-# ---------------------------------------------------------------------------
-
-
-def to_pil(image: Union[Image.Image, Dict[str, Any], str, bytes]) -> Image.Image:
-    if isinstance(image, Image.Image):
-        return image.convert("RGB")
-    if isinstance(image, dict) and "bytes" in image:
-        return Image.open(io.BytesIO(image["bytes"])).convert("RGB")
-    if isinstance(image, (bytes, bytearray)):
-        return Image.open(io.BytesIO(image)).convert("RGB")
-    if isinstance(image, str):
-        return Image.open(image).convert("RGB")
-    raise ValueError(f"Unsupported image type: {type(image)}")
-
-
-def pil_to_array(pil_img: Image.Image) -> np.ndarray:
-    """RGB PIL -> uint8 ndarray. PaddleOCR's predict() accepts numpy arrays directly."""
-    return np.asarray(pil_img, dtype=np.uint8)
-
-
-# ---------------------------------------------------------------------------
-# Result extraction
-# ---------------------------------------------------------------------------
-
-
-def extract_detections(result: Any) -> List[Dict[str, Any]]:
-    """Pull a clean list of detections out of a paddleocr LayoutDetection result."""
-    payload = result.json
-    res = payload.get("res", payload) if isinstance(payload, dict) else {}
-    boxes = res.get("boxes", []) if isinstance(res, dict) else []
-    detections = []
-    for box in boxes:
-        coord = box.get("coordinate") or box.get("bbox") or []
-        coord = [float(x) for x in coord]
-        detections.append(
-            {
-                "bbox": coord,
-                "label": box.get("label"),
-                "score": float(box.get("score", 0.0)),
-                "cls_id": int(box.get("cls_id", -1)),
-            }
-        )
-    return detections
-
-
-# ---------------------------------------------------------------------------
-# Sources
-# ---------------------------------------------------------------------------
-
-
-@dataclass
-class SourceItem:
-    key: str  # stable identifier per image (used for dedup/resume)
-    image: Optional[Image.Image]  # None for an unreadable row (placeholder)
-    extras: Dict[str, Any]  # original row fields (only populated for dataset source)
-
-
-def iter_dataset_images(
-    dataset_id: str,
-    image_column: str,
-    split: str,
-    shuffle: bool,
-    seed: int,
-    max_samples: Optional[int],
-):
-    """Iterate (key, PIL) pairs from an HF dataset repo.
-
-    Returns: (iterator, total, dataset_reference). The dataset reference is the
-    post-shuffle/post-select Dataset, kept around so the dataset-repo sink can
-    `add_column("layout", ...)` and preserve the original schema (especially
-    Image-type columns).
-    """
-    from datasets import load_dataset
-
-    logger.info(f"Loading dataset: {dataset_id} (split={split})")
-    ds = load_dataset(dataset_id, split=split)
-
-    if image_column not in ds.column_names:
-        raise ValueError(
-            f"Column '{image_column}' not found. Available: {ds.column_names}"
-        )
-
-    if shuffle:
-        logger.info(f"Shuffling with seed {seed}")
-        ds = ds.shuffle(seed=seed)
-    if max_samples:
-        ds = ds.select(range(min(max_samples, len(ds))))
-        logger.info(f"Limited to {len(ds)} samples")
-
-    total = len(ds)
-
-    def gen() -> Iterator[SourceItem]:
-        failed = 0
-        for i in range(total):
-            try:
-                row = ds[i]
-                image = to_pil(row[image_column])
-            except (UnidentifiedImageError, OSError) as e:
-                # Still yield a placeholder so the output row stays aligned with
-                # the source row (the dataset sink writes layouts positionally).
-                failed += 1
-                logger.warning(
-                    f"Unreadable image at row {i}: "
-                    f"{type(e).__name__}: {e} — writing empty layout"
-                )
-                yield SourceItem(
-                    key=f"row-{i:08d}",
-                    image=None,
-                    extras={"failed": True},
-                )
-                continue
-            yield SourceItem(
-                key=f"row-{i:08d}",
-                image=image,
-                extras={},  # original schema is preserved by the sink via the dataset ref
-            )
-        if failed:
-            logger.info(f"{failed} unreadable image(s) written as empty layouts")
-
-    return gen(), total, ds
-
-
-SOURCE_PATHS_SNAPSHOT = "_source_paths.json"
-
-
-def _bucket_snapshot_path(output_url: str) -> Tuple[str, str]:
-    """Return (bucket_id, key) for the source-paths snapshot inside an output bucket."""
-    out_bucket_id, out_prefix = parse_bucket_url(output_url)
-    snapshot_key = (
-        f"{out_prefix}/{SOURCE_PATHS_SNAPSHOT}".lstrip("/")
-        if out_prefix
-        else SOURCE_PATHS_SNAPSHOT
-    )
-    return out_bucket_id, snapshot_key
-
-
-def iter_bucket_images(
-    bucket_url: str,
-    shuffle: bool,
-    seed: int,
-    max_samples: Optional[int],
-    hf_token: Optional[str],
-    output_url: Optional[str] = None,
-) -> Tuple[Iterator[SourceItem], int]:
-    """Glob image files under a bucket prefix and stream them via HfFileSystem.
-
-    If `output_url` is a bucket, the resolved source-path list is snapshotted to
-    `<output>/_source_paths.json` on first run. Subsequent runs against the same
-    output prefix reuse that snapshot, so resume stays consistent even if the
-    source bucket grows or `--shuffle`/`--max-samples` would otherwise pick a
-    different subset on the second run.
-    """
-    from huggingface_hub import HfApi, HfFileSystem
-
-    bucket_id, prefix = parse_bucket_url(bucket_url)
-    fs = HfFileSystem(token=hf_token)
-    base = f"{BUCKET_PREFIX}{bucket_id}/{prefix}".rstrip("/")
-
-    snapshot_bucket_id: Optional[str] = None
-    snapshot_key: Optional[str] = None
-    cached_paths: Optional[List[str]] = None
-
-    if output_url and is_bucket_url(output_url):
-        snapshot_bucket_id, snapshot_key = _bucket_snapshot_path(output_url)
-        snapshot_url = f"{BUCKET_PREFIX}{snapshot_bucket_id}/{snapshot_key}"
-        try:
-            with fs.open(snapshot_url, "rb") as f:
-                snapshot = json.load(f)
-            if snapshot.get("source_url") != bucket_url:
-                logger.warning(
-                    f"Output prefix already has a snapshot referencing a "
-                    f"different source ({snapshot.get('source_url')!r} vs "
-                    f"{bucket_url!r}). Ignoring and re-listing."
-                )
-            else:
-                cached_paths = snapshot["paths"]
-                logger.info(
-                    f"Reusing existing snapshot of {len(cached_paths)} source paths "
-                    f"(written {snapshot.get('created_at', 'unknown')})"
-                )
-        except FileNotFoundError:
-            pass
-        except Exception as e:
-            logger.warning(f"Could not read existing snapshot ({e}); re-listing.")
-
-    if cached_paths is not None:
-        all_paths = cached_paths
-    else:
-        logger.info(f"Listing images under {base}")
-        all_paths = []
-        try:
-            for entry in fs.find(base, detail=False):
-                ext = Path(entry).suffix.lower()
-                if ext in IMAGE_EXTENSIONS:
-                    all_paths.append(entry)
-        except FileNotFoundError as e:
-            raise ValueError(f"Bucket prefix not found: {base}") from e
-
-        if not all_paths:
-            raise ValueError(
-                f"No image files (any of {sorted(IMAGE_EXTENSIONS)}) under {base}"
-            )
-
-        all_paths.sort()
-        if shuffle:
-            rng = np.random.default_rng(seed)
-            rng.shuffle(all_paths)
-        if max_samples:
-            all_paths = all_paths[:max_samples]
-
-        # Persist the chosen list so resume runs see exactly this set.
-        if snapshot_bucket_id is not None and snapshot_key is not None:
-            api = HfApi(token=hf_token)
-            payload = {
-                "source_url": bucket_url,
-                "shuffle": shuffle,
-                "seed": seed,
-                "max_samples": max_samples,
-                "created_at": datetime.now(timezone.utc).isoformat(),
-                "paths": all_paths,
-            }
-            api.batch_bucket_files(
-                snapshot_bucket_id,
-                add=[(json.dumps(payload).encode(), snapshot_key)],
-                token=hf_token,
-            )
-            logger.info(
-                f"Wrote source-path snapshot ({len(all_paths)} paths) to "
-                f"hf://buckets/{snapshot_bucket_id}/{snapshot_key}"
-            )
-
-    total = len(all_paths)
-    logger.info(f"Found {total} images in bucket")
-
-    def key_for(path: str) -> str:
-        # Use the full bucket path (`buckets/<id>/<rel>`) as returned by
-        # fs.find. This is stable across reruns (so resume works), and the
-        # stored value in `source_path` is fully addressable — open via
-        # HfFileSystem directly with `hf://` re-prepended.
-        return path
-
-    def gen() -> Iterator[SourceItem]:
-        skipped = 0
-        for path in all_paths:
-            try:
-                with fs.open(path, "rb") as f:
-                    data = f.read()
-                image = to_pil(data)
-            except (UnidentifiedImageError, OSError) as e:
-                skipped += 1
-                logger.warning(
-                    f"Skipping unreadable image {path}: "
-                    f"{type(e).__name__}: {e}"
-                )
-                continue
-            yield SourceItem(
-                key=key_for(path),
-                image=image,
-                extras={"__source_path": key_for(path)},
-            )
-        if skipped:
-            logger.info(f"Skipped {skipped} unreadable image(s) total")
-
-    return gen(), total
-
-
-# ---------------------------------------------------------------------------
-# Sinks
-# ---------------------------------------------------------------------------
-
-
-class DatasetRepoSink:
-    """Buffer all results in memory, push once at end with dataset card + inference_info.
-
-    Two modes:
-      - `original_dataset` provided (dataset-repo source): preserve the source
-        schema (including Image-type columns) and just `add_column("layout", ...)`.
-      - `original_dataset` is None (bucket-image source): build a Dataset from
-        collected rows containing __source_path + layout.
-    """
-
-    def __init__(
-        self,
-        repo_id: str,
-        *,
-        hf_token: Optional[str],
-        private: bool,
-        config: Optional[str],
-        create_pr: bool,
-        source_id: str,
-        original_dataset=None,
-    ):
-        self.repo_id = repo_id
-        self.hf_token = hf_token
-        self.private = private
-        self.config = config
-        self.create_pr = create_pr
-        self.source_id = source_id
-        self.original_dataset = original_dataset
-        # Used when original_dataset is None: row-by-row buffer.
-        self._rows: List[Dict[str, Any]] = []
-        # Used when original_dataset is set: ordered layouts aligned with dataset rows.
-        self._layouts: List[str] = []
-
-    @property
-    def kind(self) -> str:
-        return "dataset"
-
-    def already_done(self) -> set:
-        return set()  # dataset sink does a single push, no resume
-
-    def write(self, key: str, layout: List[Dict[str, Any]], extras: Dict[str, Any]) -> None:
-        layout_json = json.dumps(layout, ensure_ascii=False)
-        if self.original_dataset is not None:
-            self._layouts.append(layout_json)
-            return
-        row = {"__source_key": key, "layout": layout_json}
-        for k, v in extras.items():
-            if isinstance(v, (str, int, float, bool)) or v is None:
-                row[k] = v
-        self._rows.append(row)
-
-    def finalize(self, model_id: str, args_dict: Dict[str, Any]) -> None:
-        from datasets import Dataset
-
-        if self.original_dataset is not None:
-            if len(self._layouts) != len(self.original_dataset):
-                logger.warning(
-                    f"Layout count ({len(self._layouts)}) != dataset rows "
-                    f"({len(self.original_dataset)}); padding with empty layouts."
-                )
-                # Pad to keep add_column happy.
-                while len(self._layouts) < len(self.original_dataset):
-                    self._layouts.append("[]")
-            ds = self.original_dataset.add_column("layout", self._layouts)
-        else:
-            if not self._rows:
-                logger.warning("No rows produced; nothing to push.")
-                return
-            ds = Dataset.from_list(self._rows)
-            if "__source_key" in ds.column_names:
-                ds = ds.rename_column("__source_key", "source_path")
-
-        inference_entry = build_inference_entry(model_id, args_dict)
-
-        if "inference_info" in ds.column_names:
-            logger.info("Updating existing inference_info column")
-
-            def _update(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)}
-
-            ds = ds.map(_update)
-        else:
-            ds = ds.add_column(
-                "inference_info", [json.dumps([inference_entry])] * len(ds)
-            )
-
-        logger.info(f"Pushing {len(ds)} rows to {self.repo_id}")
-        push_kwargs = {
-            "private": self.private,
-            "token": self.hf_token,
-            "max_shard_size": "500MB",
-            "create_pr": self.create_pr,
-            "commit_message": f"Add PP-DocLayout layout predictions ({len(ds)} samples)"
-            + (f" [{self.config}]" if self.config else ""),
-        }
-        if self.config:
-            push_kwargs["config_name"] = self.config
-
-        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"
-                ds.push_to_hub(self.repo_id, **push_kwargs)
-                break
-            except Exception as e:
-                logger.error(f"Upload attempt {attempt}/{max_retries} failed: {e}")
-                if attempt == max_retries:
-                    logger.error("All upload attempts failed.")
-                    raise
-                time.sleep(30 * (2 ** (attempt - 1)))
-
-        # Dataset card
-        from huggingface_hub import DatasetCard
-
-        card = DatasetCard(
-            create_dataset_card(
-                source=self.source_id,
-                model_name=args_dict["model_name"],
-                num_samples=len(ds),
-                processing_time=args_dict["processing_time"],
-                output_column="layout",
-                threshold=args_dict["threshold"],
-                layout_nms=args_dict["layout_nms"],
-            )
-        )
-        card.push_to_hub(self.repo_id, token=self.hf_token)
-        logger.info(
-            f"Done: https://huggingface.co/datasets/{self.repo_id}"
-        )
-
-
-class BucketShardSink:
-    """Write incremental parquet shards to a bucket prefix. Resumable."""
-
-    METADATA_FILE = "_metadata.json"
-    SHARD_PATTERN = "shard-{:05d}.parquet"
-
-    def __init__(
-        self,
-        bucket_url: str,
-        *,
-        hf_token: Optional[str],
-        shard_size: int,
-        include_images: bool,
-        resume: bool,
-        source_id: str,
-    ):
-        from huggingface_hub import HfApi, HfFileSystem, create_bucket
-
-        self.bucket_url = bucket_url
-        self.bucket_id, self.prefix = parse_bucket_url(bucket_url)
-        self.hf_token = hf_token
-        self.shard_size = shard_size
-        self.include_images = include_images
-        self.resume = resume
-        self.source_id = source_id
-
-        self._api = HfApi(token=hf_token)
-        self._fs = HfFileSystem(token=hf_token)
-
-        # Make sure the bucket exists. Path inside the bucket is created lazily on first write.
-        try:
-            create_bucket(self.bucket_id, exist_ok=True, token=hf_token)
-        except Exception as e:
-            # If we don't have create rights but the bucket already exists, that's fine.
-            logger.warning(f"create_bucket('{self.bucket_id}') warning: {e}")
-
-        self._buffer: List[Dict[str, Any]] = []
-        self._next_shard_idx = self._discover_next_shard_idx()
-        self._completed_keys = self._discover_completed_keys() if resume else set()
-        if self._completed_keys:
-            logger.info(
-                f"Resume: found {len(self._completed_keys)} already-processed keys, will skip them"
-            )
-
-    @property
-    def kind(self) -> str:
-        return "bucket"
-
-    def already_done(self) -> set:
-        return self._completed_keys
-
-    # --- internal helpers ---
-
-    def _shard_path(self, idx: int) -> str:
-        return self._join(self.SHARD_PATTERN.format(idx))
-
-    def _join(self, name: str) -> str:
-        return f"{self.prefix}/{name}".lstrip("/") if self.prefix else name
-
-    def _list_existing_shards(self) -> List[str]:
-        try:
-            tree = self._api.list_bucket_tree(
-                self.bucket_id, prefix=self.prefix or None, recursive=True
-            )
-        except Exception:
-            return []
-        shards: List[str] = []
-        for item in tree:
-            path = getattr(item, "path", None)
-            ftype = getattr(item, "type", None)
-            if not path or ftype not in (None, "file"):
-                continue
-            base = Path(path).name
-            if base.startswith("shard-") and base.endswith(".parquet"):
-                shards.append(path)
-        return sorted(shards)
-
-    def _discover_next_shard_idx(self) -> int:
-        shards = self._list_existing_shards()
-        max_idx = -1
-        for s in shards:
-            stem = Path(s).stem  # shard-00007
-            try:
-                max_idx = max(max_idx, int(stem.split("-")[-1]))
-            except ValueError:
-                continue
-        return max_idx + 1
-
-    def _discover_completed_keys(self) -> set:
-        import pyarrow.parquet as pq
-
-        keys: set = set()
-        for shard_path in self._list_existing_shards():
-            full = f"{BUCKET_PREFIX}{self.bucket_id}/{shard_path}"
-            try:
-                with self._fs.open(full, "rb") as f:
-                    table = pq.read_table(f, columns=["__source_key"])
-                keys.update(table.column("__source_key").to_pylist())
-            except Exception as e:
-                logger.warning(f"Could not read keys from {shard_path}: {e}")
-        return keys
-
-    def _flush(self) -> None:
-        if not self._buffer:
-            return
-        import pyarrow as pa
-        import pyarrow.parquet as pq
-
-        # Build a stable schema. Skip the image column if not requested.
-        columns = ["__source_key", "layout"]
-        if self.include_images:
-            columns.append("__image_bytes")
-        # Carry through any extra string-coercible fields (e.g. __source_path).
-        extra_keys = sorted(
-            {k for row in self._buffer for k in row.keys() if k not in columns}
-        )
-        columns.extend(extra_keys)
-
-        table_dict = {c: [row.get(c) for row in self._buffer] for c in columns}
-        # pyarrow infers types from python objects; strings/bytes/lists handled fine.
-        table = pa.Table.from_pydict(table_dict)
-
-        buf = io.BytesIO()
-        pq.write_table(table, buf, compression="zstd")
-        data = buf.getvalue()
-
-        shard_remote = self._shard_path(self._next_shard_idx)
-        logger.info(
-            f"Writing shard {self._next_shard_idx} ({len(self._buffer)} rows, "
-            f"{len(data) / 1024 / 1024:.1f} MiB) to {shard_remote}"
-        )
-        self._api.batch_bucket_files(
-            self.bucket_id, add=[(data, shard_remote)], token=self.hf_token
-        )
-        self._next_shard_idx += 1
-        self._buffer.clear()
-
-    def write(self, key: str, layout: List[Dict[str, Any]], extras: Dict[str, Any]) -> None:
-        row: Dict[str, Any] = {
-            "__source_key": key,
-            "layout": json.dumps(layout, ensure_ascii=False),
-        }
-        if self.include_images and "__image_bytes" in extras:
-            row["__image_bytes"] = extras["__image_bytes"]
-        # Pass through string/numeric extras (skip raw PIL Image objects which
-        # the dataset source never injects directly into extras anyway).
-        for k, v in extras.items():
-            if k in row or k == "__image_bytes":
-                continue
-            if isinstance(v, (str, int, float, bool)) or v is None:
-                row[k] = v
-        self._buffer.append(row)
-        if len(self._buffer) >= self.shard_size:
-            self._flush()
-
-    def finalize(self, model_id: str, args_dict: Dict[str, Any]) -> None:
-        # Flush trailing rows.
-        self._flush()
-        # Write/update the metadata file alongside the shards.
-        meta = {
-            "model_id": model_id,
-            "model_name": args_dict["model_name"],
-            "task_mode": "layout-detection",
-            "source": self.source_id,
-            "threshold": args_dict["threshold"],
-            "layout_nms": args_dict["layout_nms"],
-            "shard_size": args_dict["shard_size"],
-            "include_images": self.include_images,
-            "last_run_at": datetime.now(timezone.utc).isoformat(),
-            "processing_time": args_dict.get("processing_time"),
-        }
-        meta_bytes = json.dumps(meta, indent=2).encode("utf-8")
-        meta_path = self._join(self.METADATA_FILE)
-        self._api.batch_bucket_files(
-            self.bucket_id, add=[(meta_bytes, meta_path)], token=self.hf_token
-        )
-        logger.info(
-            f"Done: https://huggingface.co/buckets/{self.bucket_id}"
-            + (f"/{self.prefix}" if self.prefix else "")
-        )
-
-
-# ---------------------------------------------------------------------------
-# inference_info + dataset card
-# ---------------------------------------------------------------------------
-
-
-def build_inference_entry(model_id: str, args_dict: Dict[str, Any]) -> Dict[str, Any]:
-    return {
-        "model_id": "PaddlePaddle/" + args_dict["model_name"],
-        "model_name": args_dict["model_name"],
-        "model_size": MODEL_SIZES.get(args_dict["model_name"], "unknown"),
-        "task_mode": "layout-detection",
-        "column_name": "layout",
-        "timestamp": datetime.now(timezone.utc).isoformat(),
-        "threshold": args_dict["threshold"],
-        "layout_nms": args_dict["layout_nms"],
-        "backend": "paddleocr",
-    }
-
-
-def create_dataset_card(
-    source: str,
-    model_name: str,
-    num_samples: int,
-    processing_time: str,
-    output_column: str,
-    threshold: float,
-    layout_nms: bool,
-) -> str:
-    """Render the dataset card markdown for the dataset-repo sink."""
-    if is_bucket_url(source):
-        source_link = f"[{source}]({source})"
-    else:
-        source_link = f"[{source}](https://huggingface.co/datasets/{source})"
-
-    return f"""---
-tags:
-- layout-detection
-- document-processing
-- paddleocr
-- pp-doclayout
-- uv-script
-- generated
-viewer: false
----
-
-# Layout detection with {model_name}
-
-Bounding-box layout predictions for images from {source_link}, produced by
-PaddleOCR's [{model_name}](https://huggingface.co/PaddlePaddle/{model_name}).
-
-## Processing details
-
-- **Source**: {source_link}
-- **Model**: PaddlePaddle/{model_name} ({MODEL_SIZES.get(model_name, "unknown")})
-- **Samples**: {num_samples:,}
-- **Processing time**: {processing_time}
-- **Processing date**: {datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")}
-- **Confidence threshold**: {threshold}
-- **Layout NMS**: {"on" if layout_nms else "off"}
-- **Output column**: `{output_column}` (JSON-encoded list of detections)
-
-## Schema
-
-Each row contains the original columns plus:
-
-- `{output_column}`: JSON string. List of detections:
-  ```json
-  [
-    {{"bbox": [x1, y1, x2, y2], "label": "text", "score": 0.97, "cls_id": 2}},
-    {{"bbox": [x1, y1, x2, y2], "label": "table", "score": 0.92, "cls_id": 5}}
-  ]
-  ```
-  Coordinates are in **original input-image pixel space** (top-left origin,
-  `[xmin, ymin, xmax, ymax]`).
-- `inference_info`: JSON list tracking every model that has been applied to
-  this dataset (appended on each run).
-
-## Usage
-
-```python
-import json
-from datasets import load_dataset
-
-ds = load_dataset("{{output_dataset_id}}", split="train")
-detections = json.loads(ds[0]["{output_column}"])
-for det in detections:
-    print(det["label"], det["score"], det["bbox"])
-```
-
-## Reproduction
-
-```bash
-hf jobs uv run --flavor l4x1 -s HF_TOKEN \\
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/pp-doclayout.py \\
-    {source} <output> --model-name {model_name}
-```
-
-Generated with [UV Scripts](https://huggingface.co/uv-scripts).
-"""
-
-
-# ---------------------------------------------------------------------------
-# Main
-# ---------------------------------------------------------------------------
-
-
-def resolve_device(device: str) -> str:
-    if device == "gpu":
-        try:
-            import paddle  # noqa: F401
-
-            if paddle.device.is_compiled_with_cuda() and paddle.device.cuda.device_count() > 0:
-                logger.info(
-                    f"GPU available: {paddle.device.cuda.device_count()} device(s)"
-                )
-                return "gpu"
-            logger.warning("No CUDA GPU detected; falling back to CPU.")
-            return "cpu"
-        except Exception as e:
-            logger.warning(f"GPU check failed ({e}); falling back to CPU.")
-            return "cpu"
-    return device
-
-
-def main(args: argparse.Namespace) -> None:
-    from huggingface_hub import login
-
-    start_time = datetime.now()
-    hf_token = args.hf_token or os.environ.get("HF_TOKEN")
-    if hf_token:
-        login(token=hf_token)
-
-    device = resolve_device(args.device)
-
-    # ---------- source ----------
-    original_dataset = None
-    if is_bucket_url(args.input_source):
-        src_iter, total = iter_bucket_images(
-            args.input_source,
-            shuffle=args.shuffle,
-            seed=args.seed,
-            max_samples=args.max_samples,
-            hf_token=hf_token,
-            output_url=args.output_target,
-        )
-    else:
-        src_iter, total, original_dataset = iter_dataset_images(
-            args.input_source,
-            image_column=args.image_column,
-            split=args.split,
-            shuffle=args.shuffle,
-            seed=args.seed,
-            max_samples=args.max_samples,
-        )
-
-    # ---------- sink ----------
-    if is_bucket_url(args.output_target):
-        sink: Union[BucketShardSink, DatasetRepoSink] = BucketShardSink(
-            args.output_target,
-            hf_token=hf_token,
-            shard_size=args.shard_size,
-            include_images=args.include_images,
-            resume=not args.no_resume,
-            source_id=args.input_source,
-        )
-    else:
-        sink = DatasetRepoSink(
-            args.output_target,
-            hf_token=hf_token,
-            private=args.private,
-            config=args.config,
-            create_pr=args.create_pr,
-            source_id=args.input_source,
-            original_dataset=original_dataset,
-        )
-
-    completed = sink.already_done()
-
-    # ---------- model ----------
-    if args.model_name not in VALID_MODELS:
-        raise ValueError(
-            f"Invalid model {args.model_name!r}. Choose from: {VALID_MODELS}"
-        )
-    logger.info(f"Loading PaddleOCR LayoutDetection model: {args.model_name} on {device}")
-    # PaddleX gates `import cv2` at module load time on
-    # `is_dep_available("opencv-contrib-python")`, which checks
-    # `importlib.metadata.version(...)`. We ship `opencv-contrib-python-headless`
-    # (same `cv2`, no system libGL.so.1 needed) — but that's a different
-    # distribution name, so the gate fails and `cv2` is never bound, causing
-    # NameErrors deep inside paddlex modules. Patch the metadata lookup to
-    # alias the GUI cv2 distros to the headless variant before importing
-    # paddleocr; this lets paddlex's own `import cv2` succeed naturally.
-    import importlib.metadata as _metadata
-
-    _orig_metadata_version = _metadata.version
-
-    def _patched_metadata_version(dep_name):
-        if dep_name in ("opencv-contrib-python", "opencv-python"):
-            for headless_alias in (
-                "opencv-contrib-python-headless",
-                "opencv-python-headless",
-            ):
-                try:
-                    return _orig_metadata_version(headless_alias)
-                except _metadata.PackageNotFoundError:
-                    continue
-        return _orig_metadata_version(dep_name)
-
-    _metadata.version = _patched_metadata_version
-
-    from paddleocr import LayoutDetection
-
-    model = LayoutDetection(model_name=args.model_name, device=device)
-
-    # ---------- loop ----------
-    processed = 0
-    skipped = 0
-    errors = 0
-    pbar = tqdm(src_iter, total=total, desc=f"Layout {args.model_name}")
-    for item in pbar:
-        if item.key in completed:
-            skipped += 1
-            continue
-        if item.extras.get("failed") or item.image is None:
-            # Unreadable source image — write an empty layout in position so the
-            # output stays row-aligned with the source dataset.
-            sink.write(item.key, [], {})
-            errors += 1
-            processed += 1
-            continue
-        try:
-            arr = pil_to_array(item.image)
-            results = model.predict(
-                arr,
-                batch_size=args.batch_size,
-                layout_nms=args.layout_nms,
-            )
-            if not results:
-                detections: List[Dict[str, Any]] = []
-            else:
-                detections = extract_detections(results[0])
-                if args.threshold and args.threshold > 0:
-                    detections = [d for d in detections if d["score"] >= args.threshold]
-        except Exception as e:
-            logger.error(f"Error on {item.key}: {e}")
-            detections = []
-            errors += 1
-
-        extras = dict(item.extras)
-        if isinstance(sink, BucketShardSink) and args.include_images:
-            buf = io.BytesIO()
-            item.image.save(buf, format="PNG")
-            extras["__image_bytes"] = buf.getvalue()
-
-        sink.write(item.key, detections, extras)
-        processed += 1
-
-    duration = datetime.now() - start_time
-    processing_time_str = f"{duration.total_seconds() / 60:.2f} min"
-    logger.info(
-        f"Processed {processed} (skipped {skipped}, errors {errors}) in {processing_time_str}"
-    )
-
-    args_dict = {
-        "model_name": args.model_name,
-        "threshold": args.threshold,
-        "layout_nms": args.layout_nms,
-        "shard_size": args.shard_size,
-        "processing_time": processing_time_str,
-    }
-    sink.finalize(model_id=f"PaddlePaddle/{args.model_name}", args_dict=args_dict)
-
-    if args.verbose:
-        import importlib.metadata
-
-        logger.info("--- Resolved package versions ---")
-        for pkg in [
-            "paddlepaddle",
-            "paddlepaddle-gpu",
-            "paddleocr",
-            "huggingface-hub",
-            "datasets",
-            "pyarrow",
-            "pillow",
-            "numpy",
-        ]:
-            try:
-                logger.info(f"  {pkg}=={importlib.metadata.version(pkg)}")
-            except importlib.metadata.PackageNotFoundError:
-                logger.info(f"  {pkg}: not installed")
-        logger.info("--- End versions ---")
-
-
-# ---------------------------------------------------------------------------
-# CLI
-# ---------------------------------------------------------------------------
-
-
-def _print_usage_banner() -> None:
-    print("=" * 80)
-    print("PP-DocLayout layout detection")
-    print("=" * 80)
-    print(
-        "\nDetect document layout regions (text/title/table/figure/formula/...)"
-    )
-    print("with PaddleOCR's PP-DocLayout-L (or M / S / plus-L variant).")
-    print("\nModels:")
-    for m in VALID_MODELS:
-        print(f"  {m:24s} {MODEL_SIZES.get(m, '')}")
-    print("\nSources:")
-    print("  - HF dataset repo:        namespace/dataset")
-    print("  - HF bucket of images:    hf://buckets/namespace/bucket[/prefix]")
-    print("\nSinks:")
-    print("  - HF dataset repo (one push + dataset card):")
-    print("      namespace/dataset")
-    print("  - HF bucket (incremental shards, resumable):")
-    print("      hf://buckets/namespace/bucket/run-name")
-    print("\nExamples:")
-    print("\n  # Smoke test on L4 (dataset -> dataset)")
-    print("  hf jobs uv run --flavor l4x1 -s HF_TOKEN https://huggingface.co/datasets/uv-scripts/ocr/raw/main/pp-doclayout.py \\")
-    print("      davanstrien/ufo-ColPali pp-doclayout-smoke \\")
-    print("      --max-samples 3 --shuffle --seed 42 --private")
-    print("\n  # Dataset -> bucket (incremental shards)")
-    print(
-        "  hf jobs uv run --flavor l4x1 -s HF_TOKEN https://huggingface.co/datasets/uv-scripts/ocr/raw/main/pp-doclayout.py \\"
-    )
-    print("      davanstrien/ufo-ColPali \\")
-    print(
-        "      hf://buckets/davanstrien/pp-doclayout-scratch/run1 \\"
-    )
-    print("      --max-samples 20 --shard-size 5")
-    print("\n  # Bucket of images -> dataset")
-    print(
-        "  hf jobs uv run --flavor l4x1 -s HF_TOKEN https://huggingface.co/datasets/uv-scripts/ocr/raw/main/pp-doclayout.py \\"
-    )
-    print(
-        "      hf://buckets/davanstrien/pp-doclayout-images \\"
-    )
-    print("      pp-doclayout-from-bucket --private")
-    print("\nFor full help, run: uv run pp-doclayout.py --help")
-    print("=" * 80)
-
-
-def build_parser() -> argparse.ArgumentParser:
-    p = argparse.ArgumentParser(
-        description="PP-DocLayout layout detection over an HF dataset or bucket.",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    p.add_argument(
-        "input_source",
-        help="HF dataset id (namespace/dataset) OR hf://buckets/ns/bucket[/prefix]",
-    )
-    p.add_argument(
-        "output_target",
-        help="HF dataset id (namespace/dataset) OR hf://buckets/ns/bucket/run-name",
-    )
-    p.add_argument(
-        "--model-name",
-        default="PP-DocLayout-L",
-        choices=VALID_MODELS,
-        help="PaddleOCR layout model variant (default: PP-DocLayout-L)",
-    )
-    p.add_argument(
-        "--device",
-        default="gpu",
-        choices=["gpu", "cpu"],
-        help="Device for inference (default: gpu, falls back to cpu if CUDA missing)",
-    )
-    p.add_argument(
-        "--batch-size",
-        type=int,
-        default=1,
-        help="Per-image batch size passed to model.predict (default: 1)",
-    )
-    p.add_argument(
-        "--threshold",
-        type=float,
-        default=0.5,
-        help="Drop detections below this confidence (default: 0.5; 0 disables)",
-    )
-    p.add_argument(
-        "--layout-nms",
-        dest="layout_nms",
-        action="store_true",
-        default=True,
-        help="Enable layout NMS (default: on)",
-    )
-    p.add_argument(
-        "--no-layout-nms",
-        dest="layout_nms",
-        action="store_false",
-        help="Disable layout NMS",
-    )
-    # Dataset-source-specific
-    p.add_argument(
-        "--image-column",
-        default="image",
-        help="Column containing images (dataset-repo source only, default: image)",
-    )
-    p.add_argument(
-        "--split",
-        default="train",
-        help="Dataset split (dataset-repo source only, default: train)",
-    )
-    p.add_argument(
-        "--max-samples", type=int, help="Limit number of samples (for testing)"
-    )
-    p.add_argument(
-        "--shuffle", action="store_true", help="Shuffle source before processing"
-    )
-    p.add_argument(
-        "--seed", type=int, default=42, help="Random seed for shuffle (default: 42)"
-    )
-    # Dataset-sink-specific
-    p.add_argument(
-        "--private", action="store_true", help="Private dataset output (dataset sink only)"
-    )
-    p.add_argument(
-        "--config",
-        help="Config/subset name when pushing to Hub (dataset sink only)",
-    )
-    p.add_argument(
-        "--create-pr",
-        action="store_true",
-        help="Create PR instead of direct push (dataset sink only)",
-    )
-    # Bucket-sink-specific
-    p.add_argument(
-        "--shard-size",
-        type=int,
-        default=256,
-        help="Rows per parquet shard for bucket sink (default: 256)",
-    )
-    p.add_argument(
-        "--include-images",
-        action="store_true",
-        help="Embed source image bytes in bucket output shards (off by default)",
-    )
-    p.add_argument(
-        "--no-resume",
-        action="store_true",
-        help="Disable resume scan when writing to a bucket sink",
-    )
-    # Auth + diagnostics
-    p.add_argument("--hf-token", help="Hugging Face API token (else uses HF_TOKEN env)")
-    p.add_argument(
-        "--verbose",
-        action="store_true",
-        help="Log resolved package versions at the end",
-    )
-    return p
-
-
-if __name__ == "__main__":
-    if len(sys.argv) == 1:
-        _print_usage_banner()
-        sys.exit(0)
-    main(build_parser().parse_args())

pp-ocrv6.py

@@ -1,1041 +0,0 @@
-# /// script
-# requires-python = ">=3.10"
-# dependencies = [
-#     "paddlepaddle-gpu>=3.0.0",
-#     "paddleocr>=3.7.0",
-#     "paddlex[ocr]>=3.7.0",
-#     "opencv-contrib-python-headless",
-#     "datasets>=3.1.0",
-#     "huggingface-hub",
-#     "pillow",
-#     "numpy",
-#     "tqdm",
-# ]
-#
-# [tool.uv]
-# # PaddleOCR/PaddleX pull in opencv-contrib-python (full) which needs system
-# # libGL.so.1 — not present in the slim uv-on-bookworm image used by HF Jobs.
-# # Swap to the headless cv2 variant (same `import cv2`, no GUI deps). A matching
-# # importlib.metadata patch in main() makes paddlex recognise the headless name.
-# override-dependencies = [
-#     "opencv-contrib-python ; python_version < '0'",
-#     "opencv-python ; python_version < '0'",
-# ]
-#
-# [[tool.uv.index]]
-# name = "paddle"
-# url = "https://www.paddlepaddle.org.cn/packages/stable/cu126/"
-# explicit = true
-#
-# [tool.uv.sources]
-# paddlepaddle-gpu = { index = "paddle" }
-# ///
-"""
-OCR images with PP-OCRv6 — a lightweight detection+recognition pipeline from
-PaddlePaddle. Three tiers from **1.5M to 34.5M parameters**.
-
-Unlike the VLM-based OCR recipes here, PP-OCRv6 is a **classical det+rec pipeline**
-that outputs **plain text** (not markdown). At 1.5M-34.5M params it's far smaller
-than the VLM OCRs and runs on a cheap t4-small GPU.
-
-Model tiers (pick with `--model-tier`):
-  tiny    1.5M params  (0.4M det + 1.1M rec)  49 languages, ~73% recognition
-  small   7.7M params  (2.5M det + 5.3M rec)  50 languages, ~81% recognition
-  medium  34.5M params (22M det + 19M rec)     50 languages, ~83% recognition
-
-All tiers are Apache 2.0 licensed. Runs via PaddleOCR's default Paddle engine
-(`paddle_static`) — same proven header pattern as `pp-doclayout.py`.
-
-HF Jobs examples:
-
-    # Tiny on a cheap GPU
-    hf jobs uv run --flavor t4-small -s HF_TOKEN \\
-        https://huggingface.co/datasets/uv-scripts/ocr/raw/main/pp-ocrv6.py \\
-        INPUT_DATASET OUTPUT_DATASET \\
-        --model-tier tiny --max-samples 5
-
-    # Medium on a small GPU (recommended for quality)
-    hf jobs uv run --flavor t4-small -s HF_TOKEN \\
-        https://huggingface.co/datasets/uv-scripts/ocr/raw/main/pp-ocrv6.py \\
-        INPUT_DATASET OUTPUT_DATASET \\
-        --model-tier medium --max-samples 10
-
-Models: PaddlePaddle/PP-OCRv6_<tier>_det + PP-OCRv6_<tier>_rec
-Blog: https://huggingface.co/blog/PaddlePaddle/pp-ocrv6
-"""
-
-import argparse
-import io
-import json
-import logging
-import os
-import time
-from dataclasses import dataclass
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
-
-import numpy as np
-from PIL import Image, UnidentifiedImageError
-from tqdm.auto import tqdm
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-
-# ---------------------------------------------------------------------------
-# Constants
-# ---------------------------------------------------------------------------
-
-TIER_MODELS = {
-    "tiny":   ("PP-OCRv6_tiny_det",   "PP-OCRv6_tiny_rec"),
-    "small":  ("PP-OCRv6_small_det",  "PP-OCRv6_small_rec"),
-    "medium": ("PP-OCRv6_medium_det", "PP-OCRv6_medium_rec"),
-}
-
-TIER_PARAMS = {
-    "tiny":   "1.5M (0.4M det + 1.1M rec)",
-    "small":  "7.7M (2.5M det + 5.3M rec)",
-    "medium": "34.5M (22M det + 19M rec)",
-}
-
-TIER_LANGUAGES = {
-    "tiny":   "49 languages (zh, zh-Hant, en + 46 Latin-script — no Japanese)",
-    "small":  "50 languages (zh, zh-Hant, en, ja + 46 Latin-script)",
-    "medium": "50 languages (zh, zh-Hant, en, ja + 46 Latin-script)",
-}
-
-TIER_REC = {
-    "tiny":   73.5,
-    "small":  81.3,
-    "medium": 83.2,
-}
-
-BUCKET_PREFIX = "hf://buckets/"
-
-IMAGE_EXTENSIONS = {
-    ".jpg", ".jpeg", ".png", ".tif", ".tiff", ".webp", ".bmp", ".jp2", ".j2k",
-}
-
-
-# ---------------------------------------------------------------------------
-# URL helpers
-# ---------------------------------------------------------------------------
-
-def is_bucket_url(s: str) -> bool:
-    return s.startswith(BUCKET_PREFIX)
-
-
-def parse_bucket_url(url: str) -> Tuple[str, str]:
-    if not is_bucket_url(url):
-        raise ValueError(f"Not a bucket URL: {url}")
-    rest = url[len(BUCKET_PREFIX):].strip("/")
-    parts = rest.split("/", 2)
-    if len(parts) < 2:
-        raise ValueError(f"Bucket URL must include namespace and bucket name: {url}")
-    bucket_id = f"{parts[0]}/{parts[1]}"
-    prefix = parts[2] if len(parts) > 2 else ""
-    return bucket_id, prefix
-
-
-# ---------------------------------------------------------------------------
-# Image helpers
-# ---------------------------------------------------------------------------
-
-def to_pil(image: Union[Image.Image, Dict[str, Any], str, bytes]) -> Image.Image:
-    if isinstance(image, Image.Image):
-        return image.convert("RGB")
-    if isinstance(image, dict) and "bytes" in image:
-        return Image.open(io.BytesIO(image["bytes"])).convert("RGB")
-    if isinstance(image, (bytes, bytearray)):
-        return Image.open(io.BytesIO(image)).convert("RGB")
-    if isinstance(image, str):
-        return Image.open(image).convert("RGB")
-    raise ValueError(f"Unsupported image type: {type(image)}")
-
-
-def pil_to_array(pil_img: Image.Image) -> np.ndarray:
-    return np.asarray(pil_img, dtype=np.uint8)
-
-
-# ---------------------------------------------------------------------------
-# Result extraction
-# ---------------------------------------------------------------------------
-
-def extract_text(result: Any) -> Tuple[str, List[Dict[str, Any]]]:
-    """Pull text and per-line details from a PaddleOCR predict result.
-
-    Returns (concatenated_text, per_line_details) where per_line_details is
-    a list of dicts with keys: text, score, bbox (4-point detection polygon as
-    [[x1,y1],[x2,y2],[x3,y3],[x4,y4]] in input-image pixel coordinates).
-    """
-    payload = result.json if hasattr(result, "json") else result
-    res = payload.get("res", payload) if isinstance(payload, dict) else {}
-    rec_texts = res.get("rec_texts", []) or []
-    rec_scores = res.get("rec_scores", []) or []
-    dt_polys = res.get("dt_polys", []) or []
-
-    # Concatenate reading-order text lines (PaddleOCR returns them in order)
-    text = "\n".join(rec_texts)
-
-    per_line = []
-    for i, t in enumerate(rec_texts):
-        entry = {"text": t}
-        if i < len(rec_scores):
-            entry["score"] = float(rec_scores[i])
-        if i < len(dt_polys):
-            entry["bbox"] = [[float(c) for c in point] for point in dt_polys[i]]
-        per_line.append(entry)
-
-    return text, per_line
-
-
-# ---------------------------------------------------------------------------
-# Sources
-# ---------------------------------------------------------------------------
-
-@dataclass
-class SourceItem:
-    key: str
-    image: Optional[Image.Image]
-    extras: Dict[str, Any]
-
-
-def iter_dataset_images(
-    dataset_id: str,
-    image_column: str,
-    split: str,
-    shuffle: bool,
-    seed: int,
-    max_samples: Optional[int],
-):
-    from datasets import load_dataset
-
-    logger.info(f"Loading dataset: {dataset_id} (split={split})")
-    ds = load_dataset(dataset_id, split=split)
-
-    if image_column not in ds.column_names:
-        raise ValueError(
-            f"Column '{image_column}' not found. Available: {ds.column_names}"
-        )
-
-    if shuffle:
-        logger.info(f"Shuffling with seed {seed}")
-        ds = ds.shuffle(seed=seed)
-    if max_samples:
-        ds = ds.select(range(min(max_samples, len(ds))))
-        logger.info(f"Limited to {len(ds)} samples")
-
-    total = len(ds)
-
-    def gen() -> Iterator[SourceItem]:
-        failed = 0
-        for i in range(total):
-            try:
-                row = ds[i]
-                image = to_pil(row[image_column])
-            except (UnidentifiedImageError, OSError) as e:
-                # Still yield a placeholder so the output row stays aligned with
-                # the source row (the dataset sink writes results positionally).
-                failed += 1
-                logger.warning(
-                    f"Unreadable image at row {i}: {type(e).__name__}: {e} "
-                    f"— writing empty result"
-                )
-                yield SourceItem(key=f"row-{i:08d}", image=None, extras={"failed": True})
-                continue
-            yield SourceItem(key=f"row-{i:08d}", image=image, extras={})
-        if failed:
-            logger.info(f"{failed} unreadable image(s) written as empty results")
-
-    return gen(), total, ds
-
-
-SOURCE_PATHS_SNAPSHOT = "_source_paths.json"
-
-
-def _bucket_snapshot_path(output_url: str) -> Tuple[str, str]:
-    out_bucket_id, out_prefix = parse_bucket_url(output_url)
-    snapshot_key = (
-        f"{out_prefix}/{SOURCE_PATHS_SNAPSHOT}".lstrip("/")
-        if out_prefix
-        else SOURCE_PATHS_SNAPSHOT
-    )
-    return out_bucket_id, snapshot_key
-
-
-def iter_bucket_images(
-    bucket_url: str,
-    shuffle: bool,
-    seed: int,
-    max_samples: Optional[int],
-    hf_token: Optional[str],
-    output_url: Optional[str] = None,
-) -> Tuple[Iterator[SourceItem], int]:
-    from huggingface_hub import HfApi, HfFileSystem
-
-    bucket_id, prefix = parse_bucket_url(bucket_url)
-    fs = HfFileSystem(token=hf_token)
-    base = f"{BUCKET_PREFIX}{bucket_id}/{prefix}".rstrip("/")
-
-    snapshot_bucket_id: Optional[str] = None
-    snapshot_key: Optional[str] = None
-    cached_paths: Optional[List[str]] = None
-
-    if output_url and is_bucket_url(output_url):
-        snapshot_bucket_id, snapshot_key = _bucket_snapshot_path(output_url)
-        snapshot_url = f"{BUCKET_PREFIX}{snapshot_bucket_id}/{snapshot_key}"
-        try:
-            with fs.open(snapshot_url, "rb") as f:
-                snapshot = json.load(f)
-            mismatches = []
-            if snapshot.get("source_url") != bucket_url:
-                mismatches.append(
-                    f"source_url ({snapshot.get('source_url')!r} vs {bucket_url!r})"
-                )
-            if snapshot.get("shuffle") != shuffle:
-                mismatches.append(f"shuffle ({snapshot.get('shuffle')} vs {shuffle})")
-            if shuffle and snapshot.get("seed") != seed:
-                mismatches.append(f"seed ({snapshot.get('seed')} vs {seed})")
-            if snapshot.get("max_samples") != max_samples:
-                mismatches.append(
-                    f"max_samples ({snapshot.get('max_samples')} vs {max_samples})"
-                )
-            if mismatches:
-                logger.warning(
-                    "Existing snapshot params differ from this run ("
-                    + "; ".join(mismatches)
-                    + "); ignoring snapshot and re-listing."
-                )
-            else:
-                cached_paths = snapshot["paths"]
-                logger.info(
-                    f"Reusing existing snapshot of {len(cached_paths)} source paths "
-                    f"(written {snapshot.get('created_at', 'unknown')})"
-                )
-        except FileNotFoundError:
-            pass
-        except Exception as e:
-            logger.warning(f"Could not read existing snapshot ({e}); re-listing.")
-
-    if cached_paths is not None:
-        all_paths = cached_paths
-    else:
-        logger.info(f"Listing images under {base}")
-        all_paths = []
-        try:
-            for entry in fs.find(base, detail=False):
-                ext = Path(entry).suffix.lower()
-                if ext in IMAGE_EXTENSIONS:
-                    all_paths.append(entry)
-        except FileNotFoundError as e:
-            raise ValueError(f"Bucket prefix not found: {base}") from e
-
-        if not all_paths:
-            raise ValueError(
-                f"No image files (any of {sorted(IMAGE_EXTENSIONS)}) under {base}"
-            )
-
-        all_paths.sort()
-        if shuffle:
-            rng = np.random.default_rng(seed)
-            rng.shuffle(all_paths)
-        if max_samples:
-            all_paths = all_paths[:max_samples]
-
-        if snapshot_bucket_id is not None and snapshot_key is not None:
-            api = HfApi(token=hf_token)
-            payload = {
-                "source_url": bucket_url,
-                "shuffle": shuffle,
-                "seed": seed,
-                "max_samples": max_samples,
-                "created_at": datetime.now(timezone.utc).isoformat(),
-                "paths": all_paths,
-            }
-            api.batch_bucket_files(
-                snapshot_bucket_id,
-                add=[(json.dumps(payload).encode(), snapshot_key)],
-                token=hf_token,
-            )
-            logger.info(
-                f"Wrote source-path snapshot ({len(all_paths)} paths) to "
-                f"hf://buckets/{snapshot_bucket_id}/{snapshot_key}"
-            )
-
-    total = len(all_paths)
-    logger.info(f"Found {total} images in bucket")
-
-    def key_for(path: str) -> str:
-        return path
-
-    def gen() -> Iterator[SourceItem]:
-        skipped = 0
-        for path in all_paths:
-            try:
-                with fs.open(path, "rb") as f:
-                    data = f.read()
-                image = to_pil(data)
-            except (UnidentifiedImageError, OSError) as e:
-                skipped += 1
-                logger.warning(
-                    f"Skipping unreadable image {path}: {type(e).__name__}: {e}"
-                )
-                continue
-            yield SourceItem(key=key_for(path), image=image, extras={})
-        if skipped:
-            logger.info(f"Skipped {skipped} unreadable image(s) total")
-
-    return gen(), total
-
-
-# ---------------------------------------------------------------------------
-# Sinks
-# ---------------------------------------------------------------------------
-
-class DatasetRepoSink:
-    def __init__(
-        self,
-        repo_id: str,
-        *,
-        hf_token: Optional[str],
-        private: bool,
-        config: Optional[str],
-        create_pr: bool,
-        source_id: str,
-        original_dataset=None,
-    ):
-        self.repo_id = repo_id
-        self.hf_token = hf_token
-        self.private = private
-        self.config = config
-        self.create_pr = create_pr
-        self.source_id = source_id
-        self.original_dataset = original_dataset
-        self._texts: List[str] = []
-        self._blocks: List[str] = []
-
-    @property
-    def kind(self) -> str:
-        return "dataset"
-
-    def already_done(self) -> set:
-        return set()
-
-    def write(self, key: str, text: str, blocks: List[Dict[str, Any]]) -> None:
-        self._texts.append(text)
-        self._blocks.append(json.dumps(blocks, ensure_ascii=False))
-
-    def finalize(self, tier: str, det_model: str, rec_model: str, args_dict: Dict[str, Any]) -> None:
-        from datasets import Dataset
-
-        if self.original_dataset is not None:
-            if len(self._texts) != len(self.original_dataset):
-                logger.warning(
-                    f"Text count ({len(self._texts)}) != dataset rows "
-                    f"({len(self.original_dataset)}); padding with empty strings."
-                )
-                while len(self._texts) < len(self.original_dataset):
-                    self._texts.append("")
-                    self._blocks.append("[]")
-            ds = self.original_dataset.add_column("text", self._texts)
-            ds = ds.add_column("pp_ocr_blocks", self._blocks)
-        else:
-            if not self._texts:
-                logger.warning("No rows produced; nothing to push.")
-                return
-            ds = Dataset.from_list([
-                {"source_path": None, "text": t, "pp_ocr_blocks": b}
-                for t, b in zip(self._texts, self._blocks)
-            ])
-
-        inference_entry = build_inference_entry(tier, det_model, rec_model, args_dict)
-
-        if "inference_info" in ds.column_names:
-            logger.info("Updating existing inference_info column")
-
-            def _update(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)}
-
-            ds = ds.map(_update)
-        else:
-            ds = ds.add_column(
-                "inference_info", [json.dumps([inference_entry])] * len(ds)
-            )
-
-        logger.info(f"Pushing {len(ds)} rows to {self.repo_id}")
-        push_kwargs = {
-            "private": self.private,
-            "token": self.hf_token,
-            "max_shard_size": "500MB",
-            "create_pr": self.create_pr,
-            "commit_message": f"Add PP-OCRv6-{tier} OCR results ({len(ds)} samples)"
-            + (f" [{self.config}]" if self.config else ""),
-        }
-        if self.config:
-            push_kwargs["config_name"] = self.config
-
-        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"
-                ds.push_to_hub(self.repo_id, **push_kwargs)
-                break
-            except Exception as e:
-                logger.error(f"Upload attempt {attempt}/{max_retries} failed: {e}")
-                if attempt == max_retries:
-                    logger.error("All upload attempts failed.")
-                    raise
-                time.sleep(30 * (2 ** (attempt - 1)))
-
-        from huggingface_hub import DatasetCard
-
-        card = DatasetCard(
-            create_dataset_card(
-                source=self.source_id,
-                tier=tier,
-                det_model=det_model,
-                rec_model=rec_model,
-                num_samples=len(ds),
-                processing_time=args_dict["processing_time"],
-                engine=args_dict.get("engine", "paddle_static"),
-                output_id=self.repo_id,
-            )
-        )
-        card.push_to_hub(self.repo_id, token=self.hf_token)
-        logger.info(f"Done: https://huggingface.co/datasets/{self.repo_id}")
-
-
-class BucketShardSink:
-    METADATA_FILE = "_metadata.json"
-    SHARD_PATTERN = "shard-{:05d}.parquet"
-
-    def __init__(
-        self,
-        bucket_url: str,
-        *,
-        hf_token: Optional[str],
-        shard_size: int,
-        resume: bool,
-        source_id: str,
-    ):
-        from huggingface_hub import HfApi, HfFileSystem, create_bucket
-
-        self.bucket_url = bucket_url
-        self.bucket_id, self.prefix = parse_bucket_url(bucket_url)
-        self.hf_token = hf_token
-        self.shard_size = shard_size
-        self.resume = resume
-        self.source_id = source_id
-
-        self._api = HfApi(token=hf_token)
-        self._fs = HfFileSystem(token=hf_token)
-
-        try:
-            create_bucket(self.bucket_id, exist_ok=True, token=hf_token)
-        except Exception as e:
-            logger.warning(f"create_bucket('{self.bucket_id}') warning: {e}")
-
-        self._buffer: List[Dict[str, Any]] = []
-        self._next_shard_idx = self._discover_next_shard_idx()
-        self._completed_keys = self._discover_completed_keys() if resume else set()
-        if self._completed_keys:
-            logger.info(
-                f"Resume: found {len(self._completed_keys)} already-processed keys, will skip them"
-            )
-
-    @property
-    def kind(self) -> str:
-        return "bucket"
-
-    def already_done(self) -> set:
-        return self._completed_keys
-
-    def _shard_path(self, idx: int) -> str:
-        return self._join(self.SHARD_PATTERN.format(idx))
-
-    def _join(self, name: str) -> str:
-        return f"{self.prefix}/{name}".lstrip("/") if self.prefix else name
-
-    def _list_existing_shards(self) -> List[str]:
-        try:
-            tree = self._api.list_bucket_tree(
-                self.bucket_id, prefix=self.prefix or None, recursive=True
-            )
-        except Exception:
-            return []
-        shards: List[str] = []
-        for item in tree:
-            path = getattr(item, "path", None)
-            ftype = getattr(item, "type", None)
-            if not path or ftype not in (None, "file"):
-                continue
-            base = Path(path).name
-            if base.startswith("shard-") and base.endswith(".parquet"):
-                shards.append(path)
-        return sorted(shards)
-
-    def _discover_next_shard_idx(self) -> int:
-        shards = self._list_existing_shards()
-        max_idx = -1
-        for s in shards:
-            stem = Path(s).stem
-            try:
-                max_idx = max(max_idx, int(stem.split("-")[-1]))
-            except ValueError:
-                continue
-        return max_idx + 1
-
-    def _discover_completed_keys(self) -> set:
-        import pyarrow.parquet as pq
-
-        keys: set = set()
-        for shard_path in self._list_existing_shards():
-            full = f"{BUCKET_PREFIX}{self.bucket_id}/{shard_path}"
-            try:
-                with self._fs.open(full, "rb") as f:
-                    table = pq.read_table(f, columns=["__source_key"])
-                keys.update(table.column("__source_key").to_pylist())
-            except Exception as e:
-                logger.warning(f"Could not read keys from {shard_path}: {e}")
-        return keys
-
-    def _flush(self) -> None:
-        if not self._buffer:
-            return
-        import pyarrow as pa
-        import pyarrow.parquet as pq
-
-        columns = ["__source_key", "text", "pp_ocr_blocks"]
-        table_dict = {c: [row.get(c) for row in self._buffer] for c in columns}
-        table = pa.Table.from_pydict(table_dict)
-
-        buf = io.BytesIO()
-        pq.write_table(table, buf, compression="zstd")
-        data = buf.getvalue()
-
-        shard_remote = self._shard_path(self._next_shard_idx)
-        logger.info(
-            f"Writing shard {self._next_shard_idx} ({len(self._buffer)} rows, "
-            f"{len(data) / 1024 / 1024:.1f} MiB) to {shard_remote}"
-        )
-        self._api.batch_bucket_files(
-            self.bucket_id, add=[(data, shard_remote)], token=self.hf_token
-        )
-        self._next_shard_idx += 1
-        self._buffer.clear()
-
-    def write(self, key: str, text: str, blocks: List[Dict[str, Any]]) -> None:
-        row: Dict[str, Any] = {
-            "__source_key": key,
-            "text": text,
-            "pp_ocr_blocks": json.dumps(blocks, ensure_ascii=False),
-        }
-        self._buffer.append(row)
-        if len(self._buffer) >= self.shard_size:
-            self._flush()
-
-    def finalize(self, tier: str, det_model: str, rec_model: str, args_dict: Dict[str, Any]) -> None:
-        self._flush()
-        meta = {
-            "model": f"PP-OCRv6_{tier}",
-            "det_model": det_model,
-            "rec_model": rec_model,
-            "tier": tier,
-            "engine": "paddle_static",
-            "source": self.source_id,
-            "shard_size": args_dict["shard_size"],
-            "last_run_at": datetime.now(timezone.utc).isoformat(),
-            "processing_time": args_dict.get("processing_time"),
-        }
-        meta_bytes = json.dumps(meta, indent=2).encode("utf-8")
-        meta_path = self._join(self.METADATA_FILE)
-        self._api.batch_bucket_files(
-            self.bucket_id, add=[(meta_bytes, meta_path)], token=self.hf_token
-        )
-        logger.info(
-            f"Done: https://huggingface.co/buckets/{self.bucket_id}"
-            + (f"/{self.prefix}" if self.prefix else "")
-        )
-
-
-# ---------------------------------------------------------------------------
-# inference_info + dataset card
-# ---------------------------------------------------------------------------
-
-def build_inference_entry(tier: str, det_model: str, rec_model: str, args_dict: Dict[str, Any]) -> Dict[str, Any]:
-    return {
-        "model_id": f"PaddlePaddle/PP-OCRv6_{tier}",
-        "det_model": det_model,
-        "rec_model": rec_model,
-        "tier": tier,
-        "params": TIER_PARAMS.get(tier, "unknown"),
-        "rec_accuracy_pct": TIER_REC.get(tier),
-        "languages": TIER_LANGUAGES.get(tier, ""),
-        "engine": "paddle_static",
-        "output_column": "text",
-        "blocks_column": "pp_ocr_blocks",
-        "timestamp": datetime.now(timezone.utc).isoformat(),
-    }
-
-
-def create_dataset_card(
-    source: str,
-    tier: str,
-    det_model: str,
-    rec_model: str,
-    num_samples: int,
-    processing_time: str,
-    engine: str,
-    output_id: str,
-) -> str:
-    tier_display = tier.upper() if tier == "tiny" else tier.capitalize()
-    if is_bucket_url(source):
-        source_link = f"[{source}]({source})"
-    else:
-        source_link = f"[{source}](https://huggingface.co/datasets/{source})"
-
-    return f"""---
-tags:
-- ocr
-- text-recognition
-- paddleocr
-- pp-ocrv6
-- uv-script
-- generated
----
-
-# OCR with PP-OCRv6 {tier_display}
-
-Plain-text OCR results for images from {source_link}, produced by
-PaddlePaddle's [PP-OCRv6](https://huggingface.co/collections/PaddlePaddle/pp-ocrv6)
-{tier} pipeline ({TIER_PARAMS.get(tier, "unknown")}).
-
-## Processing details
-
-- **Source**: {source_link}
-- **Model**: PP-OCRv6_{tier} ({det_model} + {rec_model})
-- **Tier**: {tier} ({TIER_PARAMS.get(tier, "unknown")})
-- **Recognition accuracy**: {TIER_REC.get(tier, "?"):.1f}%
-- **Languages**: {TIER_LANGUAGES.get(tier, "")}
-- **Engine**: {engine}
-- **Samples**: {num_samples:,}
-- **Processing time**: {processing_time}
-- **Processing date**: {datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")}
-- **License**: Apache 2.0 (models)
-
-## Schema
-
-Each row contains the original columns plus:
-
-- `text`: Plain text extracted from the image (reading-order concatenation of
-  detected text lines, newline-separated).
-- `pp_ocr_blocks`: JSON list, one dict per detected text line:
-  ```json
-  [
-    {{
-      "text": "recognized text",
-      "score": 0.987,
-      "bbox": [[x1, y1], [x2, y2], [x3, y3], [x4, y4]]
-    }}
-  ]
-  ```
-  `score` is the recognition confidence and `bbox` is the detection polygon
-  (4-point quadrilateral in input-image pixel coordinates).
-- `inference_info`: JSON list tracking every model applied to this dataset.
-
-> **Note:** PP-OCRv6 is a classical detection+recognition pipeline, not a VLM.
-> It outputs **plain text** rather than markdown. Per-line bounding boxes and
-> confidence scores are available in `pp_ocr_blocks`.
-
-## Usage
-
-```python
-import json
-from datasets import load_dataset
-
-ds = load_dataset("{output_id}", split="train")
-print(ds[0]["text"])
-for block in json.loads(ds[0]["pp_ocr_blocks"]):
-    print(block["text"], block["score"])
-```
-
-## Reproduction
-
-```bash
-hf jobs uv run --flavor t4-small -s HF_TOKEN \\
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/pp-ocrv6.py \\
-    {source} <output> --model-tier {tier}
-```
-
-Generated with [UV Scripts](https://huggingface.co/uv-scripts).
-"""
-
-
-# ---------------------------------------------------------------------------
-# Main
-# ---------------------------------------------------------------------------
-
-def main(args: argparse.Namespace) -> None:
-    from huggingface_hub import login
-
-    start_time = datetime.now()
-    hf_token = args.hf_token or os.environ.get("HF_TOKEN")
-    if hf_token:
-        login(token=hf_token)
-
-    # ---------- tier → model names ----------
-    if args.model_tier not in TIER_MODELS:
-        raise ValueError(
-            f"Invalid tier {args.model_tier!r}. Choose from: {list(TIER_MODELS)}"
-        )
-    det_model, rec_model = TIER_MODELS[args.model_tier]
-    tier = args.model_tier
-    logger.info(f"PP-OCRv6 {tier}: {det_model} + {rec_model}")
-
-    # ---------- source ----------
-    original_dataset = None
-    if is_bucket_url(args.input_source):
-        src_iter, total = iter_bucket_images(
-            args.input_source,
-            shuffle=args.shuffle,
-            seed=args.seed,
-            max_samples=args.max_samples,
-            hf_token=hf_token,
-            output_url=args.output_target,
-        )
-    else:
-        src_iter, total, original_dataset = iter_dataset_images(
-            args.input_source,
-            image_column=args.image_column,
-            split=args.split,
-            shuffle=args.shuffle,
-            seed=args.seed,
-            max_samples=args.max_samples,
-        )
-
-    # ---------- sink ----------
-    if is_bucket_url(args.output_target):
-        sink: Union[BucketShardSink, DatasetRepoSink] = BucketShardSink(
-            args.output_target,
-            hf_token=hf_token,
-            shard_size=args.shard_size,
-            resume=not args.no_resume,
-            source_id=args.input_source,
-        )
-    else:
-        sink = DatasetRepoSink(
-            args.output_target,
-            hf_token=hf_token,
-            private=args.private,
-            config=args.config,
-            create_pr=args.create_pr,
-            source_id=args.input_source,
-            original_dataset=original_dataset,
-        )
-
-    completed = sink.already_done()
-
-    # ---------- model ----------
-    # PaddleX gates `import cv2` at module load time on
-    # `is_dep_available("opencv-contrib-python")`, which checks
-    # `importlib.metadata.version(...)`. We ship `opencv-contrib-python-headless`
-    # (same `cv2`, no system libGL.so.1 needed) — but that's a different
-    # distribution name, so the gate fails and the OCR pipeline's `ocr` extra
-    # check returns False. Patch the metadata lookup to alias the GUI cv2 distros
-    # to the headless variant before importing paddleocr; this lets paddlex's own
-    # `import cv2` succeed and `is_extra_available('ocr')` return True.
-    import importlib.metadata as _metadata
-
-    _orig_metadata_version = _metadata.version
-
-    def _patched_metadata_version(dep_name):
-        if dep_name in ("opencv-contrib-python", "opencv-python"):
-            for headless_alias in (
-                "opencv-contrib-python-headless",
-                "opencv-python-headless",
-            ):
-                try:
-                    return _orig_metadata_version(headless_alias)
-                except _metadata.PackageNotFoundError:
-                    continue
-        return _orig_metadata_version(dep_name)
-
-    _metadata.version = _patched_metadata_version
-
-    # Silence the connectivity check for speed (not needed in a Job)
-    os.environ.setdefault("PADDLE_PDX_DISABLE_MODEL_SOURCE_CHECK", "True")
-
-    from paddleocr import PaddleOCR
-
-    ocr = PaddleOCR(
-        text_detection_model_name=det_model,
-        text_recognition_model_name=rec_model,
-        use_doc_orientation_classify=False,
-        use_doc_unwarping=False,
-        use_textline_orientation=False,
-    )
-
-    # ---------- loop ----------
-    processed = 0
-    skipped = 0
-    errors = 0
-    pbar = tqdm(src_iter, total=total, desc=f"PP-OCRv6 {tier}")
-    for item in pbar:
-        if item.key in completed:
-            skipped += 1
-            continue
-        if item.extras.get("failed") or item.image is None:
-            # Unreadable source image — write an empty result in position so the
-            # output stays row-aligned with the source dataset.
-            sink.write(item.key, "", [])
-            errors += 1
-            processed += 1
-            continue
-        try:
-            arr = pil_to_array(item.image)
-            result = ocr.predict(arr)
-            if result:
-                text, blocks = extract_text(result[0])
-            else:
-                text, blocks = "", []
-        except Exception as e:
-            logger.error(f"Error on {item.key}: {e}")
-            text, blocks = "", []
-            errors += 1
-
-        sink.write(item.key, text, blocks)
-        processed += 1
-
-    duration = datetime.now() - start_time
-    processing_time_str = f"{duration.total_seconds() / 60:.2f} min"
-    logger.info(
-        f"Processed {processed} (skipped {skipped}, errors {errors}) in {processing_time_str}"
-    )
-
-    args_dict = {
-        "tier": tier,
-        "det_model": det_model,
-        "rec_model": rec_model,
-        "engine": "paddle_static",
-        "shard_size": args.shard_size,
-        "processing_time": processing_time_str,
-    }
-    sink.finalize(
-        tier=tier,
-        det_model=det_model,
-        rec_model=rec_model,
-        args_dict=args_dict,
-    )
-
-    if args.verbose:
-        import importlib.metadata
-
-        logger.info("--- Resolved package versions ---")
-        for pkg in [
-            "paddleocr",
-            "paddlex",
-            "paddlepaddle-gpu",
-            "huggingface-hub",
-            "datasets",
-            "pillow",
-            "numpy",
-        ]:
-            try:
-                logger.info(f"  {pkg}=={importlib.metadata.version(pkg)}")
-            except importlib.metadata.PackageNotFoundError:
-                logger.info(f"  {pkg}: not installed")
-        logger.info("--- End versions ---")
-
-
-# ---------------------------------------------------------------------------
-# CLI
-# ---------------------------------------------------------------------------
-
-def build_parser() -> argparse.ArgumentParser:
-    p = argparse.ArgumentParser(
-        description="PP-OCRv6 OCR over an HF dataset or bucket of images.",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    p.add_argument(
-        "input_source",
-        help="HF dataset id (namespace/dataset) OR hf://buckets/ns/bucket[/prefix]",
-    )
-    p.add_argument(
-        "output_target",
-        help="HF dataset id (namespace/dataset) OR hf://buckets/ns/bucket/run-name",
-    )
-    p.add_argument(
-        "--model-tier",
-        default="medium",
-        choices=list(TIER_MODELS),
-        help="PP-OCRv6 model tier: tiny (1.5M), small (7.7M), medium (34.5M). Default: medium.",
-    )
-    # Dataset-source-specific
-    p.add_argument(
-        "--image-column",
-        default="image",
-        help="Column containing images (dataset-repo source only, default: image)",
-    )
-    p.add_argument(
-        "--split",
-        default="train",
-        help="Dataset split (dataset-repo source only, default: train)",
-    )
-    p.add_argument(
-        "--max-samples", type=int, help="Limit number of samples (for testing)"
-    )
-    p.add_argument(
-        "--shuffle", action="store_true", help="Shuffle source before processing"
-    )
-    p.add_argument(
-        "--seed", type=int, default=42, help="Random seed for shuffle (default: 42)"
-    )
-    # Dataset-sink-specific
-    p.add_argument(
-        "--private", action="store_true", help="Private dataset output (dataset sink only)"
-    )
-    p.add_argument(
-        "--config",
-        help="Config/subset name when pushing to Hub (dataset sink only)",
-    )
-    p.add_argument(
-        "--create-pr",
-        action="store_true",
-        help="Create PR instead of direct push (dataset sink only)",
-    )
-    # Bucket-sink-specific
-    p.add_argument(
-        "--shard-size",
-        type=int,
-        default=256,
-        help="Rows per parquet shard for bucket sink (default: 256)",
-    )
-    p.add_argument(
-        "--no-resume",
-        action="store_true",
-        help="Disable resume scan when writing to a bucket sink",
-    )
-    # Auth + diagnostics
-    p.add_argument("--hf-token", help="Hugging Face API token (else uses HF_TOKEN env)")
-    p.add_argument(
-        "--verbose",
-        action="store_true",
-        help="Log resolved package versions at the end",
-    )
-    return p
-
-
-if __name__ == "__main__":
-    main(build_parser().parse_args())

qianfan-ocr.py

@@ -1,632 +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 Qianfan-OCR with vLLM.
-
-Qianfan-OCR is a 4.7B end-to-end document intelligence model from Baidu,
-built on InternVL architecture with Qianfan-ViT encoder + Qwen3-4B LLM.
-
-Features:
-- #1 end-to-end model on OmniDocBench v1.5 (93.12) and OlmOCR Bench (79.8)
-- Layout-as-Thought: optional reasoning phase for complex layouts via --think
-- 192 language support (Latin, CJK, Arabic, Cyrillic, and more)
-- Multiple task modes: OCR, table (HTML), formula (LaTeX), chart, scene text
-- Key information extraction with custom prompts
-- 1.024 PPS on A100 with W8A8 quantization
-
-Model: baidu/Qianfan-OCR
-License: Apache 2.0
-Paper: https://arxiv.org/abs/2603.13398
-"""
-
-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__)
-
-MODEL = "baidu/Qianfan-OCR"
-
-PROMPT_TEMPLATES = {
-    "ocr": "Parse this document to Markdown.",
-    "table": "Extract tables to HTML format.",
-    "formula": "Extract formulas to LaTeX.",
-    "chart": "What trends are shown in this chart?",
-    "scene": "Extract all visible text from the image.",
-    "kie": None,  # requires --custom-prompt
-}
-
-
-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.")
-        sys.exit(1)
-    else:
-        logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
-
-
-def extract_content_from_thinking(text: str, include_thinking: bool = False) -> str:
-    """
-    Extract final content from Qianfan-OCR's Layout-as-Thought output.
-
-    When --think is enabled, the model generates layout analysis inside
-    <think>...</think> tags before the final markdown output.
-    """
-    if include_thinking:
-        return text.strip()
-
-    # If no thinking tags, return as-is
-    if "<think>" not in text:
-        return text.strip()
-
-    # Extract everything after </think>
-    think_end = text.find("</think>")
-    if think_end != -1:
-        return text[think_end + 8 :].strip()
-
-    # Thinking started but never closed — return full text
-    logger.warning("Found <think> but no </think>, returning full text")
-    return text.strip()
-
-
-def make_ocr_message(
-    image: Union[Image.Image, Dict[str, Any], str],
-    prompt: str,
-) -> List[Dict]:
-    """Create vLLM chat message with image and prompt."""
-    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")
-    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,
-    prompt_mode: str,
-    think: bool,
-    include_thinking: bool,
-    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
-- qianfan-ocr
-- markdown
-- uv-script
-- generated
----
-
-# Document OCR using {model_name}
-
-This dataset contains OCR results from [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using Qianfan-OCR, Baidu's 4.7B end-to-end document intelligence model.
-
-## 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**: `markdown`
-- **Dataset Split**: `{split}`
-- **Batch Size**: {batch_size}
-- **Prompt Mode**: {prompt_mode}
-- **Layout-as-Thought**: {"Enabled" if think else "Disabled"}
-- **Thinking Traces**: {"Included" if include_thinking else "Excluded"}
-- **Max Model Length**: {max_model_len:,} tokens
-- **Max Output Tokens**: {max_tokens:,}
-- **GPU Memory Utilization**: {gpu_memory_utilization:.1%}
-
-## Model Information
-
-Qianfan-OCR key capabilities:
-- #1 end-to-end model on OmniDocBench v1.5 (93.12)
-- #1 on OlmOCR Bench (79.8)
-- 192 language support
-- Layout-as-Thought reasoning for complex documents
-- Document parsing, table extraction, formula recognition, chart understanding
-- Key information extraction
-
-## 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
-
-## Reproduction
-
-```bash
-uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/qianfan-ocr.py \\
-    {source_dataset} \\
-    <output-dataset> \\
-    --image-column {image_column} \\
-    --prompt-mode {prompt_mode} \\
-    --batch-size {batch_size}{"  --think" if think 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 = 8,
-    max_model_len: int = 16384,
-    max_tokens: int = 8192,
-    temperature: float = 0.0,
-    top_p: float = 1.0,
-    gpu_memory_utilization: float = 0.85,
-    hf_token: str = None,
-    split: str = "train",
-    max_samples: int = None,
-    private: bool = False,
-    shuffle: bool = False,
-    seed: int = 42,
-    prompt_mode: str = "ocr",
-    think: bool = False,
-    include_thinking: bool = False,
-    custom_prompt: str = None,
-    output_column: str = "markdown",
-    config: str = None,
-    create_pr: bool = False,
-    verbose: bool = False,
-):
-    """Process images from HF dataset through Qianfan-OCR model."""
-
-    check_cuda_availability()
-    start_time = datetime.now()
-
-    HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
-    if HF_TOKEN:
-        login(token=HF_TOKEN)
-
-    # Build prompt
-    if custom_prompt:
-        prompt = custom_prompt
-        logger.info(f"Using custom prompt: {prompt[:80]}...")
-    else:
-        if prompt_mode == "kie":
-            logger.error("--prompt-mode kie requires --custom-prompt")
-            sys.exit(1)
-        prompt = PROMPT_TEMPLATES[prompt_mode]
-        logger.info(f"Using prompt mode: {prompt_mode}")
-
-    if think:
-        prompt = prompt + "<think>"
-        logger.info("Layout-as-Thought enabled (appending <think> to prompt)")
-
-    logger.info(f"Using model: {MODEL}")
-
-    # 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}"
-        )
-
-    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("Initializing vLLM with Qianfan-OCR")
-    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},
-        enforce_eager=False,
-    )
-
-    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}")
-
-    # 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="Qianfan-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, prompt) for img in batch_images]
-            outputs = llm.chat(batch_messages, sampling_params)
-
-            for output in outputs:
-                text = output.outputs[0].text.strip()
-                if think:
-                    text = extract_content_from_thinking(text, include_thinking)
-                all_outputs.append(text)
-
-        except Exception as e:
-            logger.error(f"Error processing batch: {e}")
-            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
-    logger.info(f"Adding '{output_column}' column to dataset")
-    dataset = dataset.add_column(output_column, all_outputs)
-
-    # Handle inference_info tracking
-    inference_entry = {
-        "model_id": MODEL,
-        "model_name": "Qianfan-OCR",
-        "column_name": output_column,
-        "timestamp": datetime.now().isoformat(),
-        "prompt_mode": prompt_mode if not custom_prompt else "custom",
-        "think": think,
-        "temperature": temperature,
-        "max_tokens": max_tokens,
-    }
-
-    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}")
-    commit_msg = f"Add Qianfan-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,
-            gpu_memory_utilization=gpu_memory_utilization,
-            prompt_mode=prompt_mode if not custom_prompt else "custom",
-            think=think,
-            include_thinking=include_thinking,
-            image_column=image_column,
-            split=split,
-        )
-        card = DatasetCard(card_content)
-        card.push_to_hub(output_dataset, token=HF_TOKEN)
-
-    logger.info("Qianfan-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"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"]:
-            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("=" * 80)
-        print("Qianfan-OCR - End-to-End Document Intelligence")
-        print("=" * 80)
-        print("\n4.7B model from Baidu, #1 on OmniDocBench v1.5 (93.12)")
-        print("\nFeatures:")
-        print("- #1 end-to-end model on OmniDocBench v1.5 and OlmOCR Bench")
-        print("- Layout-as-Thought reasoning for complex documents (--think)")
-        print("- 192 language support")
-        print("- Multiple modes: OCR, table (HTML), formula (LaTeX), chart, scene text")
-        print("- Key information extraction with custom prompts")
-        print("\nExample usage:")
-        print("\n1. Basic OCR:")
-        print("   uv run qianfan-ocr.py input-dataset output-dataset")
-        print("\n2. With Layout-as-Thought (complex documents):")
-        print("   uv run qianfan-ocr.py docs output --think")
-        print("\n3. Table extraction:")
-        print("   uv run qianfan-ocr.py docs output --prompt-mode table")
-        print("\n4. Formula extraction:")
-        print("   uv run qianfan-ocr.py docs output --prompt-mode formula")
-        print("\n5. Key information extraction:")
-        print(
-            '   uv run qianfan-ocr.py invoices output --prompt-mode kie --custom-prompt "Extract: name, date, total. Output JSON."'
-        )
-        print("\n6. Running on HF Jobs:")
-        print("   hf jobs uv run --flavor l4x1 \\")
-        print("     -s HF_TOKEN \\")
-        print(
-            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/qianfan-ocr.py \\"
-        )
-        print("       input-dataset output-dataset --max-samples 10")
-        print("\nFor full help, run: uv run qianfan-ocr.py --help")
-        sys.exit(0)
-
-    parser = argparse.ArgumentParser(
-        description="Document OCR using Qianfan-OCR (4.7B, #1 on OmniDocBench v1.5)",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Prompt modes:
-  ocr       Document parsing to Markdown (default)
-  table     Table extraction to HTML format
-  formula   Formula recognition to LaTeX
-  chart     Chart understanding and analysis
-  scene     Scene text extraction
-  kie       Key information extraction (requires --custom-prompt)
-
-Examples:
-  uv run qianfan-ocr.py my-docs analyzed-docs
-  uv run qianfan-ocr.py docs output --think --max-samples 50
-  uv run qianfan-ocr.py docs output --prompt-mode table
-  uv run qianfan-ocr.py invoices data --prompt-mode kie --custom-prompt "Extract: name, date, total."
-        """,
-    )
-
-    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=8,
-        help="Batch size for processing (default: 8)",
-    )
-    parser.add_argument(
-        "--max-model-len",
-        type=int,
-        default=16384,
-        help="Maximum model context length (default: 16384, reduce to 8192 if OOM on L4)",
-    )
-    parser.add_argument(
-        "--max-tokens",
-        type=int,
-        default=8192,
-        help="Maximum tokens to generate (default: 8192)",
-    )
-    parser.add_argument(
-        "--temperature",
-        type=float,
-        default=0.0,
-        help="Sampling temperature (default: 0.0, deterministic)",
-    )
-    parser.add_argument(
-        "--top-p",
-        type=float,
-        default=1.0,
-        help="Top-p sampling parameter (default: 1.0)",
-    )
-    parser.add_argument(
-        "--gpu-memory-utilization",
-        type=float,
-        default=0.85,
-        help="GPU memory utilization (default: 0.85)",
-    )
-    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(
-        "--prompt-mode",
-        choices=list(PROMPT_TEMPLATES.keys()),
-        default="ocr",
-        help="Prompt mode (default: ocr)",
-    )
-    parser.add_argument(
-        "--think",
-        action="store_true",
-        help="Enable Layout-as-Thought reasoning (appends <think> to prompt)",
-    )
-    parser.add_argument(
-        "--include-thinking",
-        action="store_true",
-        help="Include thinking traces in output (default: only final content)",
-    )
-    parser.add_argument(
-        "--custom-prompt",
-        help="Custom prompt text (overrides --prompt-mode)",
-    )
-    parser.add_argument(
-        "--output-column",
-        default="markdown",
-        help="Column name for output text (default: markdown)",
-    )
-    parser.add_argument(
-        "--config",
-        help="Config/subset name when pushing to 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(
-        "--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,
-        temperature=args.temperature,
-        top_p=args.top_p,
-        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,
-        prompt_mode=args.prompt_mode,
-        think=args.think,
-        include_thinking=args.include_thinking,
-        custom_prompt=args.custom_prompt,
-        output_column=args.output_column,
-        config=args.config,
-        create_pr=args.create_pr,
-        verbose=args.verbose,
-    )

rolm-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
 

serving-unlimited-ocr.md

@@ -1,97 +0,0 @@
-# Serve Unlimited-OCR as a live endpoint on HF Jobs
-
-The OCR recipes in this folder run as batch jobs (dataset in → dataset out). To call a model
-interactively, from an agent, or with ad-hoc concurrent requests, you can instead run it as a
-temporary HTTP endpoint. [HF Jobs serving](https://huggingface.co/docs/hub/jobs-serving) exposes a
-port on a GPU Job, giving an OpenAI-compatible endpoint that runs until the job is cancelled or its
-`--timeout` is reached.
-
-This is a worked example for [baidu/Unlimited-OCR](https://huggingface.co/baidu/Unlimited-OCR)
-(3B, MIT, based on DeepSeek-OCR; supports multi-page parsing in a single request). The model ships
-its own SGLang build, so it runs on the stock `lmsysorg/sglang` image with the 12 MB wheel
-installed at startup; no custom image is required.
-
-## 1. Start the server
-
-```bash
-hf jobs run --detach --expose 10000 --flavor h200 -s HF_TOKEN --timeout 30m \
-  lmsysorg/sglang:latest -- \
-  bash -lc 'pip install --no-deps https://github.com/baidu/Unlimited-OCR/raw/main/wheel/sglang-0.0.0.dev11416+g92e8bb79e-py3-none-any.whl \
-    && pip install -q kernels==0.11.7 \
-    && python -m sglang.launch_server --model baidu/Unlimited-OCR --served-model-name Unlimited-OCR \
-       --attention-backend fa3 --page-size 1 --mem-fraction-static 0.8 --context-length 32768 \
-       --enable-custom-logit-processor --disable-overlap-schedule --skip-server-warmup \
-       --host 0.0.0.0 --port 10000'
-```
-
-Notes:
-- `--` before `bash` is required, or the CLI parses `-lc` as its own flags.
-- `--timeout` stops the endpoint (and billing) at the deadline; `hf jobs cancel <id>` stops it earlier.
-- `fa3` requires a Hopper GPU (e.g. `h200`). The model is small, so the attention backend, not GPU
-  memory, determines the flavor. Run `hf jobs hardware` for available flavors.
-- Follow startup with `hf jobs logs -f <id>`; the server is ready at `Application startup complete`
-  (about 3 minutes from a cold start).
-
-## 2. Call it (OpenAI client; HF token as the API key)
-
-The exposed port is at `https://<job_id>--10000.hf.jobs`; the OpenAI base URL is that plus `/v1`.
-
-```python
-import base64, os
-from openai import OpenAI
-
-client = OpenAI(base_url="https://<job_id>--10000.hf.jobs/v1", api_key=os.environ["HF_TOKEN"])
-img = base64.b64encode(open("page.jpg", "rb").read()).decode()
-
-r = client.chat.completions.create(
-    model="Unlimited-OCR",
-    messages=[{"role": "user", "content": [
-        {"type": "text", "text": "document parsing."},
-        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{img}"}},
-    ]}],
-    temperature=0,
-    extra_body={"images_config": {"image_mode": "gundam"}},  # "gundam" (crop-tiling) or "base"
-)
-print(r.choices[0].message.content)
-```
-
-Output is layout-grounded markdown: each block is tagged `<|det|>type [x1,y1,x2,y2]<|/det|> text`,
-with coordinates normalized to 0–1000. Remove the tags for plain text
-(`re.sub(r'<\|det\|>.*?<\|/det\|>', '', text)`) or keep them for structure.
-
-## 3. Multi-page / PDF
-
-Send multiple page images in one request with the `Multi page parsing.` prompt and `image_mode="base"`:
-
-```python
-parts = [{"type": "text", "text": "Multi page parsing."}]
-for page_png in page_images:            # e.g. PDF pages rendered with pymupdf at ~150 dpi
-    b64 = base64.b64encode(open(page_png, "rb").read()).decode()
-    parts.append({"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}})
-
-r = client.chat.completions.create(
-    model="Unlimited-OCR",
-    messages=[{"role": "user", "content": parts}],
-    temperature=0, max_tokens=16384,
-    extra_body={"images_config": {"image_mode": "base"}},
-)
-```
-
-Pages are separated by `<PAGE>`; tables are returned as HTML and equations as LaTeX, with reading
-order preserved across pages. The context length is 32k tokens, so split longer documents.
-
-## 4. Concurrency
-
-SGLang batches concurrent requests, so a client can send many requests in parallel to one endpoint;
-the upstream [`infer.py`](https://github.com/baidu/Unlimited-OCR/blob/main/infer.py) uses a
-`ThreadPoolExecutor` at `concurrency=8`. For a large corpus, a batch job that runs next to the data
-(resumable, no network transfer) is usually a better fit than a client-to-endpoint loop.
-
-## 5. Stop it
-
-```bash
-hf jobs cancel <job_id>
-```
-
-Billing is per-minute for the GPU flavor plus a small flat fee for the exposed port; scheduling time
-is not billed. Run `hf jobs hardware` for current flavors and prices.

smoldocling-ocr.py

@@ -42,13 +42,9 @@ from typing import Any, Dict, 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)
@@ -303,21 +299,7 @@ def main(
         desc="OCR 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_output.extend(
-                ["[OCR SKIPPED — UNREADABLE IMAGE]"] * len(batch_indices)
-            )
-            continue
+        batch_images = [dataset[i][image_column] for i in batch_indices]
 
         try:
             # Prepare inputs for batch

surya-ocr-bucket.py

@@ -1,1389 +0,0 @@
-# /// script
-# requires-python = ">=3.10"
-# dependencies = [
-#     "surya-ocr==0.20.0",
-#     "datasets>=3.1.0",
-#     "huggingface-hub",
-#     "pillow",
-#     "imagecodecs",
-#     "toolz",
-#     "tqdm",
-# ]
-#
-# # Pin surya-ocr to the known-good build (has the `surya.inference` engine layout
-# # this recipe injects into); an unpinned/loosened resolve backtracks to an ancient
-# # surya without it. huggingface-hub is left unpinned: at runtime PYTHONPATH puts the
-# # pinned image's hub (with the buckets API) ahead of the venv, so no version tension.
-# ///
-"""
-Structured OCR over a **bucket of document files** (images + PDFs) with Datalab's
-**Surya OCR 2** (`datalab-to/surya-ocr-2`, 650M, Qwen3.5-style) — no dataset
-round-trip. This is the bucket-native sibling of `surya-ocr.py` (which reads a Hub
-dataset column). Point it straight at an HF bucket of `.jp2`/`.png`/`.pdf`/... files.
-
-Like the parent it produces *structured* OCR: per-block HTML + bounding boxes +
-reading order + confidence. `--task` switches between `ocr` (full-page text),
-`layout` (labelled regions), and `table` (HTML / rows-cols-cells).
-
-INPUT — two interchangeable I/O strategies (`--io-mode`, default `auto`):
-  mount  bucket mounted read-only at /in via `-v hf://buckets/<id>:/in:ro`; files
-         are read straight off the FUSE mount. Zero ephemeral disk.
-  copy   take a bucket id directly; the huggingface_hub library LISTs then batch-
-         DOWNLOADS each `--batch-size` chunk to local temp, OCRs it, writes output,
-         then deletes the temp batch. Avoids the known FUSE bulk-read stall; peak
-         disk = one batch. `auto` picks copy for an `hf://buckets/...` input, mount
-         for a local dir.
-
-OUTPUT — one or both (>=1 required):
-  --output-bucket  per page a `.md` (flattened reading-order text) AND a `.json`
-                   (that page's structured `surya_blocks`), mirroring the input dir
-                   structure, into a mounted dir OR an `hf://buckets/...` URL.
-                   Streaming / O(1) memory, with resume-by-skip (a file whose
-                   `.json` already exists is skipped) — the scalable path.
-  --output-dataset a parquet dataset pushed to the Hub (one row per file:
-                   file_name / markdown / surya_blocks / inference_info), like the
-                   parent recipe. Convenient; buffered in memory (no image bytes by
-                   default — use `--include-images` to embed page images).
-
-ENGINE: Surya normally spawns a vLLM **server** (Docker), which can't run inside an
-HF Job. This injects a custom in-process backend into Surya's `SuryaInferenceManager`
-that runs vLLM's offline `LLM().chat()` engine (no server). Surya still owns all the
-prompting, image preprocessing, and HTML/bbox parsing — we only swap the transport.
-
-LICENSE NOTE: Surya'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, restricted from competitive use against Datalab's API. Confirm you
-are within those terms. https://huggingface.co/datalab-to/surya-ocr-2
-
-HF Jobs — MUST use the pinned vLLM image + the site-packages python path (the model
-is the recent, version-sensitive `qwen3_5` architecture; v0.20.1 is Surya's
-known-good build, and it puts python/vLLM under /usr/local, NOT /usr/bin):
-
-    # copy input -> dataset output
-    hf jobs uv run --flavor l4x1 -s HF_TOKEN \\
-        --image vllm/vllm-openai:v0.20.1 --python /usr/local/bin/python3 \\
-        -e PYTHONPATH=/usr/local/lib/python3.12/site-packages \\
-        https://huggingface.co/datasets/uv-scripts/ocr/raw/main/surya-ocr-bucket.py \\
-        hf://buckets/<ns>/<bucket> --io-mode copy --glob "*.jp2" \\
-        --output-dataset <ns>/<out> --private
-
-    # mount input -> per-file bucket output (mirrors dir structure)
-    hf jobs uv run --flavor l4x1 -s HF_TOKEN \\
-        --image vllm/vllm-openai:v0.20.1 --python /usr/local/bin/python3 \\
-        -e PYTHONPATH=/usr/local/lib/python3.12/site-packages \\
-        -v hf://buckets/<ns>/<bucket>:/in:ro \\
-        -v hf://buckets/<ns>/<out-bucket>:/out \\
-        https://huggingface.co/datasets/uv-scripts/ocr/raw/main/surya-ocr-bucket.py \\
-        /in --io-mode mount --glob "*.jp2" --output-bucket /out
-
-Model: datalab-to/surya-ocr-2  (package: surya-ocr, https://github.com/datalab-to/surya)
-"""
-
-import argparse
-import json
-import logging
-import math
-import os
-import shutil
-import sys
-import tempfile
-import time
-from contextlib import contextmanager
-from dataclasses import dataclass
-from datetime import datetime, timezone
-from fnmatch import fnmatch
-from pathlib import Path, PurePosixPath
-from typing import Any, Dict, Iterator, List, Optional, Tuple
-
-from PIL import Image, UnidentifiedImageError
-from toolz import partition_all
-from tqdm import tqdm
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-DEFAULT_MODEL = "datalab-to/surya-ocr-2"
-# Surya's own vision-tiling bounds (from its vLLM backend), applied to the
-# offline engine too so preprocessing matches the server path exactly.
-MM_PROCESSOR_KWARGS = {"min_pixels": 3136, "max_pixels": 6291456}
-TASKS = ("ocr", "layout", "table")
-# Extensions read by default. `.jp2`/`.j2k` are first-class: the canonical test
-# corpus (Library of Congress / Chronicling America) is all JPEG-2000.
-DEFAULT_EXTENSIONS = ".jp2,.j2k,.png,.jpg,.jpeg,.tiff,.tif,.bmp,.webp,.pdf"
-JP2_EXTENSIONS = {".jp2", ".j2k"}
-PDF_EXTENSION = ".pdf"
-BUCKET_PREFIX = "hf://buckets/"
-
-
-# ---------------------------------------------------------------------------
-# GPU / page-range helpers (verbatim from surya-ocr.py)
-# ---------------------------------------------------------------------------
-
-
-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 --flavor l4x1 "
-            "--image vllm/vllm-openai:v0.20.1 ..."
-        )
-        sys.exit(1)
-    logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
-
-
-def parse_page_range(spec: Optional[str]) -> Optional[List[int]]:
-    """Turn '0-3,5' into [0,1,2,3,5]. None/empty -> None (all pages)."""
-    if not spec:
-        return None
-    pages: List[int] = []
-    for part in spec.split(","):
-        part = part.strip()
-        if not part:
-            continue
-        if "-" in part:
-            lo, hi = part.split("-", 1)
-            pages.extend(range(int(lo), int(hi) + 1))
-        else:
-            pages.append(int(part))
-    return pages or None
-
-
-# --- structured-output shim (vLLM API moved between versions) ---
-def build_structured_outputs(schema: Dict[str, Any]) -> Dict[str, Any]:
-    """SamplingParams kwargs for guided JSON, across vLLM versions (layout uses this)."""
-    try:
-        from vllm.sampling_params import StructuredOutputsParams  # vLLM >= 0.12
-
-        return {"structured_outputs": StructuredOutputsParams(json=schema)}
-    except (ImportError, TypeError):
-        pass
-    try:
-        from vllm.sampling_params import GuidedDecodingParams  # older vLLM
-
-        return {"guided_decoding": GuidedDecodingParams(json=schema)}
-    except (ImportError, TypeError):
-        pass
-    logger.warning(
-        "Guided JSON unavailable in this vLLM version; relying on the model."
-    )
-    return {}
-
-
-def _mean_token_prob(completion_output) -> Optional[float]:
-    """Mean exp(logprob) of the sampled tokens -> Surya's per-block `confidence`."""
-    lps = getattr(completion_output, "logprobs", None)
-    if not lps:
-        return None
-    probs: List[float] = []
-    for tid, lp_dict in zip(completion_output.token_ids, lps):
-        if not lp_dict:
-            continue
-        entry = lp_dict.get(tid)
-        if (
-            entry is None
-        ):  # sampled token not in the returned top-k; use the best we have
-            entry = max(lp_dict.values(), key=lambda e: e.logprob)
-        probs.append(math.exp(entry.logprob))
-    return sum(probs) / len(probs) if probs else None
-
-
-# ---------------------------------------------------------------------------
-# Offline vLLM backend + Surya manager (verbatim from surya-ocr.py)
-# ---------------------------------------------------------------------------
-
-
-class OfflineVLLMBackend:
-    """Surya `Backend` (duck-typed) that runs vLLM's offline `LLM().chat()` engine.
-
-    Surya's predictors call `manager.generate(batch)` -> `backend.generate(batch)`;
-    we satisfy that contract in-process (no server). Surya keeps ownership of the
-    prompts (`PROMPT_MAPPING`), image scaling (`scale_to_fit`), and output parsing.
-    """
-
-    name = "offline-vllm"
-
-    def __init__(
-        self,
-        model: str,
-        max_model_len: int,
-        gpu_memory_utilization: float,
-        dtype: str = "bfloat16",
-        max_tokens_default: int = 2048,
-        logprobs_default: bool = True,
-    ):
-        self.model = model
-        self.max_model_len = max_model_len
-        self.gpu_memory_utilization = gpu_memory_utilization
-        self.dtype = dtype
-        self.max_tokens_default = max_tokens_default
-        self.logprobs_default = logprobs_default
-        self.llm = None
-        self._build_messages = None
-        self._scale_to_fit = None
-        self._prompt_mapping = None
-
-    def start(self):
-        from vllm import LLM
-
-        logger.info(
-            f"Loading {self.model} into vLLM offline engine (dtype={self.dtype})..."
-        )
-        self.llm = LLM(
-            model=self.model,
-            dtype=self.dtype,
-            max_model_len=self.max_model_len,
-            gpu_memory_utilization=self.gpu_memory_utilization,
-            mm_processor_kwargs=MM_PROCESSOR_KWARGS,
-            limit_mm_per_prompt={"image": 1},
-        )
-        # Reuse Surya's exact request shaping so the offline path matches the server.
-        from surya.inference.backends.openai_client import _build_messages
-        from surya.inference.prompts import PROMPT_MAPPING
-        from surya.inference.util import scale_to_fit
-
-        self._build_messages = _build_messages
-        self._scale_to_fit = scale_to_fit
-        self._prompt_mapping = PROMPT_MAPPING
-        return None
-
-    def stop(self) -> None:
-        self.llm = None
-
-    def _sampling_params(self, item):
-        from vllm import SamplingParams
-
-        max_tokens = item.max_tokens or self.max_tokens_default
-        want_logprobs = item.request_logprobs or self.logprobs_default
-        kwargs: Dict[str, Any] = dict(temperature=0.0, top_p=0.1, max_tokens=max_tokens)
-        if want_logprobs:
-            kwargs["logprobs"] = 1
-        if item.guided_json is not None:
-            kwargs.update(build_structured_outputs(item.guided_json))
-        return SamplingParams(**kwargs)
-
-    def generate(self, batch):
-        from surya.inference.schema import BatchOutputItem
-
-        if self.llm is None:
-            self.start()
-        if not batch:
-            return []
-
-        conversations = []
-        sampling_params = []
-        for item in batch:
-            prompt = item.prompt or self._prompt_mapping[item.prompt_type]
-            image = self._scale_to_fit(item.image)
-            conversations.append(self._build_messages(image, prompt))
-            sampling_params.append(self._sampling_params(item))
-
-        outputs = self.llm.chat(
-            conversations,
-            sampling_params,
-            chat_template_content_format="openai",
-            use_tqdm=False,
-        )
-
-        results = []
-        for item, out in zip(batch, outputs):
-            comp = out.outputs[0]
-            results.append(
-                BatchOutputItem(
-                    raw=comp.text,
-                    token_count=len(comp.token_ids),
-                    error=False,
-                    mean_token_prob=_mean_token_prob(comp),
-                    logprobs=None,
-                    metadata=item.metadata,  # carries page_idx/block_idx — must round-trip
-                )
-            )
-        return results
-
-
-def make_manager(backend: OfflineVLLMBackend):
-    """A SuryaInferenceManager wired to our offline backend (bypassing autodetect)."""
-    from surya.inference import SuryaInferenceManager
-
-    manager = SuryaInferenceManager.__new__(SuryaInferenceManager)
-    manager.method = backend.name
-    manager.backend = backend
-    return manager
-
-
-# ---------------------------------------------------------------------------
-# Result serialization (verbatim from surya-ocr.py)
-# ---------------------------------------------------------------------------
-
-
-def _html_to_text(html: str) -> str:
-    from bs4 import BeautifulSoup
-
-    return BeautifulSoup(html, "html.parser").get_text(" ", strip=True)
-
-
-def serialize_pages(task: str, pages: List[Any]) -> Tuple[str, List[Dict[str, Any]]]:
-    """(text, structured-per-page) for one document's page results."""
-    structured = [p.model_dump(mode="json") for p in pages]
-    page_texts: List[str] = []
-    for page in pages:
-        if task == "ocr":
-            parts = []
-            for b in sorted(page.blocks, key=lambda b: b.reading_order):
-                if b.skipped or not b.html:
-                    continue
-                txt = _html_to_text(b.html)
-                if txt:
-                    parts.append(txt)
-            page_texts.append("\n".join(parts))
-        elif task == "layout":
-            # No OCR text in layout mode — emit a reading-order outline of labels.
-            page_texts.append(
-                "\n".join(
-                    f"{b.position}: {b.label}"
-                    for b in sorted(page.bboxes, key=lambda b: b.position)
-                )
-            )
-        else:  # table
-            if page.html:  # mode="full"
-                page_texts.append(page.html)
-            else:  # mode="simple"
-                page_texts.append(f"{len(page.rows)} rows x {len(page.cols)} cols")
-    return "\n\n".join(page_texts), structured
-
-
-def serialize_per_page(task: str, pages: List[Any]) -> List[Tuple[str, Dict[str, Any]]]:
-    """Per-page (text, structured-dict). Reuses `serialize_pages` one page at a time
-    so the per-file dataset row and the per-page bucket files share one code path."""
-    out: List[Tuple[str, Dict[str, Any]]] = []
-    for page in pages:
-        text, structured = serialize_pages(task, [page])
-        out.append((text, structured[0]))
-    return out
-
-
-# ---------------------------------------------------------------------------
-# Bucket-URL helpers (verbatim from pp-doclayout.py)
-# ---------------------------------------------------------------------------
-
-
-def is_bucket_url(s: str) -> bool:
-    return s.startswith(BUCKET_PREFIX)
-
-
-def parse_bucket_url(url: str) -> Tuple[str, str]:
-    """Split `hf://buckets/ns/bucket/path/in/bucket` into (`ns/bucket`, `path/in/bucket`)."""
-    if not is_bucket_url(url):
-        raise ValueError(f"Not a bucket URL: {url}")
-    rest = url[len(BUCKET_PREFIX) :].strip("/")
-    parts = rest.split("/", 2)
-    if len(parts) < 2:
-        raise ValueError(f"Bucket URL must include namespace and bucket name: {url}")
-    bucket_id = f"{parts[0]}/{parts[1]}"
-    prefix = parts[2] if len(parts) > 2 else ""
-    return bucket_id, prefix
-
-
-# ---------------------------------------------------------------------------
-# Image / PDF loading
-# ---------------------------------------------------------------------------
-
-
-def open_image(path: Path) -> Image.Image:
-    """Open one image as RGB. Falls back to imagecodecs for JPEG-2000, which the
-    image's bundled Pillow may not decode (no OpenJPEG)."""
-    try:
-        return Image.open(path).convert("RGB")
-    except (UnidentifiedImageError, OSError):
-        if path.suffix.lower() in JP2_EXTENSIONS:
-            import imagecodecs
-
-            arr = imagecodecs.imread(str(path))
-            logger.debug(f"Decoded {path.name} via imagecodecs (Pillow fallback)")
-            return Image.fromarray(arr).convert("RGB")
-        raise
-
-
-def load_pages(
-    kind: str,
-    local_path: Path,
-    load_pdf,
-    page_indices: Optional[List[int]],
-    pdf_dpi: int,
-) -> List[Image.Image]:
-    """A local document file -> list of RGB page images (1 for an image, N for a PDF)."""
-    if kind == "pdf":
-        images, _ = load_pdf(str(local_path), page_indices, dpi=pdf_dpi)
-        return [im.convert("RGB") for im in images]
-    return [open_image(local_path)]
-
-
-# ---------------------------------------------------------------------------
-# File listing + sources (mount vs copy)
-# ---------------------------------------------------------------------------
-
-
-@dataclass
-class FileRef:
-    """One input document. `key`/`rel` are the source-relative POSIX path (stable
-    across runs -> resume) and drive output mirroring. `local_path` is set in mount
-    mode; `bucket_file`/`bucket_path` in copy mode."""
-
-    key: str
-    rel: PurePosixPath
-    kind: str  # "image" | "pdf"
-    local_path: Optional[Path] = None
-    bucket_file: Any = None
-    bucket_path: Optional[str] = None
-
-
-def classify(path_str: str, exts: set) -> Optional[str]:
-    """Map a path to "pdf"/"image"/None using the allowed-extension set."""
-    ext = PurePosixPath(path_str).suffix.lower()
-    if ext == PDF_EXTENSION and PDF_EXTENSION in exts:
-        return "pdf"
-    if ext in exts:
-        return "image"
-    return None
-
-
-def _shuffle_slice(
-    refs: List[FileRef], shuffle: bool, seed: int, max_samples: Optional[int]
-) -> List[FileRef]:
-    refs.sort(key=lambda r: r.key)
-    if shuffle:
-        import random
-
-        random.Random(seed).shuffle(refs)
-    if max_samples:
-        refs = refs[:max_samples]
-    return refs
-
-
-class MountSource:
-    """Read files straight off a directory (a bucket mounted read-only at /in)."""
-
-    mode = "mount"
-
-    def __init__(self, root: Path, glob: str, exts: set):
-        self.root = root
-        self.glob = glob
-        self.exts = exts
-
-    def list_refs(
-        self, shuffle: bool, seed: int, max_samples: Optional[int]
-    ) -> List[FileRef]:
-        refs: List[FileRef] = []
-        for path in self.root.rglob("*"):
-            if not path.is_file():
-                continue
-            rel = path.relative_to(self.root)
-            rel_posix = rel.as_posix()
-            kind = classify(rel_posix, self.exts)
-            if kind is None or not fnmatch(rel_posix, self.glob):
-                continue
-            refs.append(
-                FileRef(
-                    key=rel_posix,
-                    rel=PurePosixPath(rel_posix),
-                    kind=kind,
-                    local_path=path,
-                )
-            )
-        return _shuffle_slice(refs, shuffle, seed, max_samples)
-
-    @contextmanager
-    def materialize(
-        self, chunk: List[FileRef], load_pdf, page_indices, pdf_dpi
-    ) -> Iterator[List[Tuple[FileRef, Optional[List[Image.Image]]]]]:
-        loaded: List[Tuple[FileRef, Optional[List[Image.Image]]]] = []
-        for ref in chunk:
-            loaded.append(
-                (
-                    ref,
-                    _safe_load(
-                        ref.kind, ref.local_path, load_pdf, page_indices, pdf_dpi
-                    ),
-                )
-            )
-        yield loaded  # nothing to clean up — reads are off the mount
-
-
-class CopySource:
-    """List + batch-download bucket files via huggingface_hub to local temp, then
-    delete the batch. The non-FUSE path (sidesteps the bulk-read stall)."""
-
-    mode = "copy"
-
-    def __init__(self, bucket_url: str, glob: str, exts: set, hf_token: Optional[str]):
-        from huggingface_hub import HfApi
-
-        self.bucket_id, self.prefix = parse_bucket_url(bucket_url)
-        self.glob = glob
-        self.exts = exts
-        self.hf_token = hf_token
-        self.api = HfApi(token=hf_token)
-
-    def list_refs(
-        self, shuffle: bool, seed: int, max_samples: Optional[int]
-    ) -> List[FileRef]:
-        logger.info(
-            f"Listing bucket {self.bucket_id}"
-            + (f"/{self.prefix}" if self.prefix else "")
-        )
-        refs: List[FileRef] = []
-        for item in self.api.list_bucket_tree(
-            self.bucket_id, prefix=self.prefix or None, recursive=True
-        ):
-            path = getattr(item, "path", None)
-            if not path:
-                continue
-            kind = classify(path, self.exts)
-            if kind is None:
-                continue
-            rel = path[len(self.prefix) :].lstrip("/") if self.prefix else path
-            if not fnmatch(rel, self.glob):
-                continue
-            refs.append(
-                FileRef(
-                    key=rel,
-                    rel=PurePosixPath(rel),
-                    kind=kind,
-                    bucket_file=item,
-                    bucket_path=path,
-                )
-            )
-        logger.info(f"Found {len(refs)} matching file(s) in bucket")
-        return _shuffle_slice(refs, shuffle, seed, max_samples)
-
-    @contextmanager
-    def materialize(
-        self, chunk: List[FileRef], load_pdf, page_indices, pdf_dpi
-    ) -> Iterator[List[Tuple[FileRef, Optional[List[Image.Image]]]]]:
-        tmp = Path(tempfile.mkdtemp(prefix="surya-copy-"))
-        try:
-            # Pass the BucketFile objects from list_bucket_tree so download skips the
-            # per-file metadata HEAD. Local names are index-keyed to avoid collisions.
-            files = []
-            locals_: List[Path] = []
-            for i, ref in enumerate(chunk):
-                local = tmp / f"{i:05d}{PurePosixPath(ref.bucket_path).suffix}"
-                files.append((ref.bucket_file, str(local)))
-                locals_.append(local)
-            self.api.download_bucket_files(
-                self.bucket_id, files=files, token=self.hf_token
-            )
-            loaded: List[Tuple[FileRef, Optional[List[Image.Image]]]] = []
-            for ref, local in zip(chunk, locals_):
-                if not local.exists():
-                    logger.warning(f"Download missing for {ref.key}; skipping")
-                    loaded.append((ref, None))
-                    continue
-                loaded.append(
-                    (ref, _safe_load(ref.kind, local, load_pdf, page_indices, pdf_dpi))
-                )
-            yield loaded
-        finally:
-            shutil.rmtree(tmp, ignore_errors=True)
-
-
-def _safe_load(
-    kind: str, local_path: Path, load_pdf, page_indices, pdf_dpi
-) -> Optional[List[Image.Image]]:
-    try:
-        return load_pages(kind, local_path, load_pdf, page_indices, pdf_dpi)
-    except Exception as e:  # noqa: BLE001 — a single bad file shouldn't kill the run
-        logger.warning(f"Failed to load {local_path.name}: {type(e).__name__}: {e}")
-        return None
-
-
-# ---------------------------------------------------------------------------
-# Sinks
-# ---------------------------------------------------------------------------
-
-
-class BucketFilesSink:
-    """Per page, write `<rel>.md` + `<rel>.json` (PDFs: `<stem>/page_NNN.{md,json}`),
-    mirroring the input structure, to a mounted dir OR an `hf://buckets/...` URL.
-    Streaming / O(1) memory. Resume-by-skip keys on the `.json` (written last)."""
-
-    def __init__(self, output_target: str, hf_token: Optional[str], resume: bool):
-        self.resume = resume
-        self.api_mode = is_bucket_url(output_target)
-        if self.api_mode:
-            from huggingface_hub import HfApi
-
-            self.bucket_id, self.prefix = parse_bucket_url(output_target)
-            self.api = HfApi(token=hf_token)
-            self.token = hf_token
-            self._buffer: List[Tuple[bytes, str]] = []
-            self._existing = self._load_existing() if resume else set()
-        else:
-            self.root = Path(output_target)
-            self.root.mkdir(parents=True, exist_ok=True)
-
-    @property
-    def label(self) -> str:
-        return (
-            f"hf://buckets/{self.bucket_id}/{self.prefix}".rstrip("/")
-            if self.api_mode
-            else str(self.root)
-        )
-
-    def _join(self, rel: str) -> str:
-        return f"{self.prefix}/{rel}".lstrip("/") if self.prefix else rel
-
-    def _load_existing(self) -> set:
-        existing = set()
-        try:
-            for item in self.api.list_bucket_tree(
-                self.bucket_id, prefix=self.prefix or None, recursive=True
-            ):
-                p = getattr(item, "path", None)
-                if p and p.endswith(".json"):
-                    existing.add(p)
-        except Exception as e:  # noqa: BLE001
-            logger.warning(f"Could not pre-list output bucket for resume: {e}")
-        if existing:
-            logger.info(f"Resume: {len(existing)} output file(s) already present")
-        return existing
-
-    def _page_targets(self, ref: FileRef, n_pages: int) -> List[Tuple[str, str]]:
-        if ref.kind == "pdf":
-            stem = ref.rel.with_suffix("")
-            return [
-                (
-                    str(stem / f"page_{i + 1:03d}.md"),
-                    str(stem / f"page_{i + 1:03d}.json"),
-                )
-                for i in range(n_pages)
-            ]
-        return [(str(ref.rel.with_suffix(".md")), str(ref.rel.with_suffix(".json")))]
-
-    def is_done(self, ref: FileRef) -> bool:
-        # Resume applies to single-image files only; PDFs are re-rendered (idempotent
-        # overwrite) since page count isn't known without opening them.
-        if not self.resume or ref.kind == "pdf":
-            return False
-        json_rel = str(ref.rel.with_suffix(".json"))
-        if self.api_mode:
-            return self._join(json_rel) in self._existing
-        return (self.root / json_rel).exists()
-
-    def write_pages(
-        self,
-        ref: FileRef,
-        per_page: List[Tuple[str, Dict[str, Any]]],
-        pages: Optional[List[Image.Image]],
-    ) -> None:
-        targets = self._page_targets(ref, len(per_page))
-        for (text, struct), (md_rel, json_rel) in zip(per_page, targets):
-            md_bytes = text.encode("utf-8")
-            json_bytes = json.dumps(struct, ensure_ascii=False).encode("utf-8")
-            if self.api_mode:
-                # .md first, .json last so a present .json marks the page complete.
-                self._buffer.append((md_bytes, self._join(md_rel)))
-                self._buffer.append((json_bytes, self._join(json_rel)))
-            else:
-                mp = self.root / md_rel
-                mp.parent.mkdir(parents=True, exist_ok=True)
-                mp.write_bytes(md_bytes)
-                (self.root / json_rel).write_bytes(json_bytes)
-
-    def write_error(self, ref: FileRef) -> None:
-        # Write nothing on error so the file is retried on the next (resumed) run.
-        pass
-
-    def flush(self) -> None:
-        if self.api_mode and self._buffer:
-            self.api.batch_bucket_files(
-                self.bucket_id, add=self._buffer, token=self.token
-            )
-            self._buffer = []
-
-    def finalize(self, summary: Dict[str, Any]) -> None:
-        self.flush()
-        logger.info(f"Bucket files written to {self.label}")
-
-
-class DatasetSink:
-    """Buffer one row per file, push a parquet dataset at the end (like surya-ocr.py)."""
-
-    def __init__(
-        self,
-        repo_id: str,
-        *,
-        hf_token: Optional[str],
-        private: bool,
-        config: Optional[str],
-        create_pr: bool,
-        include_images: bool,
-        output_column: str,
-        blocks_column: str,
-    ):
-        self.repo_id = repo_id
-        self.hf_token = hf_token
-        self.private = private
-        self.config = config
-        self.create_pr = create_pr
-        self.include_images = include_images
-        self.output_column = output_column
-        self.blocks_column = blocks_column
-        self._rows: List[Dict[str, Any]] = []
-
-    def is_done(self, ref: FileRef) -> bool:
-        return False  # single push at the end; no per-file resume
-
-    def write_pages(
-        self,
-        ref: FileRef,
-        per_page: List[Tuple[str, Dict[str, Any]]],
-        pages: Optional[List[Image.Image]],
-    ) -> None:
-        row = {
-            "file_name": ref.key,
-            "num_pages": len(per_page),
-            self.output_column: "\n\n".join(t for t, _ in per_page),
-            self.blocks_column: json.dumps(
-                [s for _, s in per_page], ensure_ascii=False
-            ),
-        }
-        if self.include_images and pages:
-            # First page only (keeps a single Image column); documented limitation.
-            row["image"] = pages[0]
-        self._rows.append(row)
-
-    def write_error(self, ref: FileRef) -> None:
-        self._rows.append(
-            {
-                "file_name": ref.key,
-                "num_pages": 0,
-                self.output_column: "[SURYA ERROR]",
-                self.blocks_column: None,
-            }
-        )
-
-    def flush(self) -> None:
-        pass  # single push at finalize
-
-    def finalize(self, summary: Dict[str, Any]) -> None:
-        from datasets import Dataset
-
-        if not self._rows:
-            logger.warning("No rows produced; nothing to push to the dataset.")
-            return
-
-        inference_entry = {
-            "model": summary["model"],
-            "model_name": "surya-ocr-2",
-            "column_name": self.output_column,
-            "blocks_column": self.blocks_column,
-            "task": summary["task"],
-            "table_mode": summary["table_mode"] if summary["task"] == "table" else None,
-            "backend": "vllm-offline",
-            "source": summary["source"],
-            "io_mode": summary["io_mode"],
-            "glob": summary["glob"],
-            "page_range": summary["page_range"],
-            "error_rate": summary["error_rate"],
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-            "script": "surya-ocr-bucket.py",
-        }
-        for row in self._rows:
-            row["inference_info"] = json.dumps([inference_entry])
-
-        ds = Dataset.from_list(self._rows)
-        if self.include_images and "image" in ds.column_names:
-            try:
-                from datasets import Image as HFImage
-
-                ds = ds.cast_column("image", HFImage())
-            except Exception as e:  # noqa: BLE001
-                logger.warning(f"Could not cast image column: {e}")
-
-        logger.info(f"Pushing {len(ds)} rows to {self.repo_id}")
-        push_kwargs = {
-            "private": self.private,
-            "token": self.hf_token,
-            "max_shard_size": "500MB",
-            "create_pr": self.create_pr,
-            "commit_message": f"Add Surya OCR 2 {summary['task']} results ({len(ds)} files)"
-            + (f" [{self.config}]" if self.config else ""),
-        }
-        if self.config:
-            push_kwargs["config_name"] = self.config
-
-        for attempt in range(1, 4):
-            try:
-                if attempt > 1:
-                    logger.warning("Disabling XET (fallback to HTTP upload)")
-                    os.environ["HF_HUB_DISABLE_XET"] = "1"
-                ds.push_to_hub(self.repo_id, **push_kwargs)
-                break
-            except Exception as e:  # noqa: BLE001
-                logger.error(f"Upload attempt {attempt}/3 failed: {e}")
-                if attempt == 3:
-                    logger.error("All upload attempts failed.")
-                    raise
-                time.sleep(30 * (2 ** (attempt - 1)))
-
-        self._push_card(summary, len(ds))
-        logger.info(f"Dataset: https://huggingface.co/datasets/{self.repo_id}")
-
-    def _push_card(self, summary: Dict[str, Any], n_rows: int) -> None:
-        try:
-            from huggingface_hub import DatasetCard
-
-            card = DatasetCard(
-                _dataset_card(
-                    source=summary["source"],
-                    model=summary["model"],
-                    task=summary["task"],
-                    table_mode=summary["table_mode"],
-                    io_mode=summary["io_mode"],
-                    n_files=n_rows,
-                    n_ok=summary["n_ok"],
-                    output_column=self.output_column,
-                    blocks_column=self.blocks_column,
-                    processing_time=summary["processing_time"],
-                )
-            )
-            card.push_to_hub(self.repo_id, token=self.hf_token)
-        except Exception as e:  # noqa: BLE001
-            logger.warning(f"Could not push dataset card: {e}")
-
-
-def _dataset_card(
-    source: str,
-    model: str,
-    task: str,
-    table_mode: str,
-    io_mode: str,
-    n_files: int,
-    n_ok: int,
-    output_column: str,
-    blocks_column: str,
-    processing_time: str,
-) -> str:
-    task_desc = {
-        "ocr": "full-page OCR (structured HTML + bounding boxes)",
-        "layout": "layout analysis (labelled regions + reading order)",
-        "table": f"table recognition (mode `{table_mode}`)",
-    }[task]
-    return f"""---
-tags:
-- ocr
-- document-processing
-- surya
-- structured
-- uv-script
-- generated
----
-
-# Surya OCR 2 ({task}) on {source}
-
-{task_desc.capitalize()} over document files in the HF bucket
-`{source}`, using [Surya OCR 2](https://huggingface.co/{model}) (650M, Qwen3.5-based)
-by Datalab, via the [`surya-ocr`](https://github.com/datalab-to/surya) package, run
-as **offline vLLM batch inference** on Hugging Face Jobs (`surya-ocr-bucket.py`).
-
-## Processing Details
-
-- **Source bucket**: `{source}`
-- **Model**: [{model}](https://huggingface.co/{model})
-- **Task**: `{task}`{f" (table mode `{table_mode}`)" if task == "table" else ""}
-- **I/O mode**: `{io_mode}`
-- **Text column**: `{output_column}` (flattened, reading-order text per file)
-- **Structured column**: `{blocks_column}` (JSON: per-page blocks with bbox / polygon / label / reading_order / confidence / html)
-- **Files**: {n_files:,}
-- **Processed OK**: {n_ok:,} / {n_files:,}
-- **Processing time**: {processing_time}
-- **Date**: {datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")}
-
-## License note
-
-Surya'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
-
-One row per source file:
-- `file_name`: source-relative path in the bucket
-- `num_pages`: pages OCR'd (1 for an image, N for a PDF)
-- `{output_column}`: flattened text (OCR), label outline (layout), or table HTML (table)
-- `{blocks_column}`: structured result as a JSON string (one entry per page)
-- `inference_info`: JSON list tracking models applied
-
-Generated with [UV Scripts](https://huggingface.co/uv-scripts).
-"""
-
-
-# ---------------------------------------------------------------------------
-# Predictor + processing loop
-# ---------------------------------------------------------------------------
-
-
-def build_predictor(task: str, table_mode: str, manager):
-    """Return a `run(images) -> page_results` closure (verbatim dispatch from parent)."""
-    if task == "ocr":
-        from surya.recognition import RecognitionPredictor
-
-        predictor = RecognitionPredictor(manager)
-
-        def run(images):
-            return predictor(images, full_page=True)
-    elif task == "layout":
-        from surya.layout import LayoutPredictor
-
-        predictor = LayoutPredictor(manager)
-
-        def run(images):
-            return predictor(images)
-    else:  # table
-        from surya.table_rec import TableRecPredictor
-
-        predictor = TableRecPredictor(manager)
-
-        def run(images):
-            return predictor(images, mode=table_mode)
-
-    return run
-
-
-def process(
-    refs: List[FileRef],
-    source,
-    run,
-    task: str,
-    sinks: List[Any],
-    batch_size: int,
-    load_pdf,
-    page_indices: Optional[List[int]],
-    pdf_dpi: int,
-) -> Tuple[int, int, int, float, float]:
-    """Resume-filter, then OCR file-by-file in batches.
-
-    Returns (processed, ok, errors, io_secs, inf_secs). `io_secs` is time spent
-    materializing batches (FUSE reads in mount mode; list-skip + batch download in
-    copy mode); `inf_secs` is engine time (incl. one-time model load on the first
-    batch). The split lets the mount-vs-copy benchmark isolate I/O from inference."""
-    pending = [r for r in refs if not all(s.is_done(r) for s in sinks)]
-    skipped = len(refs) - len(pending)
-    if skipped:
-        logger.info(f"Resume: skipping {skipped} already-complete file(s)")
-    logger.info(f"Processing {len(pending)} file(s)")
-
-    processed = ok = errors = 0
-    io_secs = inf_secs = 0.0
-    pbar = tqdm(total=len(pending), desc=f"Surya {task}")
-    for chunk in partition_all(batch_size, pending):
-        chunk = list(chunk)
-        t_io = time.monotonic()
-        with source.materialize(chunk, load_pdf, page_indices, pdf_dpi) as loaded:
-            io_secs += time.monotonic() - t_io
-            entries: List[Tuple[FileRef, List[Image.Image], int, int]] = []
-            flat: List[Image.Image] = []
-            for ref, pages in loaded:
-                if not pages:
-                    for s in sinks:
-                        s.write_error(ref)
-                    errors += 1
-                    processed += 1
-                    pbar.update(1)
-                    continue
-                entries.append((ref, pages, len(flat), len(pages)))
-                flat.extend(pages)
-
-            if flat:
-                t_inf = time.monotonic()
-                try:
-                    results = run(flat)
-                except Exception as e:  # noqa: BLE001
-                    logger.error(f"Batch generate failed: {e}")
-                    results = None
-                inf_secs += time.monotonic() - t_inf
-
-                if results is None:
-                    for ref, _pages, _start, _count in entries:
-                        for s in sinks:
-                            s.write_error(ref)
-                        errors += 1
-                        processed += 1
-                        pbar.update(1)
-                else:
-                    for ref, pages, start, count in entries:
-                        per_page = serialize_per_page(
-                            task, results[start : start + count]
-                        )
-                        for s in sinks:
-                            s.write_pages(ref, per_page, pages)
-                        ok += 1
-                        processed += 1
-                        pbar.update(1)
-
-        for s in sinks:
-            s.flush()
-    pbar.close()
-    return processed, ok, errors, io_secs, inf_secs
-
-
-# ---------------------------------------------------------------------------
-# Main
-# ---------------------------------------------------------------------------
-
-
-def resolve_io_mode(io_mode: str, input_source: str) -> str:
-    if io_mode == "auto":
-        return "copy" if is_bucket_url(input_source) else "mount"
-    return io_mode
-
-
-def main(args: argparse.Namespace) -> None:
-    # Unlock full Xet bandwidth for the model download (repo convention).
-    os.environ["HF_XET_HIGH_PERFORMANCE"] = "1"
-    # Surya reads settings from env at import; pin the checkpoint and forbid any
-    # server autostart (we inject our own offline backend instead).
-    os.environ["SURYA_MODEL_CHECKPOINT"] = args.model
-    os.environ["SURYA_INFERENCE_AUTOSTART"] = "False"
-
-    check_cuda_availability()
-    start_time = datetime.now(timezone.utc)
-
-    hf_token = args.hf_token or os.environ.get("HF_TOKEN")
-    if hf_token:
-        from huggingface_hub import login
-
-        login(token=hf_token)
-
-    exts = {e.strip().lower() for e in args.extensions.split(",") if e.strip()}
-    io_mode = resolve_io_mode(args.io_mode, args.input_source)
-
-    # ---------- source ----------
-    if io_mode == "copy":
-        if not is_bucket_url(args.input_source):
-            logger.error("--io-mode copy requires an hf://buckets/... input.")
-            sys.exit(1)
-        source = CopySource(args.input_source, args.glob, exts, hf_token)
-    else:
-        root = Path(args.input_source)
-        if not root.is_dir():
-            logger.error(
-                f"--io-mode mount requires an existing directory (got {root}). "
-                "Mount the bucket with -v hf://buckets/<id>:/in:ro and pass /in."
-            )
-            sys.exit(1)
-        source = MountSource(root, args.glob, exts)
-    logger.info(f"I/O mode: {io_mode}  Input: {args.input_source}")
-
-    # ---------- sinks ----------
-    sinks: List[Any] = []
-    if args.output_bucket:
-        sinks.append(
-            BucketFilesSink(args.output_bucket, hf_token, resume=not args.no_resume)
-        )
-    if args.output_dataset:
-        sinks.append(
-            DatasetSink(
-                args.output_dataset,
-                hf_token=hf_token,
-                private=args.private,
-                config=args.config,
-                create_pr=args.create_pr,
-                include_images=args.include_images,
-                output_column=args.output_column,
-                blocks_column=args.blocks_column,
-            )
-        )
-
-    # ---------- import Surya only after env is set ----------
-    from surya.input.load import load_pdf
-    from surya.settings import settings
-
-    page_indices = parse_page_range(args.page_range)
-    pdf_dpi = args.pdf_dpi if args.pdf_dpi else settings.IMAGE_DPI_HIGHRES
-
-    t_list = time.monotonic()
-    refs = source.list_refs(args.shuffle, args.seed, args.max_samples)
-    list_secs = time.monotonic() - t_list
-    if not refs:
-        logger.error("No matching files found. Check --glob / --extensions / input.")
-        sys.exit(1)
-    logger.info(
-        f"{len(refs)} file(s) listed in {list_secs:.1f}s | Model: {args.model}  "
-        f"Task: {args.task}"
-        + (f" (mode {args.table_mode})" if args.task == "table" else "")
-    )
-
-    # ---------- engine ----------
-    backend = OfflineVLLMBackend(
-        model=args.model,
-        max_model_len=args.max_model_len,
-        gpu_memory_utilization=args.gpu_memory_utilization,
-        dtype=args.dtype,
-    )
-    manager = make_manager(backend)
-    run = build_predictor(args.task, args.table_mode, manager)
-
-    processed, ok, errors, io_secs, inf_secs = process(
-        refs,
-        source,
-        run,
-        args.task,
-        sinks,
-        args.batch_size,
-        load_pdf,
-        page_indices,
-        pdf_dpi,
-    )
-
-    processing_time = (
-        f"{(datetime.now(timezone.utc) - start_time).total_seconds() / 60:.1f} min"
-    )
-    logger.info(
-        f"Processed {processed} (ok {ok}, errors {errors}) in {processing_time}"
-    )
-    # Benchmark breakdown: separate listing + per-batch I/O from engine time so the
-    # mount-vs-copy comparison isn't swamped by (identical) inference + model load.
-    pages_per_sec = ok / io_secs if io_secs else 0.0
-    logger.info(
-        f"[timing] io_mode={io_mode} list={list_secs:.1f}s io={io_secs:.1f}s "
-        f"inference={inf_secs:.1f}s files={ok} io_files_per_sec={pages_per_sec:.2f}"
-    )
-
-    summary = {
-        "model": args.model,
-        "task": args.task,
-        "table_mode": args.table_mode,
-        "source": args.input_source,
-        "io_mode": io_mode,
-        "glob": args.glob,
-        "page_range": args.page_range,
-        "n_ok": ok,
-        "error_rate": (processed - ok) / processed if processed else 0.0,
-        "processing_time": processing_time,
-    }
-    for s in sinks:
-        s.finalize(summary)
-
-    logger.info("Done! Surya OCR 2 (bucket) complete.")
-
-    if args.verbose:
-        import importlib.metadata
-
-        logger.info("--- Resolved package versions ---")
-        for pkg in [
-            "surya-ocr",
-            "vllm",
-            "transformers",
-            "torch",
-            "datasets",
-            "huggingface-hub",
-            "pillow",
-            "imagecodecs",
-        ]:
-            try:
-                logger.info(f"  {pkg}=={importlib.metadata.version(pkg)}")
-            except importlib.metadata.PackageNotFoundError:
-                logger.info(f"  {pkg}: not installed")
-
-
-# ---------------------------------------------------------------------------
-# CLI
-# ---------------------------------------------------------------------------
-
-
-def build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(
-        description="Surya OCR 2 (650M): structured OCR / layout / tables over a bucket of files",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-I/O modes (--io-mode):
-  auto    copy for an hf://buckets/... input, mount for a local dir (default)
-  mount   read off a bucket mounted read-only at /in (-v hf://buckets/<id>:/in:ro)
-  copy    list + batch-download via huggingface_hub to temp, OCR, delete the batch
-
-Outputs (at least one required):
-  --output-bucket   per-page .md + .json mirroring input structure (mounted dir or
-                    hf://buckets/... URL); resumable, O(1) memory
-  --output-dataset  parquet dataset push (one row per file)
-
-Run on the vllm/vllm-openai:v0.20.1 image (offline vLLM batch; qwen3_5 is
-version-sensitive — the site-packages python path is load-bearing):
-  --image vllm/vllm-openai:v0.20.1 --python /usr/local/bin/python3 \\
-    -e PYTHONPATH=/usr/local/lib/python3.12/site-packages
-""",
-    )
-    parser.add_argument(
-        "input_source",
-        help="Mounted dir (e.g. /in) OR hf://buckets/<ns>/<bucket>[/prefix]",
-    )
-    parser.add_argument(
-        "--io-mode",
-        choices=["auto", "mount", "copy"],
-        default="auto",
-        help="Input I/O strategy (default: auto)",
-    )
-    parser.add_argument(
-        "--glob",
-        default="*",
-        help="fnmatch pattern over the source-relative path (default: '*'; "
-        "e.g. '*.jp2'). Applied on top of --extensions.",
-    )
-    parser.add_argument(
-        "--extensions",
-        default=DEFAULT_EXTENSIONS,
-        help=f"Comma-separated file extensions to read (default: {DEFAULT_EXTENSIONS})",
-    )
-    parser.add_argument(
-        "--output-bucket",
-        default=None,
-        help="Per-file .md + .json output: a mounted dir OR hf://buckets/<id>[/prefix]",
-    )
-    parser.add_argument(
-        "--output-dataset",
-        default=None,
-        help="Output dataset repo ID (parquet, one row per file)",
-    )
-    parser.add_argument(
-        "--no-resume",
-        action="store_true",
-        help="Disable resume-by-skip for --output-bucket (re-OCR everything)",
-    )
-    parser.add_argument(
-        "--task", choices=TASKS, default="ocr", help="Task (default: ocr)"
-    )
-    parser.add_argument(
-        "--table-mode",
-        choices=["full", "simple"],
-        default="full",
-        help="Table task: 'full' = HTML, 'simple' = rows/cols/cells (default: full)",
-    )
-    parser.add_argument(
-        "--page-range",
-        default=None,
-        help="Pages from PDFs, e.g. '0-5,7' (PDFs only)",
-    )
-    parser.add_argument(
-        "--pdf-dpi",
-        type=int,
-        default=None,
-        help="DPI for PDF rendering (default: Surya's IMAGE_DPI_HIGHRES)",
-    )
-    parser.add_argument(
-        "--max-samples", type=int, help="Limit number of files (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=16,
-        help="Images per offline llm.chat batch AND per copy-mode download/cleanup unit (default: 16)",
-    )
-    parser.add_argument(
-        "--max-model-len",
-        type=int,
-        default=18000,
-        help="vLLM context length (default: 18000)",
-    )
-    parser.add_argument(
-        "--gpu-memory-utilization",
-        type=float,
-        default=0.85,
-        help="vLLM GPU memory fraction (default: 0.85)",
-    )
-    parser.add_argument(
-        "--dtype",
-        default="bfloat16",
-        help="vLLM dtype (default: bfloat16; use float16 on T4/Turing)",
-    )
-    parser.add_argument(
-        "--model", default=DEFAULT_MODEL, help=f"Model ID (default: {DEFAULT_MODEL})"
-    )
-    parser.add_argument(
-        "--output-column",
-        default="markdown",
-        help="Dataset text column (default: markdown)",
-    )
-    parser.add_argument(
-        "--blocks-column",
-        default="surya_blocks",
-        help="Dataset structured JSON column (default: surya_blocks)",
-    )
-    parser.add_argument(
-        "--include-images",
-        action="store_true",
-        help="Embed the first page image in --output-dataset (memory-heavy)",
-    )
-    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 in one repo)",
-    )
-    parser.add_argument(
-        "--create-pr",
-        action="store_true",
-        help="Push dataset as a pull request instead of directly",
-    )
-    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",
-    )
-    return parser
-
-
-def _print_banner() -> None:
-    print(
-        "Surya OCR 2 (bucket) — structured OCR / layout / tables over a bucket of files (650M)"
-    )
-    print("\nUsage:")
-    print(
-        "  uv run surya-ocr-bucket.py INPUT [--output-bucket ... | --output-dataset ...] [options]"
-    )
-    print("\nExamples:")
-    print("  # copy a bucket of .jp2 -> a dataset")
-    print("  uv run surya-ocr-bucket.py hf://buckets/me/news --io-mode copy \\")
-    print("      --glob '*.jp2' --output-dataset me/news-ocr --private")
-    print("\n  # mount a bucket -> per-file .md + .json in an output bucket")
-    print("  uv run surya-ocr-bucket.py /in --io-mode mount --output-bucket /out")
-    print("\nRun on the vllm/vllm-openai:v0.20.1 image (offline vLLM batch):")
-    print("  hf jobs uv run --flavor l4x1 -s HF_TOKEN \\")
-    print("      --image vllm/vllm-openai:v0.20.1 --python /usr/local/bin/python3 \\")
-    print("      -e PYTHONPATH=/usr/local/lib/python3.12/site-packages \\")
-    print("      -v hf://buckets/me/news:/in:ro -v hf://buckets/me/news-ocr:/out \\")
-    print(
-        "      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/surya-ocr-bucket.py \\"
-    )
-    print("      /in --io-mode mount --glob '*.jp2' --output-bucket /out")
-    print("\nFor full help: uv run surya-ocr-bucket.py --help")
-
-
-if __name__ == "__main__":
-    if len(sys.argv) == 1:
-        _print_banner()
-        sys.exit(0)
-
-    args = build_parser().parse_args()
-    if not args.output_bucket and not args.output_dataset:
-        build_parser().error(
-            "at least one of --output-bucket or --output-dataset is required"
-        )
-    if args.no_resume and not args.output_bucket:
-        logger.warning("--no-resume has no effect without --output-bucket")
-    if args.include_images and not args.output_dataset:
-        logger.warning("--include-images has no effect without --output-dataset")
-
-    main(args)

surya-ocr.py

@@ -1,855 +0,0 @@
-# /// script
-# requires-python = ">=3.10"
-# dependencies = [
-#     "surya-ocr",
-#     "datasets>=3.1.0",
-#     "huggingface-hub",
-#     "pillow",
-#     "toolz",
-#     "tqdm",
-# ]
-# ///
-"""
-Document intelligence on images OR multi-page PDFs with Datalab's **Surya OCR 2**
-(`datalab-to/surya-ocr-2`, 650M, Qwen3.5-style).
-
-Surya is *structured* OCR: instead of a flat markdown blob, it returns per-block
-HTML with bounding boxes, reading order, and labels (equations in `<math>`). This
-recipe writes **both**:
-
-  --output-column   (default `markdown`)  flattened, reading-order text per row
-  surya_blocks                            the full structured result as JSON
-                                          (bbox / polygon / label / reading_order /
-                                          confidence / html per block), one entry
-                                          per page.
-
-Three tasks via `--task`:
-  ocr     (default)  full-page OCR  -> text + per-block HTML/bboxes
-  layout             layout regions -> labelled boxes + reading order
-  table              table structure -> HTML (mode `full`) or rows/cols/cells
-                     (mode `simple`, via --table-mode)
-
-Input is one document per row:
-  --image-column COL   (default `image`)  one image per row
-  --pdf-column COL                        PDF bytes per row (multi-page; honors
-                                          --page-range). Pages are concatenated in
-                                          the text column and kept per-page in
-                                          `surya_blocks`.
-
-ENGINE: Surya normally spawns a vLLM **server** (Docker) — which can't run inside
-an HF Job. This script instead does **offline batch inference**: it injects a
-custom in-process backend into Surya's `SuryaInferenceManager` that runs vLLM's
-offline `LLM().chat()` engine (no server, no HTTP). Surya still owns all the
-prompting, image preprocessing, and HTML/bbox parsing — we only swap the
-transport. Run on the **`vllm/vllm-openai:v0.20.1`** image (Surya's known-good
-vLLM build; the model is the recent, version-sensitive `qwen3_5` architecture).
-
-LICENSE NOTE: Surya'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. https://huggingface.co/datalab-to/surya-ocr-2
-
-HF Jobs (use the pinned vLLM image so vLLM + qwen3_5 support are present):
-
-    hf jobs uv run --flavor l4x1 -s HF_TOKEN \\
-        --image vllm/vllm-openai:v0.20.1 --python /usr/local/bin/python3 \\
-        -e PYTHONPATH=/usr/local/lib/python3.12/site-packages \\
-        https://huggingface.co/datasets/uv-scripts/ocr/raw/main/surya-ocr.py \\
-        INPUT_DATASET OUTPUT_DATASET \\
-        --max-samples 5 --shuffle --seed 42
-
-Model: datalab-to/surya-ocr-2  (package: surya-ocr, https://github.com/datalab-to/surya)
-"""
-
-import argparse
-import io
-import json
-import logging
-import math
-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__)
-
-DEFAULT_MODEL = "datalab-to/surya-ocr-2"
-# Surya's own vision-tiling bounds (from its vLLM backend), applied to the
-# offline engine too so preprocessing matches the server path exactly.
-MM_PROCESSOR_KWARGS = {"min_pixels": 3136, "max_pixels": 6291456}
-TASKS = ("ocr", "layout", "table")
-
-
-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 --flavor l4x1 "
-            "--image vllm/vllm-openai:v0.20.1 ..."
-        )
-        sys.exit(1)
-    logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
-
-
-def parse_page_range(spec: Optional[str]) -> Optional[List[int]]:
-    """Turn '0-3,5' into [0,1,2,3,5]. None/empty -> None (all pages)."""
-    if not spec:
-        return None
-    pages: List[int] = []
-    for part in spec.split(","):
-        part = part.strip()
-        if not part:
-            continue
-        if "-" in part:
-            lo, hi = part.split("-", 1)
-            pages.extend(range(int(lo), int(hi) + 1))
-        else:
-            pages.append(int(part))
-    return pages or None
-
-
-def cell_to_bytes(cell: Any) -> bytes:
-    """Normalize an HF dataset cell (image or document) to raw file bytes."""
-    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 cell_to_pil(cell: Any) -> Image.Image:
-    """One image cell -> RGB PIL image."""
-    if isinstance(cell, Image.Image):
-        return cell.convert("RGB")
-    return Image.open(io.BytesIO(cell_to_bytes(cell))).convert("RGB")
-
-
-def load_pdf_images(
-    load_pdf, cell: Any, page_indices: Optional[List[int]], dpi: int
-) -> List[Image.Image]:
-    """Render one PDF cell into page images via Surya's own pypdfium2 loader."""
-    data = cell_to_bytes(cell)
-    with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as tmp:
-        tmp.write(data)
-        path = tmp.name
-    try:
-        images, _ = load_pdf(path, page_indices, dpi=dpi)
-        return [im.convert("RGB") for im in images]
-    finally:
-        os.unlink(path)
-
-
-# --- structured-output shim (vLLM API moved between versions) ---
-def build_structured_outputs(schema: Dict[str, Any]) -> Dict[str, Any]:
-    """SamplingParams kwargs for guided JSON, across vLLM versions (layout uses this)."""
-    try:
-        from vllm.sampling_params import StructuredOutputsParams  # vLLM >= 0.12
-
-        return {"structured_outputs": StructuredOutputsParams(json=schema)}
-    except (ImportError, TypeError):
-        pass
-    try:
-        from vllm.sampling_params import GuidedDecodingParams  # older vLLM
-
-        return {"guided_decoding": GuidedDecodingParams(json=schema)}
-    except (ImportError, TypeError):
-        pass
-    logger.warning(
-        "Guided JSON unavailable in this vLLM version; relying on the model."
-    )
-    return {}
-
-
-def _mean_token_prob(completion_output) -> Optional[float]:
-    """Mean exp(logprob) of the sampled tokens -> Surya's per-block `confidence`."""
-    lps = getattr(completion_output, "logprobs", None)
-    if not lps:
-        return None
-    probs: List[float] = []
-    for tid, lp_dict in zip(completion_output.token_ids, lps):
-        if not lp_dict:
-            continue
-        entry = lp_dict.get(tid)
-        if (
-            entry is None
-        ):  # sampled token not in the returned top-k; use the best we have
-            entry = max(lp_dict.values(), key=lambda e: e.logprob)
-        probs.append(math.exp(entry.logprob))
-    return sum(probs) / len(probs) if probs else None
-
-
-class OfflineVLLMBackend:
-    """Surya `Backend` (duck-typed) that runs vLLM's offline `LLM().chat()` engine.
-
-    Surya's predictors call `manager.generate(batch)` -> `backend.generate(batch)`;
-    we satisfy that contract in-process (no server). Surya keeps ownership of the
-    prompts (`PROMPT_MAPPING`), image scaling (`scale_to_fit`), and output parsing.
-    """
-
-    name = "offline-vllm"
-
-    def __init__(
-        self,
-        model: str,
-        max_model_len: int,
-        gpu_memory_utilization: float,
-        dtype: str = "bfloat16",
-        max_tokens_default: int = 2048,
-        logprobs_default: bool = True,
-    ):
-        self.model = model
-        self.max_model_len = max_model_len
-        self.gpu_memory_utilization = gpu_memory_utilization
-        self.dtype = dtype
-        self.max_tokens_default = max_tokens_default
-        self.logprobs_default = logprobs_default
-        self.llm = None
-        self._build_messages = None
-        self._scale_to_fit = None
-        self._prompt_mapping = None
-
-    def start(self):
-        from vllm import LLM
-
-        logger.info(
-            f"Loading {self.model} into vLLM offline engine (dtype={self.dtype})..."
-        )
-        self.llm = LLM(
-            model=self.model,
-            dtype=self.dtype,
-            max_model_len=self.max_model_len,
-            gpu_memory_utilization=self.gpu_memory_utilization,
-            mm_processor_kwargs=MM_PROCESSOR_KWARGS,
-            limit_mm_per_prompt={"image": 1},
-        )
-        # Reuse Surya's exact request shaping so the offline path matches the server.
-        from surya.inference.backends.openai_client import _build_messages
-        from surya.inference.prompts import PROMPT_MAPPING
-        from surya.inference.util import scale_to_fit
-
-        self._build_messages = _build_messages
-        self._scale_to_fit = scale_to_fit
-        self._prompt_mapping = PROMPT_MAPPING
-        return None
-
-    def stop(self) -> None:
-        self.llm = None
-
-    def _sampling_params(self, item):
-        from vllm import SamplingParams
-
-        max_tokens = item.max_tokens or self.max_tokens_default
-        want_logprobs = item.request_logprobs or self.logprobs_default
-        kwargs: Dict[str, Any] = dict(temperature=0.0, top_p=0.1, max_tokens=max_tokens)
-        if want_logprobs:
-            kwargs["logprobs"] = 1
-        if item.guided_json is not None:
-            kwargs.update(build_structured_outputs(item.guided_json))
-        return SamplingParams(**kwargs)
-
-    def generate(self, batch):
-        from surya.inference.schema import BatchOutputItem
-
-        if self.llm is None:
-            self.start()
-        if not batch:
-            return []
-
-        conversations = []
-        sampling_params = []
-        for item in batch:
-            prompt = item.prompt or self._prompt_mapping[item.prompt_type]
-            image = self._scale_to_fit(item.image)
-            conversations.append(self._build_messages(image, prompt))
-            sampling_params.append(self._sampling_params(item))
-
-        outputs = self.llm.chat(
-            conversations,
-            sampling_params,
-            chat_template_content_format="openai",
-            use_tqdm=False,
-        )
-
-        results = []
-        for item, out in zip(batch, outputs):
-            comp = out.outputs[0]
-            results.append(
-                BatchOutputItem(
-                    raw=comp.text,
-                    token_count=len(comp.token_ids),
-                    error=False,
-                    mean_token_prob=_mean_token_prob(comp),
-                    logprobs=None,
-                    metadata=item.metadata,  # carries page_idx/block_idx — must round-trip
-                )
-            )
-        return results
-
-
-def make_manager(backend: OfflineVLLMBackend):
-    """A SuryaInferenceManager wired to our offline backend (bypassing autodetect)."""
-    from surya.inference import SuryaInferenceManager
-
-    manager = SuryaInferenceManager.__new__(SuryaInferenceManager)
-    manager.method = backend.name
-    manager.backend = backend
-    return manager
-
-
-# --- result serialization (text column + structured surya_blocks) ---
-def _html_to_text(html: str) -> str:
-    from bs4 import BeautifulSoup
-
-    return BeautifulSoup(html, "html.parser").get_text(" ", strip=True)
-
-
-def serialize_pages(task: str, pages: List[Any]) -> Tuple[str, List[Dict[str, Any]]]:
-    """(text, structured-per-page) for one row's page results."""
-    structured = [p.model_dump(mode="json") for p in pages]
-    page_texts: List[str] = []
-    for page in pages:
-        if task == "ocr":
-            parts = []
-            for b in sorted(page.blocks, key=lambda b: b.reading_order):
-                if b.skipped or not b.html:
-                    continue
-                txt = _html_to_text(b.html)
-                if txt:
-                    parts.append(txt)
-            page_texts.append("\n".join(parts))
-        elif task == "layout":
-            # No OCR text in layout mode — emit a reading-order outline of labels.
-            page_texts.append(
-                "\n".join(
-                    f"{b.position}: {b.label}"
-                    for b in sorted(page.bboxes, key=lambda b: b.position)
-                )
-            )
-        else:  # table
-            if page.html:  # mode="full"
-                page_texts.append(page.html)
-            else:  # mode="simple"
-                page_texts.append(f"{len(page.rows)} rows x {len(page.cols)} cols")
-    return "\n\n".join(page_texts), structured
-
-
-def create_dataset_card(
-    source_dataset: str,
-    model: str,
-    task: str,
-    table_mode: str,
-    num_samples: int,
-    n_ok: int,
-    source_column: str,
-    is_pdf: bool,
-    page_range: Optional[str],
-    output_column: str,
-    blocks_column: str,
-    split: str,
-    processing_time: str,
-) -> str:
-    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}"
-    task_desc = {
-        "ocr": "full-page OCR (structured HTML + bounding boxes)",
-        "layout": "layout analysis (labelled regions + reading order)",
-        "table": f"table recognition (mode `{table_mode}`)",
-    }[task]
-    return f"""---
-tags:
-- ocr
-- document-processing
-- surya
-- structured
-- uv-script
-- generated
----
-
-# Surya OCR 2 ({task}) on {source_dataset}
-
-{task_desc.capitalize()} over {input_kind} in
-[{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using
-[Surya OCR 2](https://huggingface.co/{model}) (650M, Qwen3.5-based) by Datalab, via the
-[`surya-ocr`](https://github.com/datalab-to/surya) package, run as **offline vLLM batch
-inference** on Hugging Face Jobs.
-
-## Processing Details
-
-- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
-- **Model**: [{model}](https://huggingface.co/{model})
-- **Task**: `{task}`{f" (table mode `{table_mode}`)" if task == "table" else ""}
-- **Input column**: `{source_column}` ({col_desc})
-- **Text column**: `{output_column}` (flattened, reading-order text per row)
-- **Structured column**: `{blocks_column}` (JSON: per-page blocks with bbox / polygon / label / reading_order / confidence / html)
-- **Split**: `{split}`
-- **Samples**: {num_samples:,}
-- **Processed OK**: {n_ok:,} / {num_samples:,}
-- **Processing time**: {processing_time}
-- **Date**: {datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")}
-
-## License note
-
-Surya'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}`: flattened text (OCR), label outline (layout), or table HTML (table)
-- `{blocks_column}`: structured result as a JSON string (one entry per page)
-- `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,
-    task: str = "ocr",
-    table_mode: str = "full",
-    image_column: str = "image",
-    pdf_column: Optional[str] = None,
-    output_column: str = "markdown",
-    blocks_column: str = "surya_blocks",
-    page_range: Optional[str] = None,
-    split: str = "train",
-    max_samples: Optional[int] = None,
-    shuffle: bool = False,
-    seed: int = 42,
-    batch_size: int = 16,
-    max_model_len: int = 18000,
-    gpu_memory_utilization: float = 0.85,
-    dtype: str = "bfloat16",
-    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 model download (repo convention).
-    os.environ["HF_XET_HIGH_PERFORMANCE"] = "1"
-    # Surya reads settings from env at import; pin the checkpoint and forbid any
-    # server autostart (we inject our own offline backend instead).
-    os.environ["SURYA_MODEL_CHECKPOINT"] = model
-    os.environ["SURYA_INFERENCE_AUTOSTART"] = "False"
-
-    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)
-
-    # Import Surya only after env is set.
-    from surya.input.load import load_pdf
-    from surya.settings import settings
-
-    source_column = pdf_column or image_column
-    is_pdf = pdf_column is not None
-    page_indices = parse_page_range(page_range)
-    pdf_dpi = settings.IMAGE_DPI_HIGHRES
-
-    logger.info(
-        f"Model: {model}  Task: {task}"
-        + (f" (mode {table_mode})" if task == "table" else "")
-    )
-    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)
-    if shuffle:
-        dataset = dataset.shuffle(seed=seed)
-    if max_samples:
-        dataset = dataset.select(range(min(max_samples, len(dataset))))
-    n = len(dataset)
-    logger.info(f"Processing {n} documents from column '{source_column}'")
-
-    # Build the offline engine + inject it into a Surya manager, then pick the predictor.
-    backend = OfflineVLLMBackend(
-        model=model,
-        max_model_len=max_model_len,
-        gpu_memory_utilization=gpu_memory_utilization,
-        dtype=dtype,
-    )
-    manager = make_manager(backend)
-
-    if task == "ocr":
-        from surya.recognition import RecognitionPredictor
-
-        predictor = RecognitionPredictor(manager)
-
-        def run(images):
-            return predictor(images, full_page=True)
-    elif task == "layout":
-        from surya.layout import LayoutPredictor
-
-        predictor = LayoutPredictor(manager)
-
-        def run(images):
-            return predictor(images)
-    else:  # table
-        from surya.table_rec import TableRecPredictor
-
-        predictor = TableRecPredictor(manager)
-
-        def run(images):
-            return predictor(images, mode=table_mode)
-
-    texts: List[Optional[str]] = [None] * n
-    blocks: List[Optional[str]] = [None] * n
-    error_flags: List[bool] = [True] * n
-
-    for chunk in tqdm(list(partition_all(batch_size, range(n))), desc=f"Surya {task}"):
-        chunk = list(chunk)
-        flat_images: List[Image.Image] = []
-        spans: List[Tuple[int, int, int]] = []  # (row_idx, start, count)
-        for i in chunk:
-            try:
-                if is_pdf:
-                    imgs = load_pdf_images(
-                        load_pdf, dataset[i][source_column], page_indices, pdf_dpi
-                    )
-                else:
-                    imgs = [cell_to_pil(dataset[i][source_column])]
-            except Exception as e:
-                logger.warning(f"Row {i}: failed to load document: {e}")
-                texts[i] = f"[SURYA LOAD ERROR] {e}"
-                blocks[i] = None
-                continue
-            if not imgs:
-                texts[i] = "[SURYA EMPTY DOCUMENT]"
-                continue
-            spans.append((i, len(flat_images), len(imgs)))
-            flat_images.extend(imgs)
-
-        if not flat_images:
-            continue
-        try:
-            results = run(flat_images)
-        except Exception as e:
-            logger.error(f"Batch generate failed: {e}")
-            for i, _, _ in spans:
-                texts[i] = "[SURYA GENERATE ERROR]"
-                blocks[i] = None
-            continue
-
-        for i, start, count in spans:
-            page_results = results[start : start + count]
-            text, structured = serialize_pages(task, page_results)
-            texts[i] = text
-            blocks[i] = json.dumps(structured, ensure_ascii=False)
-            error_flags[i] = False
-
-    n_ok = sum(not f for f in error_flags)
-    logger.info(f"Processed OK: {n_ok}/{n}")
-
-    dataset = dataset.add_column(output_column, texts)
-    dataset = dataset.add_column(blocks_column, blocks)
-
-    inference_entry = {
-        "model": model,
-        "model_name": "surya-ocr-2",
-        "column_name": output_column,
-        "blocks_column": blocks_column,
-        "task": task,
-        "table_mode": table_mode if task == "table" else None,
-        "backend": "vllm-offline",
-        "page_range": page_range,
-        "error_rate": (n - n_ok) / n if n else 0.0,
-        "timestamp": datetime.now(timezone.utc).isoformat(),
-        "script": "surya-ocr.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])] * n
-        )
-
-    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 Surya OCR 2 {task} results ({n} 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,
-                task=task,
-                table_mode=table_mode,
-                num_samples=n,
-                n_ok=n_ok,
-                source_column=source_column,
-                is_pdf=is_pdf,
-                page_range=page_range,
-                output_column=output_column,
-                blocks_column=blocks_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! Surya OCR 2 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 ---")
-        for pkg in ["surya-ocr", "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__":
-    if len(sys.argv) == 1:
-        print(
-            "Surya OCR 2 — structured OCR / layout / tables from images & PDFs (650M)"
-        )
-        print("\nUsage:")
-        print("  uv run surya-ocr.py INPUT OUTPUT [--task ocr|layout|table] [options]")
-        print("\nExamples:")
-        print("  # full-page OCR -> text + structured surya_blocks")
-        print("  uv run surya-ocr.py my-images my-ocr")
-        print("\n  # layout regions / table structure")
-        print("  uv run surya-ocr.py my-images my-layout --task layout")
-        print("  uv run surya-ocr.py my-tables my-tables-out --task table")
-        print("\n  # multi-page PDFs")
-        print("  uv run surya-ocr.py my-pdfs my-ocr --pdf-column pdf --page-range 0-5")
-        print("\nRun on the vllm/vllm-openai:v0.20.1 image (offline vLLM batch).")
-        print("For full help: uv run surya-ocr.py --help")
-        sys.exit(0)
-
-    parser = argparse.ArgumentParser(
-        description="Surya OCR 2 (650M): structured OCR / layout / tables, offline vLLM batch",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Tasks (--task):
-  ocr     full-page OCR -> reading-order text + per-block HTML/bboxes (default)
-  layout  layout regions -> labelled boxes + reading order
-  table   table structure -> HTML (--table-mode full) or rows/cols/cells (simple)
-
-Output columns:
-  --output-column   flattened text per row (default: markdown)
-  surya_blocks      structured JSON per row (bbox/label/reading_order/confidence/html)
-
-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)
-
-Run on the vllm/vllm-openai:v0.20.1 image:
-  --image vllm/vllm-openai:v0.20.1 --python /usr/local/bin/python3 \\
-    -e PYTHONPATH=/usr/local/lib/python3.12/site-packages
-""",
-    )
-    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(
-        "--task", choices=TASKS, default="ocr", help="Task (default: ocr)"
-    )
-    parser.add_argument(
-        "--table-mode",
-        choices=["full", "simple"],
-        default="full",
-        help="Table task: 'full' = HTML, 'simple' = rows/cols/cells (default: full)",
-    )
-    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="markdown",
-        help="Text output column (default: markdown)",
-    )
-    parser.add_argument(
-        "--blocks-column",
-        default="surya_blocks",
-        help="Structured JSON output column (default: surya_blocks)",
-    )
-    parser.add_argument(
-        "--page-range",
-        default=None,
-        help="Pages 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=16,
-        help="Rows (images) per offline llm.chat batch (default: 16)",
-    )
-    parser.add_argument(
-        "--max-model-len",
-        type=int,
-        default=18000,
-        help="vLLM context length (default: 18000)",
-    )
-    parser.add_argument(
-        "--gpu-memory-utilization",
-        type=float,
-        default=0.85,
-        help="vLLM GPU memory fraction (default: 0.85)",
-    )
-    parser.add_argument(
-        "--dtype",
-        default="bfloat16",
-        help="vLLM dtype (default: bfloat16; use float16 on T4/Turing)",
-    )
-    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 in one repo)",
-    )
-    parser.add_argument(
-        "--create-pr",
-        action="store_true",
-        help="Push as a pull request instead of directly",
-    )
-    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,
-        task=args.task,
-        table_mode=args.table_mode,
-        image_column=args.image_column,
-        pdf_column=args.pdf_column,
-        output_column=args.output_column,
-        blocks_column=args.blocks_column,
-        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_model_len=args.max_model_len,
-        gpu_memory_utilization=args.gpu_memory_utilization,
-        dtype=args.dtype,
-        model=args.model,
-        private=args.private,
-        config=args.config,
-        create_pr=args.create_pr,
-        hf_token=args.hf_token,
-        verbose=args.verbose,
-    )