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
-
----
-
-## 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
-```
+**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
 
-**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
 
@@ -242,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

@@ -7,7 +7,7 @@ tags: [uv-script, ocr, vision-language-model, document-processing, hf-jobs]
 
 > Part of [uv-scripts](https://huggingface.co/uv-scripts) - ready-to-run ML tools powered by UV and HuggingFace Jobs.
 
-20 OCR scripts (text extraction) + 1 layout-detection script. Pick a model, point at your dataset, get markdown — no setup required. Layout-detection runs separately when you need bboxes for regions (text/title/table/figure/...) rather than the text itself.
+14 OCR models from 0.9B to 8B parameters. Pick a model, point at your dataset, get markdown — no setup required.
 
 ## 🚀 Quick Start
 
@@ -33,7 +33,6 @@ That's it! The script will:
 
 | Script | Model | Size | Backend | Notes |
 |--------|-------|------|---------|-------|
-| `falcon-ocr.py` | [Falcon-OCR](https://huggingface.co/tiiuae/Falcon-OCR) | 0.3B | falcon-perception | Smallest 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 |
 | `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) |
@@ -44,34 +43,17 @@ That's it! The script will:
 | `dots-ocr.py` | [DoTS.ocr](https://huggingface.co/Tencent/DoTS.ocr) | 1.7B | vLLM | 100+ languages |
 | `firered-ocr.py` | [FireRed-OCR](https://huggingface.co/FireRedTeam/FireRed-OCR) | 2.1B | vLLM | Qwen3-VL fine-tune, Apache 2.0 |
 | `nanonets-ocr.py` | [Nanonets-OCR-s](https://huggingface.co/nanonets/Nanonets-OCR-s) | 2B | vLLM | LaTeX, tables, forms |
-| `dots-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, requires nightly vLLM |
-| `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 |
 | `olmocr2-vllm.py` | [olmOCR-2-7B](https://huggingface.co/allenai/olmOCR-2-7B-1025-FP8) | 7B | vLLM | 82.4% olmOCR-Bench |
 | `rolm-ocr.py` | [RolmOCR](https://huggingface.co/reducto/RolmOCR) | 7B | vLLM | Qwen2.5-VL based, general-purpose |
 | `numarkdown-ocr.py` | [NuMarkdown-8B](https://huggingface.co/numind/NuMarkdown-8B-Thinking) | 8B | vLLM | Reasoning-based OCR |
 
 </details>
 
-## Layout detection (not OCR)
-
-`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.
-
-| 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. |
-
-```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
-```
-
-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.
-
 ## Common Options
 
 All scripts accept the same core flags. Model-specific defaults (batch size, context length, temperature) are tuned per model based on model card recommendations and can be overridden.
@@ -409,46 +391,7 @@ Advanced reasoning-based OCR using [numind/NuMarkdown-8B-Thinking](https://huggi
 - 🔍 **Multi-column Layouts** - Handles complex document structures
 - ✨ **Thinking Traces** - Optional inclusion of reasoning process with `--include-thinking`
 
-### dots.mocr (`dots-mocr.py`) — SVG generation + SOTA OCR
-
-Advanced multilingual OCR and SVG generation using [rednote-hilab/dots.mocr](https://huggingface.co/rednote-hilab/dots.mocr) with 3B parameters:
-
-- 🌍 **100+ Languages** - Extensive multilingual support
-- 📝 **Document OCR** - Clean text extraction (default mode)
-- 📊 **Layout Analysis** - Structured output with bboxes and categories
-- 📐 **Formula recognition** - LaTeX format support
-- 🖼️ **SVG generation** - Convert charts, UI layouts, figures to editable SVG code
-- 🔀 **8 prompt modes** - OCR, layout-all, layout-only, web-parsing, scene-spotting, grounding-ocr, svg, general
-- 📄 **[Paper](https://arxiv.org/abs/2603.13032)** - 83.9% on olmOCR-Bench
-
-**SVG variant:** Use `--model rednote-hilab/dots.mocr-svg` with `--prompt-mode svg` for best SVG results.
-
-**Quick start:**
-
-```bash
-# Basic OCR
-hf jobs uv run --flavor l4x1 \
-    -s HF_TOKEN \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-mocr.py \
-    your-input-dataset your-output-dataset \
-    --max-samples 100
-
-# 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
-
-# Layout analysis with bounding boxes
-hf jobs uv run --flavor l4x1 \
-    -s HF_TOKEN \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-mocr.py \
-    your-documents layout-output \
-    --prompt-mode layout-all
-```
-
-### DoTS.ocr v1 (`dots-ocr.py`)
+### DoTS.ocr (`dots-ocr.py`)
 
 Compact multilingual OCR using [rednote-hilab/dots.ocr](https://huggingface.co/rednote-hilab/dots.ocr) with only 1.7B parameters:
 
@@ -479,55 +422,6 @@ hf jobs uv run --flavor l4x1 \
     --max-samples 100
 ```
 
-### Qianfan-OCR (`qianfan-ocr.py`) — #1 on OmniDocBench v1.5
-
-End-to-end document intelligence using [baidu/Qianfan-OCR](https://huggingface.co/baidu/Qianfan-OCR) with 4.7B parameters:
-
-- **93.12 on OmniDocBench v1.5** — #1 end-to-end model
-- **79.8 on OlmOCR Bench** — #1 end-to-end model
-- 🧠 **Layout-as-Thought** — Optional reasoning phase for complex layouts (`--think`)
-- 🌍 **192 languages** — Latin, CJK, Arabic, Cyrillic, and more
-- 📝 **OCR mode** — Document parsing to markdown (default)
-- 📊 **Table mode** — HTML table extraction
-- 📐 **Formula mode** — LaTeX recognition
-- 📈 **Chart mode** — Chart understanding and analysis
-- 🔍 **Scene mode** — Scene text extraction
-- 🔑 **KIE mode** — Key information extraction with custom prompts
-
-**Prompt Modes:**
-
-- `ocr`: Document parsing to markdown (default)
-- `table`: Table extraction to HTML
-- `formula`: Formula recognition to LaTeX
-- `chart`: Chart understanding
-- `scene`: Scene text extraction
-- `kie`: Key information extraction (requires `--custom-prompt`)
-
-**Quick start:**
-
-```bash
-# Basic OCR
-hf jobs uv run --flavor l4x1 \
-    -s HF_TOKEN \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/qianfan-ocr.py \
-    your-input-dataset your-output-dataset \
-    --max-samples 100
-
-# Layout-as-Thought for complex documents
-hf jobs uv run --flavor l4x1 \
-    -s HF_TOKEN \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/qianfan-ocr.py \
-    your-input-dataset your-output-dataset \
-    --think --max-samples 50
-
-# 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."
-```
-
 ### 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:

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
@@ -60,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 = {
@@ -84,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": """ """,
 }
 
@@ -129,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")
@@ -172,7 +154,7 @@ def create_dataset_card(
 tags:
 - ocr
 - document-processing
-- dots-mocr
+- dots-ocr-1.5
 - multilingual
 - markdown
 - uv-script
@@ -181,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
 
@@ -204,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
 
@@ -241,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} \\
@@ -264,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,
@@ -283,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()
@@ -334,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,
@@ -355,7 +330,7 @@ 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)
         batch_images = [dataset[i][image_column] for i in batch_indices]
@@ -364,12 +339,8 @@ def main(
             # 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:
@@ -392,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",
@@ -473,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}"
     )
@@ -495,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
         """,
     )
 
@@ -590,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",

falcon-ocr-bucket.py

@@ -1,278 +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) -> list[Path]:
-    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]]:
-    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(
-        "--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
-    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)")
-
-    # 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

@@ -104,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 [
@@ -228,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,
@@ -335,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)
 
@@ -483,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,364 +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
-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()

pp-doclayout.py

@@ -1,1159 +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
-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: Image.Image
-    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]:
-        for i in range(total):
-            row = ds[i]
-            yield SourceItem(
-                key=f"row-{i:08d}",
-                image=to_pil(row[image_column]),
-                extras={},  # original schema is preserved by the sink via the dataset ref
-            )
-
-    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]:
-        for path in all_paths:
-            with fs.open(path, "rb") as f:
-                data = f.read()
-            yield SourceItem(
-                key=key_for(path),
-                image=to_pil(data),
-                extras={"__source_path": key_for(path)},
-            )
-
-    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
-        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())

qianfan-ocr.py

@@ -1,628 +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
-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,
-    )