scripts/verify.py

"""Verify concept-analysis trajectory configs are reproducible from HF.

Downloads all inputs directly from HuggingFace, reruns the build logic for
concept_verse_edge_sp and concept_trajectory_sp, then compares freshly-built
outputs against the published NuBerea/concept-analysis parquets.

Exits 0 if everything matches, 1 if any check fails.

Note: Only the trajectory (_sp) configs are HF-reproducible from first principles.
community_candidate, community_membership, concept_centroids, and concept_drift
are outputs of other pipelines (concept-graph BERTopic, drift analysis) and are
not independently verified here.
"""

from __future__ import annotations

import re
import sys
import tempfile
from collections import defaultdict
from pathlib import Path

import numpy as np
import pandas as pd
from huggingface_hub import hf_hub_download


def dl(repo_id: str, config: str, tmp: Path) -> pd.DataFrame:
    fname = f"data/{config}/train-00000-of-00001.parquet"
    print(f"  Downloading {repo_id}/{config} ...")
    path = hf_hub_download(
        repo_id=repo_id,
        filename=fname,
        repo_type="dataset",
        local_dir=str(tmp / repo_id.replace("/", "__")),
    )
    df = pd.read_parquet(path)
    print(f"    {len(df):,} rows, cols: {list(df.columns)}")
    return df


def parse_osis(ref: str):
    if " " in ref and ":" in ref:
        book, cv = ref.split(" ", 1)
        ch_s, v_s = cv.split(":")
    else:
        parts = ref.split(".")
        book = parts[0]; ch_s = parts[1]; v_s = parts[2]
    ch = int(ch_s)
    m = re.match(r"^(\d+)([a-zA-Z]?)$", v_s)
    if not m:
        raise ValueError(f"Cannot parse verse '{v_s}' in ref '{ref}'")
    return book, ch, (int(m.group(1)), m.group(2))


def group_by_book(df: pd.DataFrame) -> dict:
    by_book: dict = defaultdict(list)
    for osis_ref, emb in zip(df["osis_ref"], df["embedding"]):
        book, ch, v_tup = parse_osis(osis_ref)
        by_book[book].append((ch, v_tup, osis_ref, np.array(emb, dtype=np.float32)))
    for book in by_book:
        by_book[book].sort(key=lambda x: (x[0], x[1]))
    return by_book


def get_verses_in_range(by_book: dict, start_ref: str, end_ref: str) -> list:
    start_book, start_ch, start_v = parse_osis(start_ref)
    end_book, end_ch, end_v = parse_osis(end_ref)
    assert start_book == end_book
    result = []
    for ch, v_tup, osis_ref, emb in by_book.get(start_book, []):
        if (start_ch, start_v) <= (ch, v_tup) <= (end_ch, end_v):
            result.append((osis_ref, emb))
    return result


def rebuild(cse: pd.DataFrame, sn: pd.DataFrame, cn: pd.DataFrame,
            lxx: pd.DataFrame, nt: pd.DataFrame, vg: pd.DataFrame):
    MODEL_ID = "bowphs/SPhilBerta"
    pericopes = sn[sn["span_grain"] == "pericope"][
        ["span_id", "corpus_id", "osis_start", "osis_end"]
    ].copy()
    edges = cse[["src", "dst", "weight"]].merge(
        pericopes, left_on="dst", right_on="span_id", how="inner"
    )
    concept_labels = cn.set_index("concept_id")["label"].to_dict()
    print(f"  {len(edges)} concept-pericope edges ({edges['src'].nunique()} concepts)")

    lxx_by_book   = group_by_book(lxx)
    nt_by_book    = group_by_book(nt)
    vg_ot_by_book = group_by_book(vg[vg["stratum"] == "vg_ot"])
    vg_nt_by_book = group_by_book(vg[vg["stratum"] == "vg_nt"])

    records, miss = [], {"lxx": 0, "nt": 0, "vg": 0}
    for _, edge in edges.iterrows():
        cid = edge["src"]
        label = concept_labels.get(cid, "")
        is_ot = edge["corpus_id"] == "ot"

        greek_bb = lxx_by_book if is_ot else nt_by_book
        greek_st = "lxx" if is_ot else "nt"
        for ref, emb in get_verses_in_range(greek_bb, edge["osis_start"], edge["osis_end"]) or (miss.__setitem__(greek_st, miss[greek_st]+1), []):
            records.append({"concept_id": cid, "concept_label": label,
                            "osis_ref": ref, "stratum": greek_st,
                            "edge_weight": float(edge["weight"]),
                            "embedding": emb.tolist()})

        for ref, emb in get_verses_in_range(vg_ot_by_book if is_ot else vg_nt_by_book,
                                            edge["osis_start"], edge["osis_end"]) or (miss.__setitem__("vg", miss["vg"]+1), []):
            records.append({"concept_id": cid, "concept_label": label,
                            "osis_ref": ref, "stratum": "vg",
                            "edge_weight": float(edge["weight"]),
                            "embedding": emb.tolist()})

    cve = pd.DataFrame(records)
    cve["model_id"] = MODEL_ID
    print(f"  concept_verse_edge_sp: {len(cve):,} rows  misses={miss}")

    traj = []
    for (cid, stratum), grp in cve.groupby(["concept_id", "stratum"]):
        mats = np.stack([np.array(e, dtype=np.float32) for e in grp["embedding"]])
        centroid = mats.mean(axis=0)
        cnorm = np.linalg.norm(centroid)
        cu = centroid / (cnorm + 1e-8)
        norms = np.linalg.norm(mats, axis=1, keepdims=True)
        units = mats / (norms + 1e-8)
        cosine = float((units @ cu).mean())
        traj.append({"concept_id": cid, "concept_label": grp["concept_label"].iloc[0],
                     "stratum": stratum, "verse_count": len(grp),
                     "centroid": centroid.tolist(),
                     "mean_cosine_to_centroid": cosine,
                     "verse_refs": grp["osis_ref"].tolist(),
                     "model_id": MODEL_ID})

    traj_df = pd.DataFrame(traj)
    print(f"  concept_trajectory_sp: {len(traj_df):,} rows")
    return cve, traj_df


def check(name: str, rebuilt: pd.DataFrame, published: pd.DataFrame) -> list[str]:
    errors = []
    if len(rebuilt) != len(published):
        errors.append(f"{name}: row count {len(rebuilt)} vs published {len(published)}")
    else:
        print(f"  {name}: rows match ({len(rebuilt):,})")
    rb_cols, pb_cols = set(rebuilt.columns), set(published.columns)
    if rb_cols != pb_cols:
        errors.append(f"{name}: columns differ — extra={rb_cols-pb_cols} missing={pb_cols-rb_cols}")
    else:
        print(f"  {name}: columns match")
    return errors


def check_drift_stats(traj: pd.DataFrame, label: str) -> None:
    lxx_t = traj[traj["stratum"] == "lxx"].set_index("concept_id")
    nt_t  = traj[traj["stratum"] == "nt"].set_index("concept_id")
    vg_t  = traj[traj["stratum"] == "vg"].set_index("concept_id")
    for a_label, a_t, b_label, b_t in [("LXX", lxx_t, "VG", vg_t), ("NT", nt_t, "VG", vg_t)]:
        common = a_t.index.intersection(b_t.index)
        sims = [
            float(np.dot(
                np.array(a_t.loc[cid, "centroid"], dtype=np.float32),
                np.array(b_t.loc[cid, "centroid"], dtype=np.float32),
            ) / (
                np.linalg.norm(np.array(a_t.loc[cid, "centroid"], dtype=np.float32)) *
                np.linalg.norm(np.array(b_t.loc[cid, "centroid"], dtype=np.float32)) + 1e-8
            ))
            for cid in common
        ]
        print(f"  [{label}] {a_label} vs {b_label} ({len(common)} concepts): "
              f"mean={np.mean(sims):.4f}  min={np.min(sims):.4f}  max={np.max(sims):.4f}")


def main() -> int:
    errors: list[str] = []

    with tempfile.TemporaryDirectory() as tmp_str:
        tmp = Path(tmp_str)

        print("\n=== Downloading concept-graph inputs ===")
        cse = dl("NuBerea/concept-graph",              "concept_span_edge", tmp)
        sn  = dl("NuBerea/concept-graph",              "span_node",         tmp)
        cn  = dl("NuBerea/concept-graph",              "concept_node",      tmp)

        print("\n=== Downloading greek-embeddings-primitives (_sp configs) ===")
        lxx = dl("NuBerea/greek-embeddings-primitives", "lxx_verse_embeddings_sp",  tmp)
        nt  = dl("NuBerea/greek-embeddings-primitives", "nt_verse_embeddings_sp",   tmp)
        vg  = dl("NuBerea/greek-embeddings-primitives", "vulgate_verse_embeddings", tmp)

        print("\n=== Downloading published concept-analysis outputs ===")
        pub_cve  = dl("NuBerea/concept-analysis", "concept_verse_edge_sp", tmp)
        pub_traj = dl("NuBerea/concept-analysis", "concept_trajectory_sp", tmp)

        print("\n=== Rebuilding from HF inputs ===")
        rb_cve, rb_traj = rebuild(cse, sn, cn, lxx, nt, vg)

        print("\n=== Comparing ===")
        errors += check("concept_verse_edge_sp", rb_cve,  pub_cve)
        errors += check("concept_trajectory_sp", rb_traj, pub_traj)

        print("\n=== Drift stats (rebuilt) ===")
        check_drift_stats(rb_traj, "rebuilt")

        print("\n=== Drift stats (published) ===")
        check_drift_stats(pub_traj, "published")

    if errors:
        print("\nFAIL:")
        for e in errors:
            print(" ", e)
        return 1

    print("\nPASS — HF-native rebuild matches published outputs.")
    return 0


if __name__ == "__main__":
    sys.exit(main())