tools/groundtruth_diff.py

#!/usr/bin/env python3
"""Rank and visually inspect changes to parser text ground truth."""

from __future__ import annotations

import argparse
import difflib
import json
import re
import subprocess
import sys
import webbrowser
from collections import Counter
from dataclasses import asdict, dataclass
from http import HTTPStatus
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from urllib.parse import parse_qs, urlparse


KINDS = ("char", "word", "line")
ARTIFACT_RE = re.compile(r"^(?P<page>.+\.py\.json)\.(?P<kind>char|word|line)\.txt$")
DEFAULT_BASELINE = Path("groundtruth/parser")


@dataclass(frozen=True)
class Artifact:
    page: str
    kind: str
    status: str
    score: float
    added: int
    removed: int
    old_lines: int
    new_lines: int


@dataclass
class Page:
    name: str
    score: float
    artifacts: dict[str, Artifact]

    def public_dict(self) -> dict[str, object]:
        return {
            "name": self.name,
            "score": self.score,
            "artifacts": {kind: asdict(item) for kind, item in self.artifacts.items()},
        }


@dataclass(frozen=True)
class ContentPair:
    old: str
    new: str


def artifact_name(path: Path | str) -> tuple[str, str] | None:
    match = ARTIFACT_RE.match(Path(path).name)
    if not match:
        return None
    return match.group("page"), match.group("kind")


def parser_dir(path: Path) -> Path:
    """Accept either a ground-truth root or its parser directory."""
    nested = path / "parser"
    return nested if nested.is_dir() else path


def run_git(repo: Path, *args: str, check: bool = True) -> subprocess.CompletedProcess[bytes]:
    return subprocess.run(
        ["git", "--no-optional-locks", *args],
        cwd=repo,
        check=check,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
    )


def repo_root(start: Path) -> Path:
    result = run_git(start, "rev-parse", "--show-toplevel")
    return Path(result.stdout.decode().strip()).resolve()


def read_text(path: Path) -> str:
    try:
        return path.read_text(encoding="utf-8")
    except UnicodeDecodeError:
        return path.read_text(encoding="utf-8", errors="replace")


class Comparison:
    """Content source for either a Git working tree or two directories."""

    def __init__(
        self,
        baseline: Path,
        candidate: Path | None = None,
        ref: str = "HEAD",
        root: Path | None = None,
    ) -> None:
        self.root = (root or Path.cwd()).resolve()
        self.baseline = parser_dir(baseline).resolve()
        self.candidate = parser_dir(candidate).resolve() if candidate else None
        self.ref = ref
        self._paths: dict[tuple[str, str], tuple[Path | None, Path | None]] = {}

    @property
    def mode(self) -> str:
        return "directory" if self.candidate else "git"

    def discover(self) -> list[tuple[str, str]]:
        if self.candidate:
            self._discover_directories()
        else:
            self._discover_git()
        return sorted(self._paths)

    def _files(self, directory: Path) -> dict[tuple[str, str], Path]:
        if not directory.is_dir():
            raise ValueError(f"parser directory does not exist: {directory}")
        found: dict[tuple[str, str], Path] = {}
        for path in directory.iterdir():
            parsed = artifact_name(path)
            if path.is_file() and parsed:
                found[parsed] = path
        return found

    def _discover_directories(self) -> None:
        old = self._files(self.baseline)
        assert self.candidate is not None
        new = self._files(self.candidate)
        self._paths = {key: (old.get(key), new.get(key)) for key in old.keys() | new.keys()}

    def _discover_git(self) -> None:
        repo = repo_root(self.root)
        try:
            relative = self.baseline.relative_to(repo).as_posix()
        except ValueError as error:
            raise ValueError("--baseline must be inside the Git repository in Git mode") from error

        pathspecs = [f"{relative}/*.{kind}.txt" for kind in KINDS]
        changed = run_git(repo, "diff", "--name-only", "-z", self.ref, "--", *pathspecs)
        untracked = run_git(repo, "ls-files", "--others", "--exclude-standard", "-z", "--", *pathspecs)
        names = set(changed.stdout.split(b"\0")) | set(untracked.stdout.split(b"\0"))
        for raw in names:
            if not raw:
                continue
            rel_path = Path(raw.decode("utf-8", errors="surrogateescape"))
            parsed = artifact_name(rel_path)
            if parsed:
                working = repo / rel_path
                self._paths[parsed] = (rel_path, working if working.is_file() else None)
        self.root = repo

    def contents(self, key: tuple[str, str]) -> ContentPair:
        if key not in self._paths:
            raise KeyError(key)
        old_path, new_path = self._paths[key]
        if self.candidate:
            old = read_text(old_path) if old_path else ""
        elif old_path:
            spec = f"{self.ref}:{old_path.as_posix()}"
            result = run_git(self.root, "show", spec, check=False)
            old = result.stdout.decode("utf-8", errors="replace") if result.returncode == 0 else ""
        else:
            old = ""
        new = read_text(new_path) if new_path else ""
        return ContentPair(old, new)


def measure(page: str, kind: str, pair: ContentPair) -> Artifact:
    old = pair.old.splitlines()
    new = pair.new.splitlines()
    if pair.old == pair.new:
        return Artifact(page, kind, "unchanged", 0.0, 0, 0, len(old), len(new))

    line_matcher = difflib.SequenceMatcher(None, old, new, autojunk=True)
    added = removed = 0
    for tag, old_start, old_end, new_start, new_end in line_matcher.get_opcodes():
        if tag in {"insert", "replace"}:
            added += new_end - new_start
        if tag in {"delete", "replace"}:
            removed += old_end - old_start
    if not pair.old:
        status = "added"
    elif not pair.new:
        status = "deleted"
    else:
        status = "modified"
    # Exact-line matching reports 100% difference when every geometry record has
    # a small coordinate change. Token and adjacent-token overlap keeps those
    # changes visible, credits shared content, detects reordering, and stays
    # linear for very large character dumps.
    old_tokens, new_tokens = pair.old.split(), pair.new.split()
    unigram_score = multiset_distance(old_tokens, new_tokens)
    old_bigrams = list(zip(old_tokens, old_tokens[1:]))
    new_bigrams = list(zip(new_tokens, new_tokens[1:]))
    bigram_score = multiset_distance(old_bigrams, new_bigrams)
    score = (unigram_score + bigram_score) / 2 if old_bigrams or new_bigrams else unigram_score
    return Artifact(page, kind, status, score, added, removed, len(old), len(new))


def multiset_distance(old: list[object], new: list[object]) -> float:
    """Return a normalized Dice distance for two multisets."""
    total = len(old) + len(new)
    if total == 0:
        return 0.0
    common = sum((Counter(old) & Counter(new)).values())
    return 1.0 - (2.0 * common / total)


def analyze(comparison: Comparison) -> list[Page]:
    grouped: dict[str, dict[str, Artifact]] = {}
    for page, kind in comparison.discover():
        artifact = measure(page, kind, comparison.contents((page, kind)))
        if artifact.status != "unchanged":
            grouped.setdefault(page, {})[kind] = artifact
    pages = [Page(name, max(item.score for item in items.values()), items) for name, items in grouped.items()]
    return sorted(pages, key=lambda page: (-page.score, page.name))


def format_summary(pages: list[Page], limit: int) -> str:
    shown = pages if limit == 0 else pages[:limit]
    header = f"{'score':>7}  {'char':>7}  {'word':>7}  {'line':>7}  {'+lines':>7}  {'-lines':>7}  page"
    rows = [header, "-" * len(header)]
    for page in shown:
        scores = [page.artifacts.get(kind) for kind in KINDS]
        cells = [f"{item.score * 100:6.1f}%" if item else "      -" for item in scores]
        added = sum(item.added for item in page.artifacts.values())
        removed = sum(item.removed for item in page.artifacts.values())
        rows.append(f"{page.score * 100:6.1f}%  {'  '.join(cells)}  {added:7d}  {removed:7d}  {page.name}")
    rows.append(f"\n{len(pages)} changed page(s); showing {len(shown)}.")
    return "\n".join(rows)


PAGE_HTML = """<!doctype html>
<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width">
<title>Ground-truth diff inspector</title>
<style>
:root{color-scheme:light dark;--bg:#f7f7f5;--panel:#fff;--ink:#202124;--muted:#697078;--rule:#d9dcdf;--accent:#155eef;--add:#d7f5dd;--del:#ffd9d5;--change:#fff0b8}
@media(prefers-color-scheme:dark){:root{--bg:#151719;--panel:#202326;--ink:#eef0f2;--muted:#aab0b7;--rule:#3b4045;--accent:#78a9ff;--add:#174c2a;--del:#5a2525;--change:#554616}}
*{box-sizing:border-box}body{margin:0;background:var(--bg);color:var(--ink);font:14px system-ui,sans-serif}header{position:sticky;top:0;z-index:3;padding:14px 20px;background:var(--panel);border-bottom:1px solid var(--rule)}h1{font-size:18px;margin:0 0 10px}.controls{display:flex;gap:10px;flex-wrap:wrap}input,select,button{font:inherit;padding:7px 9px;border:1px solid var(--rule);border-radius:6px;background:var(--panel);color:var(--ink)}input{min-width:310px}main{display:grid;grid-template-columns:minmax(420px,42%) 1fr;height:calc(100vh - 93px)}section{overflow:auto}.list{border-right:1px solid var(--rule)}table{border-collapse:collapse;width:100%}th,td{padding:7px 8px;border-bottom:1px solid var(--rule);text-align:right;white-space:nowrap}th{position:sticky;top:0;background:var(--panel)}th:last-child,td:last-child{text-align:left}.row{cursor:pointer}.row:hover,.row.selected{background:color-mix(in srgb,var(--accent) 13%,transparent)}.score{font-variant-numeric:tabular-nums}.muted{color:var(--muted)}#detail{padding:15px}.tabs{display:flex;gap:6px;margin-bottom:12px}.tabs button.active{background:var(--accent);color:white}.summary{margin:0 0 12px;color:var(--muted)}.diff{font:12px ui-monospace,SFMono-Regular,Consolas,monospace;overflow:auto}.diff table{width:max-content;min-width:100%}.diff_header{background:var(--panel);color:var(--muted)}td.diff_header{user-select:none}.diff_next{display:none}.diff_add{background:var(--add)}.diff_sub{background:var(--del)}.diff_chg{background:var(--change)}.empty{padding:30px;color:var(--muted)}@media(max-width:900px){main{display:block;height:auto}.list{max-height:45vh;border-right:0;border-bottom:1px solid var(--rule)}}
</style></head><body>
<header><h1>Ground-truth diff inspector <span id="count" class="muted"></span></h1><div class="controls">
<input id="search" type="search" placeholder="Filter by PDF or page…"><select id="sort"><option value="score">Largest score</option><option value="added">Most additions</option><option value="removed">Most removals</option><option value="name">Filename</option></select>
</div></header><main><section class="list"><table><thead><tr><th>overall</th><th>char</th><th>word</th><th>line</th><th>+</th><th>−</th><th>page</th></tr></thead><tbody id="rows"></tbody></table></section><section id="detail"><div class="empty">Select a page to inspect its diff.</div></section></main>
<script>
let pages=[], selected=null, kind='word'; const pct=n=>n==null?'–':(n*100).toFixed(1)+'%';
const totals=p=>Object.values(p.artifacts).reduce((a,x)=>({added:a.added+x.added,removed:a.removed+x.removed}),{added:0,removed:0});
async function load(){pages=await (await fetch('/api/pages')).json(); renderRows();}
function renderRows(){const q=document.querySelector('#search').value.toLowerCase(), sort=document.querySelector('#sort').value; let visible=pages.filter(p=>p.name.toLowerCase().includes(q)); visible.sort((a,b)=>sort==='name'?a.name.localeCompare(b.name):sort==='score'?b.score-a.score:totals(b)[sort]-totals(a)[sort]); document.querySelector('#count').textContent=`— ${visible.length} of ${pages.length} pages`; document.querySelector('#rows').innerHTML=visible.map(p=>{const t=totals(p),cell=k=>pct(p.artifacts[k]?.score);return `<tr class="row ${selected===p.name?'selected':''}" data-page="${attr(p.name)}"><td class="score">${pct(p.score)}</td><td>${cell('char')}</td><td>${cell('word')}</td><td>${cell('line')}</td><td>${t.added}</td><td>${t.removed}</td><td title="${attr(p.name)}">${esc(p.name)}</td></tr>`}).join(''); document.querySelectorAll('.row').forEach(r=>r.onclick=()=>selectPage(r.dataset.page));}
function esc(s){const d=document.createElement('div');d.textContent=s;return d.innerHTML}
function attr(s){return esc(s).replaceAll('"','&quot;').replaceAll("'",'&#39;')}
async function selectPage(name){selected=name;const p=pages.find(x=>x.name===name);if(!p.artifacts[kind])kind=Object.keys(p.artifacts)[0];renderRows();await renderDetail();}
async function renderDetail(){const p=pages.find(x=>x.name===selected);const tabs=Object.keys(p.artifacts).map(k=>`<button data-kind="${k}" class="${k===kind?'active':''}">${k}</button>`).join('');const a=p.artifacts[kind];document.querySelector('#detail').innerHTML=`<h2>${esc(p.name)}</h2><div class="tabs">${tabs}</div><p class="summary">Loading ${kind} diff…</p>`;document.querySelectorAll('.tabs button').forEach(b=>b.onclick=()=>{kind=b.dataset.kind;renderDetail()});const data=await (await fetch(`/api/diff?page=${encodeURIComponent(p.name)}&kind=${kind}`)).json();document.querySelector('#detail').innerHTML=`<h2>${esc(p.name)}</h2><div class="tabs">${tabs}</div><p class="summary">${kind}: ${pct(a.score)} difference · +${a.added} / −${a.removed} lines · ${a.status}</p><div class="diff">${data.html}</div>`;document.querySelectorAll('.tabs button').forEach(b=>b.onclick=()=>{kind=b.dataset.kind;renderDetail()});}
document.querySelector('#search').oninput=renderRows;document.querySelector('#sort').onchange=renderRows;load();
</script></body></html>"""


def diff_table(pair: ContentPair) -> str:
    maker = difflib.HtmlDiff(tabsize=4, wrapcolumn=120)
    return maker.make_table(
        pair.old.splitlines(), pair.new.splitlines(), fromdesc="baseline", todesc="candidate", context=True, numlines=4
    )


def serve(comparison: Comparison, pages: list[Page], host: str, port: int, open_browser: bool) -> None:
    public_pages = [page.public_dict() for page in pages]
    valid = {(page.name, kind) for page in pages for kind in page.artifacts}

    class Handler(BaseHTTPRequestHandler):
        def send(self, body: bytes, content_type: str, status: HTTPStatus = HTTPStatus.OK) -> None:
            self.send_response(status)
            self.send_header("Content-Type", content_type)
            self.send_header("Content-Length", str(len(body)))
            self.send_header("Cache-Control", "no-store")
            self.end_headers()
            self.wfile.write(body)

        def do_GET(self) -> None:  # noqa: N802
            parsed = urlparse(self.path)
            if parsed.path == "/":
                self.send(PAGE_HTML.encode(), "text/html; charset=utf-8")
            elif parsed.path == "/api/pages":
                self.send(json.dumps(public_pages, ensure_ascii=False).encode(), "application/json; charset=utf-8")
            elif parsed.path == "/api/diff":
                query = parse_qs(parsed.query)
                key = (query.get("page", [""])[0], query.get("kind", [""])[0])
                if key not in valid:
                    self.send(b'{"error":"unknown artifact"}', "application/json", HTTPStatus.NOT_FOUND)
                    return
                body = json.dumps({"html": diff_table(comparison.contents(key))}, ensure_ascii=False).encode()
                self.send(body, "application/json; charset=utf-8")
            else:
                self.send(b"not found", "text/plain", HTTPStatus.NOT_FOUND)

        def log_message(self, format: str, *args: object) -> None:
            sys.stderr.write("[groundtruth-diff] " + format % args + "\n")

    server = ThreadingHTTPServer((host, port), Handler)
    url = f"http://{host}:{server.server_port}/"
    print(f"Inspecting {len(pages)} changed page(s) at {url}")
    print("Press Ctrl-C to stop.")
    if open_browser:
        webbrowser.open(url)
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        print("\nStopped.")
    finally:
        server.server_close()


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(description=__doc__)
    commands = parser.add_subparsers(dest="command", required=True)

    def common(command: argparse.ArgumentParser) -> None:
        command.add_argument("--baseline", type=Path, default=DEFAULT_BASELINE)
        command.add_argument("--candidate", type=Path, help="candidate root or parser directory")
        command.add_argument("--ref", default="HEAD", help="Git baseline ref (default: HEAD)")

    summary = commands.add_parser("summary", help="print ranked changed pages")
    common(summary)
    summary.add_argument("--limit", type=int, default=30, help="rows to show; 0 means all")
    summary.add_argument("--json", action="store_true", help="emit JSON")

    server = commands.add_parser("serve", help="start the visual diff inspector")
    common(server)
    server.add_argument("--host", default="127.0.0.1")
    server.add_argument("--port", type=int, default=8765, help="use 0 to choose a free port")
    server.add_argument("--open", action="store_true", help="open the browser automatically")
    return parser


def main(argv: list[str] | None = None) -> int:
    args = build_parser().parse_args(argv)
    try:
        comparison = Comparison(args.baseline, args.candidate, args.ref)
        pages = analyze(comparison)
    except (OSError, subprocess.CalledProcessError, ValueError) as error:
        print(f"error: {error}", file=sys.stderr)
        return 2
    if args.command == "summary":
        if args.json:
            print(json.dumps([page.public_dict() for page in pages], ensure_ascii=False, indent=2))
        else:
            print(format_summary(pages, args.limit))
    else:
        serve(comparison, pages, args.host, args.port, args.open)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())