| """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 |
|
|
| 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)" |
| |
| 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_<variable>` 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() |
|
|
