scripts/build_l1_dataset.py

#!/usr/bin/env python3
"""Build L1 MCQ dataset for LLM benchmark.

Generates 2,000 multiple-choice questions across 4 classes:
  A) Active    (400) — confirmed active, ChEMBL positives pChEMBL ≥ 6
  B) Inactive  (800) — confirmed inactive, NegBioDB silver tier
  C) Inconclusive (400) — ambiguous evidence (bronze tier, borderline)
  D) Conditionally active (400) — cross-target selectivity compounds

Difficulty: Easy 40% / Medium 35% / Hard 25%
Split: 200 few-shot (50/class) + 200 val (50/class) + 1,600 test

Output: exports/llm_benchmarks/l1_mcq.jsonl
"""

import argparse
import json
import random
import sqlite3
import time
import urllib.request
import urllib.error
from pathlib import Path

import pandas as pd

PROJECT_ROOT = Path(__file__).resolve().parent.parent
NEGBIODB_PATH = PROJECT_ROOT / "data" / "negbiodb.db"
CHEMBL_PATH = PROJECT_ROOT / "data" / "chembl" / "chembl_36.db"
POSITIVES_PATH = PROJECT_ROOT / "exports" / "chembl_positives_pchembl6.parquet"
M1_PATH = PROJECT_ROOT / "exports" / "negbiodb_m1_balanced.parquet"
NAMES_PATH = PROJECT_ROOT / "exports" / "compound_names.parquet"
OUTPUT_PATH = PROJECT_ROOT / "exports" / "llm_benchmarks" / "l1_mcq.jsonl"

# Class sizes
N_ACTIVE = 400
N_INACTIVE = 800
N_INCONCLUSIVE = 400
N_CONDITIONAL = 400

# L-7: Max times a compound can appear within a single class.
# Set to 12 to accommodate DAVIS kinase panel (68 compounds × 375 targets).
# Prevents extreme dominance while allowing natural assay panel structure.
MAX_PER_COMPOUND = 12

# Difficulty proportions
FRAC_EASY = 0.40
FRAC_MEDIUM = 0.35
FRAC_HARD = 0.25


def load_compound_names() -> dict:
    """Load compound name cache: compound_id -> pref_name."""
    df = pd.read_parquet(NAMES_PATH)
    # Build lookup by compound_id
    id_names = {}
    for _, row in df.iterrows():
        if pd.notna(row["pref_name"]):
            id_names[int(row["compound_id"])] = row["pref_name"]
    return id_names


def load_target_info(db_path: Path) -> dict:
    """Load target info: target_id -> {uniprot, gene_symbol, family}."""
    conn = sqlite3.connect(str(db_path))
    rows = conn.execute(
        "SELECT target_id, uniprot_accession, gene_symbol, target_family "
        "FROM targets"
    ).fetchall()
    conn.close()
    return {
        r[0]: {"uniprot": r[1], "gene_symbol": r[2], "family": r[3]}
        for r in rows
    }


def load_compound_ids(db_path: Path) -> dict:
    """Load compound lookup: inchikey -> compound_id and chembl_id -> compound_id."""
    conn = sqlite3.connect(str(db_path))
    rows = conn.execute(
        "SELECT compound_id, inchikey, chembl_id, pubchem_cid FROM compounds"
    ).fetchall()
    conn.close()
    ik_map = {}
    chembl_map = {}
    for cid, ik, chembl, pcid in rows:
        if ik:
            ik_map[ik] = cid
        if chembl:
            chembl_map[chembl] = cid
    return ik_map, chembl_map


def fetch_pubchem_names(cids: list[int]) -> dict[int, str]:
    """Fetch names for PubChem CIDs not in cache."""
    if not cids:
        return {}
    all_names = {}
    batch_size = 100
    for i in range(0, len(cids), batch_size):
        batch = cids[i : i + batch_size]
        url = "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/cid/synonyms/JSON"
        data = f"cid={','.join(str(c) for c in batch)}".encode()
        req = urllib.request.Request(
            url,
            data=data,
            method="POST",
            headers={"Content-Type": "application/x-www-form-urlencoded"},
        )
        try:
            with urllib.request.urlopen(req, timeout=30) as resp:
                result = json.loads(resp.read())
            for entry in result.get("InformationList", {}).get("Information", []):
                cid = entry.get("CID")
                synonyms = entry.get("Synonym", [])
                if cid and synonyms and not synonyms[0].isdigit():
                    all_names[cid] = synonyms[0]
        except Exception:
            pass
        time.sleep(0.3)
    return all_names


# ── Class A: Active ──────────────────────────────────────────────────────────


def select_active(positives_df: pd.DataFrame, names: dict,
                  ik_to_cid: dict, n: int, seed: int) -> list[dict]:
    """Select n active compound-target pairs from ChEMBL positives."""
    rng = random.Random(seed)
    df = positives_df.copy()

    # Map inchikey -> compound_id for name lookup
    df["compound_id"] = df["inchikey"].map(ik_to_cid)

    # Filter to compounds with names (for better MCQ quality)
    df["compound_name"] = df["compound_id"].map(names)
    named = df[df["compound_name"].notna()].copy()
    print(f"  Active: {len(named)}/{len(df)} have names")

    # Stratify by difficulty (based on pchembl)
    easy = named[named["pchembl_value"] > 7.5].copy()
    medium = named[
        (named["pchembl_value"] > 6.5) & (named["pchembl_value"] <= 7.5)
    ].copy()
    hard = named[named["pchembl_value"] <= 6.5].copy()

    n_easy = int(n * FRAC_EASY)
    n_medium = int(n * FRAC_MEDIUM)
    n_hard = n - n_easy - n_medium

    # Sample from each difficulty band
    selected = []
    for subset, count, diff in [
        (easy, n_easy, "easy"),
        (medium, n_medium, "medium"),
        (hard, n_hard, "hard"),
    ]:
        # Diversify: max 1 per UniProt to spread across targets
        by_target = subset.groupby("uniprot_id")
        pool = []
        for _, group in by_target:
            pool.append(group.sample(1, random_state=seed))
        if pool:
            pool_df = pd.concat(pool)
            if len(pool_df) < count:
                # Need more — allow duplicates per target
                extra = subset[~subset.index.isin(pool_df.index)]
                pool_df = pd.concat([pool_df, extra]).head(count * 3)
            sampled = pool_df.sample(min(count, len(pool_df)), random_state=seed)
        else:
            sampled = subset.sample(min(count, len(subset)), random_state=seed)

        for _, row in sampled.iterrows():
            selected.append(
                {
                    "class": "active",
                    "correct_answer": "A",
                    "difficulty": diff,
                    "compound_name": row["compound_name"],
                    "compound_smiles": row["smiles"],
                    "compound_inchikey": row["inchikey"],
                    "target_uniprot": row["uniprot_id"],
                    "activity_type": row["activity_type"],
                    "activity_value_nm": float(row["activity_value_nm"]),
                    "pchembl_value": float(row["pchembl_value"]),
                    "publication_year": (
                        int(row["publication_year"])
                        if pd.notna(row.get("publication_year"))
                        else None
                    ),
                    "evidence_quality": "gold",
                    "source_db": "ChEMBL",
                }
            )

    rng.shuffle(selected)
    return selected[:n]


# ── Class B: Inactive ────────────────────────────────────────────────────────


def select_inactive(
    db_path: Path, names: dict, target_info: dict, n: int, seed: int
) -> list[dict]:
    """Select n inactive pairs from NegBioDB silver tier."""
    conn = sqlite3.connect(str(db_path))

    # Query silver-tier pairs for compounds with chembl_id (ensures names)
    rows = conn.execute(
        """
        SELECT ctp.compound_id, ctp.target_id,
               c.canonical_smiles, c.inchikey,
               ctp.num_assays, ctp.num_sources, ctp.median_pchembl,
               ctp.min_activity_value, ctp.max_activity_value,
               ctp.earliest_year, ctp.best_confidence
        FROM compound_target_pairs ctp
        JOIN compounds c ON ctp.compound_id = c.compound_id
        WHERE ctp.best_confidence = 'silver'
          AND c.chembl_id IS NOT NULL
        ORDER BY RANDOM()
        LIMIT ?
        """,
        (n * 10,),
    ).fetchall()
    conn.close()

    cols = [
        "compound_id", "target_id", "smiles", "inchikey",
        "num_assays", "num_sources", "median_pchembl",
        "min_activity_value", "max_activity_value",
        "earliest_year", "best_confidence",
    ]
    df = pd.DataFrame(rows, columns=cols)

    # Add names and target info
    df["compound_name"] = df["compound_id"].map(names)
    named = df[df["compound_name"].notna()].copy()
    print(f"  Inactive: {len(named)}/{len(df)} have names")

    # Add target gene symbols
    named["gene_symbol"] = named["target_id"].map(
        lambda tid: target_info.get(tid, {}).get("gene_symbol")
    )
    named["target_family"] = named["target_id"].map(
        lambda tid: target_info.get(tid, {}).get("family")
    )
    named["target_uniprot"] = named["target_id"].map(
        lambda tid: target_info.get(tid, {}).get("uniprot")
    )

    # Difficulty based on evidence strength
    # Easy: many assays, clear inactive (low pchembl or null)
    # Medium: fewer assays, moderate evidence
    # Hard: single assay, near threshold
    named["difficulty"] = "medium"
    named.loc[named["num_assays"] >= 3, "difficulty"] = "easy"
    named.loc[named["num_sources"] >= 2, "difficulty"] = "easy"
    named.loc[
        (named["num_assays"] == 1) & (named["num_sources"] == 1), "difficulty"
    ] = "hard"

    n_easy = int(n * FRAC_EASY)
    n_medium = int(n * FRAC_MEDIUM)
    n_hard = n - n_easy - n_medium

    selected = []
    seen_compounds = set()
    for diff, count in [("easy", n_easy), ("medium", n_medium), ("hard", n_hard)]:
        pool = named[named["difficulty"] == diff]
        # Diversify compounds
        pool = pool[~pool["compound_id"].isin(seen_compounds)]
        sampled = pool.sample(min(count, len(pool)), random_state=seed)
        seen_compounds.update(sampled["compound_id"])

        for _, row in sampled.iterrows():
            activity_desc = _format_activity(
                row["min_activity_value"], row["max_activity_value"],
                row["median_pchembl"]
            )
            selected.append(
                {
                    "class": "inactive",
                    "correct_answer": "B",
                    "difficulty": diff,
                    "compound_name": row["compound_name"],
                    "compound_smiles": row["smiles"],
                    "compound_inchikey": row["inchikey"],
                    "target_uniprot": row["target_uniprot"],
                    "target_gene": row["gene_symbol"],
                    "target_family": row["target_family"],
                    "num_assays": int(row["num_assays"]),
                    "num_sources": int(row["num_sources"]),
                    "activity_description": activity_desc,
                    "pchembl_value": (
                        float(row["median_pchembl"])
                        if pd.notna(row["median_pchembl"])
                        else None
                    ),
                    "publication_year": (
                        int(row["earliest_year"])
                        if pd.notna(row["earliest_year"])
                        else None
                    ),
                    "evidence_quality": "silver",
                    "source_db": "NegBioDB",
                }
            )

    random.Random(seed).shuffle(selected)
    return selected[:n]


def _format_activity(min_val, max_val, median_pchembl):
    """Format activity description for inactive pairs."""
    parts = []
    if pd.notna(min_val):
        if min_val >= 10000:
            parts.append("No significant activity at 10 µM")
        elif min_val >= 1000:
            parts.append(f"Weak activity (>{min_val:.0f} nM)")
        else:
            # min_val < 1000 nM in an inactive pair means inconsistent assay results
            parts.append(
                f"Best measurement: {min_val:.0f} nM "
                f"(inconsistent across assays; classified inactive at 10 µM threshold)"
            )
    if pd.notna(median_pchembl) and median_pchembl > 0:
        parts.append(f"pChEMBL: {median_pchembl:.1f}")
    if not parts:
        parts.append("Inactive (below detection threshold)")
    return "; ".join(parts)


# ── Class C: Inconclusive ────────────────────────────────────────────────────


def select_inconclusive(
    db_path: Path, names: dict, target_info: dict, n: int, seed: int
) -> list[dict]:
    """Select n inconclusive pairs (bronze tier + borderline silver)."""
    conn = sqlite3.connect(str(db_path))

    # Part 1: Bronze tier (DAVIS) — all are single-assay Kd at threshold
    # DAVIS compounds have no chembl_id, so fetch PubChem names on demand
    bronze_rows = conn.execute(
        """
        SELECT ctp.compound_id, ctp.target_id,
               c.canonical_smiles, c.inchikey, c.pubchem_cid,
               ctp.num_assays, ctp.num_sources, ctp.median_pchembl,
               ctp.min_activity_value, ctp.max_activity_value,
               ctp.earliest_year
        FROM compound_target_pairs ctp
        JOIN compounds c ON ctp.compound_id = c.compound_id
        WHERE ctp.best_confidence = 'bronze'
        ORDER BY RANDOM()
        LIMIT ?
        """,
        (n * 3,),
    ).fetchall()

    # Fetch PubChem names for DAVIS compounds missing from cache
    bronze_cids_needing_names = set()
    for row in bronze_rows:
        cid = row[0]  # compound_id
        pcid = row[4]  # pubchem_cid
        if cid not in names and pcid:
            bronze_cids_needing_names.add(int(pcid))

    if bronze_cids_needing_names:
        print(f"  Fetching PubChem names for {len(bronze_cids_needing_names)} DAVIS compounds...")
        pc_names = fetch_pubchem_names(list(bronze_cids_needing_names))
        # Map pubchem_cid -> compound_id for update
        pcid_to_compid = {
            int(row[4]): row[0]
            for row in bronze_rows
            if row[4]
        }
        for pcid, name in pc_names.items():
            if pcid in pcid_to_compid:
                names[pcid_to_compid[pcid]] = name

    # Part 2: Borderline silver — single assay, activity near threshold, named
    borderline_rows = conn.execute(
        """
        SELECT ctp.compound_id, ctp.target_id,
               c.canonical_smiles, c.inchikey, c.pubchem_cid,
               ctp.num_assays, ctp.num_sources, ctp.median_pchembl,
               ctp.min_activity_value, ctp.max_activity_value,
               ctp.earliest_year
        FROM compound_target_pairs ctp
        JOIN compounds c ON ctp.compound_id = c.compound_id
        WHERE ctp.best_confidence = 'silver'
          AND c.chembl_id IS NOT NULL
          AND ctp.num_assays = 1
          AND ctp.num_sources = 1
          AND ctp.min_activity_value BETWEEN 5000 AND 15000
        ORDER BY RANDOM()
        LIMIT ?
        """,
        (n * 5,),
    ).fetchall()
    conn.close()

    cols = [
        "compound_id", "target_id", "smiles", "inchikey", "pubchem_cid",
        "num_assays", "num_sources", "median_pchembl",
        "min_activity_value", "max_activity_value", "earliest_year",
    ]

    bronze_df = pd.DataFrame(bronze_rows, columns=cols)
    bronze_df["inconclusive_reason"] = "single_assay_bronze"

    borderline_df = pd.DataFrame(borderline_rows, columns=cols)
    borderline_df["inconclusive_reason"] = "borderline_threshold"

    df = pd.concat([bronze_df, borderline_df], ignore_index=True)

    # Add names
    df["compound_name"] = df["compound_id"].map(names)
    named = df[df["compound_name"].notna()].copy()
    print(f"  Inconclusive: {len(named)}/{len(df)} have names")

    # If not enough named, use unnamed with SMILES
    if len(named) < n:
        unnamed = df[df["compound_name"].isna()].copy()
        unnamed["compound_name"] = unnamed["smiles"].str[:50] + "..."
        named = pd.concat([named, unnamed])

    # Add target info
    named["gene_symbol"] = named["target_id"].map(
        lambda tid: target_info.get(tid, {}).get("gene_symbol")
    )
    named["target_family"] = named["target_id"].map(
        lambda tid: target_info.get(tid, {}).get("family")
    )
    named["target_uniprot"] = named["target_id"].map(
        lambda tid: target_info.get(tid, {}).get("uniprot")
    )

    # Difficulty: bronze = medium (single-assay, ambiguous evidence),
    # borderline threshold = hard (near 10 µM cutoff, requires nuanced judgment)
    # No "easy" tier: inconclusive cases inherently require careful interpretation
    named["difficulty"] = named["inconclusive_reason"].map(
        {"single_assay_bronze": "medium", "borderline_threshold": "hard"}
    )

    # Sample: 60% medium (bronze), 40% hard (borderline)
    n_medium = int(n * 0.6)
    n_hard = n - n_medium

    selected = []
    for diff, count in [("medium", n_medium), ("hard", n_hard)]:
        pool = named[named["difficulty"] == diff]
        sampled = pool.sample(min(count, len(pool)), random_state=seed)
        for _, row in sampled.iterrows():
            reason = (
                "Single Kd measurement at threshold (DAVIS kinase panel)"
                if row["inconclusive_reason"] == "single_assay_bronze"
                else "Borderline activity near 10 µM threshold, single assay"
            )
            selected.append(
                {
                    "class": "inconclusive",
                    "correct_answer": "C",
                    "difficulty": diff,
                    "compound_name": row["compound_name"],
                    "compound_smiles": row["smiles"],
                    "compound_inchikey": row["inchikey"],
                    "target_uniprot": row["target_uniprot"],
                    "target_gene": row["gene_symbol"],
                    "target_family": row["target_family"],
                    "num_assays": int(row["num_assays"]),
                    "num_sources": int(row["num_sources"]),
                    "activity_description": reason,
                    "pchembl_value": (
                        float(row["median_pchembl"])
                        if pd.notna(row["median_pchembl"])
                        else None
                    ),
                    "evidence_quality": (
                        "bronze"
                        if row["inconclusive_reason"] == "single_assay_bronze"
                        else "silver"
                    ),
                    "source_db": (
                        "DAVIS"
                        if row["inconclusive_reason"] == "single_assay_bronze"
                        else "NegBioDB"
                    ),
                }
            )

    random.Random(seed).shuffle(selected)
    return selected[:n]


# ── Class D: Conditional ─────────────────────────────────────────────────────


def select_conditional(
    m1_path: Path,
    positives_df: pd.DataFrame,
    names: dict,
    ik_to_cid: dict,
    target_info: dict,
    n: int,
    seed: int,
) -> list[dict]:
    """Select n conditional (cross-target selectivity) pairs.

    These are compounds active against some targets but inactive against others.
    """
    m1 = pd.read_parquet(m1_path, columns=["smiles", "inchikey", "uniprot_id", "Y"])

    # Find compounds that appear as both active and inactive
    compound_labels = m1.groupby("inchikey")["Y"].agg(["sum", "count"])
    compound_labels.columns = ["n_active", "n_total"]
    compound_labels["n_inactive"] = (
        compound_labels["n_total"] - compound_labels["n_active"]
    )

    # Cross-target selectivity: active in ≥1, inactive in ≥1
    cross_target = compound_labels[
        (compound_labels["n_active"] >= 1) & (compound_labels["n_inactive"] >= 1)
    ].index.tolist()

    print(f"  Conditional: {len(cross_target)} cross-target selectivity compounds")

    # Map to compound_ids for name lookup
    cross_iks = set(cross_target)
    m1_cross = m1[m1["inchikey"].isin(cross_iks)].copy()
    m1_cross["compound_id"] = m1_cross["inchikey"].map(ik_to_cid)
    m1_cross["compound_name"] = m1_cross["compound_id"].map(names)

    # Filter to named compounds
    named_iks = set(
        m1_cross.loc[m1_cross["compound_name"].notna(), "inchikey"].unique()
    )
    print(f"  Conditional: {len(named_iks)} with names")

    # For each named cross-target compound, get its active and inactive targets
    selected = []
    rng = random.Random(seed)
    shuffled_iks = list(named_iks)
    rng.shuffle(shuffled_iks)

    for ik in shuffled_iks:
        if len(selected) >= n:
            break

        comp_data = m1_cross[m1_cross["inchikey"] == ik]
        active_targets = comp_data[comp_data["Y"] == 1]["uniprot_id"].tolist()
        inactive_targets = comp_data[comp_data["Y"] == 0]["uniprot_id"].tolist()

        if not active_targets or not inactive_targets:
            continue

        compound_name = comp_data["compound_name"].iloc[0]
        smiles = comp_data["smiles"].iloc[0]
        compound_id = comp_data["compound_id"].iloc[0]

        # Pick one inactive target for the question
        inactive_t = rng.choice(inactive_targets)
        # Get active target names for context
        active_genes = []
        for at in active_targets[:3]:  # Show up to 3 active targets
            info = _find_target_by_uniprot(target_info, at)
            if info and info.get("gene_symbol"):
                active_genes.append(info["gene_symbol"])

        inactive_info = _find_target_by_uniprot(target_info, inactive_t)

        # Difficulty based on number of targets
        if len(active_targets) >= 5 and len(inactive_targets) >= 3:
            difficulty = "hard"
        elif len(active_targets) >= 2:
            difficulty = "medium"
        else:
            difficulty = "hard"  # few targets = harder to reason about

        active_context = (
            f"Known active against: {', '.join(active_genes)}"
            if active_genes
            else f"Active against {len(active_targets)} other target(s)"
        )

        selected.append(
            {
                "class": "conditional",
                "correct_answer": "D",
                "difficulty": difficulty,
                "compound_name": compound_name,
                "compound_smiles": smiles,
                "compound_inchikey": ik,
                "target_uniprot": inactive_t,
                "target_gene": (
                    inactive_info["gene_symbol"] if inactive_info else None
                ),
                "target_family": (
                    inactive_info["family"] if inactive_info else None
                ),
                "num_active_targets": len(active_targets),
                "num_inactive_targets": len(inactive_targets),
                "active_context": active_context,
                "evidence_quality": "silver",
                "source_db": "NegBioDB+ChEMBL",
            }
        )

    rng.shuffle(selected)
    return selected[:n]


def _find_target_by_uniprot(target_info: dict, uniprot: str) -> dict | None:
    """Find target info by UniProt accession."""
    for tid, info in target_info.items():
        if info["uniprot"] == uniprot:
            return info
    return None


# ── Assembly ─────────────────────────────────────────────────────────────────


def add_target_info_to_active(records: list[dict], target_info: dict):
    """Add target gene/family to active records."""
    for rec in records:
        info = _find_target_by_uniprot(target_info, rec["target_uniprot"])
        if info:
            rec["target_gene"] = info.get("gene_symbol")
            rec["target_family"] = info.get("family")
        else:
            rec["target_gene"] = None
            rec["target_family"] = None


def generate_context_text(record: dict) -> str:
    """Generate the MCQ prompt context from a record.

    Design intent: This is an assay data interpretation test. The prompt
    deliberately includes activity measurements (pChEMBL, assay counts,
    activity descriptions) because the task tests whether the LLM can
    correctly interpret bioactivity data, not whether it can guess from
    compound/target names alone.
    """
    name = record.get("compound_name", "Unknown")
    smiles = record.get("compound_smiles", "")
    gene = record.get("target_gene")
    uniprot = record.get("target_uniprot", "Unknown")
    family = record.get("target_family") or "protein"

    # Target display: "EGFR (P00533), kinase" or "P00533, protein" if no gene
    if gene:
        target_str = f"{gene} ({uniprot}), {family}"
    else:
        target_str = f"{uniprot}, {family}"

    lines = [
        f"Compound: {name}",
        f"SMILES: {smiles}",
        f"Target: {target_str}",
    ]

    cls = record["class"]
    if cls == "active":
        act_type = record.get("activity_type", "IC50")
        act_val = record.get("activity_value_nm", 0)
        pchembl = record.get("pchembl_value", 0)
        lines.append(f"Activity: {act_type} = {act_val:.1f} nM (pChEMBL {pchembl:.2f})")
    elif cls == "inactive":
        desc = record.get("activity_description", "Inactive")
        n_assays = record.get("num_assays", 1)
        n_src = record.get("num_sources", 1)
        lines.append(f"Result: {desc}")
        lines.append(f"Evidence: {n_assays} assay(s), {n_src} source(s)")
    elif cls == "inconclusive":
        desc = record.get("activity_description", "Inconclusive")
        lines.append(f"Result: {desc}")
        lines.append(f"Evidence: {record.get('num_assays', 1)} assay, single source")
    elif cls == "conditional":
        ctx = record.get("active_context", "")
        lines.append(f"Context: {ctx}")
        lines.append("Tested against this target: no significant activity at 10 µM")

    lines.append("")
    lines.append("What is the most likely interaction outcome for this compound-target pair?")
    lines.append("A) Active  B) Inactive  C) Inconclusive  D) Conditionally active")

    return "\n".join(lines)


def split_dataset(records: list[dict], seed: int) -> list[dict]:
    """Assign split: 200 fewshot (50/class), 200 val (50/class), rest test."""
    rng = random.Random(seed)

    by_class = {}
    for rec in records:
        by_class.setdefault(rec["class"], []).append(rec)

    for cls_records in by_class.values():
        rng.shuffle(cls_records)

    for cls, cls_records in by_class.items():
        for i, rec in enumerate(cls_records):
            if i < 50:
                rec["split"] = "fewshot"
            elif i < 100:
                rec["split"] = "val"
            else:
                rec["split"] = "test"

    all_records = []
    for cls_records in by_class.values():
        all_records.extend(cls_records)

    rng.shuffle(all_records)
    return all_records


def main():
    parser = argparse.ArgumentParser(description="Build L1 MCQ dataset")
    parser.add_argument("--seed", type=int, default=42)
    args = parser.parse_args()
    seed = args.seed

    print("Loading data sources...")
    names = load_compound_names()
    print(f"  Compound names: {len(names)}")

    target_info = load_target_info(NEGBIODB_PATH)
    print(f"  Targets: {len(target_info)}")

    ik_to_cid, chembl_to_cid = load_compound_ids(NEGBIODB_PATH)
    print(f"  InChIKey map: {len(ik_to_cid)}")

    positives = pd.read_parquet(POSITIVES_PATH)
    print(f"  ChEMBL positives: {len(positives)}")

    # ── Select each class ──
    print("\nSelecting Active (A)...")
    active = select_active(positives, names, ik_to_cid, N_ACTIVE, seed)
    add_target_info_to_active(active, target_info)
    print(f"  Selected: {len(active)}")

    print("\nSelecting Inactive (B)...")
    inactive = select_inactive(NEGBIODB_PATH, names, target_info, N_INACTIVE, seed)
    print(f"  Selected: {len(inactive)}")

    print("\nSelecting Inconclusive (C)...")
    inconclusive = select_inconclusive(
        NEGBIODB_PATH, names, target_info, N_INCONCLUSIVE, seed
    )
    print(f"  Selected: {len(inconclusive)}")

    print("\nSelecting Conditional (D)...")
    conditional = select_conditional(
        M1_PATH, positives, names, ik_to_cid, target_info, N_CONDITIONAL, seed
    )
    print(f"  Selected: {len(conditional)}")

    # ── C-2: Cross-class dedup + L-7: Per-class compound repetition cap ──
    # Remove compound-target pairs that appear in multiple classes.
    # Priority: active > inactive > inconclusive > conditional.
    # Compound cap is per-class (not global) because the same compound
    # appearing as active against target A and inconclusive against target B
    # is scientifically valid (selectivity) and IS what L1 tests.
    used_pairs = set()      # (inchikey[:14], uniprot) pairs already used

    def _dedup_class(records, class_name):
        """Filter records removing cross-class pair conflicts and applying per-class compound cap."""
        kept = []
        removed_pair = 0
        removed_cap = 0
        class_compound_counts = {}  # per-class compound cap
        for rec in records:
            ik = rec.get("compound_inchikey", "")
            uni = rec.get("target_uniprot", "")
            ik14 = ik[:14] if ik else ""
            pair = (ik14, uni)

            if pair in used_pairs:
                removed_pair += 1
                continue
            if ik14 and class_compound_counts.get(ik14, 0) >= MAX_PER_COMPOUND:
                removed_cap += 1
                continue

            kept.append(rec)
            used_pairs.add(pair)
            class_compound_counts[ik14] = class_compound_counts.get(ik14, 0) + 1

        if removed_pair or removed_cap:
            print(f"  {class_name}: removed {removed_pair} pair conflicts, "
                  f"{removed_cap} compound cap violations")
        return kept

    active = _dedup_class(active, "Active")
    inactive = _dedup_class(inactive, "Inactive")
    inconclusive = _dedup_class(inconclusive, "Inconclusive")
    conditional = _dedup_class(conditional, "Conditional")

    # ── Assemble ──
    all_records = active + inactive + inconclusive + conditional
    total = len(all_records)
    print(f"\nTotal records: {total} (after dedup)")

    # Generate context text
    for rec in all_records:
        rec["context_text"] = generate_context_text(rec)

    # Assign splits
    all_records = split_dataset(all_records, seed)

    # Add question IDs
    for i, rec in enumerate(all_records):
        rec["question_id"] = f"L1-{i:04d}"

    # ── Summary ──
    print("\n=== Dataset Summary ===")
    class_counts = {}
    diff_counts = {}
    split_counts = {}
    for rec in all_records:
        class_counts[rec["class"]] = class_counts.get(rec["class"], 0) + 1
        diff_counts[rec["difficulty"]] = diff_counts.get(rec["difficulty"], 0) + 1
        split_counts[rec["split"]] = split_counts.get(rec["split"], 0) + 1

    print(f"Classes: {class_counts}")
    print(f"Difficulty: {diff_counts}")
    print(f"Splits: {split_counts}")

    # ── Save ──
    OUTPUT_PATH.parent.mkdir(parents=True, exist_ok=True)
    with open(OUTPUT_PATH, "w") as f:
        for rec in all_records:
            f.write(json.dumps(rec, ensure_ascii=False) + "\n")

    print(f"\nSaved to {OUTPUT_PATH}")
    print(f"  {total} questions")


if __name__ == "__main__":
    main()