Add files using upload-large-folder tool

.gitattributes

@@ -58,3 +58,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+fonts/IBMPlexMono-Bold.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/JetBrainsMono-Variable.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/IBMPlexMono-Regular.ttf filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,87 @@
+---
+license: apache-2.0
+language:
+  - en
+  - de
+  - it
+  - fr
+task_categories:
+  - image-to-text
+  - object-detection
+size_categories:
+  - 10K<n<100K
+tags:
+  - ocr
+  - receipts-ocr
+  - receipt
+  - receipts
+  - invoice
+  - document-ai
+  - kie
+  - key-information-extraction
+  - document-parsing
+  - bounding-boxes
+  - synthetic
+  - donut
+  - layoutlm
+  - text-recognition
+pretty_name: "Synthetic Receipts OCR — 32k receipts, word boxes, structured fields"
+---
+
+# synthetic-receipts-ocr
+
+**32,000 synthetic thermal receipts across 5 locales (US/UK/DE/IT/FR), each with pixel-exact word bounding boxes, full transcription, and structured key-information fields — as both a clean render and a photo-degraded pair.** Built for training and evaluating receipt OCR, document KIE (Donut/LayoutLM-style), text detection, and denoising models.
+
+Every number on every receipt **adds up**: line totals × quantities, per-class contained VAT (`ENTH. MwSt 7%`, `DONT TVA 5,5%`, `DI CUI IVA 22%`), US sales tax, cash tendered and change. Models trained on receipts whose math is wrong learn to hallucinate totals; these don't lie.
+
+## What's in a sample?
+
+| column | what |
+|---|---|
+| `image_clean` | PNG, the rendered receipt (thermal-printer aesthetic, 2 font families) |
+| `image_photo` | JPEG, photo-realistic degradation: perspective on a surface, uneven lighting, shadow bands, thermal fade, noise, blur, JPEG grunge |
+| `full_text` | exact printed text, line by line |
+| `words` | word-level boxes on `image_clean` — **exact by construction** (captured during rendering, never re-OCR'd) |
+| `words_photo` | the same boxes mapped into `image_photo` space (axis-aligned hulls) |
+| `homography` | the 3×3 matrix mapping clean → photo coordinates, so you can map anything else |
+| `fields` | structured KIE ground truth: merchant, address, phone, tax id (P.IVA / USt-IdNr / SIRET / VAT No), date, time, receipt no, line items (name, qty, unit price, total, tax rate, **source product title**), subtotal, per-class taxes, total, payment, tendered, change, loyalty |
+| `locale`, `font`, `degradations`, `n_items` | metadata for slicing |
+
+**The ground-truth contract: a field is non-null if and only if its value is printed on the image.** No invisible labels to hallucinate.
+
+## Why synthetic — and what that honestly means
+
+Real receipt datasets are small (CORD ~1k, SROIE ~1k) because receipts are private. Synthetic generation trades realism risk for three things you can't otherwise have: **scale, perfect labels, and zero privacy exposure**. This dataset is **100% synthetic and says so** — no synthetic data is presented as real. What makes it less artificial than most:
+
+- **Line items are real product vocabulary**: 60,000 product titles from the Amazon ESCI dataset (Apache-2.0), run through a thermal-printer abbreviator (`NNSTCK FRY PAN 12`), with the untruncated source title kept in the ground truth — every item name traces to a real product.
+- **Locale realism is enforced, not decorative**: real VAT rate structures per country, locale-true currency/decimal/date formats (`1.234,56 EUR`, `5,5%`), localized section labels (SCONTRINO/BELEG/TICKET, TOTALE/SUMME, RESTO/RUECKGELD), locale-correct phone formats and address order, printed tax registration numbers.
+- **It was adversarially QA'd across three review rounds before publication**: independent inspectors recomputed every number from pixels and ground truth, checked box alignment at 4× zoom, and audited locale consistency — first on a pilot batch (7 systematic defect classes found and fixed: misbound quantity lines, glyph-clipping boxes, a VAT-label rounding bug, unprintable ground truth), then again on samples drawn from the actual production run (2 more: a printed-name/label desync on narrow layouts, a trademarked footer slogan — both fixed, all 32,000 samples regenerated). Category-blind VAT assignment and anglophone merchant names on EU receipts were also caught and fixed (reduced VAT rates now go to food-adjacent items only; Italian receipts are issued by MERCATO ROSSI, not ROSSI'S GROCERY). Finally, every sample passed a machine validation gate — arithmetic, label-locale conventions, and the printed-only contract — shipped in this repo as `generator/validate.py`.
+
+**Limitations, plainly**: monospace thermal-style receipts only — no proportional-font layouts, no handwriting, no 3D crumple, no logos/barcodes yet. Five locales, Latin script. The degradations are parametric, not photographs. **Transfer to real receipt photos is plausible but unmeasured until someone evaluates on real data** — if you do, please share numbers in a discussion.
+
+## The eval split measures generalization, not memorization
+
+`eval` (2,000 receipts) shares **no font** (JetBrains Mono, unseen in train), **no product title** (held-out vocabulary slice), and **no merchant surname** with `train` (30,000). Same generator, disjoint surface distribution — so eval performance means your model learned receipt structure, not these particular pixels.
+
+## How do I use it?
+
+```python
+from datasets import load_dataset
+import json, io
+from PIL import Image
+
+ds = load_dataset("albertobarnabo/synthetic-receipts-ocr", split="train")
+s = ds[0]
+img = Image.open(io.BytesIO(s["image_photo"]))
+fields = json.loads(s["fields"])
+words = json.loads(s["words_photo"])
+print(fields["merchant"], fields["total"], len(words), "words")
+```
+
+Train a Donut-style KIE model on (`image_photo`, `fields`); an OCR/text-recognition model on (`image_photo`, `full_text`); a text detector on (`image_photo`, `words_photo`); a denoiser on (`image_photo` → `image_clean`). The homography supports anything geometric.
+
+## Provenance & reproduction
+
+The **entire generator ships in this repo** (`generator/`): content model, renderer, degradation pipeline, validation gate, and the OFL fonts. Every receipt is a pure function of `(seed, index)` — regenerate, extend to new locales, or scale to millions. Product vocabulary derives from [tasksource/esci](https://huggingface.co/datasets/tasksource/esci) (Apache-2.0). Fonts: Space Mono, IBM Plex Mono, JetBrains Mono (OFL).
+
+Related work from the same author: [the e-commerce search stack](https://huggingface.co/collections/albertobarnabo/the-e-commerce-search-stack-6a61ce392b12ab400f276b31) — the ESCI-trained retrieval models whose corpus supplies this dataset's product vocabulary.

data/eval-0000.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e924aa73d8b77531a3241555a2ba8c1e4b397060ae4a2fde1416ff006e5af18a
+size 239484303

data/train-0000.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d0a1298c0ebc8dbf8d7880f739ea97916538d493b288ae30b30a3ce59d501838
+size 241797273

data/train-0001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0d291b08d8175cf4d7f0a15e490f79fd52a27877c0ddbf46d62d2a723f684138
+size 243076181

data/train-0002.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2e9ffcae89f1e7185b4d9050bab0acc39ddd490817061d5abf7a15afb49e3c3d
+size 244539495

data/train-0003.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7fc43128a09bbe889f7b619a665bb634934c3570cd60027ff25e6823bf31c9e8
+size 242766418

data/train-0004.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dc7e4f5ca8a7fa5c0ad6722be654b4b1c963345d7df560f0f2a67939904f2cab
+size 242987176

data/train-0005.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a9cd58b34a8dcec5f9a8290a48fb9367754b007bab5d824f5c2a06a31de79421
+size 239180397

data/train-0006.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3bfca189bcbf73b40253494f3e23a9ec19eed2b56625b58aaf0a2da671e6e066
+size 241453161

data/train-0007.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6f6cdec9c9c5513205c2709307bfb0190d10f883d66f50c01211e89780ee336a
+size 242550293

data/train-0008.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a2ee8f7222462dc8d6f172847f7c174aa41b93adbb77ea9270db6a7354c5104e
+size 239833279

data/train-0009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a72b27bc6fd190d21875110db3cf5899a026cc05b9f6b21b7df9426511922eab
+size 241627631

data/train-0010.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:185fc34c2cd3b2cc9eff364fcc15509c18952858ad2a49d2f875790171d7f3ae
+size 244395540

data/train-0011.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:926795094e6e511b731926a09788c0698278d09c6190b32ef81b659e390bbbdc
+size 241101809

data/train-0012.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e76d3b1de019af047407a10619ec296f3de383c80aa37d4df837961ee1c97586
+size 242663649

data/train-0013.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3cafe148f424976176f7866104a3395092f6af299dfe62e411315ac26134efaa
+size 241166700

data/train-0014.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f8ecbb43c2b96dc5978ff99db0050f3a5696a4f3a6fefe2451ca07d007295122
+size 241842613

fonts/IBMPlexMono-Bold.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac27abd6450a64dd94467580a02fe6235156d5b92f2926ebbc8e7489df64e0be
+size 137784

fonts/IBMPlexMono-Regular.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a3412f058c7d8dfd9170c41e85ade48e5156ecb89356110ca57a0a27734af46
+size 135580

fonts/JetBrainsMono-Variable.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:48715a42ec242c21e9f02692891e147d022299a52e48d5e413e1a942193ffeda
+size 187208

generator/build.py

@@ -0,0 +1,129 @@
+"""Assemble the dataset: (clean, degraded, text, words, fields) -> parquet.
+
+Split policy — eval generalization is measured, not assumed:
+  train: SpaceMono + IBM Plex fonts, product vocab [0:55000], merchant pool A
+  eval:  JetBrains Mono ONLY, product vocab [55000:60000], merchant pool B
+so an eval receipt shares no font, no product string, and no merchant surname
+with train. Same generator code, disjoint surface distribution.
+
+Usage: build.py --split train --n 30000 --out data/shards [--workers 8]
+       build.py --split eval  --n 2000  --out data/shards
+"""
+import argparse
+import io
+import json
+import random
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from content import ContentGenerator, Receipt
+from degrade import degrade, map_boxes
+from render import ReceiptRenderer
+import render as render_mod
+
+SPLIT_CFG = {
+    "train": dict(seed=11, vocab_lo=0, vocab_hi=55000,
+                  fonts=[("SpaceMono-Regular.ttf", "SpaceMono-Bold.ttf"),
+                         ("IBMPlexMono-Regular.ttf", "IBMPlexMono-Bold.ttf")],
+                  surnames=["ROSSI", "MUELLER", "SMITH", "DUBOIS", "LOPEZ", "JANSEN"]),
+    "eval": dict(seed=77, vocab_lo=55000, vocab_hi=60000,
+                 fonts=[("JetBrainsMono-Variable.ttf", "JetBrainsMono-Variable.ttf")],
+                 surnames=["KOWALSKI", "BROWN", "GARCIA", "WEBER", "MORETTI", "LARSEN"]),
+}
+
+
+def fields_of(r: Receipt) -> dict:
+    """GT contract: a field is non-null IFF its value is printed on the image."""
+    return {
+        "locale": r.locale, "merchant": r.merchant, "address": r.address,
+        "phone": r.phone if r.show_phone else None,
+        "tax_id": r.tax_id,
+        "date": r.date, "time": r.time,
+        "receipt_no": r.receipt_no, "cashier": r.cashier,
+        "currency": "USD" if r.locale == "US" else ("GBP" if r.locale == "UK" else "EUR"),
+        "lines": [{"name": l.name, "qty": l.qty, "unit_price": l.unit_price,
+                   "total": l.total, "tax_rate": l.tax_rate,
+                   "source_title": l.source_title} for l in r.lines],
+        "subtotal": r.subtotal if r.show_subtotal else None,
+        "taxes": [{"label": lab, "rate": rate, "amount": amt} for lab, rate, amt in r.tax_lines],
+        "tax_included": r.tax_included,
+        "total": r.total, "payment": r.payment,
+        "tendered": r.tendered, "change": r.change,
+        "loyalty": r.loyalty,
+    }
+
+
+def png_bytes(img) -> bytes:
+    b = io.BytesIO(); img.save(b, "PNG", optimize=True); return b.getvalue()
+
+
+def jpg_bytes(img) -> bytes:
+    b = io.BytesIO(); img.convert("L").save(b, "JPEG", quality=90); return b.getvalue()
+
+
+def make_sample(args):
+    idx, split = args
+    cfg = SPLIT_CFG[split]
+    gen = _GEN[split]
+    ren = _REN[split]
+    r = gen.generate(idx)
+    out = ren.render(r, idx)
+    rng = random.Random((cfg["seed"] << 24) ^ idx)
+    deg, H3, notes = degrade(out.image, rng)
+    return {
+        "id": f"{split}-{idx:06d}",
+        "image_clean": png_bytes(out.image),
+        "image_photo": jpg_bytes(deg),
+        "full_text": out.full_text,
+        "words": json.dumps(out.words),
+        "words_photo": json.dumps(map_boxes(out.words, H3)),
+        "homography": json.dumps([[round(float(x), 6) for x in row] for row in H3]),
+        "fields": json.dumps(fields_of(r)),
+        "locale": r.locale,
+        "degradations": ",".join(notes),
+        "font": out.meta["font"],
+        "n_items": len(r.lines),
+        "split_policy": "heldout-font+vocab+merchants" if split == "eval" else "train",
+    }
+
+
+_GEN, _REN = {}, {}
+
+
+def _init(split):
+    cfg = SPLIT_CFG[split]
+    g = ContentGenerator(seed=cfg["seed"])
+    g.vocab = g.vocab[cfg["vocab_lo"]:cfg["vocab_hi"]]
+    g._surnames = cfg["surnames"]
+    render_mod.FONT_FILES = cfg["fonts"]
+    _GEN[split] = g
+    _REN[split] = ReceiptRenderer(seed=cfg["seed"])
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--split", choices=["train", "eval"], required=True)
+    ap.add_argument("--n", type=int, required=True)
+    ap.add_argument("--out", default="data/shards")
+    ap.add_argument("--shard-size", type=int, default=2000)
+    args = ap.parse_args()
+
+    _init(args.split)
+    outdir = Path(args.out); outdir.mkdir(parents=True, exist_ok=True)
+    import pyarrow as pa, pyarrow.parquet as pq
+
+    buf, shard = [], 0
+    for i in range(args.n):
+        buf.append(make_sample((i, args.split)))
+        if len(buf) >= args.shard_size or i == args.n - 1:
+            table = pa.Table.from_pylist(buf)
+            pq.write_table(table, outdir / f"{args.split}-{shard:04d}.parquet",
+                           compression="zstd")
+            print(f"shard {shard}: {len(buf)} samples (through {i+1}/{args.n})", flush=True)
+            buf, shard = [], shard + 1
+    print("DONE", args.split, args.n)
+
+
+if __name__ == "__main__":
+    main()

generator/content.py

@@ -0,0 +1,296 @@
+"""Receipt content model v2 — everything printed, nothing unprintable in GT.
+
+Post-QA fixes baked in (24-sample adversarial review, 2026-07-24):
+  - US: ONE sales-tax rate per receipt (a store has one jurisdiction); GT rate
+    always reproduces the printed amount exactly.
+  - EU labels localized (TOTALE/SUMME, CONTANTI/BAR/ESPECES, RESTO/RUECKGELD),
+    VAT % formatted exactly (5.5% never becomes 6%).
+  - Payment methods, phone formats (+39/+49/+1...), and address order are
+    locale-consistent; EC-KARTE can no longer pay for a New York deli run.
+  - Printed-only ground truth: phone/subtotal/loyalty appear in fields ONLY if
+    the renderer prints them (decided here via show_* flags).
+  - VAT-registered locales print a tax id (P.IVA / USt-IdNr / SIRET / VAT No),
+    which is also a labeled KIE field.
+  - Dates capped at 2025 (no future receipts in a 2026 build).
+"""
+import json
+import random
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+DATA = Path(__file__).resolve().parent.parent / "data"
+
+LOCALES = {
+    "US": dict(cur="$", cur_pos="pre", dec=".", thou=",", date="{m:02d}/{d:02d}/{y}",
+               tax_name="TAX", tax_rates=(0.04, 0.06, 0.0725, 0.0825, 0.095), tax_incl=False),
+    "UK": dict(cur="£", cur_pos="pre", dec=".", thou=",", date="{d:02d}/{m:02d}/{y}",
+               tax_name="VAT", tax_rates=(0.20,), tax_incl=True),
+    "DE": dict(cur="EUR", cur_pos="post", dec=",", thou=".", date="{d:02d}.{m:02d}.{y}",
+               tax_name="MwSt", tax_rates=(0.19, 0.07), tax_incl=True),
+    "IT": dict(cur="EUR", cur_pos="post", dec=",", thou=".", date="{d:02d}/{m:02d}/{y}",
+               tax_name="IVA", tax_rates=(0.22, 0.10, 0.04), tax_incl=True),
+    "FR": dict(cur="EUR", cur_pos="post", dec=",", thou=" ", date="{d:02d}/{m:02d}/{y}",
+               tax_name="TVA", tax_rates=(0.20, 0.055), tax_incl=True),
+}
+
+STORE_KINDS = {
+    "US": ["MARKET", "SUPERMARKET", "MINIMART", "TRADING", "STORES", "EXPRESS", "CORNER SHOP"],
+    "UK": ["MARKET", "SUPERMARKET", "MINIMART", "STORES", "EXPRESS", "CORNER SHOP"],
+    "DE": ["MARKT", "SUPERMARKT", "KAUFHAUS", "HANDEL"],
+    "IT": ["MERCATO", "SUPERMERCATO", "EMPORIO", "MERCERIA"],
+    "FR": ["MARCHE", "SUPERMARCHE", "BAZAR", "COMPTOIR"],
+}
+
+FLAVOR = {
+    "US": dict(streets=["MAIN ST", "ELM AVE", "OAK BLVD", "5TH AVENUE", "MAPLE DR", "BROADWAY"],
+               addr="num-first",
+               cashiers=["ANNA", "MIKE", "J.SMITH", "OP-04", "TILL 3", "REG 02"],
+               rcpt="RECEIPT",
+               payments=["CASH", "VISA DEBIT", "VISA CREDIT", "MASTERCARD", "AMEX",
+                         "CONTACTLESS", "APPLE PAY"],
+               labels=dict(subtotal="SUBTOTAL", total="TOTAL", cash="CASH", change="CHANGE",
+                           incl="INCL"),
+               loyalty="LOYALTY PTS +{n}",
+               phone="us",
+               tax_id=None,
+               footers=["THANK YOU FOR SHOPPING WITH US", "PLEASE COME AGAIN", "HAVE A NICE DAY",
+                        "RETURNS WITHIN 30 DAYS WITH RECEIPT", "ALL ITEMS SUBJECT TO AVAILABILITY"]),
+    "UK": dict(streets=["HIGH STREET", "STATION RD", "KING ST", "PARK LANE", "CHURCH LANE"],
+               addr="num-first",
+               cashiers=["TILL 3", "TILL 1", "S. PATEL", "OP-11", "EMMA"],
+               rcpt="RECEIPT",
+               payments=["CASH", "VISA DEBIT", "MASTERCARD", "CONTACTLESS", "APPLE PAY", "MAESTRO"],
+               labels=dict(subtotal="SUBTOTAL", total="TOTAL", cash="CASH", change="CHANGE",
+                           incl="INCL"),
+               loyalty="LOYALTY PTS +{n}",
+               phone="uk",
+               tax_id="uk",
+               footers=["THANK YOU FOR SHOPPING WITH US", "KEEP RECEIPT FOR RETURNS", "PLEASE COME AGAIN"]),
+    "DE": dict(streets=["BAHNHOFSTR.", "HAUPTSTR.", "GARTENWEG", "MARKTPLATZ", "SCHILLERSTR."],
+               addr="street-first",
+               cashiers=["KASSE 2", "KASSE 1", "S. WEBER", "BED. 04"],
+               rcpt="BELEG",
+               payments=["BAR", "EC-KARTE", "GIROCARD", "VISA", "MASTERCARD", "KONTAKTLOS"],
+               labels=dict(subtotal="ZWISCHENSUMME", total="SUMME", cash="BAR",
+                           change="RUECKGELD", incl="ENTH."),
+               loyalty="PUNKTE +{n}",
+               phone="de",
+               tax_id="de",
+               footers=["VIELEN DANK FUER IHREN EINKAUF", "AUF WIEDERSEHEN", "BITTE BELEG AUFBEWAHREN"]),
+    "IT": dict(streets=["VIA ROMA", "CORSO ITALIA", "VIA GARIBALDI", "PIAZZA DANTE", "VIA VERDI"],
+               addr="street-first",
+               cashiers=["CASSA 2", "CASSA 1", "LUCIA", "OP. 03"],
+               rcpt="SCONTRINO",
+               payments=["CONTANTI", "BANCOMAT", "VISA", "MASTERCARD", "CARTA CONTACTLESS"],
+               labels=dict(subtotal="SUBTOTALE", total="TOTALE", cash="CONTANTI",
+                           change="RESTO", incl="DI CUI"),
+               loyalty="PUNTI +{n}",
+               phone="it",
+               tax_id="it",
+               footers=["GRAZIE E ARRIVEDERCI", "CONSERVARE LO SCONTRINO", "GRAZIE PER LA VISITA"]),
+    "FR": dict(streets=["RUE DE LA GARE", "AVENUE VICTOR HUGO", "RUE DU MARCHE", "BD SAINT-MICHEL"],
+               addr="street-first",
+               cashiers=["CAISSE 1", "CAISSE 2", "MARIE", "OP. 07"],
+               rcpt="TICKET",
+               payments=["ESPECES", "CB", "VISA", "MASTERCARD", "SANS CONTACT"],
+               labels=dict(subtotal="SOUS-TOTAL", total="TOTAL", cash="ESPECES",
+                           change="RENDU", incl="DONT"),
+               loyalty="POINTS FIDELITE +{n}",
+               phone="fr",
+               tax_id="fr",
+               footers=["MERCI DE VOTRE VISITE", "A BIENTOT", "CONSERVEZ VOTRE TICKET"]),
+}
+
+_PHONE = {
+    "us": lambda rng: f"+1 ({rng.randint(201,989)}) {rng.randint(200,999)}-{rng.randint(1000,9999)}",
+    "uk": lambda rng: f"+44 {rng.randint(1200,7999)} {rng.randint(100000,999999)}",
+    "de": lambda rng: f"+49 {rng.randint(30,89)} {rng.randint(1000000,9999999)}",
+    "it": lambda rng: f"+39 0{rng.randint(2,9)} {rng.randint(1000000,9999999)}",
+    "fr": lambda rng: f"+33 {rng.randint(1,5)} " + " ".join(f"{rng.randint(10,99)}" for _ in range(4)),
+}
+_TAX_ID = {
+    "uk": lambda rng: f"VAT NO GB{rng.randint(100000000,999999999)}",
+    "de": lambda rng: f"USt-IdNr DE{rng.randint(100000000,999999999)}",
+    "it": lambda rng: f"P.IVA {rng.randint(10000000000,99999999999)}",
+    "fr": lambda rng: f"SIRET {rng.randint(10000000000000,99999999999999)}",
+}
+
+_VOWELS = str.maketrans("", "", "aeiouAEIOU")
+_CASH_WORDS = {"CASH", "BAR", "CONTANTI", "ESPECES"}
+_FOOD_WORDS = re.compile(r"\b(coffee|tea|chocolate|candy|snack|cookie|biscuit|pasta|sauce|"
+                         r"oil|olive|milk|juice|water|soda|cereal|granola|honey|jam|spice|"
+                         r"seasoning|flour|sugar|rice|bean|nut|dried|organic|gluten.free|"
+                         r"protein|vitamin|supplement|food|grocery)\b", re.I)
+
+
+def _abbrev_word(w: str, rng: random.Random) -> str:
+    if len(w) <= 4 or w.isdigit():
+        return w
+    style = rng.random()
+    if style < 0.35:
+        return (w[0] + w[1:].translate(_VOWELS))[:8]
+    if style < 0.7:
+        return w[: rng.choice((3, 4, 5, 6))]
+    return w
+
+
+def receipt_item_name(title: str, brand: str, rng: random.Random) -> tuple[str, str]:
+    """(printed item text, exact source title) — both stored, pair auditable."""
+    clean_title = title.strip()
+    words = re.sub(r"[^\w\s%/.-]", " ", clean_title).split()
+    lead = ""
+    if brand and rng.random() < 0.6:
+        lead = brand.upper().split()[0][:8]
+        words = [w for w in words if w.lower() != lead.lower()]
+    keep = [w for w in words if len(w) > 2 or w.isdigit()][: rng.choice((2, 3, 3, 4))]
+    out = " ".join(_abbrev_word(w, rng).upper() for w in keep)
+    out = (f"{lead} {out}" if lead else out).strip()
+    return out[:24] or "ITEM", clean_title
+
+
+@dataclass
+class Line:
+    name: str
+    qty: int
+    unit_price: float
+    total: float
+    tax_rate: float
+    source_title: str
+
+
+@dataclass
+class Receipt:
+    locale: str
+    merchant: str
+    address: str
+    phone: str
+    show_phone: bool
+    tax_id: str | None
+    date: str
+    time: str
+    receipt_no: str
+    cashier: str
+    rcpt_word: str
+    labels: dict
+    lines: list = field(default_factory=list)
+    subtotal: float = 0.0
+    show_subtotal: bool = False
+    tax_lines: list = field(default_factory=list)   # (printed_label, rate, amount)
+    total: float = 0.0
+    payment: str = ""
+    tendered: float | None = None
+    change: float | None = None
+    loyalty: str | None = None
+    footer: str = ""
+    tax_included: bool = False
+
+
+def _pct(rate: float, dec: str = ".") -> str:
+    out = f"{rate * 100:g}%"           # 0.055 -> '5.5%', 0.20 -> '20%'
+    return out.replace(".", dec)       # FR/DE/IT receipts write '5,5%'
+
+
+class ContentGenerator:
+    def __init__(self, seed: int = 0):
+        self.vocab = json.loads((DATA / "product_vocab.json").read_text())
+        self.brands = json.loads((DATA / "brand_vocab.json").read_text())
+        self.seed = seed
+
+    def merchant_name(self, rng: random.Random, locale: str) -> str:
+        kinds = STORE_KINDS[locale]
+        if rng.random() < 0.4:
+            base = rng.choice(self.brands) or "ACME"
+            base = re.sub(r"[^A-Za-z ]", "", base).strip().upper() or "ACME"
+            name = base.split()[0]
+        else:
+            pool = getattr(self, "_surnames", ["ROSSI", "MUELLER", "SMITH", "DUBOIS", "LOPEZ",
+                                               "JANSEN", "KOWALSKI", "BROWN", "GARCIA", "WEBER",
+                                               "MORETTI", "LARSEN"])
+            name = rng.choice(pool)
+        if locale in ("US", "UK"):
+            # possessive only in anglophone locales
+            lead = f"{name}'S" if rng.random() < 0.6 else name
+            return f"{lead} {rng.choice(kinds)}"[:28]
+        # romance/germanic order: SUPERMERCATO ROSSI / MARKT WEBER
+        return f"{rng.choice(kinds)} {name}"[:28]
+
+    def generate(self, idx: int) -> Receipt:
+        rng = random.Random((self.seed << 20) ^ idx)
+        locale = rng.choices(list(LOCALES), weights=[40, 15, 15, 15, 15])[0]
+        L, F = LOCALES[locale], FLAVOR[locale]
+
+        y, m, d = rng.randint(2019, 2025), rng.randint(1, 12), rng.randint(1, 28)
+        n_items = rng.choices((1, 2, 3, 4, 5, 6, 8, 10, 13),
+                              weights=(5, 10, 16, 18, 16, 12, 10, 8, 5))[0]
+
+        # US: one jurisdiction, one rate per receipt. EU: per-item VAT class.
+        us_rate = rng.choice(L["tax_rates"])
+        lines, subtotal = [], 0.0
+        buckets: dict = {}
+        for _ in range(n_items):
+            v = rng.choice(self.vocab)
+            qty = rng.choices((1, 1, 1, 2, 3), weights=(60, 15, 10, 10, 5))[0]
+            unit = round(rng.choice((0.49, 0.79, 0.99, 1.29, 1.49, 1.99, 2.49, 2.99, 3.49,
+                                     4.99, 5.99, 7.99, 9.99, 12.99, 14.99, 19.99, 24.99,
+                                     29.99, 49.99)) * rng.choice((1, 1, 1, 1, 2)), 2)
+            if not L["tax_incl"]:
+                rate = us_rate
+            else:
+                rates = L["tax_rates"]
+                if len(rates) > 1 and _FOOD_WORDS.search(v["t"]):
+                    rate = rng.choice(rates[1:])   # reduced classes: food-adjacent only
+                else:
+                    rate = rates[0]                # standard rate for general goods
+            name, src = receipt_item_name(v["t"], v["b"], rng)
+            tot = round(qty * unit, 2)
+            lines.append(Line(name, qty, unit, tot, rate, src))
+            subtotal = round(subtotal + tot, 2)
+            buckets[rate] = round(buckets.get(rate, 0.0) + tot, 2)
+
+        tax_lines = []
+        if L["tax_incl"]:
+            for rate, gross in sorted(buckets.items()):
+                amt = round(gross - gross / (1 + rate), 2)
+                tax_lines.append((f"{L['tax_name']} {_pct(rate, L['dec'])}", rate, amt))
+            total = subtotal
+        else:
+            amt = round(subtotal * us_rate, 2)
+            label = f"{L['tax_name']} {_pct(us_rate, L['dec'])}" if rng.random() < 0.5 else L["tax_name"]
+            tax_lines.append((label, us_rate, amt))
+            total = round(subtotal + amt, 2)
+
+        payment = rng.choice(F["payments"])
+        tendered = change = None
+        if payment in _CASH_WORDS:
+            step = 5.0
+            tendered = float(int(total // step + 1) * step) if total % step else total
+            if rng.random() < 0.3:
+                tendered = round(total + rng.choice((0.01, 0.50, 1.00, 2.00)), 2)
+            change = round(tendered - total, 2)
+
+        street = rng.choice(F["streets"])
+        num = rng.randint(1, 299)
+        return Receipt(
+            locale=locale, merchant=self.merchant_name(rng, locale),
+            address=f"{num} {street}" if F["addr"] == "num-first" else f"{street} {num}",
+            phone=_PHONE[F["phone"]](rng), show_phone=rng.random() < 0.7,
+            tax_id=(_TAX_ID[F["tax_id"]](rng) if (F["tax_id"] and rng.random() < 0.8) else None),
+            date=L["date"].format(d=d, m=m, y=y),
+            time=f"{rng.randint(7,22):02d}:{rng.randint(0,59):02d}",
+            receipt_no=f"{rng.randint(1,9)}-{rng.randint(10000,99999)}-{rng.randint(100,999)}",
+            cashier=rng.choice(F["cashiers"]), rcpt_word=F["rcpt"], labels=F["labels"],
+            lines=lines, subtotal=subtotal, show_subtotal=not L["tax_incl"],
+            tax_lines=tax_lines, total=total, payment=payment,
+            tendered=tendered, change=change,
+            loyalty=(F["loyalty"].format(n=rng.randint(1,99)) if rng.random() < 0.35 else None),
+            footer=rng.choice(F["footers"]), tax_included=L["tax_incl"],
+        )
+
+
+def fmt_money(x: float, locale: str) -> str:
+    L = LOCALES[locale]
+    s = f"{x:,.2f}"
+    if L["dec"] == ",":
+        s = s.replace(",", "@SEP@").replace(".", ",").replace("@SEP@", L["thou"])
+    return f"{L['cur']}{s}" if L["cur_pos"] == "pre" else f"{s} {L['cur']}"

generator/degrade.py

@@ -0,0 +1,138 @@
+"""Photo-realistic degradation of clean receipt renders.
+
+Every sample ships as a PAIR (clean, degraded) plus the 3x3 homography H that
+maps clean-image coordinates to degraded-image coordinates. Word boxes are
+exact on the clean image by construction; degraded-space boxes are the
+axis-aligned hull of the box corners mapped through H — stated as such, never
+pretended to be tight rotated boxes.
+
+Degradations (each applied with probability, severity seeded):
+  geometric:   small rotation, perspective keystone, translation on a larger
+               "table" background
+  photometric: uneven lighting gradient, hard shadow band, thermal fade bands
+               (the classic dying-receipt look), gaussian + salt noise, mild
+               blur, JPEG round-trip
+"""
+import io
+import random
+
+import numpy as np
+from PIL import Image, ImageFilter
+
+
+def _perspective_coeffs(src, dst):
+    A = []
+    for (x, y), (u, v) in zip(src, dst):
+        A.append([x, y, 1, 0, 0, 0, -u * x, -u * y])
+        A.append([0, 0, 0, x, y, 1, -v * x, -v * y])
+    A = np.asarray(A, dtype=np.float64)
+    b = np.asarray([c for pt in dst for c in pt], dtype=np.float64)
+    h = np.linalg.solve(A, b)
+    return h  # 8 coeffs for PIL, maps DST->SRC when used with Image.transform
+
+
+def degrade(img: Image.Image, rng: random.Random):
+    """Returns (degraded RGB image, H 3x3 clean->degraded, notes list)."""
+    notes = []
+    w, h = img.size
+    # place on a slightly larger background ("photo of a receipt on a surface")
+    mx, my = int(w * rng.uniform(0.04, 0.14)), int(h * rng.uniform(0.03, 0.10))
+    W, H_ = w + 2 * mx, h + 2 * my
+    bg_shade = rng.randint(120, 210)
+    bg = Image.new("L", (W, H_), bg_shade)
+    bg.paste(img, (mx, my))
+
+    # target quad: perspective jitter of the pasted receipt's corners
+    jx, jy = w * 0.06, h * 0.03
+    src = [(mx, my), (mx + w, my), (mx + w, my + h), (mx, my + h)]
+    dst = [(sx + rng.uniform(-jx, jx), sy + rng.uniform(-jy, jy)) for sx, sy in src]
+    if rng.random() < 0.25:  # sometimes keep it flat-scanned
+        dst = src
+        notes.append("flat")
+    else:
+        notes.append("perspective")
+    coeffs = _perspective_coeffs(dst, src)  # PIL wants dst->src
+    warped = bg.transform((W, H_), Image.PERSPECTIVE, coeffs, resample=Image.BICUBIC,
+                          fillcolor=bg_shade)
+
+    # H mapping clean (x,y) -> degraded: translate then the src->dst homography.
+    A = []
+    for (x, y), (u, v) in zip(src, dst):
+        A.append([x, y, 1, 0, 0, 0, -u * x, -u * y])
+        A.append([0, 0, 0, x, y, 1, -v * x, -v * y])
+    hcoef = np.linalg.solve(np.asarray(A, float),
+                            np.asarray([c for pt in dst for c in pt], float))
+    Hm = np.array([[hcoef[0], hcoef[1], hcoef[2]],
+                   [hcoef[3], hcoef[4], hcoef[5]],
+                   [hcoef[6], hcoef[7], 1.0]])
+    T = np.array([[1, 0, mx], [0, 1, my], [0, 0, 1.0]])
+    H3 = Hm @ T
+
+    arr = np.asarray(warped, dtype=np.float32)
+
+    # uneven lighting: low-frequency MULTIPLICATIVE gradient (additive version
+    # clipped to a hard white band across paper AND background — QA finding)
+    if rng.random() < 0.8:
+        gx = np.linspace(rng.uniform(-1, 1), rng.uniform(-1, 1), arr.shape[1])
+        gy = np.linspace(rng.uniform(-1, 1), rng.uniform(-1, 1), arr.shape[0])
+        grad = 1.0 + np.outer(gy, gx) * rng.uniform(0.04, 0.11)
+        arr = arr * grad
+        notes.append("lighting")
+
+    # hard shadow band (phone photo classic)
+    if rng.random() < 0.35:
+        x0 = rng.randint(0, arr.shape[1] - 1)
+        width = rng.randint(arr.shape[1] // 6, arr.shape[1] // 2)
+        mask = np.zeros(arr.shape[1]); mask[x0:x0 + width] = 1
+        mask = np.convolve(mask, np.ones(31) / 31, mode="same")
+        arr = arr - mask[None, :] * rng.uniform(15, 45)
+        notes.append("shadow")
+
+    # thermal fade: vertical bands where the print is dying
+    if rng.random() < 0.4:
+        n_bands = rng.randint(1, 3)
+        for _ in range(n_bands):
+            y0 = rng.randint(0, arr.shape[0] - 1)
+            bh = rng.randint(arr.shape[0] // 12, arr.shape[0] // 5)
+            fade = np.zeros(arr.shape[0]); fade[y0:y0 + bh] = 1
+            fade = np.convolve(fade, np.ones(21) / 21, mode="same")
+            # push dark pixels toward paper (ink fading), leave paper alone
+            dark = arr < 150
+            arr = np.where(dark, arr + fade[:, None] * rng.uniform(40, 110), arr)
+        notes.append("thermal_fade")
+
+    # noise
+    if rng.random() < 0.85:
+        arr = arr + np.random.default_rng(rng.getrandbits(32)).normal(
+            0, rng.uniform(2, 9), arr.shape)
+        notes.append("noise")
+
+    arr = np.clip(arr, 0, 255).astype(np.uint8)
+    out = Image.fromarray(arr, "L")
+
+    if rng.random() < 0.5:
+        out = out.filter(ImageFilter.GaussianBlur(rng.uniform(0.4, 1.1)))
+        notes.append("blur")
+
+    # JPEG round-trip grunge
+    q = rng.randint(55, 92)
+    buf = io.BytesIO()
+    out.convert("RGB").save(buf, "JPEG", quality=q)
+    out = Image.open(buf).convert("L")
+    notes.append(f"jpeg{q}")
+
+    return out, H3, notes
+
+
+def map_boxes(words, H3):
+    """Clean-space word boxes -> degraded-space axis-aligned hulls."""
+    out = []
+    for wd in words:
+        corners = np.array([[wd["x0"], wd["y0"], 1], [wd["x1"], wd["y0"], 1],
+                            [wd["x1"], wd["y1"], 1], [wd["x0"], wd["y1"], 1]], float).T
+        p = H3 @ corners
+        p = p[:2] / p[2]
+        out.append({"text": wd["text"],
+                    "x0": float(p[0].min()), "y0": float(p[1].min()),
+                    "x1": float(p[0].max()), "y1": float(p[1].max())})
+    return out

generator/render.py

@@ -0,0 +1,125 @@
+"""Pillow renderer v2: Receipt -> thermal image + ink-accurate word boxes.
+
+Post-QA fixes:
+  - word box y-extent comes from draw.textbbox of the actual line (real ink,
+    ascenders+descenders), not the nominal font size — boxes were clipping
+    glyph bottoms by 15-50% before
+  - quantity detail line ('2 x $24.99') prints UNDER its item, as real
+    printers do — it visually bound to the WRONG item before
+  - localized section labels (TOTALE / SUMME / RESTO ...), tax-id line,
+    phone printed iff Receipt.show_phone (GT mirrors print exactly)
+"""
+import random
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from PIL import Image, ImageDraw, ImageFont
+
+from content import Receipt, fmt_money
+
+FONTS = Path(__file__).resolve().parent.parent / "fonts"
+FONT_FILES = [("SpaceMono-Regular.ttf", "SpaceMono-Bold.ttf"),
+              ("IBMPlexMono-Regular.ttf", "IBMPlexMono-Bold.ttf")]
+
+
+@dataclass
+class Rendered:
+    image: Image.Image
+    full_text: str
+    words: list = field(default_factory=list)
+    meta: dict = field(default_factory=dict)
+
+
+class ReceiptRenderer:
+    def __init__(self, seed: int = 0):
+        self.seed = seed
+
+    def render(self, r: Receipt, idx: int) -> Rendered:
+        rng = random.Random((self.seed << 21) ^ (idx * 2654435761))
+        cols = rng.choice((32, 38, 42, 48))
+        fsize = rng.choice((20, 22, 24))
+        reg_f, bold_f = FONT_FILES[rng.randrange(len(FONT_FILES))]
+        font = ImageFont.truetype(str(FONTS / reg_f), fsize)
+        bold = ImageFont.truetype(str(FONTS / bold_f), fsize)
+        cw = font.getbbox("M")[2]
+        lh = int(fsize * rng.uniform(1.25, 1.45))
+        pad = rng.randint(14, 30)
+
+        lines = self._layout(r, cols, rng)
+        W = cols * cw + 2 * pad
+        H = len(lines) * lh + 2 * pad + rng.randint(0, 40)
+        paper = rng.randint(238, 252)
+        img = Image.new("L", (W, H), paper)
+        draw = ImageDraw.Draw(img)
+
+        words, out_lines = [], []
+        y = pad
+        for text, style in lines:
+            f = bold if style == "bold" else font
+            x0 = pad + (max(0, (cols - len(text)) // 2) * cw if style == "center" else 0)
+            draw.text((x0, y), text, font=f, fill=rng.randint(20, 70))
+            if text.strip():
+                # real ink extent of this line (ascenders + descenders)
+                bb = draw.textbbox((x0, y), text, font=f)
+                iy0, iy1 = bb[1], bb[3]
+                col = 0
+                for w in text.split(" "):
+                    if w and set(w) != {"-"}:
+                        wx0 = x0 + col * cw
+                        words.append({"text": w, "x0": wx0, "y0": iy0,
+                                      "x1": wx0 + len(w) * cw, "y1": iy1})
+                    col += len(w) + 1
+            out_lines.append(text)
+            y += lh
+        return Rendered(image=img, full_text="\n".join(out_lines), words=words,
+                        meta={"cols": cols, "font": reg_f, "fontsize": fsize})
+
+    def _layout(self, r: Receipt, cols: int, rng: random.Random):
+        L = []
+        lab = r.labels
+        money = lambda x: fmt_money(x, r.locale)
+
+        def kv(left: str, right: str, style="plain"):
+            gap = cols - len(left) - len(right)
+            L.append((left + " " * max(1, gap) + right if gap > 0
+                      else (left[: cols - len(right) - 1] + " " + right), style))
+
+        L.append((r.merchant[:cols], "bold" if rng.random() < 0.8 else "center"))
+        L.append((r.address[:cols], "center"))
+        if r.show_phone:
+            L.append((f"TEL {r.phone}"[:cols], "center"))
+        if r.tax_id:
+            L.append((r.tax_id[:cols], "center"))
+        L.append(("-" * cols, "plain"))
+        kv(r.date, r.time)
+        kv(f"{r.rcpt_word} {r.receipt_no}"[: cols - 8], r.cashier)
+        L.append(("-" * cols, "plain"))
+        for ln in r.lines:
+            price = money(ln.total)
+            printed = ln.name[: cols - len(price) - 1].rstrip()
+            # drop a trailing bare-digit token: 'SWEET HOME 7  9,98' reads as 79,98
+            toks = printed.split(" ")
+            if len(toks) > 1 and toks[-1].isdigit():
+                printed = " ".join(toks[:-1])
+            ln.name = printed                    # GT stores EXACTLY what is printed
+            kv(printed, price)
+            if ln.qty > 1:                       # multiplier goes UNDER its item
+                L.append((f"  {ln.qty} x {money(ln.unit_price)}"[: cols], "plain"))
+        L.append(("-" * cols, "plain"))
+        if r.show_subtotal:
+            kv(lab["subtotal"], money(r.subtotal))
+            for label, _, amt in r.tax_lines:
+                kv(label, money(amt))
+        kv(lab["total"], money(r.total), "bold")
+        if r.tax_included:
+            for label, _, amt in r.tax_lines:
+                kv(f"{lab['incl']} {label}", money(amt))
+        L.append((" ", "plain"))
+        kv(r.payment, money(r.tendered if r.tendered is not None else r.total))
+        if r.change is not None:
+            kv(lab["change"], money(r.change))
+        if r.loyalty:
+            L.append((r.loyalty[:cols], "plain"))
+        L.append((" ", "plain"))
+        L.append((r.footer[:cols], "center"))
+        return L

generator/validate.py

@@ -0,0 +1,39 @@
+"""Machine gate over every generated shard — run before any upload."""
+import json, sys
+from pathlib import Path
+import pyarrow.parquet as pq
+
+n = bad = 0
+for shard in sorted(Path(sys.argv[1]).glob("*.parquet")):
+    for s in pq.read_table(shard).to_pylist():
+        n += 1
+        try:
+            f = json.loads(s["fields"])
+            sub = round(sum(l["total"] for l in f["lines"]), 2)
+            for l in f["lines"]:
+                assert abs(l["qty"] * l["unit_price"] - l["total"]) < 0.005
+            if f["tax_included"]:
+                assert f["subtotal"] is None and abs(sub - f["total"]) < 0.005
+                for t in f["taxes"]:
+                    base = round(sum(l["total"] for l in f["lines"]
+                                     if abs(l["tax_rate"] - t["rate"]) < 1e-9), 2)
+                    assert abs(round(base - base / (1 + t["rate"]), 2) - t["amount"]) < 0.011
+                    assert not (s["locale"] != "US" and "." in t["label"])
+            else:
+                t = f["taxes"][0]
+                assert abs(round(f["subtotal"] * t["rate"], 2) - t["amount"]) < 0.005
+                assert abs(f["subtotal"] + t["amount"] - f["total"]) < 0.005
+            if f["change"] is not None:
+                assert abs(f["tendered"] - f["total"] - f["change"]) < 0.005
+            tel_printed = any(l.strip().startswith("TEL ") for l in s["full_text"].split("\n"))
+            assert (f["phone"] is not None) == tel_printed
+            for l in f["lines"]:
+                assert l["name"] in s["full_text"], ("GT name not printed", l["name"])
+            if f["loyalty"]: assert f["loyalty"] in s["full_text"]
+            words = json.loads(s["words"])
+            assert len(words) > 10 and all(w["x1"] > w["x0"] and w["y1"] > w["y0"] for w in words)
+        except AssertionError as e:
+            bad += 1
+            print("FAIL", s["id"], e)
+print(f"validated {n} samples, {bad} failures")
+sys.exit(1 if bad else 0)