scripts/v1_1/render.py

"""Turn document items into extracted-text rows.

A document is a list of items: ``("line", text)``, ``("kv", label, value)`` or
``("table", header, rows)``. A layout decides how the items become text, the
way different PDF extractors (PyMuPDF, pdftotext -raw, Docling markdown, a
CSV export) print the same page. Title lines are tagged so a row can be
rendered with the title on top, at the bottom (footer-only form IDs), or not
at all (cropped scans), which forces the content to carry the label.
"""

from __future__ import annotations

import random
import re

from specs import COINS, EXTRA_POOLS, FIRST, LAST, MAKES, SECURITIES, STREETS, CITIES
import specs

FORM_LAYOUTS = ["stacked", "inline", "columns", "boxed", "flat", "markdown"]
STATEMENT_LAYOUTS = ["stacked", "inline", "columns", "csv", "flat", "markdown"]
TITLE = "title"


# ── Values ──────────────────────────────────────────────────────────────────

def money(rng: random.Random, low: float, high: float, dollar: float = 0.5) -> str:
    """Return a formatted amount, sometimes with a dollar sign."""
    value = rng.uniform(low, high)
    text = f"{value:,.2f}"
    return ("$" + text) if rng.random() < dollar else text


def date(rng: random.Random, year: int) -> str:
    """Return a date in one of the formats statements print."""
    m, d = rng.randint(1, 12), rng.randint(1, 28)
    style = rng.randrange(4)
    if style == 0:
        return f"{m:02d}/{d:02d}/{year}"
    if style == 1:
        return f"{year}-{m:02d}-{d:02d}"
    months = ["January", "February", "March", "April", "May", "June", "July", "August", "September",
              "October", "November", "December"]
    if style == 2:
        return f"{months[m - 1]} {d}, {year}"
    return f"{m}/{d}/{str(year)[2:]}"


def person(rng: random.Random) -> str:
    """Return an invented full name."""
    middle = f" {rng.choice('ABCDEJKLMRS')}." if rng.random() < 0.3 else ""
    return f"{rng.choice(FIRST)}{middle} {rng.choice(LAST)}"


def address(rng: random.Random) -> tuple[str, str]:
    """Return an invented street line and city line."""
    city, state = rng.choice(CITIES)
    return f"{rng.randint(10, 9899)} {rng.choice(STREETS)}", f"{city}, {state} {rng.randint(10000, 99999)}"


def masked(rng: random.Random, digits: int = 4) -> str:
    """Return a masked account or TIN tail."""
    return rng.choice(["XXX-XX-", "***-**-", "XXXXX", "****", "ending in "]) + "".join(
        rng.choice("0123456789") for _ in range(digits))


def ein(rng: random.Random) -> str:
    """Return an invented EIN."""
    return f"{rng.randint(10, 98)}-{rng.randint(1000000, 9999999)}"


def pool(name: str) -> list[str]:
    """Return a named organization pool from specs."""
    return EXTRA_POOLS.get(name) or getattr(specs, name)


def box_value(rng: random.Random, kind: str, year: int) -> str | None:
    """Return a value for one IRS box kind; None leaves the box blank."""
    if kind == "money":
        return money(rng, 800, 140000)
    if kind == "small_money":
        return money(rng, 3, 9500)
    if kind == "big_money":
        return money(rng, 80000, 650000)
    if kind == "zero":
        return rng.choice(["0.00", "$0.00", "", "", None])
    if kind == "signed":
        v = rng.uniform(-9000, 30000)
        return f"({abs(v):,.2f})" if v < 0 and rng.random() < 0.5 else f"{v:,.2f}"
    if kind == "date":
        return date(rng, year - rng.choice([0, 0, 1, 3]))
    if kind == "text_year":
        return str(year)
    if kind == "code":
        return f"{rng.choice(['D', 'DD', 'W', 'C', 'AA', 'V'])} {money(rng, 50, 9000, 0)}"
    if kind == "check":
        return rng.choice(["X", "☒", "[X]", "", "☐"])
    if kind == "count":
        return str(rng.randint(1, 999))
    if kind == "state":
        return f"{rng.choice(['IL', 'WI', 'OH', 'CO', 'MN', 'TX', 'GA', 'PA'])} {rng.randint(1000000, 9999999)}"
    if kind == "percent":
        return f"{rng.uniform(1, 100):.4f} %"
    if kind == "wager":
        return rng.choice(["Slots", "Keno", "Poker tournament", "Horse race", "Lottery"])
    if kind == "dist_code":
        return rng.choice(["7", "1", "G", "2", "4", "7D"])
    if kind == "term":
        return rng.choice(["Short-term", "Long-term", "X Short-term", "X Long-term"])
    if kind == "security":
        return rng.choice(SECURITIES)
    if kind == "address":
        return " ".join(address(rng))
    if kind == "one":
        return "1"
    if kind == "code1":
        return rng.choice(["1", "2", "A", "F", "G"])
    if kind == "hsa":
        return "HSA ☒"
    if kind == "debt":
        return rng.choice(["Credit card", "Personal loan", "Auto loan deficiency"])
    if kind == "coin":
        return rng.choice(COINS)
    if kind == "units":
        return f"{rng.uniform(0.01, 40):.6f}"
    if kind == "make":
        return rng.choice(MAKES)[0]
    if kind == "model":
        return rng.choice(MAKES)[1]
    if kind == "vin":
        return "".join(rng.choice("ABCDEFGHJKLMNPRSTUVWXYZ0123456789") for _ in range(17))
    if kind == "yesno":
        return rng.choice(["Yes ☐  No ☒", "No"])
    if kind == "ira":
        return rng.choice(["IRA ☒", "Roth IRA ☒", "SEP ☒"])
    if kind == "origin":
        return rng.choice(["A", "B", "C", "D"])
    if kind == "person":
        return person(rng)
    if kind == "offer":
        return rng.choice(["1A", "1E", "1H"])
    if kind == "safe":
        return rng.choice(["2C", "2D", "2H"])
    if kind == "month":
        return f"{rng.randint(1, 12):02d}"
    if kind == "voucher":
        return str(rng.randint(1, 4))
    if kind == "due":
        return rng.choice([f"April 15, {year}", f"June 15, {year}", f"Sept. 15, {year}", f"Jan. 15, {year + 1}"])
    if kind == "explain":
        return rng.choice(["Received a corrected Form 1099-DIV after filing.", "Claimed a missed education credit.",
                           "Reported omitted interest income."])
    if kind == "classification":
        return rng.choice(["☒ Individual/sole proprietor", "☒ C corporation", "☒ Limited liability company  P",
                           "☒ S corporation"])
    if kind == "goods":
        return rng.choice(["Household furniture, good condition", "Clothing, 6 bags, good used", "Laptop computer, fair"])
    if kind == "how":
        return rng.choice(["Purchase", "Gift", "Inheritance"])
    if kind == "fmv":
        return rng.choice(["Thrift shop value", "Comparable sales", "Appraisal"])
    return None


# ── Forms → items ───────────────────────────────────────────────────────────

def compact_form_items(rng: random.Random, spec: dict, year: int) -> list[tuple]:
    """A short snippet of a form: one title line, short party lines, a few boxes.

    Matches cropped photos, one-box summaries and preparer notes, where only a
    handful of boxes survive extraction.
    """
    form = spec["form"]
    form_id = form if form.startswith(("SCHEDULE", "Schedule")) else f"Form {form}"
    items: list[tuple] = [("title", f"{form_id} {spec['titles'][0]} {year}" if rng.random() < 0.6 else f"{form_id} {spec['titles'][0]}")]
    if spec["payer_pool"]:
        short = spec["parties"][0].split(" name")[0].split(",")[0].split("'")[0].strip() or "PAYER"
        items.append(("kv", rng.choice([f"{short}:", f"{short}'S name:", "From:"]), rng.choice(pool(spec["payer_pool"]))))
        items.append(("kv", rng.choice(["RECIPIENT:", "Recipient's name:", "To:"]), person(rng)))
    else:
        items.append(("kv", "Name:", person(rng)))
    boxes = [b for b in spec["boxes"] if b[2] not in ("none", "zero")] or spec["boxes"]
    for number, label, kind in rng.sample(boxes, k=min(len(boxes), rng.randint(1, 4))):
        value = box_value(rng, kind, year) or "0.00"
        items.append(("kv", f"{number} {label}".strip(), value))
    return items


def form_items(rng: random.Random, spec: dict, year: int) -> list[tuple]:
    """Build the items of one IRS form copy; a quarter of rows are compact snippets."""
    if rng.random() < 0.25:
        return compact_form_items(rng, spec, year)
    form = spec["form"]
    form_id = form if form.startswith(("SCHEDULE", "Schedule")) else f"Form {form}"
    items: list[tuple] = []
    if rng.random() < 0.35:
        items.append(("line", rng.choice(["CORRECTED (if checked)", "VOID  CORRECTED", "☐ CORRECTED"])))
    items.append(("title", form_id))
    for title in spec["titles"]:
        items.append(("title", title))
    if rng.random() < 0.8:
        items.append(("line", str(year) if rng.random() < 0.5 else f"For calendar year {year}"))
    if spec["omb"] and rng.random() < 0.7:
        items.append(("line", f"OMB No. {spec['omb']}"))
    for copy in spec["copies"]:
        if rng.random() < 0.6:
            items.append(("line", copy))
    payer_label, recipient_label, payer_tin, recipient_tin = spec["parties"]
    payer = rng.choice(pool(spec["payer_pool"])) if spec["payer_pool"] else None
    street, city = address(rng)
    if payer:
        p_street, p_city = address(rng)
        items.append(("kv", payer_label, f"{payer} {p_street} {p_city}"))
        items.append(("kv", payer_tin, ein(rng)))
        items.append(("kv", recipient_label, person(rng)))
        items.append(("kv", recipient_tin, masked(rng)))
        if rng.random() < 0.7:
            items.append(("kv", "Street address (including apt. no.)", street))
            items.append(("kv", "City or town, state or province, country, and ZIP or foreign postal code", city))
        if rng.random() < 0.4:
            items.append(("kv", "Account number (see instructions)", masked(rng, 6)))
    else:
        items.append(("kv", payer_label, person(rng)))
        items.append(("kv", recipient_label, f"{street} {city}"))
        items.append(("kv", payer_tin, masked(rng)))
        items.append(("line", recipient_tin))
    for number, label, kind in spec["boxes"]:
        if rng.random() < 0.15:
            continue
        value = box_value(rng, kind, year)
        text = f"{number} {label}".strip()
        items.append(("kv", text, value or ""))
    if rng.random() < 0.6:
        tail = f"Form {form.replace('Schedule ', '').replace('SCHEDULE ', '')}"
        items.append(("title", f"{tail} (keep for your records)  www.irs.gov/Form{re.sub('[^0-9A-Za-z]', '', spec['form'])}"))
        items.append(("line", "Department of the Treasury - Internal Revenue Service"))
    return items


# ── Layouts ─────────────────────────────────────────────────────────────────

def _gap(rng: random.Random) -> str:
    return " " * rng.choice([1, 1, 2, 3, 6])


def _runs(items: list[tuple]) -> list[tuple[str, list]]:
    """Group consecutive items of the same type."""
    runs: list[tuple[str, list]] = []
    for item in items:
        kind = "kv" if item[0] == "kv" else item[0]
        if runs and runs[-1][0] == kind and kind == "kv":
            runs[-1][1].append(item)
        else:
            runs.append((kind, [item]))
    return runs


def render(rng: random.Random, items: list[tuple], layout: str, title_mode: str) -> str:
    """Render items with a layout; title_mode is top, bottom or none."""
    titles = [i for i in items if i[0] == TITLE]
    body = [i for i in items if i[0] != TITLE]
    if title_mode == "top":
        items = [("line", t[1]) for t in titles if "www.irs.gov" not in t[1]] + \
                [i for i in body] + [("line", t[1]) for t in titles if "www.irs.gov" in t[1]]
        items = _keep_order(items, titles, body)
    elif title_mode == "bottom":
        items = body + [("line", t[1]) for t in titles]
    else:
        items = body
    lines: list[str] = []
    for kind, run in _runs(items):
        if kind == "line":
            text = run[0][1]
            lines.append(("## " + text) if layout == "markdown" and rng.random() < 0.3 else text)
        elif kind == "table":
            _, header, rows = run[0]
            lines.extend(_table(rng, header, rows, layout))
        else:
            lines.extend(_kv(rng, [(r[1], r[2]) for r in run], layout))
    if layout == "flat":
        words = " ".join(l for l in lines if l).split()
        cut = sorted(rng.sample(range(1, max(2, len(words))), k=min(2, max(0, len(words) - 2))))
        parts, start = [], 0
        for c in cut + [len(words)]:
            parts.append(" ".join(words[start:c]))
            start = c
        return "\n".join(p for p in parts if p)
    return "\n".join(lines).strip()


def _keep_order(items: list[tuple], titles: list[tuple], body: list[tuple]) -> list[tuple]:
    """Keep a CORRECTED marker above the title, as printed forms do."""
    if body and body[0][0] == "line" and "CORRECTED" in body[0][1]:
        return [body[0]] + [i for i in items if i is not body[0]]
    return items


def _kv(rng: random.Random, pairs: list[tuple[str, str]], layout: str) -> list[str]:
    if layout == "stacked":
        out = []
        for label, value in pairs:
            out.append(label)
            if value:
                out.append(value)
        return out
    if layout in ("inline", "flat"):
        return [f"{label}{_gap(rng)}{value}".rstrip() for label, value in pairs]
    if layout == "columns":
        return [p[0] for p in pairs] + [p[1] for p in pairs if p[1]]
    if layout == "boxed":
        prefix = rng.choice(["Box ", "", "Line "])
        return [f"{prefix}{label}: {value}".rstrip(": ") if re.match(r"^[0-9]", label) else f"{label}: {value}"
                for label, value in pairs]
    if layout == "csv":
        return [f"{_csv(label)},{_csv(value)}" for label, value in pairs]
    out = ["| Field | Value |", "| --- | --- |"]
    out += [f"| {label} | {value} |" for label, value in pairs]
    return out


def _table(rng: random.Random, header: list[str], rows: list[list[str]], layout: str) -> list[str]:
    if layout == "csv":
        return [",".join(_csv(h) for h in header)] + [",".join(_csv(c) for c in r) for r in rows]
    if layout == "markdown":
        return ["| " + " | ".join(header) + " |", "|" + " --- |" * len(header)] + \
               ["| " + " | ".join(r) + " |" for r in rows]
    if layout == "columns":
        return header + [c for r in rows for c in r]
    if layout == "stacked":
        return ["  ".join(header)] + [c for r in rows for c in r]
    return [_gap(rng).join(header)] + [_gap(rng).join(r) for r in rows]


def _csv(value: str) -> str:
    return f'"{value}"' if ("," in value or '"' in value) else value


# ── OCR noise ───────────────────────────────────────────────────────────────

SWAPS = [("0", "O"), ("1", "l"), ("rn", "m"), ("l", "1"), ("O", "0"), ("S", "5"), ("cl", "d"), ("e", "c"), ("i", "í")]


def ocr_noise(rng: random.Random, text: str) -> str:
    """Apply scan-like damage: swapped glyphs, lost spaces, split words."""
    chars = list(text)
    out = "".join(chars)
    for _ in range(max(1, len(out) // 60)):
        a, b = rng.choice(SWAPS)
        idx = out.find(a, rng.randrange(max(1, len(out))))
        if idx >= 0:
            out = out[:idx] + b + out[idx + len(a):]
    words = out.split(" ")
    for _ in range(max(1, len(words) // 25)):
        if len(words) > 3:
            k = rng.randrange(len(words) - 1)
            words[k] = words[k] + words.pop(k + 1)
    out = " ".join(words)
    if rng.random() < 0.3:
        out = out.replace("$", "S", 1)
    return out