scripts/pubchem_qc_report.py

"""Generate a lightweight PubChem raw-data QC report.

This script is safe to run while ETL is in progress because it only reads:
- Downloaded PubChem files
- SID lookup SQLite

Output:
- JSON report in exports/
- Markdown summary in exports/
"""

from __future__ import annotations

import argparse
import json
import sqlite3
from datetime import datetime, timezone
from pathlib import Path

import pandas as pd

from negbiodb.db import _PROJECT_ROOT
from negbiodb.download import load_config
from negbiodb.etl_pubchem import (
    _find_col,
    _normalize_accession,
    _normalize_columns,
)

_HUMAN_TAXID = 9606

_ASSAY_TYPE_CANDIDATES = [
    "assay_type",
    "outcome_type",
    "bioassay_type",
    "bioassay_types",
    "aid_type",
    "activity_type",
    "screening_type",
]
_ACCESSION_COLS = {
    "protein_accession",
    "protein_accessions",
    "proteinaccession",
    "uniprot",
    "uniprot_accession",
    "uniprots_id",
    "uniprots_ids",
}
_TAXID_COLS = {
    "target_taxid",
    "target_taxids",
    "taxonomy_id",
    "taxonomy_ids",
}
_TARGET_COLS = _ACCESSION_COLS | {
    "gene_id",
    "gene_ids",
    "target_id",
} | _TAXID_COLS


def _pct(n: int, d: int) -> float | None:
    if d == 0:
        return None
    return round((100.0 * n) / d, 4)


def _file_meta(path: Path) -> dict:
    st = path.stat()
    return {
        "path": str(path),
        "bytes": int(st.st_size),
        "size_mb": round(st.st_size / (1024 * 1024), 2),
        "mtime_utc": datetime.fromtimestamp(st.st_mtime, tz=timezone.utc).isoformat(),
    }


def _lookup_sid_rows(
    lookup_conn: sqlite3.Connection,
    sids: list[int],
) -> dict[int, tuple[int | None, str | None]]:
    if not sids:
        return {}
    unique_sids = list(dict.fromkeys(int(sid) for sid in sids))
    out: dict[int, tuple[int | None, str | None]] = {}
    batch_size = 500
    for i in range(0, len(unique_sids), batch_size):
        batch = unique_sids[i : i + batch_size]
        placeholders = ",".join("?" * len(batch))
        rows = lookup_conn.execute(
            f"SELECT sid, cid, smiles FROM sid_cid_map WHERE sid IN ({placeholders})",
            batch,
        ).fetchall()
        for sid, cid, smiles in rows:
            out[int(sid)] = (None if cid is None else int(cid), smiles)
    return out


def scan_bioassays(path: Path, chunksize: int) -> tuple[dict, set[int]]:
    stats = {
        "rows_total": 0,
        "rows_aid_valid": 0,
        "rows_confirmatory": 0,
        "rows_confirmatory_with_target_annotation": 0,
        "rows_confirmatory_human_taxid": 0,
        "unique_confirmatory_aids": 0,
    }
    confirmatory_aids: set[int] = set()
    aid_col = None
    assay_type_candidates: list[str] = []
    target_cols: list[str] = []
    taxid_cols: list[str] = []

    reader = pd.read_csv(
        path,
        sep="\t",
        compression="gzip" if path.suffix == ".gz" else None,
        chunksize=chunksize,
        low_memory=False,
    )
    for chunk in reader:
        chunk = _normalize_columns(chunk)
        cols = list(chunk.columns)
        stats["rows_total"] += len(chunk)

        if aid_col is None:
            aid_col = _find_col(cols, ["aid"])
            if aid_col is None:
                raise ValueError(f"Could not find AID column in {path}")
            assay_type_candidates = [c for c in _ASSAY_TYPE_CANDIDATES if c in cols]
            target_cols = [c for c in cols if c in _TARGET_COLS]
            taxid_cols = [c for c in cols if c in _TAXID_COLS]

        out = chunk[pd.to_numeric(chunk[aid_col], errors="coerce").notna()].copy()
        if out.empty:
            continue
        out[aid_col] = out[aid_col].astype(int)
        stats["rows_aid_valid"] += len(out)

        assay_type_col = None
        for c in assay_type_candidates:
            if out[c].astype(str).str.contains("confirm", case=False, na=False).any():
                assay_type_col = c
                break
        if assay_type_col is None and assay_type_candidates:
            assay_type_col = assay_type_candidates[0]

        if assay_type_col is not None:
            conf = out[out[assay_type_col].astype(str).str.contains("confirm", case=False, na=False)]
        else:
            conf = out
        if conf.empty:
            continue

        stats["rows_confirmatory"] += len(conf)
        confirmatory_aids.update(int(v) for v in conf[aid_col].tolist())

        if target_cols:
            target_mask = pd.Series(False, index=conf.index)
            for c in target_cols:
                col = conf[c]
                if c in _ACCESSION_COLS:
                    target_mask = target_mask | col.map(_normalize_accession).notna()
                else:
                    target_mask = target_mask | col.notna()
            stats["rows_confirmatory_with_target_annotation"] += int(target_mask.sum())

        if taxid_cols:
            human_mask = pd.Series(False, index=conf.index)
            for c in taxid_cols:
                human_mask = human_mask | (pd.to_numeric(conf[c], errors="coerce") == _HUMAN_TAXID)
            stats["rows_confirmatory_human_taxid"] += int(human_mask.sum())

    stats["unique_confirmatory_aids"] = len(confirmatory_aids)
    stats["confirmatory_with_target_pct"] = _pct(
        stats["rows_confirmatory_with_target_annotation"],
        stats["rows_confirmatory"],
    )
    stats["confirmatory_human_taxid_pct"] = _pct(
        stats["rows_confirmatory_human_taxid"],
        stats["rows_confirmatory"],
    )
    return stats, confirmatory_aids


def scan_aid_map(path: Path, chunksize: int) -> tuple[dict, dict[int, str]]:
    stats = {
        "rows_total": 0,
        "rows_aid_valid": 0,
        "rows_accession_valid": 0,
        "unique_aids_with_accession": 0,
        "duplicate_aid_rows": 0,
        "conflicting_duplicate_aid_rows": 0,
    }
    aid_to_uniprot: dict[int, str] = {}
    aid_col = None
    uniprot_col = None

    reader = pd.read_csv(
        path,
        sep="\t",
        compression="gzip" if path.suffix == ".gz" else None,
        chunksize=chunksize,
        low_memory=False,
    )
    for chunk in reader:
        chunk = _normalize_columns(chunk)
        cols = list(chunk.columns)
        stats["rows_total"] += len(chunk)

        if aid_col is None:
            aid_col = _find_col(cols, ["aid"])
            if aid_col is None:
                raise ValueError(f"Could not find AID column in {path}")
            uniprot_col = _find_col(
                cols,
                [
                    "uniprot",
                    "uniprotkb_ac_id",
                    "uniprotkb_ac",
                    "uniprotkb_id",
                    "uniprot_accession",
                    "protein_accession",
                    "proteinaccession",
                    "accession",
                ],
            )
            if uniprot_col is None:
                raise ValueError(f"Could not find UniProt/accession column in {path}")

        out = chunk[[aid_col, uniprot_col]].copy()
        out = out[pd.to_numeric(out[aid_col], errors="coerce").notna()]
        if out.empty:
            continue
        out[aid_col] = out[aid_col].astype(int)
        stats["rows_aid_valid"] += len(out)

        out[uniprot_col] = out[uniprot_col].map(_normalize_accession)
        out = out[out[uniprot_col].notna()]
        if out.empty:
            continue
        stats["rows_accession_valid"] += len(out)

        for r in out.itertuples(index=False):
            aid = int(getattr(r, aid_col))
            acc = str(getattr(r, uniprot_col))
            if aid in aid_to_uniprot:
                stats["duplicate_aid_rows"] += 1
                if aid_to_uniprot[aid] != acc:
                    stats["conflicting_duplicate_aid_rows"] += 1
                continue
            aid_to_uniprot[aid] = acc

    stats["unique_aids_with_accession"] = len(aid_to_uniprot)
    stats["aid_valid_pct"] = _pct(stats["rows_aid_valid"], stats["rows_total"])
    stats["accession_valid_pct"] = _pct(stats["rows_accession_valid"], stats["rows_total"])
    return stats, aid_to_uniprot


def summarize_sid_lookup(path: Path) -> dict:
    with sqlite3.connect(str(path)) as conn:
        total = conn.execute("SELECT COUNT(*) FROM sid_cid_map").fetchone()[0]
        with_cid = conn.execute("SELECT COUNT(*) FROM sid_cid_map WHERE cid IS NOT NULL").fetchone()[0]
        with_smiles = conn.execute(
            "SELECT COUNT(*) FROM sid_cid_map WHERE smiles IS NOT NULL AND TRIM(smiles) <> ''"
        ).fetchone()[0]
        with_both = conn.execute(
            "SELECT COUNT(*) FROM sid_cid_map WHERE cid IS NOT NULL AND smiles IS NOT NULL AND TRIM(smiles) <> ''"
        ).fetchone()[0]
    return {
        "rows_total": int(total),
        "rows_with_cid": int(with_cid),
        "rows_with_smiles": int(with_smiles),
        "rows_with_cid_and_smiles": int(with_both),
        "with_cid_pct": _pct(int(with_cid), int(total)),
        "with_smiles_pct": _pct(int(with_smiles), int(total)),
        "with_cid_and_smiles_pct": _pct(int(with_both), int(total)),
    }


def sample_bioactivities(
    bioactivities_path: Path,
    sid_lookup_path: Path,
    confirmatory_aids: set[int],
    aid_to_uniprot: dict[int, str],
    chunksize: int,
    sample_rows: int,
) -> dict:
    stats = {
        "rows_sampled": 0,
        "rows_aid_sid_valid": 0,
        "rows_inactive": 0,
        "rows_inactive_confirmatory": 0,
        "rows_inactive_confirmatory_with_uniprot": 0,
        "rows_inactive_confirmatory_with_cid_smiles": 0,
        "rows_inactive_confirmatory_ready_all": 0,
        "rows_inactive_confirmatory_human_taxid": 0,
    }

    aid_col = None
    sid_col = None
    cid_col = None
    outcome_col = None
    accession_col = None
    taxid_col = None

    with sqlite3.connect(str(sid_lookup_path)) as sid_conn:
        reader = pd.read_csv(
            bioactivities_path,
            sep="\t",
            compression="gzip" if bioactivities_path.suffix == ".gz" else None,
            chunksize=chunksize,
            low_memory=False,
        )
        remaining = sample_rows
        for chunk in reader:
            if remaining <= 0:
                break
            if len(chunk) > remaining:
                chunk = chunk.iloc[:remaining].copy()
            remaining -= len(chunk)

            chunk = _normalize_columns(chunk)
            cols = list(chunk.columns)
            if aid_col is None:
                aid_col = _find_col(cols, ["aid"])
                sid_col = _find_col(cols, ["sid"])
                cid_col = _find_col(cols, ["cid"])
                outcome_col = _find_col(cols, ["activity_outcome", "activityoutcome"])
                accession_col = _find_col(
                    cols,
                    ["protein_accession", "proteinaccession", "uniprot_accession", "uniprot"],
                )
                taxid_col = _find_col(cols, ["target_taxid", "target_tax_id", "taxid", "taxonomy_id"])
                if aid_col is None or sid_col is None or outcome_col is None:
                    raise ValueError(
                        "Missing required bioactivities columns: need AID, SID, Activity Outcome"
                    )

            stats["rows_sampled"] += len(chunk)

            out = pd.DataFrame()
            out["aid"] = pd.to_numeric(chunk[aid_col], errors="coerce")
            out["sid"] = pd.to_numeric(chunk[sid_col], errors="coerce")
            out["cid"] = pd.to_numeric(chunk[cid_col], errors="coerce") if cid_col else pd.NA
            out["activity_outcome"] = chunk[outcome_col].astype(str)
            out["uniprot_direct"] = (
                chunk[accession_col].map(_normalize_accession) if accession_col else None
            )
            out["target_taxid"] = (
                pd.to_numeric(chunk[taxid_col], errors="coerce") if taxid_col else pd.NA
            )

            out = out[out["aid"].notna() & out["sid"].notna()].copy()
            if out.empty:
                continue
            out["aid"] = out["aid"].astype(int)
            out["sid"] = out["sid"].astype(int)
            stats["rows_aid_sid_valid"] += len(out)

            inactive = out[out["activity_outcome"].str.contains("inactive", case=False, na=False)].copy()
            if inactive.empty:
                continue
            stats["rows_inactive"] += len(inactive)

            inactive = inactive[inactive["aid"].isin(confirmatory_aids)].copy()
            if inactive.empty:
                continue
            stats["rows_inactive_confirmatory"] += len(inactive)

            aid_uniprot = inactive["aid"].map(aid_to_uniprot).map(_normalize_accession)
            inactive["resolved_uniprot"] = inactive["uniprot_direct"].where(
                inactive["uniprot_direct"].notna(),
                aid_uniprot,
            )
            stats["rows_inactive_confirmatory_with_uniprot"] += int(
                inactive["resolved_uniprot"].notna().sum()
            )

            sid_lookup = _lookup_sid_rows(sid_conn, inactive["sid"].tolist())
            resolved_cids: list[int | None] = []
            resolved_smiles: list[str | None] = []
            for r in inactive.itertuples(index=False):
                sid_info = sid_lookup.get(int(r.sid))
                cid = int(r.cid) if pd.notna(r.cid) else None
                smiles = None
                if sid_info is not None:
                    lookup_cid, lookup_smiles = sid_info
                    if cid is None:
                        cid = lookup_cid
                    smiles = lookup_smiles
                resolved_cids.append(cid)
                resolved_smiles.append(smiles)
            inactive["resolved_cid"] = resolved_cids
            inactive["resolved_smiles"] = resolved_smiles

            cid_smiles_ok = inactive["resolved_cid"].notna() & inactive["resolved_smiles"].notna()
            stats["rows_inactive_confirmatory_with_cid_smiles"] += int(cid_smiles_ok.sum())

            ready_all = cid_smiles_ok & inactive["resolved_uniprot"].notna()
            stats["rows_inactive_confirmatory_ready_all"] += int(ready_all.sum())

            if taxid_col is not None:
                stats["rows_inactive_confirmatory_human_taxid"] += int(
                    (inactive["target_taxid"] == _HUMAN_TAXID).sum()
                )

    stats["inactive_pct"] = _pct(stats["rows_inactive"], stats["rows_sampled"])
    stats["inactive_confirmatory_pct"] = _pct(
        stats["rows_inactive_confirmatory"],
        stats["rows_sampled"],
    )
    stats["inactive_confirmatory_with_uniprot_pct"] = _pct(
        stats["rows_inactive_confirmatory_with_uniprot"],
        stats["rows_inactive_confirmatory"],
    )
    stats["inactive_confirmatory_with_cid_smiles_pct"] = _pct(
        stats["rows_inactive_confirmatory_with_cid_smiles"],
        stats["rows_inactive_confirmatory"],
    )
    stats["inactive_confirmatory_ready_all_pct"] = _pct(
        stats["rows_inactive_confirmatory_ready_all"],
        stats["rows_inactive_confirmatory"],
    )
    stats["inactive_confirmatory_human_taxid_pct"] = _pct(
        stats["rows_inactive_confirmatory_human_taxid"],
        stats["rows_inactive_confirmatory"],
    )
    return stats


def render_markdown(report: dict) -> str:
    files = report["files"]
    bioassays = report["bioassays"]
    aid_map = report["aid_map"]
    sid_lookup = report["sid_lookup"]
    sample = report["bioactivities_sample"]
    lines = [
        "# PubChem QC Report",
        "",
        f"- generated_at_utc: {report['generated_at_utc']}",
        f"- sample_rows_target: {sample['sample_rows_target']}",
        f"- sample_rows_actual: {sample['rows_sampled']}",
        "",
        "## Files",
        "",
        "| file | size_mb | mtime_utc |",
        "|---|---:|---|",
    ]
    for key in [
        "bioactivities",
        "bioassays",
        "aid_uniprot",
        "sid_cid_smiles",
        "sid_lookup_db",
    ]:
        meta = files[key]
        lines.append(f"| {key} | {meta['size_mb']} | {meta['mtime_utc']} |")

    lines += [
        "",
        "## Bioassays",
        "",
        f"- rows_total: {bioassays['rows_total']}",
        f"- rows_confirmatory: {bioassays['rows_confirmatory']}",
        f"- unique_confirmatory_aids: {bioassays['unique_confirmatory_aids']}",
        f"- rows_confirmatory_with_target_annotation: {bioassays['rows_confirmatory_with_target_annotation']}",
        f"- confirmatory_with_target_pct: {bioassays['confirmatory_with_target_pct']}",
        f"- rows_confirmatory_human_taxid: {bioassays['rows_confirmatory_human_taxid']}",
        f"- confirmatory_human_taxid_pct: {bioassays['confirmatory_human_taxid_pct']}",
        "",
        "## AID Map",
        "",
        f"- rows_total: {aid_map['rows_total']}",
        f"- rows_accession_valid: {aid_map['rows_accession_valid']}",
        f"- unique_aids_with_accession: {aid_map['unique_aids_with_accession']}",
        f"- duplicate_aid_rows: {aid_map['duplicate_aid_rows']}",
        f"- conflicting_duplicate_aid_rows: {aid_map['conflicting_duplicate_aid_rows']}",
        "",
        "## SID Lookup",
        "",
        f"- rows_total: {sid_lookup['rows_total']}",
        f"- rows_with_cid: {sid_lookup['rows_with_cid']}",
        f"- rows_with_smiles: {sid_lookup['rows_with_smiles']}",
        f"- rows_with_cid_and_smiles: {sid_lookup['rows_with_cid_and_smiles']}",
        "",
        "## Bioactivities Sample",
        "",
        f"- rows_sampled: {sample['rows_sampled']}",
        f"- rows_inactive: {sample['rows_inactive']}",
        f"- rows_inactive_confirmatory: {sample['rows_inactive_confirmatory']}",
        f"- rows_inactive_confirmatory_with_uniprot: {sample['rows_inactive_confirmatory_with_uniprot']}",
        f"- rows_inactive_confirmatory_with_cid_smiles: {sample['rows_inactive_confirmatory_with_cid_smiles']}",
        f"- rows_inactive_confirmatory_ready_all: {sample['rows_inactive_confirmatory_ready_all']}",
        f"- inactive_confirmatory_ready_all_pct: {sample['inactive_confirmatory_ready_all_pct']}",
        "",
    ]
    return "\n".join(lines) + "\n"


def main() -> None:
    parser = argparse.ArgumentParser(description="Generate PubChem raw-data QC report")
    parser.add_argument(
        "--sample-rows",
        type=int,
        default=2_000_000,
        help="Rows to sample from bioactivities.tsv.gz (set 0 to disable sample)",
    )
    parser.add_argument(
        "--chunksize",
        type=int,
        default=200_000,
        help="Chunk size for streamed TSV reads",
    )
    parser.add_argument(
        "--output-prefix",
        type=str,
        default="pubchem_qc",
        help="Output filename prefix under exports/",
    )
    args = parser.parse_args()

    cfg = load_config()
    pubchem_cfg = cfg["downloads"]["pubchem"]

    bioactivities_path = _PROJECT_ROOT / pubchem_cfg["dest"]
    bioassays_path = _PROJECT_ROOT / pubchem_cfg["bioassays_dest"]
    aid_uniprot_path = _PROJECT_ROOT / pubchem_cfg["aid_uniprot_dest"]
    sid_cid_smiles_path = _PROJECT_ROOT / pubchem_cfg["sid_cid_smiles_dest"]
    sid_lookup_path = _PROJECT_ROOT / pubchem_cfg["sid_lookup_db"]

    for p in [bioactivities_path, bioassays_path, aid_uniprot_path, sid_cid_smiles_path, sid_lookup_path]:
        if not p.exists():
            raise FileNotFoundError(f"Required file missing: {p}")

    bioassays_stats, confirmatory_aids = scan_bioassays(bioassays_path, chunksize=args.chunksize)
    aid_map_stats, aid_to_uniprot = scan_aid_map(aid_uniprot_path, chunksize=args.chunksize)
    sid_lookup_stats = summarize_sid_lookup(sid_lookup_path)

    sample_stats = {
        "sample_rows_target": int(args.sample_rows),
    }
    if args.sample_rows > 0:
        sample_stats.update(
            sample_bioactivities(
                bioactivities_path=bioactivities_path,
                sid_lookup_path=sid_lookup_path,
                confirmatory_aids=confirmatory_aids,
                aid_to_uniprot=aid_to_uniprot,
                chunksize=args.chunksize,
                sample_rows=args.sample_rows,
            )
        )
    else:
        sample_stats["rows_sampled"] = 0

    report = {
        "generated_at_utc": datetime.now(timezone.utc).isoformat(),
        "files": {
            "bioactivities": _file_meta(bioactivities_path),
            "bioassays": _file_meta(bioassays_path),
            "aid_uniprot": _file_meta(aid_uniprot_path),
            "sid_cid_smiles": _file_meta(sid_cid_smiles_path),
            "sid_lookup_db": _file_meta(sid_lookup_path),
        },
        "bioassays": bioassays_stats,
        "aid_map": aid_map_stats,
        "sid_lookup": sid_lookup_stats,
        "bioactivities_sample": sample_stats,
    }

    exports_dir = _PROJECT_ROOT / cfg["paths"]["exports_dir"]
    exports_dir.mkdir(parents=True, exist_ok=True)
    ts = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
    json_path = exports_dir / f"{args.output_prefix}_{ts}.json"
    md_path = exports_dir / f"{args.output_prefix}_{ts}.md"

    json_path.write_text(json.dumps(report, indent=2), encoding="utf-8")
    md_path.write_text(render_markdown(report), encoding="utf-8")

    print(f"QC JSON: {json_path}")
    print(f"QC Markdown: {md_path}")
    print(f"Sample rows: {sample_stats.get('rows_sampled', 0)}")
    if sample_stats.get("rows_inactive_confirmatory_ready_all") is not None:
        print(
            "Ready-all rows (sample): "
            f"{sample_stats.get('rows_inactive_confirmatory_ready_all')} "
            f"({sample_stats.get('inactive_confirmatory_ready_all_pct')}%)"
        )


if __name__ == "__main__":
    main()