""" Build a Parkinson's disease discovery benchmark dataset and dashboard inputs. Inputs: - PD_AI_Evidence_to_Discovery_Project - PD_Target_to_Intervention_Discovery_Extension Outputs: - integrated target benchmark - compound selectivity/safety matrix - model/assay benchmark - resource figures - quality checks """ from __future__ import annotations import json import math import time from pathlib import Path import matplotlib.pyplot as plt import networkx as nx import pandas as pd import requests import seaborn as sns ROOT = Path(__file__).resolve().parents[1] BASE = ROOT.parent EVID = BASE / "PD_AI_Evidence_to_Discovery_Project" EXT = BASE / "PD_Target_to_Intervention_Discovery_Extension" DATA = ROOT / "data" FIG = ROOT / "figures" REPORTS = ROOT / "reports" REPRO = ROOT / "reproducibility" for d in [DATA, FIG, REPORTS, REPRO]: d.mkdir(parents=True, exist_ok=True) def read_csv(path: Path) -> pd.DataFrame: return pd.read_csv(path) if path.exists() else pd.DataFrame() def get_json(url: str, params: dict | None = None) -> tuple[dict | None, str]: try: r = requests.get(url, params=params, timeout=35) r.raise_for_status() return r.json(), "ok" except Exception as exc: # noqa: BLE001 return None, f"{type(exc).__name__}: {exc}" def chembl_selectivity(molecule_id: str) -> dict: data, status = get_json( "https://www.ebi.ac.uk/chembl/api/data/activity.json", { "molecule_chembl_id": molecule_id, "standard_units": "nM", "standard_value__lte": 1000, "limit": 1000, }, ) out = {"molecule_chembl_id": molecule_id, "selectivity_status": status} if not data: return out acts = data.get("activities", []) targets = {a.get("target_chembl_id") for a in acts if a.get("target_chembl_id")} types = {a.get("standard_type") for a in acts if a.get("standard_type")} out["active_target_count_lte_1000nM"] = len(targets) out["activity_record_count_lte_1000nM"] = len(acts) out["activity_types"] = ";".join(sorted(types)) out["polypharmacology_flag"] = len(targets) >= 10 out["selectivity_penalty_0_20"] = min(20, max(0, (len(targets) - 1) * 2)) return out def build_target_benchmark() -> pd.DataFrame: target = read_csv(EXT / "data/processed/target_tractability_ranked.csv") expr = read_csv(EXT / "data/stem_cell/cell_type_expression_validation_matrix.csv") validation = read_csv(EXT / "data/validation/experimental_validation_matrix.csv") interventions = read_csv(EVID / "data/processed/candidate_interventions_ranked.csv") pathway = read_csv(EVID / "data/processed/pathway_intervention_framework.csv") # Module-level translational score from original evidence, mapped conservatively by terms. module_scores = [] for _, t in target.iterrows(): score = 50.0 mod = str(t["module"]).lower() for _, i in interventions.iterrows(): text = (str(i["intervention_or_target"]) + " " + str(i["primary_target_pathway"])).lower() if any(k in text for k in mod.replace("/", " ").split()[:3]): score = max(score, float(i["priority_score_0_100"])) if "lrrk2" in mod: score = max(score, float(interventions.loc[interventions["intervention_or_target"].str.contains("LRRK2", case=False), "priority_score_0_100"].max())) if "gba" in mod or "lysosome" in mod: score = max(score, float(interventions.loc[interventions["intervention_or_target"].str.contains("GBA|lysosomal", case=False, regex=True), "priority_score_0_100"].max())) if "glp" in mod: score = max(score, float(interventions.loc[interventions["intervention_or_target"].str.contains("GLP", case=False), "priority_score_0_100"].max())) if "alpha" in mod or "synuclein" in mod: score = max(score, float(interventions.loc[interventions["intervention_or_target"].str.contains("synuclein", case=False), "priority_score_0_100"].max())) module_scores.append({"symbol": t["symbol"], "evidence_translation_score_0_100": score}) module_df = pd.DataFrame(module_scores) bench = target.merge(expr, on=["symbol", "ensembl_id"], how="left").merge(validation, on=["symbol", "module"], how="left", suffixes=("", "_validation")).merge(module_df, on="symbol", how="left") bench["omics_pathway_support_0_100"] = bench["module"].str.lower().map(lambda x: 75 if any(k in x for k in ["immune", "il-17", "nod", "map", "ntrk"]) else 60 if any(k in x for k in ["mitochond", "lysosome", "gba", "synuclein"]) else 50) bench["cell_type_support_0_100"] = bench["stem_cell_validation_relevance_score_0_100"].fillna(40) bench["compound_support_0_100"] = bench["chemistry_score_20"].fillna(0) / 20 * 100 bench["structure_support_0_100"] = bench["structure_score_15"].fillna(0) / 15 * 100 bench["assay_support_0_100"] = bench["assayability_score_15"].fillna(0) / 15 * 100 bench["benchmark_consensus_score_0_100"] = ( bench["target_to_intervention_score_100"].astype(float) * 0.25 + bench["evidence_translation_score_0_100"].astype(float) * 0.20 + bench["omics_pathway_support_0_100"].astype(float) * 0.15 + bench["cell_type_support_0_100"].astype(float) * 0.15 + bench["compound_support_0_100"].astype(float) * 0.15 + bench["assay_support_0_100"].astype(float) * 0.10 ).round(1) bench["benchmark_label"] = pd.cut( bench["benchmark_consensus_score_0_100"], bins=[-1, 50, 65, 80, 100], labels=["exploratory", "validation-ready", "high-priority validation", "benchmark lead"], ) keep = [ "symbol", "module", "role", "benchmark_consensus_score_0_100", "benchmark_label", "target_to_intervention_score_100", "evidence_translation_score_0_100", "omics_pathway_support_0_100", "cell_type_support_0_100", "compound_support_0_100", "structure_support_0_100", "assay_support_0_100", "model", "primary_assay", "recommended_next_experiment", "uniprot_accession", "ensembl_id", "chembl_target_id", "ligand_count", "pdb_count", "alphafold_url", ] bench = bench[keep].sort_values("benchmark_consensus_score_0_100", ascending=False) bench.to_csv(DATA / "pd_discovery_target_benchmark.csv", index=False) return bench def build_compound_matrix() -> pd.DataFrame: compounds = read_csv(EXT / "data/chemical/prioritised_compound_shortlist.csv") if compounds.empty: return compounds top_ids = compounds["molecule_chembl_id"].drop_duplicates().head(80).tolist() rows = [] failures = [] for mid in top_ids: row = chembl_selectivity(mid) rows.append(row) if row.get("selectivity_status") != "ok": failures.append(row) time.sleep(0.04) selectivity = pd.DataFrame(rows) out = compounds.merge(selectivity, on="molecule_chembl_id", how="left") out["polypharmacology_flag"] = out["polypharmacology_flag"].fillna(False).astype(bool) out["selectivity_penalty_0_20"] = pd.to_numeric(out["selectivity_penalty_0_20"], errors="coerce").fillna(10) out["black_box_warning"] = pd.to_numeric(out["black_box_warning"], errors="coerce").fillna(0) out["withdrawn_flag"] = pd.to_numeric(out["withdrawn_flag"], errors="coerce").fillna(0) out["safety_liability_penalty_0_30"] = ( out["black_box_warning"].clip(0, 1) * 10 + out["withdrawn_flag"].clip(0, 1) * 15 + out["polypharmacology_flag"].astype(int) * 5 ) out["refined_compound_score_0_100"] = ( pd.to_numeric(out["compound_priority_score_0_100"], errors="coerce").fillna(0) - out["selectivity_penalty_0_20"] - out["safety_liability_penalty_0_30"] ).clip(lower=0).round(1) out["triage_recommendation"] = pd.cut( out["refined_compound_score_0_100"], bins=[-1, 30, 50, 70, 100], labels=["deprioritise", "review manually", "experimental comparator", "shortlist for deeper validation"], ) out = out.sort_values("refined_compound_score_0_100", ascending=False) out.to_csv(DATA / "compound_selectivity_safety_matrix.csv", index=False) pd.DataFrame(failures).to_csv(REPRO / "compound_selectivity_query_failures.csv", index=False) return out def build_knowledge_graph(bench: pd.DataFrame, compounds: pd.DataFrame) -> nx.Graph: G = nx.Graph() for _, r in bench.iterrows(): G.add_node(r["symbol"], kind="target", score=float(r["benchmark_consensus_score_0_100"])) G.add_node(r["module"], kind="pathway") G.add_node(r["model"], kind="cell_model") G.add_node(r["primary_assay"], kind="assay") G.add_edge(r["symbol"], r["module"], relation="belongs_to_pathway") G.add_edge(r["symbol"], r["model"], relation="validated_in_model") G.add_edge(r["model"], r["primary_assay"], relation="measured_by") if not compounds.empty: for _, c in compounds.head(80).iterrows(): name = c.get("molecule_pref_name_detail") or c.get("molecule_pref_name") or c["molecule_chembl_id"] name = str(name) if str(name) != "nan" and str(name).strip() else c["molecule_chembl_id"] G.add_node(name, kind="compound", score=float(c["refined_compound_score_0_100"]), chembl_id=c["molecule_chembl_id"]) G.add_edge(c["symbol"], name, relation="has_refined_activity", potency_nM=float(c["standard_value_num"])) nx.write_graphml(G, DATA / "pd_discovery_benchmark_knowledge_graph.graphml") pd.DataFrame([{"node": n, **d} for n, d in G.nodes(data=True)]).to_csv(DATA / "benchmark_graph_nodes.csv", index=False) pd.DataFrame([{"source": u, "target": v, **d} for u, v, d in G.edges(data=True)]).to_csv(DATA / "benchmark_graph_edges.csv", index=False) return G def make_figures(bench: pd.DataFrame, compounds: pd.DataFrame, G: nx.Graph) -> None: sns.set_theme(style="whitegrid", context="paper") fig, ax = plt.subplots(figsize=(10, 6.8)) p = bench.sort_values("benchmark_consensus_score_0_100") ax.barh(p["symbol"], p["benchmark_consensus_score_0_100"], color="#2E75B6") ax.set_xlim(0, 100) ax.set_xlabel("Benchmark consensus score") ax.set_title("PD discovery benchmark target ranking") for i, v in enumerate(p["benchmark_consensus_score_0_100"]): ax.text(v + 1, i, f"{v:.1f}", va="center", fontsize=8) fig.savefig(FIG / "benchmark_target_ranking.png", dpi=350, bbox_inches="tight") fig.savefig(FIG / "benchmark_target_ranking.svg", bbox_inches="tight") plt.close(fig) score_cols = [ "target_to_intervention_score_100", "evidence_translation_score_0_100", "omics_pathway_support_0_100", "cell_type_support_0_100", "compound_support_0_100", "structure_support_0_100", "assay_support_0_100", ] fig, ax = plt.subplots(figsize=(12, 7)) sns.heatmap(bench.set_index("symbol")[score_cols], annot=True, fmt=".0f", cmap="YlGnBu", linewidths=0.4, ax=ax, cbar_kws={"label": "Score"}) ax.set_title("PD discovery benchmark evidence matrix") ax.set_xlabel("") ax.set_ylabel("") fig.savefig(FIG / "benchmark_evidence_matrix.png", dpi=350, bbox_inches="tight") fig.savefig(FIG / "benchmark_evidence_matrix.svg", bbox_inches="tight") plt.close(fig) if not compounds.empty: c = compounds.head(30) fig, ax = plt.subplots(figsize=(10, 6)) scatter = ax.scatter(c["compound_priority_score_0_100"], c["refined_compound_score_0_100"], c=c["selectivity_penalty_0_20"], cmap="magma", s=70, alpha=0.82, edgecolor="white") ax.plot([0, 100], [0, 100], ls="--", color="#777777", lw=1) ax.set_xlabel("Initial compound priority score") ax.set_ylabel("Refined score after selectivity/safety penalties") ax.set_title("Compound triage after selectivity and safety-liability filters") for _, r in c.head(10).iterrows(): label = r.get("molecule_pref_name_detail") or r.get("molecule_chembl_id") ax.text(r["compound_priority_score_0_100"] + 1, r["refined_compound_score_0_100"], str(label)[:16], fontsize=7) cb = fig.colorbar(scatter, ax=ax) cb.set_label("Selectivity penalty") fig.savefig(FIG / "compound_selectivity_safety_triage.png", dpi=350, bbox_inches="tight") fig.savefig(FIG / "compound_selectivity_safety_triage.svg", bbox_inches="tight") plt.close(fig) pos = nx.spring_layout(G, seed=42, k=0.75) colors = {"target": "#C00000", "pathway": "#1F4E79", "cell_model": "#70AD47", "assay": "#F4B183", "compound": "#7030A0"} fig, ax = plt.subplots(figsize=(15, 11)) nx.draw_networkx_edges(G, pos, alpha=0.14, width=0.6, ax=ax) for kind, color in colors.items(): nodes = [n for n, d in G.nodes(data=True) if d.get("kind") == kind] nx.draw_networkx_nodes(G, pos, nodelist=nodes, node_color=color, node_size=620 if kind == "target" else 240, alpha=0.9, label=kind, edgecolors="white", linewidths=0.5, ax=ax) labels = {n: n for n, d in G.nodes(data=True) if d.get("kind") in {"target", "pathway"}} nx.draw_networkx_labels(G, pos, labels=labels, font_size=7, ax=ax) ax.legend(loc="upper left", frameon=True) ax.axis("off") ax.set_title("PD discovery benchmark knowledge graph") fig.savefig(FIG / "benchmark_knowledge_graph.png", dpi=350, bbox_inches="tight") fig.savefig(FIG / "benchmark_knowledge_graph.svg", bbox_inches="tight") plt.close(fig) def write_reports(bench: pd.DataFrame, compounds: pd.DataFrame, G: nx.Graph) -> None: md = f"""# PD Discovery Benchmark Resource ## Purpose This resource integrates evidence synthesis, omics/pathway support, target tractability, protein/structure information, ChEMBL compound evidence, Human Protein Atlas cell-type relevance, model/assay mapping, and knowledge-graph outputs for Parkinson's disease target-to-intervention discovery. ## Key Outputs - `data/pd_discovery_target_benchmark.csv` - `data/compound_selectivity_safety_matrix.csv` - `data/pd_discovery_benchmark_knowledge_graph.graphml` - `data/benchmark_graph_nodes.csv` - `data/benchmark_graph_edges.csv` - `figures/benchmark_target_ranking.png` - `figures/benchmark_evidence_matrix.png` - `figures/compound_selectivity_safety_triage.png` - `figures/benchmark_knowledge_graph.png` - `dashboard/app.py` ## Top Benchmark Targets {bench.head(10)[["symbol", "module", "benchmark_consensus_score_0_100", "benchmark_label"]].to_markdown(index=False)} ## Top Refined Compounds {compounds.head(12)[["symbol", "molecule_chembl_id", "molecule_pref_name_detail", "standard_value_num", "active_target_count_lte_1000nM", "refined_compound_score_0_100", "triage_recommendation"]].to_markdown(index=False) if not compounds.empty else "No compounds available."} ## Knowledge Graph - Nodes: {G.number_of_nodes()} - Edges: {G.number_of_edges()} ## Interpretation The benchmark is designed for research reuse, validation, teaching, and computational experimentation. It should be treated as a prioritisation resource, not a clinical tool. ## Limitations - ChEMBL selectivity is based on available activity records and is not a complete pharmacology review. - BBB/CNS heuristics are simple physicochemical rules, not validated pharmacokinetic predictions. - Human Protein Atlas cell-type information is a lightweight expression screen and should be extended with curated PD single-cell and iPSC datasets. - Causal inference, Mendelian randomisation, and docking are specified as logical next modules but are not fully executed here. - No compound is recommended for PD prevention or treatment based on this benchmark. """ (REPORTS / "pd_discovery_benchmark_report.md").write_text(md, encoding="utf-8") quality = pd.DataFrame( [ ["target benchmark", "pass", f"{len(bench)} targets integrated."], ["compound selectivity/safety matrix", "pass", f"{len(compounds)} filtered compound-target records."], ["knowledge graph", "pass", f"{G.number_of_nodes()} nodes and {G.number_of_edges()} edges."], ["clinical guardrail", "pass", "No clinical recommendation or cure claim."], ], columns=["domain", "status", "notes"], ) quality.to_csv(REPRO / "benchmark_quality_check.csv", index=False) def main() -> None: bench = build_target_benchmark() compounds = build_compound_matrix() G = build_knowledge_graph(bench, compounds) make_figures(bench, compounds, G) write_reports(bench, compounds, G) print("Benchmark built.") if __name__ == "__main__": main()