"""Compare the per-column prompts of the two Legora runs against prompts v3. The 2026-08-05 Legora export (``data/raw/legora_2026-08-05_prompts.xlsx``) is a re-export of the 2026-08-01 tabular review with the "with prompt" option enabled: the data rows are byte-identical to ``legora_2026-08-01.xlsx``; row 2 additionally carries the question text of every column. As with the values (see ``scripts/compare_legora_runs.py``), the left column group belongs to ``legora-1`` and the right one to ``legora-2``. This script extracts both prompt sets — from the raw export, or with ``--prompts-dir`` from the published ``prompts_legora_{1,2}.jsonl`` — aligns them with the per-variable sections of ``legex/prompts/v3.py``, and writes a markdown report with word-level diffs (``[-deleted-]`` / ``{+inserted+}``). uv run python scripts/compare_legora_prompts.py \ [--xlsx data/raw/legora_2026-08-05_prompts.xlsx] \ [--prompts-dir ../inference-results/prompts] \ [--out data/analysis/legora_prompt_comparison.md] """ import argparse import difflib import json import re import sys from pathlib import Path import openpyxl sys.path.insert(0, str(Path(__file__).resolve().parents[1])) from legex.prompts import v3 # noqa: E402 MODEL_A, MODEL_B = "legora-1", "legora-2" DEFAULT_XLSX = Path("data/raw/legora_2026-08-05_prompts.xlsx") DEFAULT_OUT = Path("data/analysis/legora_prompt_comparison.md") PROMPT_SUFFIX = " (with prompt)" # Equal stretches longer than this many words are elided in the diffs. CONTEXT_WORDS = 6 FINDINGS = """\ ## Findings * Both column groups are per-column adaptations of the v3 coding rules, rewritten for Legora's tabular-review UI. Structural v3 material that cannot exist per column is gone in both runs: the JSON-typing preamble, the JSON-`null` semantics (the columns ask for the literal string `None` instead), and the companion `Currency_` fields — the export has no currency columns at all. * **legora-2 is the cleaner, complete set**: all 12 prompts follow one template ("Where to find it: … Formatting rules: … Permissible values: …") and carry the full substance of the matching v3 section. * **legora-1 deviates from the v3 content twice.** 1. `legal_subject_judgement` is not our rule at all but Legora's auto-generated question ("What legal subjects or issues are addressed …"), an essay-style prompt without the underscore/slash coding format. This explains the essay-like answers of legora-1 on that column and the low inter-run agreement (39.9 % when both filled, see `legora_run_comparison.md`). 2. `case_id` has an ad-hoc tail appended ("Put here only the number (with slahs, dots etc) no more information. No dates or text", note the typo) that legora-2 lacks. The other ten legora-1 prompts match legora-2 in substance and differ only in scaffolding (flowing text vs. labelled sections, "None (the literal string)" vs. "None"). * **Both runs extend v3** with material that is not in the repo prompt: a U.S. federal-court hint for `trial_start_date`; Swiss search anchors ("Mit Beschwerde vom", "Lausanne, [date]", "Erwägungen — Eintreten / recevabilité", "Die Gerichtskosten von Fr. …", "… à titre de dépens"; legora-2 also "Gegenstand/Objet/Oggetto"); "typically item 2"/"item 3" locations in the operative part; an explicit sum-to-1.0 constraint for `plaintiff_loosing_share`; and, for the ISIC columns, a dominant-activity rule for multi-sector entities, extra `no_allocation_possible` examples (tenant, consumer, patient, unemployed) and anonymized-party examples for `None`. The wrong-example currency changed from v3's `CHF 150000` to `USD 150000`. * **The ISIC category list is handled differently per run**: legora-1 inlines all 24 permitted values in the prompt; legora-2 only asserts "You MUST enter exactly one of the 24 permitted coded values" without listing them and instead adds coding examples (law firm → n_professional_scientific_technical, hospital → r_human_health_social_work, tradesperson → f_construction). Both runs nevertheless answered in coded values. Notably, `defendant_no1_ISIC1_industry_category` is the one field where legora-2 is clearly worse than legora-1 against the Goldensets (acc 0.522 vs 0.563). """ def word_diff(a: str, b: str) -> str: """Inline word-level diff of ``a`` → ``b`` with long equal runs elided.""" aw, bw = a.split(), b.split() sm = difflib.SequenceMatcher(None, aw, bw, autojunk=False) out: list[str] = [] for tag, i1, i2, j1, j2 in sm.get_opcodes(): if tag == "equal": words = aw[i1:i2] if len(words) > 2 * CONTEXT_WORDS + 2: words = [*words[:CONTEXT_WORDS], "[…]", *words[-CONTEXT_WORDS:]] out.append(" ".join(words)) else: if tag in ("delete", "replace"): out.append("[-" + " ".join(aw[i1:i2]) + "-]") if tag in ("insert", "replace"): out.append("{+" + " ".join(bw[j1:j2]) + "+}") return " ".join(out) def similarity(a: str, b: str) -> float: return difflib.SequenceMatcher(None, a.split(), b.split(), autojunk=False).ratio() def read_prompts(xlsx: Path) -> dict[str, dict[str, str]]: """Return ``{model: {field: prompt}}`` from the export's prompt row.""" wb = openpyxl.load_workbook(xlsx, data_only=True, read_only=True) ws = wb.worksheets[0] rows = ws.iter_rows(min_row=1, max_row=2, values_only=True) header, prompt_row = next(rows), next(rows) out: dict[str, dict[str, str]] = {MODEL_A: {}, MODEL_B: {}} for head, prompt in zip(header, prompt_row): if not head or not str(head).endswith(PROMPT_SUFFIX) or not prompt: continue field = str(head)[: -len(PROMPT_SUFFIX)] model = MODEL_A if field not in out[MODEL_A] else MODEL_B out[model][field] = " ".join(str(prompt).split()) return out def read_published_prompts(prompts_dir: Path) -> dict[str, dict[str, str]]: """Return ``{model: {field: prompt}}`` from the published prompt JSONL.""" out: dict[str, dict[str, str]] = {} for model in (MODEL_A, MODEL_B): path = prompts_dir / f"prompts_{model.replace('-', '_')}.jsonl" out[model] = { rec["field"]: rec["prompt"] for rec in map(json.loads, path.read_text(encoding="utf-8").splitlines()) } return out def v3_sections() -> dict[str, str]: """Per-variable rule sections of the v3 system prompt, whitespace-flattened.""" match = re.search( r"## Variable coding rules\n(.*?)\n## Allowed ISIC", v3.PROMPT, re.S ) if not match: raise SystemExit("could not locate the variable sections in v3.PROMPT") sections = {} for sec in re.finditer(r"### (\S+)\n(.*?)(?=\n### |\Z)", match.group(1), re.S): sections[sec.group(1)] = " ".join(sec.group(2).split()) return sections def main() -> None: parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) parser.add_argument("--xlsx", type=Path, default=DEFAULT_XLSX) parser.add_argument("--prompts-dir", type=Path, default=None, help="read the published prompts_legora_{1,2}.jsonl from this " "directory instead of the raw --xlsx export") parser.add_argument("--out", type=Path, default=DEFAULT_OUT) args = parser.parse_args() prompts = ( read_published_prompts(args.prompts_dir) if args.prompts_dir is not None else read_prompts(args.xlsx) ) rules = v3_sections() fields = list(prompts[MODEL_A]) if list(prompts[MODEL_B]) != fields: raise SystemExit("the two column groups carry different field sets") lines: list[str] = [] lines.append(f"# Legora prompt comparison: {MODEL_A} vs {MODEL_B} vs prompts v3\n") lines.append( "Prompts from the 2026-08-05 prompt-bearing re-export of the 2026-08-01 " "tabular review (published as `prompts/prompts_legora_{1,2}.jsonl` in " "the inference-results dataset; the data rows are byte-identical to " f"the 2026-08-01 export). Left column group = `{MODEL_A}`, right group " f"= `{MODEL_B}`, as established in `legora_run_comparison.md`. The v3 " "baseline is the per-variable section of `legex/prompts/v3.py`. " "Similarities are word-level `difflib` ratios (1.0 = identical). " "Generated by `scripts/compare_legora_prompts.py`.\n" ) lines.append("## Similarity overview\n") lines.append( f"| field | {MODEL_A} words | {MODEL_B} words " f"| {MODEL_A} ≈ {MODEL_B} | v3 ≈ {MODEL_A} | v3 ≈ {MODEL_B} |" ) lines.append("|---|---|---|---|---|---|") for field in fields: a, b, rule = prompts[MODEL_A][field], prompts[MODEL_B][field], rules[field] lines.append( f"| {field} | {len(a.split())} | {len(b.split())} " f"| {similarity(a, b):.2f} | {similarity(rule, a):.2f} " f"| {similarity(rule, b):.2f} |" ) lines.append("") lines.append(FINDINGS) lines.append("## Per-field prompts and diffs\n") lines.append( "Diff notation: `[-only in the left text-]`, `{+only in the right " "text+}`, `[…]` elides unchanged words. For the ISIC fields the v3 " "category list lives in a separate shared section and is therefore " "not part of the v3 rule text below.\n" ) for field in fields: a, b, rule = prompts[MODEL_A][field], prompts[MODEL_B][field], rules[field] lines.append(f"### {field}\n") lines.append("**v3 rule**\n") lines.append(f"> {rule}\n") lines.append(f"**{MODEL_A} → {MODEL_B}**\n") lines.append("```diff-words") lines.append(word_diff(a, b)) lines.append("```\n") lines.append(f"**v3 → {MODEL_A}**\n") lines.append("```diff-words") lines.append(word_diff(rule, a)) lines.append("```\n") lines.append(f"**v3 → {MODEL_B}**\n") lines.append("```diff-words") lines.append(word_diff(rule, b)) lines.append("```\n") args.out.parent.mkdir(parents=True, exist_ok=True) args.out.write_text("\n".join(lines), encoding="utf-8") print(f"wrote {args.out}") if __name__ == "__main__": main()