| |
| """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" |
| |
| |
| |
| |
| 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('"','"').replaceAll("'",''')} |
| 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: |
| 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()) |
|
|
