Sync from GitHub via hub-sync

CLAUDE.md

@@ -273,6 +273,16 @@ ARM wheels) — if a nightly-recipe install fails on resolution, wait and retry
 
 ## Change log
 
+- **2026-07-29** — added the first two **`-saturate.py` companions**: `lighton-ocr2-saturate.py` and
+  `ovis-ocr2-saturate.py`. Same model/prompt/sampling/post-processing as their `-server.py` siblings;
+  the driver half (concurrency, retries, output, resume) is the `saturate` package (pinned `>=0.1.1`,
+  the allowed *package*-dep pattern — no local imports). Each carries a `SERVING` dict at the top
+  (serve flags + client sampling + context-math assert) as the machine-readable tuning prior — the
+  runtime-consumed successor to the dropped `[tool.serving]` header idea. Output shape differs from
+  `-server.py`: a NEW dataset repo of `{id, markdown, …, error}` parquet rows keyed by input id
+  (resume = anti-join on id), not input+column push; failed pages become durable error rows
+  (`--retry-errors` heals), NOT `[OCR ERROR]` sentinels — the first recipes closing the
+  error-signalling gap noted in Conventions.
 - **2026-07-14** — added `ovis-ocr2.py` (`ATH-MaaS/OvisOCR2`, 0.9B Qwen3.5, 96.58 OmniDocBench v1.6,
   Apache-2.0; stable vLLM ≥0.22.1, `gdn_prefill_backend="triton"`, card-exact prompt/postprocessing).
   Smoke-tested green on the default uv image, a10g-small, resolved vLLM 0.25.1 (5/5 pages, tags filtered,

README.md

@@ -33,7 +33,7 @@ This will:
 
 ## Serve a model as a live endpoint
 
-The recipes here run as batch jobs. Some models also have a **`-server.py` sibling recipe** that runs the same dataset→dataset batch job through an in-job `vllm serve` + concurrent driver — measurably faster (continuous batching stays fed) and more robust (one bad image fails one request, not a whole batch); see [SERVING.md](SERVING.md) for the architecture, A/B numbers, and which models officially document server mode. To call a model interactively, from an agent, or with concurrent ad-hoc requests, you can instead run it as a temporary endpoint: [HF Jobs serving](https://huggingface.co/docs/hub/jobs-serving) exposes a port on a GPU Job, giving an OpenAI-compatible endpoint that runs until the job is cancelled or its `--timeout` is reached. See [serving-unlimited-ocr.md](serving-unlimited-ocr.md) for a worked example serving Baidu's [Unlimited-OCR](https://huggingface.co/baidu/Unlimited-OCR) — with vLLM (official image) or SGLang. To OCR a whole corpus of single-page images instead, the batch recipe `unlimited-ocr-vllm.py` is the better fit (it's single-image only). **Multi-page** documents need a server: both vLLM and SGLang read clean multi-page docs, but **SGLang is the more robust** — on hard/degraded scans vLLM multi-page hallucinated in our tests while SGLang held up.
+The recipes here run as batch jobs. Some models also have a **`-server.py` sibling recipe** that runs the same dataset→dataset batch job through an in-job `vllm serve` + concurrent driver — measurably faster (continuous batching stays fed) and more robust (one bad image fails one request, not a whole batch); see [SERVING.md](SERVING.md) for the architecture, A/B numbers, and which models officially document server mode. A third lane is starting: **`-saturate.py` companions** ([`lighton-ocr2-saturate.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/lighton-ocr2-saturate.py), [`ovis-ocr2-saturate.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/ovis-ocr2-saturate.py)) keep the same model, prompt, and sampling but replace the hand-rolled driver half with the [saturate](https://github.com/davanstrien/saturate) library — adaptive concurrency (no `--concurrency` to tune), crash-safe resumable output (re-running skips finished rows), and durable per-row error records instead of `[OCR ERROR]` strings. Each carries a machine-readable `SERVING` dict (serve flags + sampling + context math) at the top of the script. To call a model interactively, from an agent, or with concurrent ad-hoc requests, you can instead run it as a temporary endpoint: [HF Jobs serving](https://huggingface.co/docs/hub/jobs-serving) exposes a port on a GPU Job, giving an OpenAI-compatible endpoint that runs until the job is cancelled or its `--timeout` is reached. See [serving-unlimited-ocr.md](serving-unlimited-ocr.md) for a worked example serving Baidu's [Unlimited-OCR](https://huggingface.co/baidu/Unlimited-OCR) — with vLLM (official image) or SGLang. To OCR a whole corpus of single-page images instead, the batch recipe `unlimited-ocr-vllm.py` is the better fit (it's single-image only). **Multi-page** documents need a server: both vLLM and SGLang read clean multi-page docs, but **SGLang is the more robust** — on hard/degraded scans vLLM multi-page hallucinated in our tests while SGLang held up.
 
 ## Models at a glance
 

lighton-ocr2-saturate.py

@@ -0,0 +1,174 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "saturate[hf]>=0.1.1",
+#     "pillow>=10",
+# ]
+# ///
+"""
+Convert document images to markdown using LightOnOCR-2 via saturate.
+
+Companion to `lighton-ocr2-server.py`: same model, same message shape, same
+sampling, same in-job `vllm serve` — but the driver half (concurrency, retries,
+output, resume) is the `saturate` library instead of hand-rolled code. What that
+buys over the -server recipe:
+
+- **Adaptive concurrency** — the window sizes itself from live engine signals
+  (no `--concurrency` flag to tune).
+- **Crash-safe, resumable output** — results stream to the output repo as
+  parquet parts while the run is hot; re-running the same command skips
+  everything already done (exact anti-join on id). A 10k-page job that dies at
+  9k resumes at 9k.
+- **Durable error rows** — a failed page is recorded as `{id, error}` instead of
+  an `[OCR ERROR]` string in the text column; `--retry-errors` re-admits only
+  those rows on a later run.
+
+Run on HF Jobs (the script starts `vllm serve` itself; the --image flag
+provides the `vllm` binary):
+
+  hf jobs uv run --detach --flavor a10g-small -s HF_TOKEN --timeout 4h \\
+      --image vllm/vllm-openai:latest \\
+      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr2-saturate.py \\
+      <input-dataset> <output-dataset>
+
+Output layout (differs from the -server recipe, which pushes input+markdown):
+the output repo holds `data/part-*.parquet` with rows
+`{id, markdown, model, prompt_tokens, completion_tokens, error}` keyed by the
+input row id (`--id-column`, or `<split>-<index>` by default). Read it with
+`datasets.load_dataset(<output>, data_dir="data")` or `saturate.read_output`;
+join back to the input on id. Run metadata lands in `data/completions/`.
+
+Model: lightonai/LightOnOCR-2-1B (1B, Apache-2.0)
+- Message is the image ONLY (no text prompt) — LightOnOCR-2's trained format.
+- Images resized client-side so the longest dimension is 1540px (training
+  resolution at 200 DPI), same as the offline recipe.
+- Sampling per the card: temperature 0.2, top_p 0.9, max_tokens 4096.
+
+The SERVING dict below is the per-model tuning prior (serve flags + client
+sampling + context math). Agents can `ast.literal_eval` it without running
+the script; the script itself consumes it, so it cannot drift from reality.
+"""
+
+import argparse
+import base64
+import io
+import sys
+
+# Serving starting values for lightonai/LightOnOCR-2-1B. Per-value provenance:
+# - serve_args: the model card's own `vllm serve` command, verbatim (the three
+#   cache/mm flags; OCR never reuses images, so those caches only cost memory).
+# - max_model_len 8192: NOT in the card's serve command (card default = native
+#   16384). House choice inherited from lighton-ocr2-server.py: halves the KV
+#   allocation on 24GB and still fits a 1540px page (~2.5k image tokens) + 4096
+#   output with headroom.
+# - max_tokens/temperature/top_p: card's sampling example, verbatim.
+# - target_size 1540: card's stated training resolution (200 DPI longest side).
+# Throughput receipt (a10g-small): 0.955 img/s at 1k pages incl. streaming.
+SERVING = {
+    "model": "lightonai/LightOnOCR-2-1B",
+    "image": "vllm/vllm-openai:latest",
+    "max_model_len": 8192,
+    "serve_args": [
+        "--limit-mm-per-prompt", '{"image": 1}',
+        "--mm-processor-cache-gb", "0",
+        "--no-enable-prefix-caching",
+    ],
+    "max_tokens": 4096,
+    "temperature": 0.2,
+    "top_p": 0.9,
+    "target_size": 1540,
+}
+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)"
+)
+
+
+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, target_size: int) -> str:
+    """RGB-convert, resize longest dimension to target_size, return base64 PNG."""
+    from PIL import Image
+
+    img = to_pil(value).convert("RGB")
+    if target_size:
+        w, h = img.size
+        if max(w, h) != target_size:
+            scale = target_size / max(w, h)
+            img = img.resize((round(w * scale), round(h * scale)), Image.LANCZOS)
+    buf = io.BytesIO()
+    img.save(buf, format="PNG")
+    return base64.b64encode(buf.getvalue()).decode()
+
+
+def main():
+    ap = argparse.ArgumentParser(description="LightOnOCR-2 batch OCR via saturate")
+    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 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("--limit", type=int, default=None)
+    ap.add_argument("--max-tokens", type=int, default=SERVING["max_tokens"])
+    ap.add_argument("--temperature", type=float, default=SERVING["temperature"])
+    ap.add_argument("--target-size", type=int, default=SERVING["target_size"])
+    ap.add_argument("--no-resize", action="store_true")
+    ap.add_argument("--retry-errors", action="store_true",
+                    help="Re-admit rows whose only record is an error row")
+    args = ap.parse_args()
+
+    from saturate import Auto, Engine, dataset_rows, pump
+
+    target_size = 0 if args.no_resize else args.target_size
+    rows = dataset_rows(
+        args.input_dataset, config=args.config, split=args.split,
+        columns=[args.image_column], ids=args.id_column or "index", limit=args.limit,
+    )
+
+    def to_request(row):
+        b64 = encode_image(row[args.image_column], target_size)
+        return {
+            "model": SERVING["model"],
+            "messages": [{"role": "user", "content": [
+                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}},
+            ]}],
+            "temperature": args.temperature,
+            "top_p": SERVING["top_p"],
+            "max_tokens": args.max_tokens,
+        }
+
+    def parse(row, body):
+        usage = body.get("usage") or {}
+        return {
+            "markdown": body["choices"][0]["message"]["content"].strip(),
+            "model": SERVING["model"],
+            "prompt_tokens": usage.get("prompt_tokens"),
+            "completion_tokens": usage.get("completion_tokens"),
+        }
+
+    extra = ["--max-model-len", str(SERVING["max_model_len"]), *SERVING["serve_args"]]
+    output = f"hf://datasets/{args.output_dataset}/data"
+    with Engine(SERVING["model"], engine="vllm", extra_args=extra) as endpoint:
+        stats = pump(rows, to_request, parse, endpoint, output,
+                     window=Auto(initial=8, max_limit=48),
+                     retry_errors=args.retry_errors)
+
+    print(f"https://huggingface.co/datasets/{args.output_dataset} "
+          f"({stats.rows_processed} ok, {stats.rows_failed} error rows)", file=sys.stderr)
+    print("LIGHTON_OCR2_SATURATE " + stats.to_json(), flush=True)
+
+
+if __name__ == "__main__":
+    main()

models.json

@@ -129,6 +129,17 @@
     "notes": "Server-mode sibling of ovis-ocr2.py: ~1.7x its inference throughput, per-request failure isolation. See SERVING.md.",
     "languages": { "evidence": "not-stated" }
   },
+  "ovis-ocr2-saturate.py": {
+    "model_id": "ATH-MaaS/OvisOCR2",
+    "params": "0.9B",
+    "backend": "saturate (in-job vllm serve + saturate pump)",
+    "image": "vllm/vllm-openai:latest",
+    "task": "ocr",
+    "output": "markdown + LaTeX + HTML tables",
+    "license": "apache-2.0",
+    "notes": "saturate companion of ovis-ocr2-server.py: same model/prompt/sampling/post-processing; the driver half (adaptive concurrency, retries, resumable parquet output, durable error rows) is the saturate library. SERVING dict at the top of the script is the machine-readable tuning prior.",
+    "languages": { "evidence": "not-stated" }
+  },
   "lighton-ocr.py": {
     "model_id": "lightonai/LightOnOCR-1B-1025",
     "params": "1B",
@@ -170,6 +181,21 @@
       "notes": "Adds zh/ja over v1; declared, not benchmarked per language."
     }
   },
+  "lighton-ocr2-saturate.py": {
+    "model_id": "lightonai/LightOnOCR-2-1B",
+    "params": "1B",
+    "backend": "saturate (in-job vllm serve + saturate pump)",
+    "image": "vllm/vllm-openai:latest",
+    "task": "ocr",
+    "output": "markdown",
+    "notes": "saturate companion of lighton-ocr2-server.py: same model/message shape/sampling; the driver half (adaptive concurrency, retries, resumable parquet output, durable error rows) is the saturate library. SERVING dict at the top of the script is the machine-readable tuning prior.",
+    "languages": {
+      "evidence": "named-list",
+      "count": 11,
+      "named": ["en", "fr", "de", "es", "it", "nl", "pt", "sv", "da", "zh", "ja"],
+      "notes": "Adds zh/ja over v1; declared, not benchmarked per language."
+    }
+  },
   "hunyuan-ocr.py": {
     "model_id": "tencent/HunyuanOCR",
     "revision": "f6af82ee007fe6091b29fb3bb287b491ead41c82",

ovis-ocr2-saturate.py

@@ -0,0 +1,235 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "saturate[hf]>=0.1.1",
+#     "pillow>=10",
+# ]
+# ///
+"""
+Convert document images to markdown using OvisOCR2 via saturate.
+
+Companion to `ovis-ocr2-server.py`: same model, prompt, message shape, sampling,
+and post-processing, same in-job `vllm serve` — but the driver half (concurrency,
+retries, output, resume) is the `saturate` library instead of hand-rolled code.
+What that buys over the -server recipe:
+
+- **Adaptive concurrency** — the window sizes itself from live engine signals
+  (no `--concurrency` flag to tune).
+- **Crash-safe, resumable output** — results stream to the output repo as
+  parquet parts while the run is hot; re-running the same command skips
+  everything already done (exact anti-join on id).
+- **Durable error rows** — a failed page is recorded as `{id, error}` instead of
+  an `[OCR ERROR]` string in the text column; `--retry-errors` re-admits only
+  those rows on a later run.
+
+Run on HF Jobs (the script starts `vllm serve` itself; the --image flag
+provides the `vllm` binary):
+
+  hf jobs uv run --detach --flavor a10g-small -s HF_TOKEN --timeout 4h \\
+      --image vllm/vllm-openai:latest \\
+      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/ovis-ocr2-saturate.py \\
+      <input-dataset> <output-dataset>
+
+Output layout (differs from the -server recipe, which pushes input+markdown):
+the output repo holds `data/part-*.parquet` with rows
+`{id, markdown, model, prompt_tokens, completion_tokens, error}` keyed by the
+input row id (`--id-column`, or `<split>-<index>` by default). Read it with
+`datasets.load_dataset(<output>, data_dir="data")` or `saturate.read_output`;
+join back to the input on id. Run metadata lands in `data/completions/`.
+
+Model: ATH-MaaS/OvisOCR2 (0.9B, Apache-2.0, 96.58 OmniDocBench)
+- The card's exact OCR prompt (leading newline included — outputs are tuned to
+  this wording), image before text, `enable_thinking=False` via
+  chat_template_kwargs (the Qwen3.5 template otherwise injects a thinking
+  preamble).
+- Images downscaled client-side to the processor's max_pixels bound (8.3MP) and
+  sent as JPEG q95 — the same clamp the server would apply, moved client-side to
+  shrink the payload; min/max pixel bounds ride on the engine boot flag.
+- Post-processing per the card: bbox `<img>` placeholder blocks dropped (keep
+  with --keep-image-tags) and degenerate trailing repeats trimmed.
+
+The SERVING dict below is the per-model tuning prior (serve flags + client
+sampling + context math). Agents can `ast.literal_eval` it without running
+the script; the script itself consumes it, so it cannot drift from reality.
+"""
+
+import argparse
+import base64
+import io
+import math
+import sys
+
+# Serving starting values for ATH-MaaS/OvisOCR2. Per-value provenance:
+# - The card documents OFFLINE inference only — no `vllm serve` command exists
+#   upstream. The whole server arrangement here (incl. serve_args) is the
+#   uv-scripts construction inherited from ovis-ocr2-server.py.
+# - max_model_len 32768: house choice (card sets none; native ctx is 262144 —
+#   NEVER boot without a cap on 24GB, the full-context KV profile kills boot).
+# - cache/mm flags: house OCR defaults (OCR never reuses images, so prefix/
+#   processor caches only cost memory).
+# - mm-processor-kwargs pixel bounds: card's offline example, verbatim
+#   (min 448*448=200704, max 2880*2880=8294400), moved to the engine flag.
+# - max_tokens 16384 / temperature 0.0: card's sampling, verbatim.
+# Throughput receipt (a10g-small, 20 pages): 4,057 tok/s, window ramped to 32.
+SERVING = {
+    "model": "ATH-MaaS/OvisOCR2",
+    "image": "vllm/vllm-openai:latest",
+    "max_model_len": 32768,
+    "serve_args": [
+        "--limit-mm-per-prompt", '{"image": 1}',
+        "--mm-processor-cache-gb", "0",
+        "--no-enable-prefix-caching",
+        "--mm-processor-kwargs",
+        '{"images_kwargs": {"min_pixels": 200704, "max_pixels": 8294400}}',
+    ],
+    "max_tokens": 16384,
+    "temperature": 0.0,
+    "max_pixels": 8294400,
+}
+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)"
+)
+
+OCR_PROMPT = (
+    "\nExtract all readable content from the image in natural human reading order "
+    "and output the result as a single Markdown document. For charts or images, "
+    'represent them using an HTML image tag: <img src="images/bbox_{left}_{top}_{right}_{bottom}.jpg" />, '
+    "where left, top, right, bottom are bounding box coordinates scaled to [0, 1000). "
+    "Format formulas as LaTeX. Format tables as HTML: <table>...</table>. "
+    "Transcribe all other text as standard Markdown. Preserve the original text "
+    "without translation or paraphrasing."
+)
+
+
+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 to max_pixels if needed, return base64 JPEG q95."""
+    from PIL import Image
+
+    img = to_pil(value).convert("RGB")
+    w, h = img.size
+    if w * h > max_pixels:
+        scale = math.sqrt(max_pixels / (w * h))
+        img = img.resize((int(w * scale), int(h * scale)), Image.LANCZOS)
+    buf = io.BytesIO()
+    img.save(buf, format="JPEG", quality=95)
+    return base64.b64encode(buf.getvalue()).decode()
+
+
+def clean_truncated_repeats(
+    text: str,
+    min_text_len: int = 8000,
+    max_period: int = 200,
+    min_period: int = 1,
+    min_repeat_chars: int = 100,
+    min_repeat_times: int = 5,
+) -> str:
+    """Trim degenerate trailing repetition (verbatim port of the model card's cleanup)."""
+    n = len(text)
+    if n < min_text_len:
+        return text
+
+    max_period = min(max_period, n - 1)
+    for unit_len in range(min_period, max_period + 1):
+        if text[n - 1] != text[n - 1 - unit_len]:
+            continue
+
+        match_len = 1
+        idx = n - 2
+        while idx >= unit_len and text[idx] == text[idx - unit_len]:
+            match_len += 1
+            idx -= 1
+
+        total_len = match_len + unit_len
+        repeat_times = total_len // unit_len
+        tail_len = total_len % unit_len
+
+        if repeat_times >= min_repeat_times and total_len >= min_repeat_chars:
+            return text[: n - total_len + unit_len] + text[n - tail_len:]
+
+    return text
+
+
+def filter_image_tags(text: str) -> str:
+    blocks = text.split("\n\n")
+    return "\n\n".join(
+        b for b in blocks if not b.strip().startswith('<img src="images/bbox_')
+    )
+
+
+def main():
+    ap = argparse.ArgumentParser(description="OvisOCR2 batch OCR via saturate")
+    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 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("--limit", type=int, default=None)
+    ap.add_argument("--max-tokens", type=int, default=SERVING["max_tokens"])
+    ap.add_argument("--keep-image-tags", action="store_true",
+                    help="Keep the bbox <img> placeholder blocks in the output")
+    ap.add_argument("--retry-errors", action="store_true",
+                    help="Re-admit rows whose only record is an error row")
+    args = ap.parse_args()
+
+    from saturate import Auto, Engine, dataset_rows, pump
+
+    rows = dataset_rows(
+        args.input_dataset, config=args.config, split=args.split,
+        columns=[args.image_column], ids=args.id_column or "index", limit=args.limit,
+    )
+
+    def to_request(row):
+        b64 = encode_image(row[args.image_column], SERVING["max_pixels"])
+        return {
+            "model": SERVING["model"],
+            "messages": [{"role": "user", "content": [
+                {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b64}"}},
+                {"type": "text", "text": OCR_PROMPT},
+            ]}],
+            "temperature": SERVING["temperature"],
+            "max_tokens": args.max_tokens,
+            "chat_template_kwargs": {"enable_thinking": False},
+        }
+
+    def parse(row, body):
+        text = body["choices"][0]["message"]["content"].strip()
+        if not args.keep_image_tags:
+            text = filter_image_tags(text)
+        text = clean_truncated_repeats(text)
+        usage = body.get("usage") or {}
+        return {
+            "markdown": text,
+            "model": SERVING["model"],
+            "prompt_tokens": usage.get("prompt_tokens"),
+            "completion_tokens": usage.get("completion_tokens"),
+        }
+
+    extra = ["--max-model-len", str(SERVING["max_model_len"]), *SERVING["serve_args"]]
+    output = f"hf://datasets/{args.output_dataset}/data"
+    with Engine(SERVING["model"], engine="vllm", extra_args=extra) as endpoint:
+        stats = pump(rows, to_request, parse, endpoint, output,
+                     window=Auto(initial=8, max_limit=48),
+                     retry_errors=args.retry_errors)
+
+    print(f"https://huggingface.co/datasets/{args.output_dataset} "
+          f"({stats.rows_processed} ok, {stats.rows_failed} error rows)", file=sys.stderr)
+    print("OVIS_OCR2_SATURATE " + stats.to_json(), flush=True)
+
+
+if __name__ == "__main__":
+    main()