Sync from davanstrien/uv-scripts via hub-sync

CLAUDE.md

@@ -88,6 +88,7 @@ Legend: ✅ production-ready · ⚠️ works only with a required pinned image
 | `lighton-ocr2.py` | ✅ | vLLM | a100-large / l4x1 | resize 1540px; `--max-model-len` 16384 |
 | `lighton-ocr3-bucket.py` | ✅ | vLLM `:v0.30.0` | a10g-small | `hf://buckets/...` or dir → `.md` (+ `.json` blocks in grounding); bucket I/O via `bucketbag` v0.3.1 (no mount); `.jp2` via imagecodecs; resume-by-skip; failed pages write nothing |
 | `lighton-ocr3.py` | ✅ | vLLM `:v0.30.0` | a10g-small | 4B/0.8B Qwen3.5; resize 2048px; `--mode grounding` → `layout_blocks`; pinned upstream `lightonocr` client dep — see gotcha |
+| `lighton-ocr3-live.py` | 🧪 | saturate + vLLM `:v0.30.0` | rtx-pro-6000 | experimental: `lighton-ocr3-saturate.py` + `--live-port` page (finished pages at the run's pace; `?view=single`) |
 | `paddleocr-vl-1.5.py` | ✅ | transformers | l4x1 | not vLLM (server-only upstream); single-image |
 | `paddleocr-vl-1.6.py` | ✅ | vLLM | l4x1 | smart-resize ~1M px; SOTA OmniDocBench |
 | `paddleocr-vl.py` | ✅ | vLLM | l4x1 | |

lighton-ocr3-live.py

@@ -0,0 +1,785 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "saturate[hf]==0.3.1",
+#     "pillow>=10",
+#     # LightOn's official client, pinned to a commit (not on PyPI). Used for its page
+#     # resize, grounding parser and dollar-delimiter repair so outputs match upstream.
+#     "lightonocr @ https://github.com/lightonai/LightOnOCR/archive/36755d461be079737860a5f03ae0c803501269e9.tar.gz",
+# ]
+#
+# [tool.hf-jobs]
+# image = "vllm/vllm-openai:v0.30.0"
+# flavor = "rtx-pro-6000"
+# timeout = "4h"
+# secrets = ["HF_TOKEN"]
+# ///
+"""
+EXPERIMENTAL: lighton-ocr3-saturate.py with a live view you can watch (and screen-record) while the Job runs.
+
+Same OCR, flags and output as lighton-ocr3-saturate.py; use that script for normal runs and
+read its description for the model settings, the measured speeds and the repair pass. This
+one adds `--live-port`: a page served from inside the Job that shows every finished page
+moving past at the speed the model reads them, the pages read a second, and the text the
+model wrote for one of them.
+
+  hf jobs uv run --detach --expose-public 7860 \\
+      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr3-live.py \\
+      <input-dataset> <output-dataset> --live-port 7860
+
+The Job log prints the link: https://<job id>--7860.hf.jobs (public while the Job runs).
+The header picks rtx-pro-6000, the fastest flavor per dollar in lighton-ocr3-saturate.py's
+table (about 10 pages per second with the 0.8B); add --flavor a10g-small for a small run.
+
+What the page shows, and how it is paced:
+- Each tile on the belt is one finished page. A page is shown only after its text came
+  back, and the belt moves at the rate the pages finish, so its speed is the throughput.
+  The page draws a finished page about 1.5 seconds after the model returned it.
+- "Pages a second" is the number of pages finished in the last 10 seconds, divided by 10.
+  It covers reading only, not the server start (about 4 minutes). After the run it is the
+  average over the whole reading time.
+- The text under the belt is one recent finished page's text, changed every few seconds.
+  It is a sample: at several pages a second most pages are never shown with their text.
+- Add ?view=single to the link for one page at a time: each finished page is laid on the
+  last at the same pace, with that page's text beside it.
+- The live view costs a 480 px JPEG per page in the preparation threads and one small
+  request per open tab every half second. It never changes what is sent or written.
+- The page shows the main pass. Pages re-sent by --repair-max-tokens are not shown again.
+- The Job, and with it the page, ends 20 seconds after the run. An open tab keeps the
+  final numbers on screen.
+
+The SERVING dict below is the per-model tuning prior, as in lighton-ocr3-saturate.py.
+"""
+
+import argparse
+import base64
+import collections
+import hashlib
+import io
+import json
+import os
+import shlex
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+# Serving starting values for LightOnOCR-3 (0.8B and 4B). Per-value provenance:
+# - image: vLLM 0.30.0, the version LightOn's client pins and tests (0.27.1 makes the
+#   models loop, per the LightOnOCR README).
+# - context 18000 and serve_args: the LightOnOCR README "Models" table for the 0.8B and 4B,
+#   plus its `--limit-mm-per-prompt '{"image": 1}'`.
+# - max_tokens/temperature/top_p: the model card's vLLM example, verbatim.
+# - longest_edge 2048: the card's rendering tip and the client's page size for these models.
+# - patch 32: 16 px patches with a 2x2 merge, so a 2048x2048 page is at most 64x64 = 4,096
+#   image tokens (used for the context check).
+# - --max-num-batched-tokens 16384: speed only. vLLM 0.30 serves with 2048 on A10G, L4 and
+#   A100 (8192 on other GPUs of 70 GB or more), less than one page's image tokens. Measured on a100-large:
+#   6.20 and 6.30 pages/s against 5.83 without it, outputs within the run-to-run noise.
+# - pages_per_gib: see window_cap().
+# - api_servers 4 when CPU_CORES >= 12: speed only. With one vLLM API server, a100-large and
+#   rtx-pro-6000 had 128-256 pages in flight but only 36-60 running in the engine and none
+#   waiting: the rest queued for image preprocessing in the API process. Measured, 4 API
+#   servers against one: a100-large 7.29 and 7.18 against 6.20 and 6.30 pages/s,
+#   rtx-pro-6000 10.0 against 9.15, a10g-large 2.74 against 2.49; outputs within the
+#   run-to-run noise. Small flavors (a10g-small 3 cores, l4x1 8) keep one, to leave CPU
+#   for page preparation.
+SERVING = {
+    "models": ["lightonai/LightOnOCR-3-0.8B", "lightonai/LightOnOCR-3-4B"],
+    "image": "vllm/vllm-openai:v0.30.0",
+    "context": 18000,
+    "serve_args": [
+        "--default-chat-template-kwargs", '{"enable_thinking": false}',
+        "--limit-mm-per-prompt", '{"image": 1}',
+        "--mm-processor-cache-gb", "0",
+        "--no-enable-prefix-caching",
+        "--max-num-batched-tokens", "16384",
+    ],
+    "pages_per_gib": 6,
+    "api_servers": 4,
+    "api_servers_min_cores": 12,
+    "max_tokens": 4096,
+    "temperature": 0.2,
+    "top_p": 0.9,
+    "repair_temperature": 0.1,
+    "longest_edge": 2048,
+    "patch": 32,
+}
+
+
+def window_cap() -> int:
+    """Most pages in flight that this machine's memory allows.
+
+    Every page in flight holds about 0.1 GiB of image data on the host (the client's copy and
+    the server's preprocessed image), on top of 7 to 9 GiB for the engine itself. On
+    a10g-small (14.9 GiB limit), 64 pages in flight reached the limit and the Job stopped
+    making progress; 32 peaked at 12.0 GiB, and up to 39 peaked at 13.0 and 14.8 GiB on two
+    runs. So the window may grow by SERVING "pages_per_gib" pages per GiB above 10 GiB: 29 on
+    a10g-small (which is GPU-bound from about 20 pages in flight), about 100 on l4x1, the full
+    512 on a100-large. The limit is read from the container (cgroup v2), then from the MEMORY
+    variable that HF Jobs sets.
+    """
+    limit_gib = None
+    try:
+        with open("/sys/fs/cgroup/memory.max") as handle:
+            value = handle.read().strip()
+        if value != "max":
+            limit_gib = int(value) / 2**30
+    except (OSError, ValueError):
+        pass
+    if limit_gib is None and os.environ.get("MEMORY"):
+        try:  # e.g. "16.0G" (decimal gigabytes)
+            limit_gib = float(os.environ["MEMORY"].upper().rstrip("GIB ")) * 1e9 / 2**30
+        except ValueError:
+            pass
+    if limit_gib is None:
+        return 512
+    return max(8, min(512, int((limit_gib - 10) * SERVING["pages_per_gib"])))
+
+
+def flag_value(tokens: list[str], name: str):
+    """Last value given for `name` in a `vllm serve` argument list (`--x v` or `--x=v`), else None."""
+    value = None
+    for index, token in enumerate(tokens):
+        if token == name and index + 1 < len(tokens):
+            value = tokens[index + 1]
+        elif token.startswith(name + "="):
+            value = token.split("=", 1)[1]
+    return value
+
+
+def saved_truncations(output_dataset: str) -> set:
+    """Ids whose saved result in data/ stopped at max_tokens and that have no saved repair.
+
+    A restarted run skips rows already in data/, so without this the pages truncated
+    before the restart would never reach the repair pass. Reads only three columns.
+    """
+    import fsspec
+    import pyarrow.parquet as pq
+
+    def records(subdir, columns):
+        fs, root = fsspec.core.url_to_fs(f"hf://datasets/{output_dataset}/{subdir}")
+        if not fs.exists(root):
+            return
+        for path in fs.glob(f"{root}/part-*.parquet"):
+            with fs.open(path, "rb") as handle:
+                yield from pq.read_table(handle, columns=columns).to_pylist()
+
+    finish = {}
+    for record in records("data", ["id", "error", "finish_reason"]):
+        if record["error"] is None:
+            finish[record["id"]] = record["finish_reason"]
+    repaired = {r["id"] for r in records("repair", ["id", "error"]) if r["error"] is None}
+    return {row_id for row_id, reason in finish.items() if reason == "length" and row_id not in repaired}
+
+
+def max_image_tokens(longest_edge: int) -> int:
+    """Upper bound on the image tokens of a page fitted to longest_edge (square page)."""
+    side = -(-longest_edge // SERVING["patch"])
+    return side * side
+
+
+def to_pil(value):
+    from PIL import Image
+
+    if isinstance(value, Image.Image):
+        return value
+    if isinstance(value, dict) and value.get("bytes"):
+        return Image.open(io.BytesIO(value["bytes"]))
+    if isinstance(value, dict) and value.get("path"):
+        return Image.open(value["path"])
+    if isinstance(value, (bytes, bytearray)):
+        return Image.open(io.BytesIO(value))
+    raise ValueError(f"unsupported image value: {type(value)}")
+
+
+def page_png(value, longest_edge: int) -> bytes:
+    """RGB page fitted to longest_edge with LightOn's resize, as PNG bytes.
+
+    compress_level=1 instead of Pillow's default 6: PNG is lossless at every level, so the
+    pixels are identical, and level 1 encodes several times faster (CPU is the limit on
+    small flavors).
+    """
+    return png_bytes(fitted_page(value, longest_edge))
+
+
+def fitted_page(value, longest_edge: int):
+    """RGB page fitted to longest_edge with LightOn's resize."""
+    from lightonocr import fit
+
+    return fit(to_pil(value).convert("RGB"), longest_edge)
+
+
+def png_bytes(image) -> bytes:
+    buffer = io.BytesIO()
+    image.save(buffer, format="PNG", compress_level=1)
+    return buffer.getvalue()
+
+
+def chat_request(model: str, png: bytes, mode: str, max_tokens: int, temperature: float, top_p: float) -> dict:
+    """One page as the client sends it: the image, plus the word "grounding" in grounding mode."""
+    from lightonocr import GROUNDING_PROMPT
+
+    url = "data:image/png;base64," + base64.b64encode(png).decode()
+    content = [{"type": "image_url", "image_url": {"url": url}}]
+    if mode == "grounding":
+        content.append({"type": "text", "text": GROUNDING_PROMPT})
+    return {
+        "model": model,
+        "messages": [{"role": "user", "content": content}],
+        "max_tokens": max_tokens,
+        "temperature": temperature,
+        "top_p": top_p,
+        "chat_template_kwargs": {"enable_thinking": False},
+    }
+
+
+def postprocess(raw: str, mode: str, fix_dollars: bool):
+    """Return (markdown, layout_blocks JSON or None) for one model output, as lighton-ocr3.py."""
+    from lightonocr import fix_escaped_dollars, parse_blocks, to_markdown
+
+    text = fix_escaped_dollars(raw) if fix_dollars else raw
+    if mode != "grounding":
+        return text, None
+    blocks = parse_blocks(text)
+    if not blocks:
+        return text, json.dumps([])  # no markers parsed: keep the text so nothing is lost
+    return to_markdown(blocks), json.dumps([b.to_dict() for b in blocks], ensure_ascii=False)
+
+
+def count_pages(dataset: str, config, split: str, limit):
+    """Number of rows the run will read, from the dataset's metadata (None if it does not say)."""
+    try:
+        from datasets import load_dataset_builder
+
+        total = load_dataset_builder(dataset, name=config).info.splits[split].num_examples
+    except Exception as e:  # noqa: BLE001 - the count is only shown; the run must not depend on it
+        print(f"Live view: page count unknown ({type(e).__name__})", file=sys.stderr)
+        return limit
+    return min(total, limit) if limit else total
+
+
+LIVE_PAGE = """<!doctype html><meta charset="utf-8"><title>LightOnOCR-3 live</title>
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<style>
+/* A copy stand: a neutral ground, and the paper is the only colour on it. */
+:root{--ground:#2b2f34;--ink:#f4f2ed;--quiet:#a4aab1;--rule:rgba(244,242,237,.22);--paper:#fbfaf7;
+ --lift:0 0 0 1px rgba(0,0,0,.10),0 .7vmin 2vmin rgba(0,0,0,.34)}
+@media (prefers-color-scheme:light){:root{--ground:#c9cdd1;--ink:#15171a;--quiet:#4a4f56;--rule:rgba(21,23,26,.22);
+ --lift:0 0 0 1px rgba(0,0,0,.07),0 .5vmin 1.6vmin rgba(0,0,0,.20)}}
+*{box-sizing:border-box}
+html{font-size:clamp(15px,2.1vmin,24px)}
+body{margin:0;height:100vh;overflow:hidden;background:var(--ground);color:var(--ink);
+ font-family:"Avenir Next","Helvetica Neue",system-ui,sans-serif;line-height:1.35;
+ display:grid;grid-template-rows:minmax(0,1fr) auto}
+#belt{position:relative;display:flex;flex-direction:column;gap:1.7vmin;padding:2.2vmin 0;min-height:0;overflow:hidden}
+.row{position:relative;flex:1;min-height:0}
+.track{position:absolute;inset:0;will-change:transform}
+.track img{position:absolute;top:0;height:100%;object-fit:cover;object-position:top;background:var(--paper);
+ border-radius:2px;box-shadow:var(--lift)}
+#progress{height:2px;background:var(--rule)}
+#progress div{height:2px;width:0;background:var(--ink)}
+#band{display:grid;grid-template-columns:minmax(0,1fr);gap:1.1rem;padding:1.5rem 4vmin 1.9rem}
+#rate{font-size:2.55rem;font-weight:600;line-height:1.08;letter-spacing:-.012em;margin:0 0 .45rem;
+ font-variant-numeric:tabular-nums;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+#run,#count{margin:0}
+#count{color:var(--quiet);font-variant-numeric:tabular-nums}
+#sample{margin:0;min-width:0;transition:opacity .4s}
+#sample.out{opacity:0}
+#text{margin:0;font-family:"Iowan Old Style",Charter,Georgia,serif;font-size:1.02rem;line-height:1.5;height:4.5em;
+ overflow:hidden;white-space:pre-line}
+#from{margin:.3rem 0 0;color:var(--quiet);font-size:.82rem}
+@media (min-aspect-ratio:13/10){#band{grid-template-columns:minmax(0,5fr) minmax(0,6fr);gap:5vmin;align-items:end}}
+/* ?view=single: one page at a time, each laid on the last, at the same pace */
+.single #belt{display:block;padding:0}
+#pile{position:absolute;inset:3vmin 0 2.4vmin}
+#pile img{position:absolute;left:50%;top:0;height:100%;aspect-ratio:.74;object-fit:cover;object-position:top;
+ background:var(--paper);border-radius:3px;box-shadow:var(--lift)}
+.single #text{height:10.5em}
+@media (min-aspect-ratio:13/10){
+ body.single{grid-template-columns:minmax(0,9fr) minmax(0,11fr);grid-template-rows:minmax(0,1fr) auto}
+ .single #belt{grid-row:1;grid-column:1}.single #progress{grid-row:2;grid-column:1/-1}
+ .single #band{grid-row:1;grid-column:2;grid-template-columns:minmax(0,1fr);align-content:center;gap:2.2rem;padding-left:1vmin}
+ .single #text{height:12em}}
+</style>
+<section id="belt" aria-label="Pages the model has read"></section>
+<div id="progress"><div id="bar"></div></div>
+<section id="band">
+ <div><p id="rate">Starting</p><p id="run"></p><p id="count"></p></div>
+ <figure id="sample" class="out"><p id="text"></p><figcaption id="from"></figcaption></figure>
+</section>
+<script>
+const $ = id => document.getElementById(id), fmt = n => Math.round(n).toLocaleString("en-US");
+const clock = s => { s = Number.isFinite(s) ? Math.max(0, Math.round(s)) : 0;
+  return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, "0")}`; };
+const NL = String.fromCharCode(10);
+const LAG = 1.5;  // seconds a finished page waits before it is drawn, so the belt moves evenly
+const still = matchMedia("(prefers-reduced-motion: reduce)").matches;  // then the belt moves in steps
+const single = new URLSearchParams(location.search).get("view") === "single";
+document.body.classList.toggle("single", single);
+let since = 0, last = null, misses = 0, first = true, stopped = false;
+let rows = [], tileW = 0, pitch = 0, beltW = 0, offset = 0, drawn = 0, speed = 0;
+const waiting = [], ready = [];  // finished pages: image still loading, then loaded; oldest first
+let shown = 0, shownWords = 0, recent = [];
+
+function layout() {
+  if (single) { const pile = document.createElement("div"); pile.id = "pile"; $("belt").replaceChildren(pile); return; }
+  const belt = $("belt"), vmin = Math.min(innerWidth, innerHeight), gap = vmin * 0.017;
+  const h = belt.clientHeight - vmin * 0.044, n = Math.max(2, Math.min(5, Math.round(h / (vmin * 0.26))));
+  const rowH = (h - gap * (n - 1)) / n;
+  tileW = Math.round(rowH * 0.74); pitch = tileW + gap; beltW = belt.clientWidth; offset = drawn = 0;
+  belt.replaceChildren();
+  rows = Array.from({length: n}, () => {
+    const row = document.createElement("div"), track = document.createElement("div");
+    row.className = "row"; track.className = "track"; row.append(track); belt.append(row);
+    return {track, tail: 0, tiles: []};
+  });
+}
+
+// One finished page becomes one tile, placed at the end of the shortest row.
+function place(p) {
+  shown += 1; shownWords += p.words;
+  if (p.missing) return;
+  const row = rows.reduce((a, b) => b.tail < a.tail ? b : a), x = Math.max(row.tail, offset + beltW);
+  p.el.style.left = x + "px"; p.el.style.width = tileW + "px";
+  row.track.append(p.el); row.tiles.push({x, el: p.el}); row.tail = x + pitch;
+  recent.push(p); if (recent.length > 40) recent.shift();
+}
+
+// Single view: the page goes on top of the pile, with a small turn so earlier pages show at the edges.
+let credit = 0;
+function deal(p) {
+  shown += 1; shownWords += p.words;
+  if (p.missing) return;
+  const turn = still ? 0 : (Math.random() - 0.5) * 2.4, dx = (Math.random() - 0.5) * 1.4, dy = (Math.random() - 0.5) * 0.9;
+  p.el.style.transform = `translate(calc(-50% + ${dx}vmin), ${dy}vmin) rotate(${turn}deg)`;
+  const pile = $("pile"); pile.append(p.el);
+  while (pile.children.length > 10) pile.firstChild.remove();
+  recent.push(p); if (recent.length > 40) recent.shift();
+  write(p);
+}
+
+// The belt moves so that the pages waiting to be drawn clear in LAG seconds: while pages
+// finish at a steady rate that is the rate itself, and when none are left it stops.
+let before = performance.now();
+function frame(now) {
+  const dt = Math.min(0.1, (now - before) / 1000); before = now;
+  const want = ready.length ? Math.max(1, ready.length / LAG) : 0;
+  const target = rows.length ? want * pitch / rows.length : 0;
+  if (single) {  // the same pace, counted in pages instead of distance
+    speed += (want - speed) * Math.min(1, dt * 2.5); credit = Math.min(3, credit + speed * dt);
+    while (ready.length && (ready[0].missing || credit >= 1)) { if (!ready[0].missing) credit -= 1; deal(ready.shift()); }
+    words(); requestAnimationFrame(frame); return;
+  }
+  speed += (target - speed) * Math.min(1, dt * 2.5);
+  offset += speed * dt;
+  while (ready.length && (ready[0].missing || Math.min(...rows.map(r => r.tail)) <= offset + beltW)) place(ready.shift());
+  if (!still || offset - drawn >= pitch) drawn = offset;
+  for (const r of rows) {
+    r.track.style.transform = `translateX(${-drawn}px)`;
+    while (r.tiles.length && r.tiles[0].x + pitch < drawn) r.tiles.shift().el.remove();
+  }
+  words();
+  requestAnimationFrame(frame);
+}
+
+// The three lines under the belt, as sentences.
+function words() {
+  const s = last; if (!s) return;
+  const all = s.finished && !ready.length && !waiting.length, done = all ? s.pages_done : shown;
+  const of = s.pages_total ? ` of ${fmt(s.pages_total)}` : "";
+  if (s.pages_total) $("bar").style.width = Math.min(100, 100 * done / s.pages_total) + "%";
+  $("run").textContent = s.model.split("/").pop() + (s.gpu_name ? ` on one ${s.gpu_name}, ` : " on ") + "Hugging Face Jobs";
+  if (!s.reading) {
+    $("rate").textContent = s.phase;
+    $("count").textContent = `Started ${clock(s.uptime_s)} ago` + (s.pages_total ? `, ${fmt(s.pages_total)} pages to read` : "");
+  } else {
+    const rate = s.finished ? s.pages_done / Math.max(1, s.reading_s) : s.rate_pps;
+    $("rate").textContent = rate ? `${rate.toFixed(1)} pages a second` : "Reading the first pages";
+    $("count").textContent = stopped ? "The Job stopped. Check the Job logs."
+      : all ? `All ${fmt(done)} pages read in ${clock(s.reading_s)}`
+      : `${fmt(done)}${of} pages read in ${clock(s.reading_s)}`;
+  }
+}
+
+function ingest(d) {
+  const s = d.stats; last = s;
+  document.title = s.model.split("/").pop() + " live";
+  // A late open or a reload starts from the newest pages, not the whole history.
+  let pages = d.pages;
+  if (first) { pages = pages.slice(-12); first = false;
+    shown = s.pages_done - pages.length; shownWords = s.words - pages.reduce((a, p) => a + p.words, 0); }
+  for (const p of d.pages) since = Math.max(since, p.seq);
+  for (const p of pages) {
+    const el = new Image(); p.el = el; el.alt = "";
+    el.onload = () => { p.loaded = true; flush(); };
+    el.onerror = () => {  // one retry, then the page is counted without a tile
+      if (p.retried) { p.missing = true; p.loaded = true; flush(); }
+      else { p.retried = true; setTimeout(() => { el.src = "img/" + p.img + "?retry"; }, 400); }
+    };
+    el.src = "img/" + p.img; waiting.push(p);
+  }
+}
+
+// Pages enter the belt in the order they finished, each once its image has loaded.
+function flush() { while (waiting.length && waiting[0].loaded) ready.push(waiting.shift()); }
+
+// A page's text as the model wrote it, without table and heading markup.
+function write(p) {
+  const plain = (p.text || "").replace(/<[^>]+>/g, " ").replace(/^#+ /gm, "").replaceAll("**", "")
+    .replace(/ {2,}/g, " ").replace(new RegExp("( ?" + NL + " ?){2,}", "g"), NL).trim();
+  $("text").textContent = plain || "(no text on this page)";
+  $("from").textContent = single ? "The text of the page on top" : "The text of one of these pages";
+  $("sample").classList.remove("out");
+}
+
+// Belt view: one recent page's text, changed every few seconds. (Single view writes every page.)
+let sampled = null;
+function sample() {
+  if (single) return;
+  const withText = recent.filter(p => (p.text || "").length > 200), p = (withText.length ? withText : recent).at(-1);
+  if (p && p !== sampled) {
+    sampled = p; $("sample").classList.add("out");
+    setTimeout(() => write(p), 400);
+  }
+  setTimeout(sample, 4000);
+}
+
+async function poll() {
+  try {
+    ingest(await (await fetch("feed.json?since=" + since)).json()); misses = 0;
+  } catch (e) {
+    misses += 1;
+    if (misses >= 6 && last && !last.finished) stopped = true;
+  }
+  setTimeout(poll, 500);
+}
+layout(); addEventListener("resize", layout);
+poll(); sample(); requestAnimationFrame(frame);
+</script>"""
+
+
+class LiveView:
+    """Finished pages and run counters, served as a web page from inside the Job (`--live-port`)."""
+
+    def __init__(self, port: int, model: str, pages_total, keep: int = 240, stale_s: float = 1800):
+        self.model, self.pages_total = model, pages_total
+        self.pages = collections.deque(maxlen=keep)  # finished pages, newest last
+        self.images: dict[str, bytes] = {}  # key -> JPEG, for prepared and kept pages
+        self.prepared: dict[str, tuple[str, float]] = {}  # row id -> (image key, time prepared)
+        self.stale_s = stale_s  # a prepared page not back after this long failed or was dropped
+        self.lock = threading.Lock()
+        self.made = self.seq = self.pages_done = self.words = 0
+        self.booted = time.time()
+        self.started = None  # first page prepared: the rate and the clock leave out the server start
+        self.finished = None
+        self.done_times = collections.deque()  # when each recent page finished, for the rolling rate
+        self.gpu_name = None
+        live = self
+
+        class Handler(BaseHTTPRequestHandler):
+            def do_GET(self):
+                try:
+                    if self.path.startswith("/feed.json"):
+                        try:
+                            since = int(self.path.partition("since=")[2] or 0)
+                        except ValueError:
+                            since = 0
+                        self.reply(json.dumps(live.feed(since)).encode(), "application/json")
+                    elif self.path.startswith("/img/"):
+                        with live.lock:
+                            jpeg = live.images.get(self.path[len("/img/"):].partition("?")[0])
+                        if jpeg is None:
+                            self.send_error(404)
+                        else:
+                            self.reply(jpeg, "image/jpeg", cache="max-age=86400")
+                    else:
+                        self.reply(LIVE_PAGE.encode(), "text/html; charset=utf-8")
+                except (BrokenPipeError, ConnectionResetError):
+                    pass  # the viewer closed the tab mid-reply
+
+            def reply(self, body: bytes, ctype: str, cache: str = "no-store"):
+                self.send_response(200)
+                self.send_header("Content-Type", ctype)
+                self.send_header("Cache-Control", cache)
+                self.end_headers()
+                self.wfile.write(body)
+
+            def log_message(self, *args):  # keep the Job log for the OCR run
+                pass
+
+        class Server(ThreadingHTTPServer):
+            request_queue_size = 128  # a tab asks for several page images at once
+
+        server = Server(("0.0.0.0", port), Handler)
+        threading.Thread(target=server.serve_forever, daemon=True).start()
+        threading.Thread(target=self.name_gpu, daemon=True).start()
+        # An exposed Job port is served at https://<job id>--<port>.hf.jobs.
+        where = (f"https://{os.environ['JOB_ID']}--{port}.hf.jobs (needs --expose-public {port})"
+                 if os.environ.get("JOB_ID") else f"http://localhost:{port}")
+        print(f"Live view: {where}", file=sys.stderr, flush=True)
+
+    def name_gpu(self):
+        try:
+            out = subprocess.run(["nvidia-smi", "--query-gpu=name", "--format=csv,noheader"],
+                                 capture_output=True, text=True, timeout=10, check=True).stdout.splitlines()
+        except (OSError, subprocess.SubprocessError):
+            return
+        if len(out) == 1:  # the page says "one <GPU>": leave it out on a multi-GPU flavor
+            with self.lock:
+                self.gpu_name = out[0].strip()
+
+    def add_thumbnail(self, row_id: str, image):
+        thumb = image.copy()
+        thumb.thumbnail((480, 480))
+        buffer = io.BytesIO()
+        thumb.save(buffer, format="JPEG", quality=78)
+        with self.lock:
+            if self.started is None:
+                self.started = time.time()
+            self.made += 1
+            key = f"{self.made}.jpg"
+            self.images[key] = buffer.getvalue()
+            old = self.prepared.get(row_id)
+            if old:  # prepared again for a retry: drop the earlier copy
+                self.images.pop(old[0], None)
+            self.prepared[row_id] = (key, time.time())
+
+    def add_page(self, row_id: str, text: str):
+        now = time.time()
+        tail = row_id.rsplit(":", 1)[-1]
+        with self.lock:
+            key, _ = self.prepared.pop(row_id, ("", now))
+            if len(self.pages) == self.pages.maxlen:  # the oldest kept page leaves: drop its image
+                self.images.pop(self.pages[0]["img"], None)
+            words = len(text.split())
+            self.seq += 1
+            self.pages_done += 1
+            self.words += words
+            self.done_times.append(now)
+            self.pages.append({"seq": self.seq, "img": key, "text": text[:700], "words": words,
+                               "n": int(tail) + 1 if tail.isdigit() else None})
+
+    def finish(self):
+        with self.lock:
+            self.finished = time.time()
+
+    def feed(self, since: int) -> dict:
+        now = time.time()
+        with self.lock:
+            for row_id, (key, t) in list(self.prepared.items()):
+                if now - t > self.stale_s:
+                    del self.prepared[row_id]
+                    self.images.pop(key, None)
+            while self.done_times and now - self.done_times[0] > 10:
+                self.done_times.popleft()
+            end = self.finished or now
+            reading_s = end - self.started if self.started else 0
+            rate = len(self.done_times) / 10 if reading_s >= 10 and not self.finished else 0
+            phase = "Finished" if self.finished else "Reading pages" if self.pages_done else \
+                "Preparing the first pages" if self.started else "Starting the model server"
+            return {"stats": {"model": self.model, "gpu_name": self.gpu_name, "phase": phase,
+                              "reading": self.pages_done > 0, "finished": self.finished is not None,
+                              "uptime_s": round(now - self.booted), "reading_s": round(reading_s),
+                              "pages_total": self.pages_total, "pages_done": self.pages_done,
+                              "words": self.words, "rate_pps": round(rate, 1)},
+                    "pages": [p for p in self.pages if p["seq"] > since][-120:]}
+
+
+def main():
+    ap = argparse.ArgumentParser(description="LightOnOCR-3 batch OCR via saturate, with a live view")
+    ap.add_argument("input_dataset", help="Input dataset repo id (rows with an image column)")
+    ap.add_argument("output_dataset", help="Output dataset repo id (created private if missing)")
+    ap.add_argument("--model", default=SERVING["models"][0], choices=SERVING["models"])
+    ap.add_argument("--mode", default="plain", choices=["plain", "grounding"],
+                    help="plain = markdown; grounding = labelled layout blocks with 0-1000 boxes")
+    ap.add_argument("--image-column", default="image")
+    ap.add_argument("--config", default=None, help="Dataset config name")
+    ap.add_argument("--split", default="train")
+    ap.add_argument("--id-column", default=None,
+                    help="Column to use as row id (default: split-index ids)")
+    ap.add_argument("--max-samples", "--limit", dest="limit", type=int, default=None,
+                    help="Process only the first N rows (smoke test)")
+    ap.add_argument("--max-tokens", type=int, default=SERVING["max_tokens"],
+                    help="Output cap per page (default 4096, the model card's)")
+    ap.add_argument("--temperature", type=float, default=SERVING["temperature"])
+    ap.add_argument("--top-p", type=float, default=SERVING["top_p"],
+                    help="Default 0.9, the model card's; LightOn's client uses 1.0")
+    ap.add_argument("--longest-edge", type=int, default=SERVING["longest_edge"],
+                    help="Downscale pages to at most this many pixels on the longest edge")
+    ap.add_argument("--no-fix-dollars", action="store_true",
+                    help="Keep the model's text in `markdown` without repairing escaped dollars")
+    ap.add_argument("--repair-max-tokens", type=int, default=0,
+                    help="Re-send pages that hit --max-tokens once, with this cap and "
+                         "temperature 0.1, into repair/ (default 0: off; 8192 suggested)")
+    ap.add_argument("--window", default="auto",
+                    help="Pages in flight: 'auto' (saturate adapts it) or a fixed number")
+    ap.add_argument("--prepare-workers", type=int, default=None,
+                    help="Threads that decode, resize and encode pages (default: CPU_CORES)")
+    ap.add_argument("--serve-args", default="",
+                    help="Extra `vllm serve` flags, one quoted string, e.g. "
+                         "\"--max-num-batched-tokens 16384\"")
+    ap.add_argument("--retry-errors", action="store_true",
+                    help="Re-admit rows whose only record is an error row")
+    ap.add_argument("--live-port", type=int, default=None,
+                    help="Serve the live view on this port (on Jobs, also pass --expose-public "
+                         "with the same port)")
+    args = ap.parse_args()
+
+    user_serve_args = shlex.split(args.serve_args)
+    if args.longest_edge < 1:
+        ap.error("--longest-edge must be at least 1")
+    try:  # --serve-args may set its own --max-model-len; vLLM uses the last one given
+        context = int(flag_value(user_serve_args, "--max-model-len") or SERVING["context"])
+    except ValueError:
+        ap.error("--max-model-len in --serve-args must be a whole number of tokens")
+    room = context - max_image_tokens(args.longest_edge) - 64
+    for flag, value in (("--max-tokens", args.max_tokens), ("--repair-max-tokens", args.repair_max_tokens)):
+        if value > room:
+            ap.error(f"{flag} {value} can overflow the {context}-token context with a "
+                     f"{args.longest_edge} px page; use at most {room}")
+    if args.max_tokens < 1:
+        ap.error("--max-tokens must be at least 1")
+    if args.repair_max_tokens and args.repair_max_tokens <= args.max_tokens:
+        ap.error("--repair-max-tokens must be larger than --max-tokens")
+    if args.window != "auto" and not (args.window.isdigit() and int(args.window) >= 1):
+        ap.error("--window must be 'auto' or a number of at least 1")
+
+    import pyarrow as pa
+    from saturate import Auto, Engine, Fixed, dataset_rows, pump
+
+    if args.id_column is None:
+        ids = "index"
+    elif args.id_column in ("index", "content"):
+        # saturate reads these two names as id strategies, so a column with one of them
+        # needs a callable. It returns the raw value, so saturate still refuses a null id.
+        def ids(example):
+            return example[args.id_column]
+    else:
+        ids = args.id_column
+
+    rows = dataset_rows(
+        args.input_dataset, config=args.config, split=args.split,
+        columns=[args.image_column], ids=ids, limit=args.limit,
+    )
+
+    # Declared, so a part holding only error rows has the same columns as the rest
+    # (datasets.load_dataset reads every part with one schema).
+    schema = pa.schema([
+        ("id", pa.string()), ("error", pa.string()), ("markdown", pa.string()), ("raw", pa.string()),
+        ("finish_reason", pa.string()), ("layout_blocks", pa.string()), ("model", pa.string()),
+        ("prompt_tokens", pa.int64()), ("completion_tokens", pa.int64()),
+    ])  # fmt: skip
+
+    # Pages that hit --max-tokens, kept on local disk for the repair pass: those truncated
+    # in this run (stashed in parse) and those saved as truncated by an earlier, interrupted
+    # run (stashed as the stream passes them; the main pass skips them).
+    repair_dir = tempfile.mkdtemp(prefix="lighton-ocr3-repair-") if args.repair_max_tokens else None
+    earlier = saved_truncations(args.output_dataset) if repair_dir else set()
+    truncated = []
+
+    def stash(row_id, image):
+        path = os.path.join(repair_dir, hashlib.sha1(row_id.encode()).hexdigest() + ".png")
+        with open(path, "wb") as handle:
+            handle.write(page_png(image, args.longest_edge))
+        truncated.append((row_id, path))
+
+    live = None
+    if args.live_port:
+        live = LiveView(args.live_port, args.model,
+                        count_pages(args.input_dataset, args.config, args.split, args.limit))
+
+    def to_request(row):
+        image = fitted_page(row[args.image_column], args.longest_edge)
+        if live:
+            live.add_thumbnail(row["__id"], image)
+        return chat_request(args.model, png_bytes(image), args.mode, args.max_tokens, args.temperature, args.top_p)
+
+    def make_parse(stash_truncated: bool):
+        def parse(row, body):
+            choice = body["choices"][0]
+            raw = (choice["message"].get("content") or "").strip()
+            markdown, blocks = postprocess(raw, args.mode, fix_dollars=not args.no_fix_dollars)
+            usage = body.get("usage") or {}
+            if stash_truncated and choice.get("finish_reason") == "length":
+                stash(row["__id"], row[args.image_column])
+            if live and "__id" in row:  # repair rows carry no id: the live view shows the main pass
+                live.add_page(row["__id"], markdown)
+            return {
+                "markdown": markdown,
+                "raw": raw,
+                "finish_reason": choice.get("finish_reason"),
+                "layout_blocks": blocks,
+                "model": args.model,
+                "prompt_tokens": usage.get("prompt_tokens"),
+                "completion_tokens": usage.get("completion_tokens"),
+            }
+        return parse
+
+    def with_ids(source):
+        # Keep each row's id on the row, so parse can name the page it stashes for repair.
+        for row_id, row in source:
+            if row_id in earlier:
+                stash(row_id, row[args.image_column])
+            yield row_id, {**row, "__id": row_id}
+
+    cap = window_cap()
+    if args.window == "auto":
+        window = Auto(initial=min(64, cap), max_limit=cap)
+        print(f"window: auto, at most {cap} pages in flight (host memory)", file=sys.stderr)
+    else:
+        window = Fixed(int(args.window))
+        if int(args.window) > cap:
+            print(f"warning: --window {args.window} is above the {cap} pages this machine's "
+                  "memory allows; the Job may run out of memory", file=sys.stderr)
+    cores = max(1, int(float(os.environ.get("CPU_CORES") or "4")))
+    workers = args.prepare_workers if args.prepare_workers is not None else cores
+    extra = [
+        "--max-model-len", str(SERVING["context"]),
+        *SERVING["serve_args"],
+        *user_serve_args,
+    ]
+    # Several API server processes share the image decoding and preprocessing, which one
+    # process cannot keep up with on a fast GPU. Only where there are cores to spare.
+    if cores >= SERVING["api_servers_min_cores"] and flag_value(extra, "--api-server-count") is None:
+        extra += ["--api-server-count", str(SERVING["api_servers"])]
+        print(f"server: --api-server-count {SERVING['api_servers']} ({cores} CPU cores)", file=sys.stderr)
+
+    output = f"hf://datasets/{args.output_dataset}/data"
+    with Engine(args.model, engine="vllm", extra_args=extra) as endpoint:
+        stats = pump(with_ids(rows), to_request, make_parse(bool(repair_dir)),
+                     endpoint, output, window=window, prepare_workers=workers,
+                     retry_errors=args.retry_errors, schema=schema)
+        print("LIGHTON_OCR3_SATURATE " + stats.to_json(), flush=True)
+        if live:
+            live.finish()
+
+        if repair_dir and truncated:
+            print(f"repair: re-sending {len(truncated)} pages that hit --max-tokens "
+                  f"with a cap of {args.repair_max_tokens}", file=sys.stderr, flush=True)
+
+            def repair_rows():
+                for row_id, path in truncated:
+                    with open(path, "rb") as handle:
+                        yield row_id, {"png": handle.read()}
+
+            def repair_request(row):
+                return chat_request(args.model, row["png"], args.mode, args.repair_max_tokens,
+                                    SERVING["repair_temperature"], args.top_p)
+
+            repair_stats = pump(repair_rows(), repair_request, make_parse(False), endpoint,
+                                f"hf://datasets/{args.output_dataset}/repair", window=window,
+                                retry_errors=args.retry_errors, schema=schema)
+            print("LIGHTON_OCR3_SATURATE_REPAIR " + repair_stats.to_json(), flush=True)
+
+    print(f"https://huggingface.co/datasets/{args.output_dataset} "
+          f"({stats.rows_processed} ok, {stats.rows_failed} error rows, "
+          f"{len(truncated) if repair_dir else 'n/a'} truncated pages re-sent to repair/)", file=sys.stderr)
+    if live:
+        time.sleep(20)  # the Job (and this page) ends with the script: let open tabs fetch the final numbers
+
+
+if __name__ == "__main__":
+    main()

models.json

@@ -415,6 +415,30 @@
       ]
     }
   },
+  "lighton-ocr3-live.py": {
+    "model_id": "lightonai/LightOnOCR-3-0.8B",
+    "params": "0.8B (or 4B via --model)",
+    "backend": "saturate (in-job vllm serve + saturate pump)",
+    "image": "vllm/vllm-openai:v0.30.0",
+    "task": "ocr with a live view of the run",
+    "output": "markdown; --mode grounding adds labelled layout blocks with 0-1000 boxes (layout_blocks JSON column)",
+    "license": "apache-2.0",
+    "notes": "lighton-ocr3-saturate.py plus --live-port: a page served from the Job that shows each finished page moving past at the rate the pages finish, the pages read a second and one page's text; ?view=single shows one page at a time with its text. For watching or screen-recording a run. Measured 2026-11-10 with these settings and the live view open, pages fed from multi-page TIFFs by a one-off source: 14,483 typed pages (about 780 output tokens a page), 7.7 pages/s on rtx-pro-6000, 0 errors.",
+    "languages": {
+      "evidence": "not-stated",
+      "notes": "LightOnOCR-3 cards give no language list (LightOnOCR-2 named 11)."
+    },
+    "support": "experimental",
+    "support_note": "Use lighton-ocr3-saturate.py for normal runs; this adds a live view for demos.",
+    "jobs": {
+      "image": "vllm/vllm-openai:v0.30.0",
+      "flavor": "rtx-pro-6000",
+      "timeout": "4h",
+      "secrets": [
+        "HF_TOKEN"
+      ]
+    }
+  },
   "lighton-ocr2-server.py": {
     "model_id": "lightonai/LightOnOCR-2-1B",
     "params": "1B",