Sync from GitHub via hub-sync

CLAUDE.md

@@ -96,6 +96,7 @@ Legend: ✅ production-ready · ⚠️ works only with a required pinned image
 | `unlimited-ocr2.py` | ✅+image | SGLang (Baidu wheel) on `lmsysorg/sglang:v0.5.20-cu130` | rtx-pro-6000 | 16-page windows; ≥48 GB GPU |
 | `unlimited-ocr2-saturate.py` | 🧪+image | same | rtx-pro-6000 | tuned/experimental: repair pass, JP2 fast decode, PDFs |
 | `unlimited-ocr2-live.py` | 🧪+image | same | rtx-pro-6000 | experimental: minimal script + `--live-port` dashboard (streams the page being read) |
+| `hpd-parsing-saturate.py` | 🧪+image | saturate + Paddle's vLLM fork on `cr.hf.co/davanstrien/hpd-parsing-vllm` (vendor image + uv) | l4x1 | `markdown` + `hpd_blocks` + `looped_blocks` — see gotcha |
 | `minicpm-ocr.py` | 🧪+image | in-job vLLM nightly + minicpm-ocr SDK on `cr.hf.co/davanstrien/minicpm-ocr` | a10g-large | vendor pipeline; custom public image; dataset **or** bucket I/O (bucketbag), `markdown_status` |
 | `surya-ocr.py` | ✅+image | vLLM `:v0.20.1` | l4x1 | offline backend inject; site-packages PYTHONPATH |
 | `surya-ocr-bucket.py` | ✅+image | vLLM `:v0.20.1` | l4x1 | bucket I/O; pin `surya-ocr==0.20.0` |
@@ -191,6 +192,48 @@ require) against `vllm serve` started in the job. Measured/learned 2026-10-27:
 - vLLM runs in its own process group and is terminated → killed → reaped on every exit path; one bad
   image or a failed SDK run marks its pages `error: ...` instead of losing finished batches.
 
+### `hpd-parsing-saturate.py` — Paddle's vLLM fork, on their image plus uv
+`PaddlePaddle/HPD-Parsing` (1B, InternVL3.5 + Qwen3-0.6B) runs only on Paddle's **fork of vLLM**
+(`0.17.1+hpdparsing`), which adds the request forking its decoding needs. The fork ships only in
+`ccr-2vdh3abv-pub.cnc.bj.baidubce.com/paddlepaddle/hpd-parsing-vllm` (tags `latest-nvidia-gpu`, and
+`-offline` with weights baked in). It pulls anonymously; the recipe pins `latest-nvidia-gpu` by digest
+(`87496aa5…`, built 2026-07-16, unchanged as of 2026-11-05). ~11 GB. Job scheduling time (queue + pull) on
+5 Nov: 7–27 min from Paddle's registry, 2.5 min for the same image from `cr.hf.co`.
+Inside: CUDA 12.8.1, python3.10 venv at `/home/hpd/venv` first on `PATH`, user `hpd`, FlashInfer.
+Measured 2026-07-27 and 2026-11-05:
+1. **No `uv` in Paddle's image**, which `hf jobs uv run` needs. The header uses
+   `cr.hf.co/davanstrien/hpd-parsing-vllm`: Paddle's image (digest-pinned) plus one layer with `uv`/`uvx`
+   (`images/hpd-parsing/build.sh`, `crane append` on a CPU Job, ~7 min; public). To rebuild after a Paddle
+   update, change `BASE_DIGEST` in `build.sh`. The docstring keeps a `hf jobs run … bash -lc 'pip install uv
+   && uv run …'` command for Paddle's image directly.
+2. `requires-python` includes 3.10 so uv uses the image's own Python instead of downloading one.
+3. **Speculative head path:** the entrypoint's `"model": "PaddlePaddle/HPD-Parsing/P-MTP"` is a local
+   directory in the `-offline` image only. The recipe downloads the `P-MTP/*` subfolder and passes its
+   path. Expected log line, every run: `Error retrieving safetensors: Repo id must be in the form …`.
+4. **`--enable-prefix-caching` stays ON** (forked children share the parent's prefix KV; 43.9–52.9% hit
+   rate). `--attention-config '{"use_prefill_query_quantization":true}'` is fork-only. Both come from
+   `/home/hpd/entrypoint.sh`. Works on `a100-large` (sm80) as well as `l4x1`.
+5. **Bboxes are 0–1000 normalized**, not pixels (`px = v/1000 * width`), verified by overlay in July.
+   The parser is the demo Space's bbox-preserving `parse_blocks`; the model repo's `eval/hpd_to_markdown.py`
+   drops chart/seal blocks and bboxes. Re-parsing July's `hpd_raw` reproduced July's markdown on 34/34 pages.
+6. saturate's readiness probe logs `The model 'readiness-probe' does not exist` (404) once; that is the
+   "server is alive" signal, not an error.
+
+**Limits seen in testing: loops, and `max_tokens` does not bound a page.** Each forked child branch has
+its own `max_tokens` budget, so a page that fragments into hundreds of regions can emit far more than the
+cap (179k completion tokens for one page at `max_tokens` 8000). On 12 Chronicling America pages
+(1774–1809), 3 pages looped: 726,706 chars (July) / 544,120 (November) vs 24,907 in LoC's OCR on the
+worst. Those 3 ended with `finish_reason=length`, the other 9 with `stop`, and `looped_blocks` > 0 on
+exactly the same 3. One UFO page had a 26,675-char loop. `looped_blocks` counts blocks
+of ≥2000 bytes whose zlib ratio is ≥4 (≥10 for `table`): ordinary text compresses ~2×, loops 6–330×
+(a counting loop "of the 860th of the 861th …" is the 6× case), the most compressible real block was a
+1.5 KB table at 5.3×. Calibrated on 345 blocks from the July outputs: 0 false positives. The text is
+kept as the model wrote it; filter rows on `looped_blocks == 0`. Accuracy (94.91 OmniDocBench v1.6) is
+below `ovis-ocr2`/`paddleocr-vl-1.6`; the recipe earns its place with the layout column. en/zh only.
+
+`hpd-parsing-server.py` (PR #95, July) is the hand-rolled driver for the same server; this recipe
+replaces it.
+
 ### `unlimited-ocr2.py` / `unlimited-ocr2-saturate.py` — Baidu SGLang wheel, multi-page windows
 v2 has no vLLM support; Baidu ships a custom SGLang wheel in the model repo. Its pins (torch 2.13.0,
 transformers 5.12.1, flashinfer 0.6.18 cu13) match **`lmsysorg/sglang:v0.5.20`** exactly → `-cu130` image,
@@ -344,6 +387,15 @@ ARM wheels) — if a nightly-recipe install fails on resolution, wait and retry
 
 ## Change log
 
+- **2026-11-05** — added `hpd-parsing-saturate.py` (experimental) for `PaddlePaddle/HPD-Parsing` (1B,
+  Apache-2.0): the July server recipe's serve command and block parser, driven by saturate `==0.3.0`
+  (`Engine(cmd=…)` for the vendor fork), plus a `looped_blocks` flag. Header image
+  `cr.hf.co/davanstrien/hpd-parsing-vllm` = Paddle's image (pinned by digest) + uv (`images/hpd-parsing/`). Smoke-tested on HF Jobs: `a100-large`, 10 UFO pages, 10/10, 0
+  error rows, 12 s pump time; `l4x1`, 12 Chronicling America pages in two runs to one repo (5, then 12:
+  the second run skipped the 5 done rows), 12/12, 0 error rows; 9 clean pages within 1–5% of LoC's OCR
+  length, 3 looping pages flagged. Header defaults on the public image (`l4x1`, published-path
+  equivalent: local script, no flags but `--max-samples 5`): 5/5, 0 error rows, 153 s scheduling incl. pull.
+
 - **2026-11-02** — `xiaomi-ocr-0-saturate.py` moved to `core`. NASA demo: 7/7 in 31 s; checked pages read well, but a table lost one item and some cells lost separators. 16 multilingual historical newspaper pages: 16/16 with no error rows, but repetition loops on 2 small-print German Fraktur pages (lines about 10–13 px after the 2048 px fit), a partial loop on a third, and Chinese characters inserted on 3 pages. `finish_reason` stayed `stop` on all of them.
 - **2026-10-30** — added `xiaomi-ocr-0-saturate.py` for `xiaomi-research/Xiaomi-OCR-0` (0.8B, Qwen3.5 arch), on
   saturate `==0.3.0`. Do not set `max_limit` by copying older saturate recipes: on `rtx-pro-6000`, `Auto(max_limit=48)`

LANGUAGES.md

@@ -21,6 +21,7 @@ _Sorted by strength of evidence, then coverage:_
 | [PaddleOCR-VL](https://huggingface.co/PaddlePaddle/PaddleOCR-VL) / [1.5](https://huggingface.co/PaddlePaddle/PaddleOCR-VL-1.5) / [1.6](https://huggingface.co/PaddlePaddle/PaddleOCR-VL-1.6) | 109 languages; 1.5 adds Tibetan + Bengali | Names scripts (Cyrillic, Arabic, Devanagari, Thai) and claims handwriting + historical documents; no per-language numbers |
 | [PP-OCRv6](https://huggingface.co/collections/PaddlePaddle/pp-ocrv6) | 48 languages | Official card claim |
 | [MiniCPM-OCR 1.0](https://huggingface.co/openbmb/MiniCPM-OCR-1.0) | Chinese and English ("primary languages") | Card names two; no per-language numbers. Examples include historical scans |
+| [HPD-Parsing](https://huggingface.co/PaddlePaddle/HPD-Parsing) | 2 (en, zh) | Card metadata only. On degraded French scans our smoke runs (July and November 2026) produced stray Chinese characters mid-word, so treat languages other than en/zh as unsupported |
 | [Nanonets-OCR2-3B](https://huggingface.co/nanonets/Nanonets-OCR2-3B) | 11 named + "many more" (incl. Arabic + CJK) | Illustrative list, no benchmark — but the only card claiming multilingual **handwriting** |
 | [LightOnOCR-2-1B](https://huggingface.co/lightonai/LightOnOCR-2-1B) | 11 (9 European + zh/ja) | Declared, not benchmarked. [v1](https://huggingface.co/lightonai/LightOnOCR-1B-1025) is explicitly European/Latin-script only (9) |
 | [GLM-OCR](https://huggingface.co/zai-org/GLM-OCR) | 8 (zh en fr es ru de ja ko) | Declared in card metadata only; no per-language evidence in the card body |

README.md

@@ -219,6 +219,15 @@ hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/pp-doclay
     your-dataset your-layout-output --max-samples 10
 ```
 
+**[HPD-Parsing](https://huggingface.co/PaddlePaddle/HPD-Parsing)** (`hpd-parsing-saturate.py`, 1B, Apache-2.0, experimental) reads text and layout in one pass. Next to the `markdown` it writes an `hpd_blocks` column with a type, a box and the text for each block, in reading order. The boxes are on a 0–1000 scale, not pixels. The model needs Paddle's own vLLM build; the script header picks an image with it ([`images/hpd-parsing/`](images/hpd-parsing/)).
+
+```bash
+hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/hpd-parsing-saturate.py \
+    your-dataset your-output --max-samples 5
+```
+
+The image is about 11 GB, so a cold start takes several minutes. On dense pages with hundreds of blocks the model can repeat itself inside many blocks at once. The `looped_blocks` column counts those blocks; keep rows where it is 0. The model card lists English and Chinese only.
+
 ## Scaling up
 
 **Large datasets:** `lighton-ocr2-saturate.py`, `ovis-ocr2-saturate.py` and `xiaomi-ocr-0-saturate.py` start a vLLM server in the Job (the Xiaomi recipe can use SGLang instead) and send pages to it with adaptive concurrency. They stream results to the output repo as parquet parts. If a run stops, run the same command again and it skips the rows that are done. A failed page is stored as an error row, and `--retry-errors` tries those rows again. The output layout is different from the other recipes; the script header explains how to read it. [SERVING.md](SERVING.md) compares server mode with offline batches (measured throughput and output parity).

SERVING.md

@@ -50,6 +50,12 @@ recipe, LightOn's card, Paddle's vLLM recipe, Unlimited-OCR's recipe):
 
 OCR workloads never reuse images, so prefix/multimodal caches only cost memory.
 
+**One exception: HPD-Parsing** (`hpd-parsing-saturate.py`). Its vendor entrypoint sets
+`--enable-prefix-caching` on purpose. Hierarchical parallel decoding forks a child branch per
+page region, and the children reuse the parent branch's prefix KV, so the cache does real work
+(hit rate 52.9% on 5 UFO pages in July 2026, 43.9% on 10 in November). Do not change it to
+`--no-enable-prefix-caching` in a sweep.
+
 ## Version pins carry over — via the image tag
 
 Where an offline recipe pins an engine version, the server variant needs the same pin

hpd-parsing-saturate.py

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

images/hpd-parsing/README.md

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

images/hpd-parsing/build.sh

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

models.json

@@ -1,7 +1,7 @@
 {
   "_meta": {
     "description": "Machine-readable catalog of the OCR recipes in this directory: script -> model, params, backend, support level, the tested Jobs launch config (the script's [tool.hf-jobs] header), and what the model's own card claims about language coverage. Human-readable language notes: LANGUAGES.md. Language evidence levels, strongest first: per-language-benchmark | count-claim | named-list | multilingual-unspecified | english-only | not-stated | not-applicable. Claims come from model cards (compiled 2026-07-15) - treat as claims, not guarantees.",
-    "updated": "2026-11-03",
+    "updated": "2026-11-05",
     "run_pattern": "hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/<script> <input-dataset> <output-dataset>  (hf CLI >= 1.32 reads image/flavor/secrets from the script's [tool.hf-jobs] header; add --timeout for long runs. Scripts without a `jobs` entry need --flavor/-s HF_TOKEN (and any --image in their docstring).)",
     "support_levels": {
       "core": "Maintained. Smoke-tested flagless on HF Jobs on 2026-09-23/24 with the pinned launch config in `jobs`.",
@@ -1058,5 +1058,34 @@
       ]
     },
     "image": "vllm/vllm-openai:v0.29.0"
+  },
+  "hpd-parsing-saturate.py": {
+    "model_id": "PaddlePaddle/HPD-Parsing",
+    "params": "1B",
+    "backend": "saturate (in-job vllm serve from Paddle's vLLM fork 0.17.1+hpdparsing: request forking + P-MTP speculative decoding)",
+    "image": "cr.hf.co/davanstrien/hpd-parsing-vllm:87496aa5-uv0.13.6",
+    "task": "ocr | layout",
+    "output": "markdown + hpd_blocks (per-block type, bbox, text; bbox 0-1000 NORMALIZED, not pixels) + raw + looped_blocks",
+    "license": "apache-2.0",
+    "notes": "Runs only on Paddle's vLLM fork, shipped in their registry image. The header image is that image (latest-nvidia-gpu, pinned by digest 87496aa5) plus uv, built by images/hpd-parsing/build.sh; the docstring also gives the command for Paddle's image directly. Serve command = the image's own entrypoint, except the P-MTP speculative head path (downloaded locally) and a --revision pin. Keeps --enable-prefix-caching ON: forked children share the parent's prefix KV. max_tokens bounds one decoding branch, not the page, so dense pages can loop in many branches; looped_blocks flags them. 94.91 OmniDocBench v1.6; accuracy below ovis-ocr2 and paddleocr-vl-1.6. ~11 GB image pull on a cold node.",
+    "languages": {
+      "evidence": "named-list",
+      "count": 2,
+      "named": [
+        "en",
+        "zh"
+      ],
+      "notes": "Card metadata lists en + zh only; no per-language numbers. Smoke runs on degraded French scans produced stray Chinese characters - treat other languages as unsupported."
+    },
+    "support": "experimental",
+    "support_note": "Dense pages loop: filter on looped_blocks == 0. Check a sample of your own pages.",
+    "jobs": {
+      "image": "cr.hf.co/davanstrien/hpd-parsing-vllm:87496aa5-uv0.13.6",
+      "flavor": "l4x1",
+      "timeout": "2h",
+      "secrets": [
+        "HF_TOKEN"
+      ]
+    }
   }
 }