scripts/prepare_hf_dataset.py

"""Build the Hugging Face package in huggingface/hrc-voting/ from the repo's own outputs.

    python scripts/prepare_hf_dataset.py

Five configs, because the source is relational and flattening it would either explode
the row count or throw away the resolution-level metadata:

  resolutions  one row per catalogued resolution           (data/csv/resolutions.csv)
  votes        one row per (resolution, country) roll-call (data/csv/votes_long.csv)
  clauses      one row per clause of a harvested text      (dashboard/texts/)
  countries    dimension table, 154 states                 (dashboard/data.js)
  subjects     dimension table, OHCHR's controlled vocab   (dashboard/data.js)

The two dimension tables exist so that caveats which are otherwise only prose become
machine-readable: which states no longer exist, which ISO code spans a change of
representation rather than of state, and which subject tags name a country situation
rather than a theme.

Everything here is derived from files already committed to this repository, so the
package can be rebuilt from a clean checkout without re-harvesting.

Derived columns exist mainly to stop downstream users repeating mistakes this project
already made and fixed (see notes/AUDIT-2026-07.md):

  prevailing_side / adopted   Under the chamber's own rules an abstention is not a vote
                              cast, so the outcome turns on Yes vs No alone. Taking
                              max(Yes, No, Abstain) instead — the obvious-looking move —
                              scores the winning Yes bloc as defeated on 53 adopted
                              resolutions in this corpus.
  rollcall_reconciles         ~9% of recorded votes have a per-country roll-call whose
                              tally does not match the official totals. The flag lets a
                              user filter them rather than discover the discrepancy
                              halfway through an analysis.
  clause_type                 Articles of annexed declarations and protocols are marked
                              `annex`, not `operative`. They are treaty-style text, not
                              commitments of the organ, and conflating them shifts every
                              operative-verb statistic.
"""
import csv
import json
import sys
from pathlib import Path

import pandas as pd
import pyarrow as pa
import pyarrow.parquet as pq

sys.path.insert(0, str(Path(__file__).resolve().parent))
from tag_terms import code_clause                      # noqa: E402
from build_dashboard_data import country_subject_matcher  # noqa: E402

ROOT = Path(__file__).resolve().parent.parent
CSVD = ROOT / "data" / "csv"
TX = ROOT / "dashboard" / "texts"
OUT = ROOT / "huggingface" / "hrc-voting"
DATA = OUT / "data"

VOTE_LABEL = {
    "Y": "yes", "N": "no", "A": "abstain",
    ".": "absent or not participating",
    "": "not a member at the time / no position recorded",
}
ADOPTION_MODE = {
    "ADOPTED WITHOUT VOTE": "adopted without a vote",
    "RECORDED": "recorded vote",
    "RECORDED, adopted at a closed meeting": "recorded vote (closed meeting)",
    "NON-RECORDED": "non-recorded vote",
    "NON-RECORDED, adopted unanimously": "non-recorded, adopted unanimously",
    "NON-RECORDED, no voting information available": "non-recorded, no voting information",
    "WITHDRAWN": "withdrawn before a decision",
    "NOT CONSIDERED": "not considered",
}


def load_payload():
    raw = (ROOT / "dashboard" / "data.js").read_text(encoding="utf-8")
    return json.loads(raw[len("window.DATA = "):].rstrip().rstrip(";"))


def as_int(v):
    return int(v) if str(v).strip().isdigit() else None


def is_amendment(title, draft):
    import re
    return bool(re.search(r":\s*amendment", title or "", re.I)
                or re.match(r"\s*amendment", draft or "", re.I))


def build_resolutions(res_rows, tally):
    rows = []
    for r in res_rows:
        y, n, a = as_int(r["yes"]), as_int(r["no"]), as_int(r["abstain"])
        nrc = as_int(r["n_rollcall"]) or 0
        # the side that prevailed: Yes vs No only (abstentions are not votes cast)
        prevailing = None if (y is None or n is None) else ("Y" if y > n else "N" if n > y else None)
        t = tally.get(r["record_id"], {})
        reconciles = None
        if nrc and None not in (y, n, a):
            reconciles = (t.get("Y", 0) == y and t.get("N", 0) == n and t.get("A", 0) == a)
        rows.append({
            "record_id": r["record_id"],
            "symbol": r["symbol"],
            "title": r["title"],
            "date": r["date"] or None,
            "year": as_int(r["year"]),
            "body": "HRC" if "Council" in r["body"] else "CHR",
            "vote_type": r["vote_type"],
            "adoption_mode": ADOPTION_MODE.get(r["vote_type"], "other"),
            "is_amendment": is_amendment(r["title"], r.get("draft", "")),
            "subject": r["agenda_subject"].strip() or None,
            "agenda_item_no": r["agenda_item_no"].strip() or None,
            "agenda_item_title": r["agenda_item_title"].strip().rstrip(" -").strip() or None,
            "main_sponsors": r["main_sponsors"].strip() or None,
            "meeting": r["meeting"].strip() or None,
            "yes": y, "no": n, "abstain": a,
            "nonvoting": as_int(r["nonvoting"]), "total": as_int(r["total"]),
            "n_rollcall": nrc,
            "has_rollcall": nrc > 0,
            "prevailing_side": prevailing,
            "adopted": None if prevailing is None else (prevailing == "Y"),
            "rollcall_reconciles": reconciles,
            "url_resolution": r["url_resolution"] or None,
            "url_draft": r["url_draft"] or None,
            "record_url": r["record_url"] or None,
        })
    return pd.DataFrame(rows)


def build_votes(vote_rows, res_df, groups):
    by_id = res_df.set_index("record_id")
    prevail = by_id["prevailing_side"].to_dict()
    subject = by_id["subject"].to_dict()
    amend = by_id["is_amendment"].to_dict()
    rows = []
    for v in vote_rows:
        rid, code = v["record_id"], v["vote"]
        p = prevail.get(rid)
        rows.append({
            "record_id": rid,
            "symbol": v["symbol"],
            "date": v["date"] or None,
            "year": as_int(v["year"]),
            "body": "HRC" if "Council" in v["body"] else "CHR",
            "iso3": v["iso3"] or None,
            "country": v["country"] or None,
            "un_regional_group": groups.get(v["iso3"]) or None,
            "vote": code or None,
            "vote_label": VOTE_LABEL.get(code, "unknown"),
            "is_cast_vote": code in ("Y", "N", "A"),
            "prevailing_side": p,
            # null when the state cast no vote, or the resolution had no Yes/No outcome
            "with_prevailing_side": (code == p) if (p and code in ("Y", "N", "A")) else None,
            "subject": subject.get(rid),
            "is_amendment": bool(amend.get(rid, False)),
        })
    return pd.DataFrame(rows)


def clause_type(label):
    if label.startswith("AX"):
        return "annex"
    if label.startswith("PP"):
        return "preambular"
    if label.startswith("OP"):
        return "operative_subitem" if "(" in label else "operative"
    return "other"


def build_countries(payload, votes_df):
    """Dimension table. Carries the caveats that are otherwise only prose: which states
    no longer exist, and which ISO code spans a change of representation rather than of
    state (the China seat, 1971)."""
    labels = payload["meta"]["groupLabels"]
    first_last = votes_df.groupby("iso3")["year"].agg(["min", "max"])
    rows = []
    for c in payload["countries"]:
        fl = first_last.loc[c["iso3"]] if c["iso3"] in first_last.index else None
        rb = c.get("repBreak") or {}
        rows.append({
            "iso3": c["iso3"],
            "name": c["name"],
            "un_regional_group": labels.get(c["group"]) or None,
            "un_regional_group_code": c["group"] or None,
            "n_rollcall_cells": c["n"],
            "n_yes": c["y"], "n_no": c["no"], "n_abstain": c["a"],
            "n_absent": c["absent"], "n_no_position": c["blank"],
            "first_vote_year": int(fl["min"]) if fl is not None else None,
            "last_vote_year": int(fl["max"]) if fl is not None else None,
            "is_historical_state": bool(c.get("hist")),
            "representation_break_year": rb.get("year"),
            "representation_break_note": rb.get("note"),
        })
    return pd.DataFrame(rows)


def build_subjects(res_df, is_country_subject):
    """OHCHR's own controlled subject vocabulary (MARC 991$d), with the thematic /
    country-situation split the dashboard uses.

    Covers all 1,033 catalogued subjects, not just the 312 that reach a recorded vote —
    the dashboard only needs the latter, but a null classification on a third of the
    resolutions would be a poor dataset. Uses the dashboard's own matcher, so the two
    can never disagree. The split is a name-matching heuristic against catalogued state
    names plus an explicit list of territories: imperfect at the margins."""
    counts_all = res_df.groupby("subject").size()
    counts_rec = res_df[res_df.has_rollcall].groupby("subject").size()
    rows = [{
        "subject": s,
        "is_country_situation": bool(is_country_subject(s)),
        "n_resolutions_recorded": int(counts_rec.get(s, 0)),
        "n_resolutions_all": int(n),
    } for s, n in counts_all.items()]
    return pd.DataFrame(rows).sort_values("n_resolutions_all", ascending=False)


def build_clauses(res_df):
    cat = json.loads((TX / "catalog.json").read_text())["docs"]
    bundles = {int(f.stem.split("-")[1]): json.loads(f.read_text())
               for f in TX.glob("docs-*.json")}
    meta = res_df.set_index("record_id")[["adoption_mode", "prevailing_side", "adopted"]].to_dict("index")
    rows = []
    for sym, rid, year, body, vt, am, subj, title in cat:
        for i, (label, text) in enumerate(bundles.get(year, {}).get(sym, [])):
            ct = clause_type(label)
            verb = dr = val = dg = None
            if ct == "operative":                      # scoring applies to top-level OP only
                verb, dr, val, dg = code_clause(text)
            m = meta.get(rid, {})
            rows.append({
                "record_id": rid,
                "symbol": sym,
                "year": year,
                "body": body,
                "subject": subj or None,
                "title": title,
                "is_amendment": bool(am),
                "adoption_mode": m.get("adoption_mode"),
                "adopted": m.get("adopted"),
                "clause_index": i,
                "clause_label": label,
                "clause_type": ct,
                "text": text,
                "n_chars": len(text),
                "n_words": len(text.split()),
                "operative_verb": verb,
                "directive_force": dr if (ct == "operative" and dr) else None,
                "sentiment": val if ct == "operative" else None,
                "creates_or_tasks_machinery": dg if ct == "operative" else None,
            })
    return pd.DataFrame(rows)


def main():
    DATA.mkdir(parents=True, exist_ok=True)
    res_rows = list(csv.DictReader(open(CSVD / "resolutions.csv", encoding="utf-8")))
    vote_rows = list(csv.DictReader(open(CSVD / "votes_long.csv", encoding="utf-8")))

    tally = {}
    for v in vote_rows:
        tally.setdefault(v["record_id"], {}).setdefault(v["vote"] or "-", 0)
        tally[v["record_id"]][v["vote"] or "-"] += 1

    payload = load_payload()
    groups = {c["iso3"]: payload["meta"]["groupLabels"].get(c["group"], None)
              for c in payload["countries"]}

    res_df = build_resolutions(res_rows, tally)

    # thematic vs country-situation, using the dashboard's own matcher over the raw
    # catalogued spellings so the two can never drift apart
    raw_names = {}
    for v in vote_rows:
        if v["iso3"]:
            raw_names.setdefault(v["iso3"], set()).add(v["country"].strip().upper())
    is_country_subject = country_subject_matcher(raw_names)
    cs = {s: is_country_subject(s) for s in res_df["subject"].dropna().unique()}

    res_df["subject_is_country_situation"] = res_df["subject"].map(cs)
    votes_df = build_votes(vote_rows, res_df, groups)
    clauses_df = build_clauses(res_df)
    clauses_df["subject_is_country_situation"] = clauses_df["subject"].map(cs)
    countries_df = build_countries(payload, votes_df)
    subjects_df = build_subjects(res_df, is_country_subject)

    for name, df in [("resolutions", res_df), ("votes", votes_df), ("clauses", clauses_df),
                     ("countries", countries_df), ("subjects", subjects_df)]:
        path = DATA / f"{name}-train.parquet"
        # pandas 3 writes object columns as arrow large_string; normalise to string so
        # older `datasets` releases read the files without a type surprise
        table = pa.Table.from_pandas(df, preserve_index=False)
        table = table.cast(pa.schema([
            f.with_type(pa.string()) if pa.types.is_large_string(f.type) else f
            for f in table.schema
        ]))
        pq.write_table(table, path, compression="zstd")
        print(f"  {name:<12} {len(df):>7,} rows  {path.stat().st_size/1024/1024:>6.1f} MB  "
              f"{len(df.columns)} cols")

    stats = {
        "resolutions": len(res_df),
        "votes": len(votes_df),
        "clauses": len(clauses_df),
        "countries": len(countries_df),
        "subjects": len(subjects_df),
        "country_situation_subjects": int(subjects_df["is_country_situation"].sum()),
        "historical_states": int(countries_df["is_historical_state"].sum()),
        "year_min": int(res_df["year"].min()),
        "year_max": int(res_df["year"].max()),
        "n_voting_states": int(votes_df["iso3"].nunique()),
        "with_rollcall": int(res_df["has_rollcall"].sum()),
        "rollcall_mismatch": int((res_df["rollcall_reconciles"] == False).sum()),  # noqa: E712
        "amendments": int(res_df["is_amendment"].sum()),
        "clause_years": [int(clauses_df["year"].min()), int(clauses_df["year"].max())],
        "clause_docs": int(clauses_df["symbol"].nunique()),
        "operative_clauses": int((clauses_df["clause_type"] == "operative").sum()),
    }
    (OUT / "dataset_stats.json").write_text(json.dumps(stats, indent=2) + "\n")
    print("\nstats:", json.dumps(stats))


if __name__ == "__main__":
    main()