Sync from GitHub via hub-sync

CLAUDE.md

@@ -1,5 +1,101 @@
 # OCR Scripts - Development Notes
 
+## Large full-page scan fixes (2026-07-01)
+
+A batch of scripts run over a **large**-page historical book-scan corpus (WebP, ~2000–4000px /
+7–9 MP) exposed 5 failures. Root-caused + fixed + verified on Jobs (l4x1, `--max-samples 4–16` on
+that corpus). `deepseek-ocr-vllm.py` / `paddleocr-vl-1.6.py` were unaffected.
+
+> ⚠️ **Gotcha for testing on such corpora:** some eval sets already ship `text`, `markdown`,
+> `docling`, `xml` columns, so **every** default `--output-column` collides — pass a distinct one
+> (e.g. `--output-column ocr_md`) on *all* the markdown-default scripts, not just pp-ocrv6.
+
+- **`surya-ocr.py` — silent per-row `[SURYA GENERATE ERROR]`, log `No module named 'vllm'`.**
+  Working as designed (deps omit `vllm`; needs `--image vllm/vllm-openai:v0.20.1` — see its own section
+  below); the batch run just dropped the image flags. **Fix:** added a `check_vllm_available()` preflight
+  that `sys.exit(1)`s with the exact required flags **before** processing, instead of writing 400 silent
+  sentinels. `--max-model-len` was already 18000. Verified: bare-image run now fails fast.
+- **`dots-ocr.py` — `[OCR ERROR]` on large pages (small pages OK).** No image resize; a 7–9 MP page →
+  up to ~14k image tokens (model's 11.29M-px processor cap) > the old `--max-model-len 8192` → vLLM
+  rejects → sentinel. **Fix:** default `--max-model-len` 8192→**32768** + new optional `--max-pixels`
+  (mm_processor cap). Verified 4/4 real OCR (matches GT; v1 works with the auto-detected `openai` chat
+  format — the dots-1.5 `content_format="string"` fix does **not** apply to v1).
+- **`lighton-ocr2.py` — `[OCR ERROR]` on large pages.** Its 1540px resize is correct, but ~6k image
+  tokens **+ `--max-tokens 4096`** > `--max-model-len 8192` at admission. **Fix:** default
+  `--max-model-len` 8192→**16384**. Verified 4/4 real OCR on l4x1.
+- **`glm-ocr.py` — whole JOB ERROR.** The *current* blocker was **not** OOM: glm pinned
+  `pyarrow>=17.0.0,<18.0.0`, but `datasets>=5.0.0` (which understands this dataset's `Json` feature
+  type) needs `pyarrow>=21`, so uv resolved `datasets 4.0.0` and `load_dataset` threw
+  `ValueError: Feature type 'Json' not found` (this is the 3-second startup ERROR seen in job history;
+  dots/lighton don't pin pyarrow, so they loaded fine). **Fix:** dropped the pyarrow pin. Also added
+  `VLLM_USE_DEEP_GEMM=0` (silences the non-fatal deep_gemm assertion on the nvcc-less nightly image) and
+  an **optional** `--max-pixels` cap. Verified: loads + completes 16/16 large pages, and **did NOT OOM
+  at defaults** (batch 16, no cap) — so `--max-pixels` stays an opt-in memory safety-valve, not a
+  default (the original "30-min OOM" didn't reproduce on 16 pages; it likely needed a specific
+  page/batch deep in a 400-row run). glm is chatty on blank pages / can emit degenerate repeats, but
+  that's model quality, not the crash.
+- **`pp-ocrv6.py` — crash on SAVE: duplicated column `['text']`.** Hardcoded output to `text` with **no**
+  `--output-column` flag; the corpus already has a `text` column. **Fix:** added `--output-column`
+  (default `markdown`, matching siblings) threaded through the sink + card + inference_info, plus a
+  **fast-fail startup guard** (`sys.exit(1)` before inference) if the chosen output column — or
+  `pp_ocr_blocks` — already exists in the input, so it never silently overwrites ground truth. Verified:
+  guard fires on the colliding default; `--output-column ocr_md` pushes cleanly.
+
+### Cross-cutting notes
+- **Output-column collision guard (rolled out to ALL ~31 output-writing scripts, 2026-07-01):**
+  generalises the pp-ocrv6 fix. A shared `ensure_output_columns_free(dataset, columns, overwrite=False)`
+  helper (copied into each standalone script — no shared lib in this repo) fails fast at startup if an
+  output column already exists in the input, instead of silently building a duplicate that crashes on
+  push *after* inference (or clobbering a ground-truth column). New `--overwrite` flag opts in to
+  replacing it. surya guards both `output_column` + `blocks_column`; the sink scripts (pp-ocrv6,
+  pp-doclayout) carry the equivalent guard inline. The 5 scripts that hardcoded `"markdown"`
+  (nanonets-ocr/-ocr2, abot-ocr, deepseek-ocr/-ocr-vllm) also gained a configurable `--output-column`.
+  Static-verified (ruff + AST + wiring) on all; the pattern is Jobs-proven via pp-ocrv6.
+- **Error signalling (#6 — documented, NOT implemented this pass):** ~39 sentinel-string sites
+  (`[OCR ERROR]`, `[SURYA GENERATE ERROR]`, …) across ~20 scripts write the sentinel *into* the OCR
+  column, so partial failures are silent and pollute downstream metrics. **Proposed follow-up:** leave
+  the OCR cell null/empty on failure and record the truncated exception in a companion `ocr_error`
+  column, so "model read nothing" is distinguishable from "the run errored." Deferred — would touch all
+  ~20 standalone scripts (no shared lib).
+- **`--max-model-len` policy:** the durable fix is to **bound the input** (image cap) and size context
+  to that bound + output — what the working `paddleocr-vl-1.6.py` (~1M-px smart resize) and `surya-ocr.py`
+  (max_pixels + 18000) already do. The per-script default bumps above are the minimal version. Don't
+  auto-size `max_model_len` from images (it's fixed at engine init, before images are seen).
+- **Context-length invariant (must hold for every vLLM recipe):**
+  `--max-tokens` ≤ `--max-model-len` ≤ the model's real max context. The real max is the language
+  model's `max_position_embeddings` in `config.json` (VLMs: usually under `text_config`/`language_config`,
+  adjusted by any `rope_scaling`). If `max_model_len` > that, vLLM refuses to start (we don't set
+  `VLLM_ALLOW_LONG_MAX_MODEL_LEN`); if `max_tokens` > `max_model_len`, the output alone can't fit.
+  Quick check: `curl -s https://huggingface.co/<model>/raw/main/config.json | python -c "import json,sys;c=json.load(sys.stdin);t=c.get('text_config',c);print(t.get('max_position_embeddings'),t.get('rope_scaling'))"`.
+  Audited 2026-07-01 across all vLLM recipes: none exceed their window (dots-ocr 32768/131072 ✓,
+  lighton-ocr2 16384/16384 = at cap/zero headroom ✓); fixed `nanonets-ocr.py` (had `max_tokens 15000`
+  > `max_model_len 8192` → raised default to 32768).
+
+### Future: "self-review a new/changed OCR recipe" skill (spark, 2026-07-01)
+A **dev-only skill** (sibling to `bump-vllm-pins`) that reviews an OCR recipe (a given script or the
+current diff / `--all`) against the invariants this repo keeps re-learning, so a new recipe or a bumped
+default is caught **before** it ships. Mostly a **static** check (fast, no compute); each maps to a
+concrete failure we've hit:
+
+1. **Context-length** — `--max-tokens` ≤ `--max-model-len` ≤ model `config.json` `max_position_embeddings`
+   (fetch the config; VLMs → `text_config`, mind `rope_scaling`). Catches vLLM-won't-start and
+   output-can't-fit (found `nanonets-ocr.py`).
+2. **Output-column collision guard** — has `ensure_output_columns_free` (or the inline sink guard) +
+   `--overwrite`, and `--output-column` default isn't a bare hardcoded name that clobbers input.
+3. **vLLM image / preflight** — if the arch isn't in a stable wheel, deps omit `vllm`/`torch` AND there's
+   a fail-fast preflight naming the required `--image`/`--python`/`PYTHONPATH` (surya-class).
+4. **Env guards on the bare image** — `VLLM_USE_FLASHINFER_SAMPLER=0` (and `VLLM_USE_DEEP_GEMM=0` for
+   nightly vLLM) set before importing vllm.
+5. **Dep sanity** — no stale caps that drag a transitive lib back (e.g. `pyarrow<18` → old `datasets`
+   lacking the `Json` feature → `load_dataset` crash, the glm-ocr bug).
+6. **Large-image bounding** — full-page recipes cap input pixels / resize, or size `max_model_len` to fit.
+7. **(optional) Jobs smoke** — only after the static checks pass, run on a tiny hard-input set (the
+   smoke-test dataset **+** a large 7–9 MP page) on l4x1, poll to terminal, and classify any failure
+   into the catalogued buckets (missing-vllm/wrong-image, collision, context-overflow `[OCR ERROR]`,
+   encoder OOM, dep-drift) with remedies.
+
+Pairs with the "OCR Smoke Test Dataset" idea below. Build after the current fixes land.
+
 ## Active Scripts
 
 ### DeepSeek-OCR v1 (`deepseek-ocr-vllm.py`)
@@ -290,7 +386,33 @@ need **+** the h200/`fa3` infra fix (for exact R-SWA quality). Single-image vLLM
 the batch default.
 
 ### Nanonets OCR (`nanonets-ocr.py`, `nanonets-ocr2.py`)
-✅ Both versions working
+✅ `nanonets-ocr.py` working.
+
+**`nanonets-ocr2.py` — ⚠️ requires pinned vLLM image `vllm/vllm-openai:v0.10.2` (fixed 2026-06-30).**
+Nanonets-OCR2-3B is a **Qwen2.5-VL** model. On a floating `vllm` pin (resolved to **0.24.0**) it
+decoded **pure `!` on every page** — the documented vLLM **>=0.11 Qwen2.5-VL regression**
+([vllm#27775](https://github.com/vllm-project/vllm/issues/27775),
+[#14126](https://github.com/vllm-project/vllm/issues/14126); 0.9.2/0.10.1/**0.10.2** are the
+known-good builds). Ruled out along the way: it is **not** context length (still `!` at
+`max_model_len=32768`) and **not** torch.compile (still `!` with `enforce_eager=True`). Pip-pinning
+`vllm==0.10.2` alone fails — its old tokenizer API (`Qwen2Tokenizer.all_special_tokens_extended`)
+clashes with modern `transformers` 5.x. **Fix:** run on the **`vllm/vllm-openai:v0.10.2` image**
+(ships a consistent vLLM 0.10.2 + transformers 4.56.1); `vllm` and `torch` are omitted from the PEP
+723 deps and come from the image via `PYTHONPATH`. Also bumped the `--max-model-len` default
+8192→32768 (the script's `--max-tokens` default is 15000 per the model card, which an 8192 context
+can't hold). Standard `/usr/bin/python3` + `dist-packages` image layout (probed). Re-test the pin
+when a newer vLLM ships a Qwen2.5-VL decode fix → it can move back to the default image.
+
+**Smoke test (2026-06-30, `davanstrien/ufo-ColPali`, 5 samples, a10g-small):** 5/5 clean markdown
+(English + Spanish, `<header>`/`<img>` semantic tags), 0 degenerate rows. Output
+`davanstrien/nanonets-ocr2-img0102-test`.
+
+```bash
+hf jobs uv run --flavor a10g-small -s HF_TOKEN \
+    --image vllm/vllm-openai:v0.10.2 --python /usr/bin/python3 \
+    -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages \
+    ./ocr/nanonets-ocr2.py INPUT_DATASET OUTPUT_DATASET --max-samples 10 --shuffle --seed 42
+```
 
 ### PaddleOCR-VL (`paddleocr-vl.py`)
 ✅ Working

dots-ocr.py

@@ -93,6 +93,28 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def make_ocr_message(
     image: Union[Image.Image, Dict[str, Any], str],
     prompt: str = PROMPT_TEMPLATES["ocr"],
@@ -239,7 +261,8 @@ def main(
     image_column: str = "image",
     batch_size: int = 16,
     model: str = "rednote-hilab/dots.ocr",
-    max_model_len: int = 8192,
+    max_model_len: int = 32768,
+    max_pixels: int = None,
     max_tokens: int = 8192,
     gpu_memory_utilization: float = 0.8,
     hf_token: str = None,
@@ -251,6 +274,7 @@ def main(
     prompt_mode: str = "ocr",
     custom_prompt: str = None,
     output_column: str = "markdown",
+    overwrite: bool = False,
     config: str = None,
     create_pr: bool = False,
 ):
@@ -285,6 +309,9 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -298,13 +325,17 @@ def main(
     # Initialize vLLM model
     logger.info(f"Initializing vLLM with model: {model}")
     logger.info("This may take a few minutes on first run...")
-    llm = LLM(
+    llm_kwargs = dict(
         model=model,
         trust_remote_code=True,
         max_model_len=max_model_len,
         gpu_memory_utilization=gpu_memory_utilization,
         limit_mm_per_prompt={"image": 1},
     )
+    if max_pixels is not None:
+        logger.info(f"Capping input images to max_pixels={max_pixels}")
+        llm_kwargs["mm_processor_kwargs"] = {"max_pixels": max_pixels}
+    llm = LLM(**llm_kwargs)
 
     sampling_params = SamplingParams(
         temperature=0.0,  # Deterministic for OCR
@@ -509,8 +540,23 @@ Examples:
     parser.add_argument(
         "--max-model-len",
         type=int,
-        default=8192,
-        help="Maximum model context length (default: 8192)",
+        default=32768,
+        help=(
+            "Maximum model context length (default: 32768). dots.ocr does NOT resize "
+            "input images, so a full page can reach ~14k image tokens (the model's "
+            "11.29M-px processor cap); the old 8192 default rejected such requests and "
+            "the row was written as '[OCR ERROR]'. Pair with --max-pixels to cap memory."
+        ),
+    )
+    parser.add_argument(
+        "--max-pixels",
+        type=int,
+        default=None,
+        help=(
+            "Optional cap on input image pixels (width*height) passed to vLLM's "
+            "mm_processor. Lower this (e.g. 4000000) to bound image tokens and GPU "
+            "memory on very large scans. Default: model's own cap (~11.29M px)."
+        ),
     )
     parser.add_argument(
         "--max-tokens",
@@ -560,6 +606,12 @@ Examples:
         default="markdown",
         help="Column name for output text (default: markdown)",
     )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--config",
         help="Config/subset name when pushing to Hub (for benchmarking multiple models in one repo)",
@@ -579,6 +631,7 @@ Examples:
         batch_size=args.batch_size,
         model=args.model,
         max_model_len=args.max_model_len,
+        max_pixels=args.max_pixels,
         max_tokens=args.max_tokens,
         gpu_memory_utilization=args.gpu_memory_utilization,
         hf_token=args.hf_token,
@@ -590,6 +643,7 @@ Examples:
         prompt_mode=args.prompt_mode,
         custom_prompt=args.custom_prompt,
         output_column=args.output_column,
+        overwrite=args.overwrite,
         config=args.config,
         create_pr=args.create_pr,
     )

glm-ocr.py

@@ -2,7 +2,6 @@
 # requires-python = ">=3.11"
 # dependencies = [
 #     "datasets>=3.1.0",
-#     "pyarrow>=17.0.0,<18.0.0",
 #     "huggingface-hub",
 #     "pillow",
 #     "vllm",
@@ -53,7 +52,7 @@ import os
 import sys
 import time
 from datetime import datetime
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List, Optional, Union
 
 import torch
 from datasets import load_dataset
@@ -64,6 +63,10 @@ from toolz import partition_all
 # default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
 # lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
 os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
+# Same story for DeepGEMM (nightly vLLM): its init calls _find_cuda_home, which asserts on the
+# nvcc-less base image (a non-fatal warning that clutters the log and hides the real traceback).
+# Greedy OCR doesn't need the DeepGEMM JIT path, so disable it explicitly.
+os.environ.setdefault("VLLM_USE_DEEP_GEMM", "0")
 from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)
@@ -89,9 +92,49 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
+def downscale_to_max_pixels(img: Image.Image, max_pixels: Optional[int]) -> Image.Image:
+    """Shrink an image so width*height <= max_pixels, preserving aspect ratio.
+
+    GLM-OCR does no internal resizing and its card gives no resolution guidance. Capping
+    input pixels bounds both image tokens and vision-encoder memory, a safety valve for very
+    large (multi-MP) scans that can pressure GPU memory at high batch sizes. No-op when
+    max_pixels is None or the image is already small enough (never upscales)."""
+    if not max_pixels:
+        return img
+    w, h = img.size
+    if w * h <= max_pixels:
+        return img
+    scale = (max_pixels / (w * h)) ** 0.5
+    new_size = (max(1, int(w * scale)), max(1, int(h * scale)))
+    return img.resize(new_size, Image.Resampling.LANCZOS)
+
+
 def make_ocr_message(
     image: Union[Image.Image, Dict[str, Any], str],
     task: str = "ocr",
+    max_pixels: Optional[int] = None,
 ) -> List[Dict]:
     """
     Create chat message for OCR processing.
@@ -112,6 +155,9 @@ def make_ocr_message(
     # Convert to RGB
     pil_img = pil_img.convert("RGB")
 
+    # Optionally cap resolution to protect the vision encoder from OOM on huge scans
+    pil_img = downscale_to_max_pixels(pil_img, max_pixels)
+
     # Convert to base64 data URI
     buf = io.BytesIO()
     pil_img.save(buf, format="PNG")
@@ -225,6 +271,7 @@ def main(
     image_column: str = "image",
     batch_size: int = 16,
     max_model_len: int = 8192,
+    max_pixels: Optional[int] = None,
     max_tokens: int = 8192,
     temperature: float = 0.01,
     top_p: float = 0.00001,
@@ -238,6 +285,7 @@ def main(
     shuffle: bool = False,
     seed: int = 42,
     output_column: str = "markdown",
+    overwrite: bool = False,
     verbose: bool = False,
     config: str = None,
     create_pr: bool = False,
@@ -269,6 +317,9 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
         dataset = dataset.shuffle(seed=seed)
@@ -319,7 +370,10 @@ def main(
         )
 
         try:
-            batch_messages = [make_ocr_message(img, task=task) for img in batch_images]
+            batch_messages = [
+                make_ocr_message(img, task=task, max_pixels=max_pixels)
+                for img in batch_images
+            ]
 
             outputs = llm.chat(batch_messages, sampling_params)
 
@@ -509,6 +563,17 @@ Examples:
         default=8192,
         help="Maximum model context length (default: 8192)",
     )
+    parser.add_argument(
+        "--max-pixels",
+        type=int,
+        default=None,
+        help=(
+            "Optional cap on input image pixels (width*height); larger scans are "
+            "downscaled (aspect preserved) before OCR. GLM-OCR does no internal resizing, "
+            "so this bounds vision-encoder memory on very large scans — set e.g. 4000000 "
+            "if you hit a GPU OOM at high batch sizes on a big-page corpus. Default: no cap."
+        ),
+    )
     parser.add_argument(
         "--max-tokens",
         type=int,
@@ -580,6 +645,12 @@ Examples:
         default="markdown",
         help="Column name for output text (default: markdown)",
     )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--verbose",
         action="store_true",
@@ -594,6 +665,7 @@ Examples:
         image_column=args.image_column,
         batch_size=args.batch_size,
         max_model_len=args.max_model_len,
+        max_pixels=args.max_pixels,
         max_tokens=args.max_tokens,
         temperature=args.temperature,
         top_p=args.top_p,
@@ -607,6 +679,7 @@ Examples:
         shuffle=args.shuffle,
         seed=args.seed,
         output_column=args.output_column,
+        overwrite=args.overwrite,
         verbose=args.verbose,
         config=args.config,
         create_pr=args.create_pr,

lighton-ocr2.py

@@ -77,6 +77,28 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def resize_image_to_target(image: Image.Image, target_size: int = 1540) -> Image.Image:
     """
     Resize image so longest dimension is target_size while maintaining aspect ratio.
@@ -286,6 +308,7 @@ def main(
     shuffle: bool = False,
     seed: int = 42,
     output_column: str = "markdown",
+    overwrite: bool = False,
     config: str = None,
     create_pr: bool = False,
     verbose: bool = False,
@@ -315,6 +338,9 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)
+
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
@@ -558,8 +584,12 @@ Examples:
     parser.add_argument(
         "--max-model-len",
         type=int,
-        default=8192,
-        help="Maximum model context length (default: 8192)",
+        default=16384,
+        help=(
+            "Maximum model context length (default: 16384). A full page resized to "
+            "1540px is ~6k image tokens; with --max-tokens 4096 output that overflows "
+            "the old 8192 default at admission and vLLM rejects the request."
+        ),
     )
     parser.add_argument(
         "--max-tokens",
@@ -631,6 +661,12 @@ Examples:
         default="markdown",
         help="Column name for output text (default: markdown)",
     )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--verbose",
         action="store_true",
@@ -658,6 +694,7 @@ Examples:
         shuffle=args.shuffle,
         seed=args.seed,
         output_column=args.output_column,
+        overwrite=args.overwrite,
         config=args.config,
         create_pr=args.create_pr,
         verbose=args.verbose,

pp-ocrv6.py

@@ -69,6 +69,7 @@ import io
 import json
 import logging
 import os
+import sys
 import time
 from dataclasses import dataclass
 from datetime import datetime, timezone
@@ -404,6 +405,8 @@ class DatasetRepoSink:
         create_pr: bool,
         source_id: str,
         original_dataset=None,
+        output_column: str = "markdown",
+        overwrite: bool = False,
     ):
         self.repo_id = repo_id
         self.hf_token = hf_token
@@ -412,6 +415,8 @@ class DatasetRepoSink:
         self.create_pr = create_pr
         self.source_id = source_id
         self.original_dataset = original_dataset
+        self.output_column = output_column
+        self.overwrite = overwrite
         self._texts: List[str] = []
         self._blocks: List[str] = []
 
@@ -438,14 +443,25 @@ class DatasetRepoSink:
                 while len(self._texts) < len(self.original_dataset):
                     self._texts.append("")
                     self._blocks.append("[]")
-            ds = self.original_dataset.add_column("text", self._texts)
+            # Guard again at save time in case the input column set changed under us.
+            base = self.original_dataset
+            clash = [c for c in (self.output_column, "pp_ocr_blocks") if c in base.column_names]
+            if clash:
+                if not self.overwrite:
+                    raise ValueError(
+                        f"Output column(s) {clash} already exist in the input dataset; "
+                        f"pass a different --output-column, or --overwrite to replace them."
+                    )
+                logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+                base = base.remove_columns(clash)
+            ds = base.add_column(self.output_column, self._texts)
             ds = ds.add_column("pp_ocr_blocks", self._blocks)
         else:
             if not self._texts:
                 logger.warning("No rows produced; nothing to push.")
                 return
             ds = Dataset.from_list([
-                {"source_path": None, "text": t, "pp_ocr_blocks": b}
+                {"source_path": None, self.output_column: t, "pp_ocr_blocks": b}
                 for t, b in zip(self._texts, self._blocks)
             ])
 
@@ -511,6 +527,7 @@ class DatasetRepoSink:
                 processing_time=args_dict["processing_time"],
                 engine=args_dict.get("engine", "paddle_static"),
                 output_id=self.repo_id,
+                output_column=self.output_column,
             )
         )
         card.push_to_hub(self.repo_id, token=self.hf_token)
@@ -684,7 +701,7 @@ def build_inference_entry(tier: str, det_model: str, rec_model: str, args_dict:
         "rec_accuracy_pct": TIER_REC.get(tier),
         "languages": TIER_LANGUAGES.get(tier, ""),
         "engine": "paddle_static",
-        "output_column": "text",
+        "output_column": args_dict.get("output_column", "markdown"),
         "blocks_column": "pp_ocr_blocks",
         "timestamp": datetime.now(timezone.utc).isoformat(),
     }
@@ -699,6 +716,7 @@ def create_dataset_card(
     processing_time: str,
     engine: str,
     output_id: str,
+    output_column: str = "markdown",
 ) -> str:
     tier_display = tier.upper() if tier == "tiny" else tier.capitalize()
     if is_bucket_url(source):
@@ -739,7 +757,7 @@ PaddlePaddle's [PP-OCRv6](https://huggingface.co/collections/PaddlePaddle/pp-ocr
 
 Each row contains the original columns plus:
 
-- `text`: Plain text extracted from the image (reading-order concatenation of
+- `{output_column}`: Plain text extracted from the image (reading-order concatenation of
   detected text lines, newline-separated).
 - `pp_ocr_blocks`: JSON list, one dict per detected text line:
   ```json
@@ -766,7 +784,7 @@ import json
 from datasets import load_dataset
 
 ds = load_dataset("{output_id}", split="train")
-print(ds[0]["text"])
+print(ds[0]["{output_column}"])
 for block in json.loads(ds[0]["pp_ocr_blocks"]):
     print(block["text"], block["score"])
 ```
@@ -824,6 +842,27 @@ def main(args: argparse.Namespace) -> None:
             seed=args.seed,
             max_samples=args.max_samples,
         )
+        # Fail fast, before minutes of inference, if the output column would collide
+        # with an existing input column (e.g. a 'text' ground-truth column). Writing
+        # into it would either crash on push or silently overwrite the input data.
+        # --overwrite opts in to replacing the existing column(s) instead of erroring.
+        if original_dataset is not None:
+            clash = [
+                col
+                for col in (args.output_column, "pp_ocr_blocks")
+                if col in original_dataset.column_names
+            ]
+            if clash and not args.overwrite:
+                logger.error(
+                    f"Output column(s) {clash} already exist in the input dataset "
+                    f"(columns: {original_dataset.column_names})."
+                )
+                logger.error(
+                    "Choose a different --output-column, or pass --overwrite to replace them."
+                )
+                sys.exit(1)
+            if clash:
+                logger.warning(f"--overwrite: will replace existing column(s) {clash}")
 
     # ---------- sink ----------
     if is_bucket_url(args.output_target):
@@ -843,6 +882,8 @@ def main(args: argparse.Namespace) -> None:
             create_pr=args.create_pr,
             source_id=args.input_source,
             original_dataset=original_dataset,
+            output_column=args.output_column,
+            overwrite=args.overwrite,
         )
 
     completed = sink.already_done()
@@ -931,6 +972,7 @@ def main(args: argparse.Namespace) -> None:
         "engine": "paddle_static",
         "shard_size": args.shard_size,
         "processing_time": processing_time_str,
+        "output_column": args.output_column,
     }
     sink.finalize(
         tier=tier,
@@ -1015,6 +1057,22 @@ def build_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="Create PR instead of direct push (dataset sink only)",
     )
+    p.add_argument(
+        "--output-column",
+        default="markdown",
+        help=(
+            "Column name for the recognized text (dataset sink only, default: markdown). "
+            "Must not collide with an existing input column — many corpora already ship a "
+            "'text' ground-truth column, so 'text' would fail on push. Blocks always go to "
+            "'pp_ocr_blocks'."
+        ),
+    )
+    p.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column(s) if they already exist in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     # Bucket-sink-specific
     p.add_argument(
         "--shard-size",

surya-ocr.py

@@ -104,6 +104,53 @@ def check_cuda_availability() -> None:
     logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
+def check_vllm_available() -> None:
+    """Fail fast (before loading 400 rows) if vLLM isn't importable.
+
+    Surya-2 runs its VLM through vLLM's offline engine, but `vllm` is deliberately
+    NOT a PEP723 dependency: the recent hybrid `qwen3_5` architecture is only in the
+    pinned `vllm/vllm-openai:v0.20.1` image, which also provides torch/transformers via
+    PYTHONPATH. Launched on the bare uv image (no `--image`), the import fails per-batch
+    and every row silently gets "[SURYA GENERATE ERROR]". Detect that up front instead.
+    """
+    import importlib.util
+
+    if importlib.util.find_spec("vllm") is None:
+        logger.error("vLLM is not importable — this recipe cannot run on the bare uv image.")
+        logger.error(
+            "Surya-2 needs the pinned vLLM build; re-run with the image + interpreter flags:"
+        )
+        logger.error(
+            "  hf jobs uv run --flavor l4x1 -s HF_TOKEN \\\n"
+            "      --image vllm/vllm-openai:v0.20.1 --python /usr/local/bin/python3 \\\n"
+            "      -e PYTHONPATH=/usr/local/lib/python3.12/site-packages \\\n"
+            "      <script_url> INPUT_DATASET OUTPUT_DATASET ..."
+        )
+        sys.exit(1)
+
+
+def ensure_output_columns_free(dataset, columns, overwrite=False):
+    """Fail fast if an output column would collide with an existing input column.
+
+    Adding a column that already exists silently overwrites it (e.g. a ground-truth
+    `text`/`markdown` column) or crashes on push with a duplicate-column error only
+    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
+    column(s) here instead (logged) so the later add_column is clean.
+    """
+    clash = [c for c in columns if c in dataset.column_names]
+    if not clash:
+        return dataset
+    if overwrite:
+        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
+        return dataset.remove_columns(clash)
+    logger.error(
+        f"Output column(s) {clash} already exist in the input dataset "
+        f"(columns: {dataset.column_names})."
+    )
+    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
+    sys.exit(1)
+
+
 def parse_page_range(spec: Optional[str]) -> Optional[List[int]]:
     """Turn '0-3,5' into [0,1,2,3,5]. None/empty -> None (all pages)."""
     if not spec:
@@ -444,6 +491,7 @@ def main(
     image_column: str = "image",
     pdf_column: Optional[str] = None,
     output_column: str = "markdown",
+    overwrite: bool = False,
     blocks_column: str = "surya_blocks",
     page_range: Optional[str] = None,
     split: str = "train",
@@ -469,6 +517,7 @@ def main(
     os.environ["SURYA_INFERENCE_AUTOSTART"] = "False"
 
     check_cuda_availability()
+    check_vllm_available()
     start_time = datetime.now(timezone.utc)
 
     HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
@@ -495,6 +544,10 @@ def main(
             f"Column '{source_column}' not found. Available: {dataset.column_names}"
         )
         sys.exit(1)
+    # Fail fast if the output column would collide with an existing input column
+    dataset = ensure_output_columns_free(
+        dataset, [output_column, blocks_column], overwrite=overwrite
+    )
     if shuffle:
         dataset = dataset.shuffle(seed=seed)
     if max_samples:
@@ -755,6 +808,12 @@ Run on the vllm/vllm-openai:v0.20.1 image:
         default="markdown",
         help="Text output column (default: markdown)",
     )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace the output column if it already exists in the input dataset "
+        "(default: error out to avoid clobbering an existing column).",
+    )
     parser.add_argument(
         "--blocks-column",
         default="surya_blocks",
@@ -836,6 +895,7 @@ Run on the vllm/vllm-openai:v0.20.1 image:
         image_column=args.image_column,
         pdf_column=args.pdf_column,
         output_column=args.output_column,
+        overwrite=args.overwrite,
         blocks_column=args.blocks_column,
         page_range=args.page_range,
         split=args.split,