| from __future__ import annotations |
|
|
| import json |
| import re |
| import subprocess |
| import urllib.parse |
| from pathlib import Path |
| from typing import Any, Dict, Iterable, List |
|
|
| import numpy as np |
| import pandas as pd |
| import requests |
| from rdkit import Chem, DataStructs |
| from rdkit.Chem import AllChem |
| from rdkit.Chem.Scaffolds import MurckoScaffold |
|
|
|
|
| def _curl_get_text(url: str, timeout: int = 30) -> str: |
| cp = subprocess.run( |
| [ |
| "curl", |
| "-L", |
| "--silent", |
| "--show-error", |
| "--fail", |
| "--retry", |
| "2", |
| "--retry-delay", |
| "1", |
| "--max-time", |
| str(int(timeout)), |
| url, |
| ], |
| capture_output=True, |
| text=True, |
| check=False, |
| ) |
| if cp.returncode != 0: |
| raise RuntimeError(f"curl failed for {url}: {cp.stderr.strip()}") |
| return cp.stdout |
|
|
|
|
| def _http_json(url: str, timeout: int = 30) -> Dict[str, Any]: |
| |
| try: |
| return json.loads(_curl_get_text(url, timeout=timeout)) |
| except Exception: |
| pass |
| r = requests.get(url, timeout=timeout) |
| r.raise_for_status() |
| return r.json() |
|
|
|
|
| def _http_text(url: str, timeout: int = 60) -> str: |
| try: |
| return _curl_get_text(url, timeout=timeout) |
| except Exception: |
| pass |
| r = requests.get(url, timeout=timeout) |
| r.raise_for_status() |
| return r.text |
|
|
|
|
| def _canonicalize_smiles(smiles: str) -> str | None: |
| mol = Chem.MolFromSmiles(str(smiles)) |
| if mol is None: |
| return None |
| return Chem.MolToSmiles(mol, canonical=True) |
|
|
|
|
| def _morgan_bv(smiles: str, nbits: int = 2048): |
| mol = Chem.MolFromSmiles(smiles) |
| if mol is None: |
| return None |
| return AllChem.GetMorganFingerprintAsBitVect(mol, radius=2, nBits=nbits) |
|
|
|
|
| def _tanimoto(smiles_a: str, smiles_b: str) -> float: |
| fp_a = _morgan_bv(smiles_a) |
| fp_b = _morgan_bv(smiles_b) |
| if fp_a is None or fp_b is None: |
| return 0.0 |
| return float(DataStructs.TanimotoSimilarity(fp_a, fp_b)) |
|
|
|
|
| def _scaffold_smiles(smiles: str) -> str | None: |
| mol = Chem.MolFromSmiles(smiles) |
| if mol is None: |
| return None |
| try: |
| return MurckoScaffold.MurckoScaffoldSmiles(mol=mol) |
| except Exception: |
| return None |
|
|
|
|
| def _chemcomp_info(comp_id: str) -> Dict[str, Any]: |
| d = _http_json(f"https://data.rcsb.org/rest/v1/core/chemcomp/{comp_id}", timeout=30) |
| desc = d.get("rcsb_chem_comp_descriptor", {}) |
| smiles = desc.get("SMILES_stereo") or desc.get("SMILES") |
| return { |
| "comp_id": comp_id, |
| "name": d.get("chem_comp", {}).get("name"), |
| "formula_weight": d.get("chem_comp", {}).get("formula_weight"), |
| "smiles": smiles, |
| "inchi_key": desc.get("InChIKey"), |
| } |
|
|
|
|
| def _download_pdb(pdb_id: str, out_path: Path) -> Path: |
| out_path.parent.mkdir(parents=True, exist_ok=True) |
| url = f"https://files.rcsb.org/download/{pdb_id}.pdb" |
| out_path.write_text(_http_text(url, timeout=60), encoding="utf-8") |
| return out_path |
|
|
|
|
| def _pubchem_similarity_cids(smiles: str, threshold: int, max_records: int) -> list[int]: |
| enc = urllib.parse.quote(smiles, safe="") |
| url = ( |
| "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/fastsimilarity_2d/smiles/" |
| f"{enc}/cids/JSON?Threshold={int(threshold)}&MaxRecords={int(max_records)}" |
| ) |
| try: |
| d = _http_json(url, timeout=30) |
| cids = [int(x) for x in d.get("IdentifierList", {}).get("CID", [])] |
| if cids: |
| return cids |
| except Exception: |
| pass |
|
|
| |
| cid_url = f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/smiles/{enc}/cids/JSON" |
| try: |
| cands = [int(x) for x in _http_json(cid_url, timeout=20).get("IdentifierList", {}).get("CID", [])] |
| except Exception: |
| return [] |
| if not cands: |
| return [] |
| cid = cands[0] |
| sim_url = ( |
| "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/fastsimilarity_2d/cid/" |
| f"{cid}/cids/JSON?Threshold={int(threshold)}&MaxRecords={int(max_records)}" |
| ) |
| try: |
| return [int(x) for x in _http_json(sim_url, timeout=30).get("IdentifierList", {}).get("CID", [])] |
| except Exception: |
| return [] |
|
|
|
|
| def _pubchem_properties_for_cids(cids: Iterable[int]) -> pd.DataFrame: |
| cids = list(cids) |
| if not cids: |
| return pd.DataFrame( |
| columns=[ |
| "cid", |
| "smiles", |
| "molecular_formula", |
| "molecular_weight", |
| "xlogp", |
| "tpsa", |
| "hbd", |
| "hba", |
| "rotatable_bonds", |
| "heavy_atom_count", |
| ] |
| ) |
|
|
| rows: list[dict[str, Any]] = [] |
| |
| chunk_size = 200 |
| for i in range(0, len(cids), chunk_size): |
| chunk = cids[i : i + chunk_size] |
| joined = ",".join(str(x) for x in chunk) |
| url = ( |
| "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/cid/" |
| f"{joined}/property/SMILES,ConnectivitySMILES,MolecularFormula,MolecularWeight," |
| "XLogP,TPSA,HBondDonorCount,HBondAcceptorCount,RotatableBondCount,HeavyAtomCount/JSON" |
| ) |
| props = [] |
| for _attempt in range(3): |
| try: |
| props = _http_json(url, timeout=30).get("PropertyTable", {}).get("Properties", []) |
| except Exception: |
| props = [] |
| if props: |
| break |
| if not props: |
| continue |
| for p in props: |
| rows.append( |
| { |
| "cid": int(p.get("CID")), |
| "smiles": str(p.get("SMILES") or p.get("ConnectivitySMILES") or ""), |
| "molecular_formula": p.get("MolecularFormula"), |
| "molecular_weight": p.get("MolecularWeight"), |
| "xlogp": p.get("XLogP"), |
| "tpsa": p.get("TPSA"), |
| "hbd": p.get("HBondDonorCount"), |
| "hba": p.get("HBondAcceptorCount"), |
| "rotatable_bonds": p.get("RotatableBondCount"), |
| "heavy_atom_count": p.get("HeavyAtomCount"), |
| } |
| ) |
| return pd.DataFrame(rows) |
|
|
|
|
| def _fetch_chembl_smiles(target_chembl_id: str, max_rows: int) -> pd.DataFrame: |
| if int(max_rows) <= 0: |
| return pd.DataFrame( |
| columns=[ |
| "smiles", |
| "molecule_chembl_id", |
| "assay_chembl_id", |
| "standard_type", |
| "standard_units", |
| "standard_value", |
| "source_database", |
| ] |
| ) |
| rows: list[dict[str, Any]] = [] |
| limit = 1000 |
| offset = 0 |
| while len(rows) < max_rows: |
| url = ( |
| "https://www.ebi.ac.uk/chembl/api/data/activity.json" |
| f"?target_chembl_id={target_chembl_id}&limit={limit}&offset={offset}" |
| ) |
| try: |
| d = _http_json(url, timeout=30) |
| except Exception: |
| break |
| acts = d.get("activities", []) |
| if not acts: |
| break |
| for a in acts: |
| smi = _canonicalize_smiles(str(a.get("canonical_smiles") or "")) |
| if smi is None: |
| continue |
| rows.append( |
| { |
| "smiles": smi, |
| "molecule_chembl_id": a.get("molecule_chembl_id"), |
| "assay_chembl_id": a.get("assay_chembl_id"), |
| "standard_type": a.get("standard_type"), |
| "standard_units": a.get("standard_units"), |
| "standard_value": a.get("standard_value"), |
| "source_database": "ChEMBL", |
| } |
| ) |
| if len(rows) >= max_rows: |
| break |
| offset += limit |
| if d.get("page_meta", {}).get("next") is None: |
| break |
| return pd.DataFrame(rows) |
|
|
|
|
| def _generate_fallback_smiles(seed_smiles: str, needed: int) -> List[str]: |
| """Conservative, deterministic fallback if database retrieval is insufficient.""" |
| variants: List[str] = [] |
| candidates = [seed_smiles] |
| replacements = [ |
| ("Cl", "F"), |
| ("F", "Cl"), |
| ("OC", "OCC"), |
| ("CC", "CCC"), |
| ] |
| while candidates and len(variants) < needed: |
| smi = candidates.pop(0) |
| for a, b in replacements: |
| if a not in smi: |
| continue |
| cand = smi.replace(a, b, 1) |
| c = _canonicalize_smiles(cand) |
| if c is None: |
| continue |
| if c not in variants: |
| variants.append(c) |
| if len(variants) >= needed: |
| break |
| return variants |
|
|
|
|
| def build_large_benchmark_library(config: Dict[str, Any], root: Path, logger) -> Dict[str, Any]: |
| dataset_cfg = config["benchmark_dataset"] |
| target_cfg = config["target"] |
| ref_cfg = config["reference"] |
|
|
| out_dir = root / dataset_cfg["output_dir"] |
| out_dir.mkdir(parents=True, exist_ok=True) |
|
|
| reference_path = out_dir / "reference_ligands.csv" |
| raw_path = out_dir / "shared_library_raw.csv" |
| dedup_path = out_dir / "shared_library_dedup.csv" |
| shuffled_path = out_dir / "shared_library_shuffled.csv" |
| provenance_path = out_dir / "ligand_provenance.csv" |
| metadata_path = out_dir / "ligand_metadata.csv" |
| similarity_path = out_dir / "similarity_distribution.csv" |
| reuse_existing = bool(dataset_cfg.get("reuse_existing", True)) |
|
|
| required = [reference_path, raw_path, dedup_path, shuffled_path, provenance_path, metadata_path] |
| docking_target_path = root / target_cfg["docking_target_path"] |
| if reuse_existing and all(p.exists() for p in required): |
| if not similarity_path.exists(): |
| dedup_existing = pd.read_csv(dedup_path) |
| _write_similarity_distribution(dedup_existing, similarity_path) |
| if not docking_target_path.exists(): |
| _download_pdb(str(ref_cfg["pdb_id"]), docking_target_path) |
| return { |
| "reference_df": pd.read_csv(reference_path), |
| "raw_df": pd.read_csv(raw_path), |
| "dedup_df": pd.read_csv(dedup_path), |
| "shuffled_df": pd.read_csv(shuffled_path), |
| "provenance_df": pd.read_csv(provenance_path), |
| "metadata_df": pd.read_csv(metadata_path), |
| "similarity_df": pd.read_csv(similarity_path), |
| "target_path": docking_target_path, |
| "out_dir": out_dir, |
| } |
|
|
| ref_smiles_cfg = str(ref_cfg.get("reference_smiles") or dataset_cfg.get("reference_smiles") or "").strip() |
| ref_name_cfg = str(ref_cfg.get("reference_name") or dataset_cfg.get("reference_name") or "").strip() |
| ref_formula_weight_cfg = dataset_cfg.get("reference_formula_weight", np.nan) |
| ref_comp: Dict[str, Any] |
| if ref_smiles_cfg: |
| ref_smiles = _canonicalize_smiles(ref_smiles_cfg) |
| if ref_smiles is None: |
| raise RuntimeError("Invalid configured reference_smiles") |
| ref_comp = { |
| "comp_id": str(ref_cfg["ligand_comp_id"]), |
| "name": ref_name_cfg or str(ref_cfg["ligand_comp_id"]), |
| "formula_weight": ref_formula_weight_cfg, |
| "smiles": ref_smiles, |
| "inchi_key": "", |
| } |
| else: |
| ref_comp = _chemcomp_info(str(ref_cfg["ligand_comp_id"])) |
| ref_smiles = _canonicalize_smiles(str(ref_comp["smiles"] or "")) |
| if ref_smiles is None: |
| raise RuntimeError("Invalid reference SMILES from RCSB chemcomp endpoint") |
|
|
| ref_df = pd.DataFrame( |
| [ |
| { |
| "reference_id": str(ref_cfg["reference_id"]), |
| "pdb_id": str(ref_cfg["pdb_id"]), |
| "ligand_comp_id": str(ref_cfg["ligand_comp_id"]), |
| "ligand_name": ref_comp["name"], |
| "reference_smiles": ref_smiles, |
| "source_structure": str(ref_cfg["pdb_id"]), |
| } |
| ] |
| ) |
| ref_df.to_csv(reference_path, index=False) |
|
|
| _download_pdb(str(ref_cfg["pdb_id"]), docking_target_path) |
|
|
| target_size = int(dataset_cfg.get("target_size", 7500)) |
| min_keep = float(dataset_cfg.get("min_similarity_keep", 0.25)) |
| max_records = int(dataset_cfg.get("pubchem_max_records", 50000)) |
| thresholds = [int(x) for x in dataset_cfg.get("pubchem_thresholds", [95, 90, 85, 80, 75, 70, 65, 60, 55, 50])] |
|
|
| records: Dict[str, Dict[str, Any]] = {} |
| for thr in thresholds: |
| cids = _pubchem_similarity_cids(ref_smiles, threshold=thr, max_records=max_records) |
| |
| remaining = max(0, int(target_size) - len(records)) |
| if remaining <= 0: |
| break |
| |
| limit = min(len(cids), max(remaining + 600, 1200)) |
| cids = cids[:limit] |
| props = _pubchem_properties_for_cids(cids) |
| if props.empty: |
| continue |
| for row in props.itertuples(index=False): |
| c = _canonicalize_smiles(str(row.smiles)) |
| if c is None: |
| continue |
| sim = _tanimoto(ref_smiles, c) |
| if sim < min_keep: |
| continue |
| prev = records.get(c) |
| base = { |
| "ligand_id": "", |
| "smiles": c, |
| "source": "database", |
| "source_database": "PubChem", |
| "source_type": "retrieved", |
| "original_database_id": f"CID:{int(row.cid)}", |
| "reference_similarity": float(sim), |
| "scaffold_core": _scaffold_smiles(c), |
| "scaffold_match": int(_scaffold_smiles(c) == _scaffold_smiles(ref_smiles)), |
| "retrieval_threshold": int(thr), |
| "is_reference": False, |
| "parent_reference_ligand": str(ref_cfg["reference_id"]), |
| "molecular_formula": row.molecular_formula, |
| "molecular_weight": row.molecular_weight, |
| "xlogp": row.xlogp, |
| "tpsa": row.tpsa, |
| "hbd": row.hbd, |
| "hba": row.hba, |
| "rotatable_bonds": row.rotatable_bonds, |
| "heavy_atom_count": row.heavy_atom_count, |
| } |
| if prev is None or (float(base["reference_similarity"]) > float(prev["reference_similarity"])): |
| records[c] = base |
| logger.info("PubChem threshold=%s cumulative=%s", thr, len(records)) |
| if len(records) >= int(target_size * 1.2): |
| break |
|
|
| |
| if len(records) < target_size: |
| chembl_target = str(dataset_cfg.get("chembl_target_id", "CHEMBL5023")) |
| chembl_max = int(dataset_cfg.get("chembl_max_rows", 25000)) |
| cdf = _fetch_chembl_smiles(target_chembl_id=chembl_target, max_rows=chembl_max) |
| for row in cdf.itertuples(index=False): |
| c = _canonicalize_smiles(str(row.smiles)) |
| if c is None or c in records: |
| continue |
| sim = _tanimoto(ref_smiles, c) |
| if sim < min_keep: |
| continue |
| records[c] = { |
| "ligand_id": "", |
| "smiles": c, |
| "source": "database", |
| "source_database": "ChEMBL", |
| "source_type": "retrieved", |
| "original_database_id": str(row.molecule_chembl_id or ""), |
| "reference_similarity": float(sim), |
| "scaffold_core": _scaffold_smiles(c), |
| "scaffold_match": int(_scaffold_smiles(c) == _scaffold_smiles(ref_smiles)), |
| "retrieval_threshold": np.nan, |
| "is_reference": False, |
| "parent_reference_ligand": str(ref_cfg["reference_id"]), |
| "molecular_formula": np.nan, |
| "molecular_weight": np.nan, |
| "xlogp": np.nan, |
| "tpsa": np.nan, |
| "hbd": np.nan, |
| "hba": np.nan, |
| "rotatable_bonds": np.nan, |
| "heavy_atom_count": np.nan, |
| } |
| if len(records) >= int(target_size * 1.2): |
| break |
| logger.info("ChEMBL supplement cumulative=%s", len(records)) |
|
|
| |
| records[ref_smiles] = { |
| "ligand_id": str(ref_cfg["reference_id"]), |
| "smiles": ref_smiles, |
| "source": "reference", |
| "source_database": "RCSB", |
| "source_type": "reference", |
| "original_database_id": str(ref_cfg["ligand_comp_id"]), |
| "reference_similarity": 1.0, |
| "scaffold_core": _scaffold_smiles(ref_smiles), |
| "scaffold_match": 1, |
| "retrieval_threshold": np.nan, |
| "is_reference": True, |
| "parent_reference_ligand": str(ref_cfg["reference_id"]), |
| "molecular_formula": np.nan, |
| "molecular_weight": ref_comp.get("formula_weight"), |
| "xlogp": np.nan, |
| "tpsa": np.nan, |
| "hbd": np.nan, |
| "hba": np.nan, |
| "rotatable_bonds": np.nan, |
| "heavy_atom_count": np.nan, |
| } |
|
|
| raw_df = pd.DataFrame(records.values()) |
| raw_df = raw_df.sort_values(["is_reference", "reference_similarity"], ascending=[False, False]).reset_index(drop=True) |
| raw_df.to_csv(raw_path, index=False) |
|
|
| dedup_df = raw_df.drop_duplicates(subset=["smiles"], keep="first").reset_index(drop=True) |
|
|
| allow_generated = bool(dataset_cfg.get("allow_generated_fallback", True)) |
| if dedup_df.shape[0] < target_size and allow_generated: |
| need = int(target_size - dedup_df.shape[0]) |
| generated = _generate_fallback_smiles(seed_smiles=ref_smiles, needed=need * 2) |
| gen_rows = [] |
| for s in generated: |
| if s in set(dedup_df["smiles"].astype(str).tolist()): |
| continue |
| sim = _tanimoto(ref_smiles, s) |
| gen_rows.append( |
| { |
| "ligand_id": "", |
| "smiles": s, |
| "source": "generated", |
| "source_database": "generated", |
| "source_type": "generated", |
| "original_database_id": "", |
| "reference_similarity": float(sim), |
| "scaffold_core": _scaffold_smiles(s), |
| "scaffold_match": int(_scaffold_smiles(s) == _scaffold_smiles(ref_smiles)), |
| "retrieval_threshold": np.nan, |
| "is_reference": False, |
| "parent_reference_ligand": str(ref_cfg["reference_id"]), |
| "molecular_formula": np.nan, |
| "molecular_weight": np.nan, |
| "xlogp": np.nan, |
| "tpsa": np.nan, |
| "hbd": np.nan, |
| "hba": np.nan, |
| "rotatable_bonds": np.nan, |
| "heavy_atom_count": np.nan, |
| } |
| ) |
| if len(gen_rows) >= need: |
| break |
| if gen_rows: |
| dedup_df = pd.concat([dedup_df, pd.DataFrame(gen_rows)], axis=0, ignore_index=True) |
|
|
| dedup_df = dedup_df.sort_values(["is_reference", "source_type", "reference_similarity"], ascending=[False, True, False]).reset_index( |
| drop=True |
| ) |
| if dedup_df.shape[0] > target_size: |
| refs = dedup_df[dedup_df["is_reference"].astype(bool)].copy() |
| non_refs = dedup_df[~dedup_df["is_reference"].astype(bool)].copy() |
| keep = max(0, target_size - refs.shape[0]) |
| dedup_df = pd.concat([refs, non_refs.head(keep)], axis=0, ignore_index=True) |
|
|
| dedup_df = dedup_df.reset_index(drop=True) |
| for i in range(dedup_df.shape[0]): |
| if bool(dedup_df.loc[i, "is_reference"]): |
| dedup_df.loc[i, "ligand_id"] = str(ref_cfg["reference_id"]) |
| else: |
| dedup_df.loc[i, "ligand_id"] = f"lb_{i:05d}" |
| dedup_df.to_csv(dedup_path, index=False) |
|
|
| shuffle_seed = int(dataset_cfg.get("shuffle_seed", 1337)) |
| shuffled_df = dedup_df.sample(frac=1.0, random_state=shuffle_seed).reset_index(drop=True) |
| shuffled_df["shuffle_seed"] = shuffle_seed |
| shuffled_df.to_csv(shuffled_path, index=False) |
|
|
| provenance_df = dedup_df[ |
| [ |
| "ligand_id", |
| "smiles", |
| "source", |
| "source_database", |
| "source_type", |
| "original_database_id", |
| "is_reference", |
| "parent_reference_ligand", |
| "reference_similarity", |
| "scaffold_core", |
| "scaffold_match", |
| "retrieval_threshold", |
| ] |
| ].copy() |
| provenance_df.to_csv(provenance_path, index=False) |
|
|
| metadata_df = dedup_df[ |
| [ |
| "ligand_id", |
| "smiles", |
| "molecular_formula", |
| "molecular_weight", |
| "xlogp", |
| "tpsa", |
| "hbd", |
| "hba", |
| "rotatable_bonds", |
| "heavy_atom_count", |
| ] |
| ].copy() |
| metadata_df.to_csv(metadata_path, index=False) |
| similarity_df = _write_similarity_distribution(dedup_df, similarity_path) |
|
|
| return { |
| "reference_df": ref_df, |
| "raw_df": raw_df, |
| "dedup_df": dedup_df, |
| "shuffled_df": shuffled_df, |
| "provenance_df": provenance_df, |
| "metadata_df": metadata_df, |
| "similarity_df": similarity_df, |
| "target_path": docking_target_path, |
| "out_dir": out_dir, |
| "shuffle_seed": shuffle_seed, |
| } |
|
|
|
|
| def _write_similarity_distribution(df: pd.DataFrame, path: Path) -> pd.DataFrame: |
| vals = pd.to_numeric(df.get("reference_similarity", pd.Series(dtype=float)), errors="coerce").dropna() |
| bins = np.linspace(0.0, 1.0, 21) |
| hist, edges = np.histogram(vals.to_numpy(dtype=float), bins=bins) |
| out = pd.DataFrame( |
| { |
| "bin_left": edges[:-1], |
| "bin_right": edges[1:], |
| "count": hist, |
| "fraction": hist / max(1, int(hist.sum())), |
| } |
| ) |
| out.to_csv(path, index=False) |
| return out |
|
|
