from __future__ import annotations from dataclasses import dataclass from typing import Dict, Iterable, List, Tuple import numpy as np import pandas as pd from rdkit import Chem from rdkit.Chem import AllChem, Descriptors, Lipinski, MolSurf, rdMolDescriptors from rdkit.Chem.Scaffolds import MurckoScaffold from rdkit.DataStructs import TanimotoSimilarity try: from rdkit.Chem import rdFreeSASA except Exception: # pragma: no cover rdFreeSASA = None # type: ignore[assignment] @dataclass class FeatureValue: value: float | None available: bool source: str feature_type: str @dataclass class FeatureBundle: object_id: str features: Dict[str, FeatureValue] def to_records(self, channel: str, round_idx: int | None = None) -> List[dict]: rows: List[dict] = [] for name, fv in sorted(self.features.items()): rows.append( { "object_id": self.object_id, "round": round_idx, "channel": channel, "feature_name": name, "value": fv.value, "available": bool(fv.available), "source": fv.source, "feature_type": fv.feature_type, } ) return rows def _fv(value: float | None, available: bool, source: str, feature_type: str) -> FeatureValue: return FeatureValue(value=value, available=available, source=source, feature_type=feature_type) def _safe_float(value: float | int | None) -> float | None: if value is None: return None try: v = float(value) except Exception: return None if not np.isfinite(v): return None return v def _compute_ligand_sasa(mol: Chem.Mol) -> Tuple[float | None, bool]: if rdFreeSASA is None: return None, False try: if mol.GetNumConformers() == 0: m = Chem.AddHs(Chem.Mol(mol)) status = AllChem.EmbedMolecule(m, AllChem.ETKDGv3()) if int(status) != 0: return None, False else: m = Chem.Mol(mol) if m.GetNumConformers() == 0: return None, False radii = rdFreeSASA.classifyAtoms(m) sasa = rdFreeSASA.CalcSASA(m, radii) return _safe_float(sasa), True except Exception: return None, False def build_ligand_feature_bundle( ligand_id: str, smiles: str, fingerprint: np.ndarray, reference_mol: Chem.Mol | None = None, compute_partial_charges: bool = True, compute_sasa: bool = True, ) -> FeatureBundle: mol = Chem.MolFromSmiles(smiles) if mol is None: raise ValueError(f"Invalid SMILES for ligand {ligand_id}: {smiles}") m_h = Chem.AddHs(Chem.Mol(mol)) if compute_partial_charges: try: AllChem.ComputeGasteigerCharges(m_h) partial_charges = [] for atom in m_h.GetAtoms(): prop = atom.GetProp("_GasteigerCharge") if atom.HasProp("_GasteigerCharge") else "nan" try: q = float(prop) except Exception: continue if np.isfinite(q): partial_charges.append(q) if partial_charges: mean_abs_q = float(np.mean(np.abs(partial_charges))) total_q = float(np.sum(partial_charges)) has_q = True else: mean_abs_q = None total_q = None has_q = False except Exception: mean_abs_q = None total_q = None has_q = False else: mean_abs_q = None total_q = None has_q = False aromatic_rings = rdMolDescriptors.CalcNumAromaticRings(mol) formal_charge = Chem.GetFormalCharge(mol) heavy_atoms = mol.GetNumHeavyAtoms() frac_csp3 = rdMolDescriptors.CalcFractionCSP3(mol) bertz_ct = Descriptors.BertzCT(mol) balaban_j = Descriptors.BalabanJ(mol) topological_complexity = rdMolDescriptors.CalcChi0v(mol) if compute_sasa: ligand_sasa, has_sasa = _compute_ligand_sasa(m_h) else: ligand_sasa, has_sasa = None, False reference_similarity = None scaffold_match = None chemical_distance = None if reference_mol is not None: fp_gen = AllChem.GetMorganGenerator(radius=2, fpSize=int(fingerprint.shape[0])) ref_fp = fp_gen.GetFingerprint(reference_mol) lig_fp = fp_gen.GetFingerprint(mol) sim = TanimotoSimilarity(ref_fp, lig_fp) reference_similarity = float(sim) chemical_distance = float(1.0 - sim) ref_scaffold = MurckoScaffold.MurckoScaffoldSmiles(mol=reference_mol) lig_scaffold = MurckoScaffold.MurckoScaffoldSmiles(mol=mol) scaffold_match = float(ref_scaffold == lig_scaffold) features: Dict[str, FeatureValue] = { "ligand_mw": _fv(_safe_float(Descriptors.MolWt(mol)), True, "rdkit", "exact"), "ligand_logp": _fv(_safe_float(Descriptors.MolLogP(mol)), True, "rdkit", "exact"), "ligand_tpsa": _fv(_safe_float(MolSurf.TPSA(mol)), True, "rdkit", "exact"), "ligand_hbd": _fv(_safe_float(Lipinski.NumHDonors(mol)), True, "rdkit", "exact"), "ligand_hba": _fv(_safe_float(Lipinski.NumHAcceptors(mol)), True, "rdkit", "exact"), "ligand_rotatable_bonds": _fv(_safe_float(Lipinski.NumRotatableBonds(mol)), True, "rdkit", "exact"), "ligand_aromatic_ring_count": _fv(_safe_float(aromatic_rings), True, "rdkit", "exact"), "ligand_formal_charge": _fv(_safe_float(formal_charge), True, "rdkit", "exact"), "ligand_partial_charge_abs_mean": _fv(mean_abs_q, has_q, "rdkit", "approximate"), "ligand_partial_charge_total": _fv(total_q, has_q, "rdkit", "approximate"), "ligand_topological_bertz": _fv(_safe_float(bertz_ct), True, "rdkit", "exact"), "ligand_topological_balaban_j": _fv(_safe_float(balaban_j), True, "rdkit", "exact"), "ligand_topological_chi0v": _fv(_safe_float(topological_complexity), True, "rdkit", "exact"), "ligand_fraction_csp3": _fv(_safe_float(frac_csp3), True, "rdkit", "exact"), "ligand_heavy_atom_count": _fv(_safe_float(heavy_atoms), True, "rdkit", "exact"), "ligand_sasa": _fv(ligand_sasa, has_sasa, "geometric", "approximate"), "similarity_to_reference": _fv(reference_similarity, reference_similarity is not None, "rdkit", "exact"), "scaffold_match": _fv(scaffold_match, scaffold_match is not None, "rdkit", "exact"), "chemical_distance_to_reference": _fv(chemical_distance, chemical_distance is not None, "rdkit", "exact"), } for i, bit in enumerate(fingerprint.astype(float).tolist()): features[f"morgan_fp_{i:04d}"] = _fv(float(bit), True, "rdkit", "exact") return FeatureBundle(object_id=ligand_id, features=features) def build_protein_feature_bundle(target_id: str, sequence_features: Dict[str, float], structure_features: Dict[str, float]) -> FeatureBundle: seq_len = float(sequence_features.get("seq_length", 1.0) or 1.0) hydrophobic = sum(sequence_features.get(f"aa_frac_{aa}", 0.0) for aa in ["A", "V", "I", "L", "M", "F", "W", "Y"]) charged = sum(sequence_features.get(f"aa_frac_{aa}", 0.0) for aa in ["K", "R", "H", "D", "E"]) polar = sum(sequence_features.get(f"aa_frac_{aa}", 0.0) for aa in ["S", "T", "N", "Q", "C"]) residue_count = float(structure_features.get("residue_count", 0.0)) mean_extent = float(structure_features.get("mean_spatial_extent", 0.0)) pocket_residues = float(structure_features.get("pocket_residue_count", 0.0)) approx_volume = float(max(0.0, mean_extent**3)) pocket_coverage = float(pocket_residues / max(residue_count, 1.0)) features = { "pocket_hydrophobic_fraction": _fv(hydrophobic, True, "protein", "exact"), "pocket_charged_fraction": _fv(charged, True, "protein", "exact"), "pocket_polar_fraction": _fv(polar, True, "protein", "exact"), "pocket_residue_count": _fv(residue_count, True, "protein", "exact"), "pocket_volume_approx": _fv(approx_volume, True, "geometric", "approximate"), "pocket_coverage_fraction": _fv(pocket_coverage, True, "geometric", "approximate"), "pocket_sequence_length": _fv(seq_len, True, "protein", "exact"), } return FeatureBundle(object_id=target_id, features=features) def build_complex_feature_bundle( ligand_id: str, docking_score: float, interface_features: Dict[str, float], ligand_bundle: FeatureBundle, protein_bundle: FeatureBundle, ) -> FeatureBundle: lig = ligand_bundle.features prot = protein_bundle.features logp = lig.get("ligand_logp", _fv(None, False, "rdkit", "exact")).value or 0.0 tpsa = lig.get("ligand_tpsa", _fv(None, False, "rdkit", "exact")).value or 0.0 charge_mag = lig.get("ligand_partial_charge_abs_mean", _fv(None, False, "rdkit", "approximate")).value heavy_atoms = lig.get("ligand_heavy_atom_count", _fv(None, False, "rdkit", "exact")).value or 1.0 pocket_volume = prot.get("pocket_volume_approx", _fv(None, False, "geometric", "approximate")).value or 1.0 pocket_hydrophobic = prot.get("pocket_hydrophobic_fraction", _fv(None, False, "protein", "exact")).value or 0.0 interface_contact_proxy = float(interface_features.get("interface_contact_proxy", max(0.0, -docking_score / 8.0))) hbond_proxy = float(interface_features.get("hbond_proxy", max(0.0, tpsa / 100.0))) shape_proxy = float(interface_features.get("shape_proxy", max(0.0, 1.0 / (1.0 + abs(docking_score))))) contact_count = max(1.0, heavy_atoms * (0.3 + interface_contact_proxy)) polar_contacts = contact_count * min(1.0, tpsa / 120.0) hydrophobic_contacts = contact_count * min(1.0, max(0.0, logp) / 6.0) * (0.5 + pocket_hydrophobic) clash_count = max(0.0, docking_score - 9.0) min_distance = max(1.5, 6.0 - interface_contact_proxy) pocket_coverage = min(1.0, contact_count / max(10.0, pocket_volume / 20.0)) interaction_density = contact_count / max(1.0, pocket_volume) ligand_sasa = lig.get("ligand_sasa", _fv(None, False, "geometric", "approximate")).value protein_sasa = pocket_volume * 0.75 if ligand_sasa is not None: complex_sasa = max(1.0, protein_sasa + ligand_sasa - 0.5 * contact_count) buried_sasa = max(0.0, protein_sasa + ligand_sasa - complex_sasa) burial_ratio = buried_sasa / max(ligand_sasa, 1e-6) sasa_available = True else: complex_sasa = None buried_sasa = None burial_ratio = None sasa_available = False if charge_mag is not None: electrostatic_proxy = -charge_mag * max(0.5, 5.0 - min_distance) electro_available = True else: electrostatic_proxy = None electro_available = False contact_energy = -0.15 * contact_count steric_penalty = 0.6 * clash_count hydrophobic_proxy = -0.1 * hydrophobic_contacts interaction_decomp = contact_energy + hydrophobic_proxy + (electrostatic_proxy or 0.0) + steric_penalty features = { "complex_contact_count": _fv(float(contact_count), True, "interaction", "proxy"), "complex_hbond_proxy": _fv(float(hbond_proxy), True, "interaction", "proxy"), "complex_polar_contact_count": _fv(float(polar_contacts), True, "interaction", "proxy"), "complex_hydrophobic_contact_proxy": _fv(float(hydrophobic_contacts), True, "interaction", "proxy"), "complex_clash_count": _fv(float(clash_count), True, "interaction", "proxy"), "complex_min_distance": _fv(float(min_distance), True, "geometric", "approximate"), "complex_pocket_coverage": _fv(float(pocket_coverage), True, "interaction", "proxy"), "complex_interaction_density": _fv(float(interaction_density), True, "interaction", "proxy"), "complex_ligand_sasa": _fv(_safe_float(ligand_sasa), ligand_sasa is not None, "geometric", "approximate"), "complex_protein_sasa": _fv(_safe_float(protein_sasa), True, "geometric", "approximate"), "complex_sasa": _fv(_safe_float(complex_sasa), sasa_available, "geometric", "approximate"), "complex_buried_sasa": _fv(_safe_float(buried_sasa), sasa_available, "geometric", "approximate"), "complex_shape_complementarity": _fv(float(shape_proxy), True, "geometric", "proxy"), "complex_ligand_burial_ratio": _fv(_safe_float(burial_ratio), sasa_available, "geometric", "approximate"), "energy_contact_proxy": _fv(float(contact_energy), True, "energy_proxy", "proxy"), "energy_electrostatic_proxy": _fv(_safe_float(electrostatic_proxy), electro_available, "energy_proxy", "proxy"), "energy_steric_clash_penalty": _fv(float(steric_penalty), True, "energy_proxy", "proxy"), "energy_hydrophobic_proxy": _fv(float(hydrophobic_proxy), True, "energy_proxy", "proxy"), "energy_interaction_decomposition": _fv(float(interaction_decomp), True, "energy_proxy", "proxy"), } return FeatureBundle(object_id=ligand_id, features=features) def build_rdock_feature_bundle( ligand_id: str, parsed_row: Dict[str, float | int | str | bool | None], ) -> FeatureBundle: """Build a feature bundle from rDock-native and rDock-derived per-ligand outputs.""" def _as_feature( key: str, source: str, ftype: str, ) -> FeatureValue: value = _safe_float(parsed_row.get(key)) # type: ignore[arg-type] return _fv(value, value is not None, source, ftype if value is not None else "unavailable") features: Dict[str, FeatureValue] = { "rdock_total_score": _as_feature("rdock_total_score", "rdock_native", "exact"), "rdock_pose_rank": _as_feature("rdock_pose_rank", "rdock_native", "exact"), "n_generated_poses": _as_feature("n_generated_poses", "rdock_native", "exact"), "best_pose_score": _as_feature("best_pose_score", "rdock_native", "exact"), "mean_top3_pose_score": _as_feature("mean_top3_pose_score", "rdock_native", "exact"), "mean_top5_pose_score": _as_feature("mean_top5_pose_score", "rdock_native", "exact"), "std_top5_pose_score": _as_feature("std_top5_pose_score", "rdock_native", "exact"), "pose_score_gap_1_2": _as_feature("pose_score_gap_1_2", "rdock_native", "exact"), "rdock_restraint_term": _as_feature("rdock_restraint_term", "rdock_native", "exact"), "rdock_internal_ligand_term": _as_feature("rdock_internal_ligand_term", "rdock_native", "exact"), "rdock_polar_term": _as_feature("rdock_polar_term", "rdock_native", "exact"), "rdock_vdw_term": _as_feature("rdock_vdw_term", "rdock_native", "exact"), "top_pose_rmsd_consistency": _as_feature("top_pose_rmsd_consistency", "rdock_derived", "proxy"), "contact_overlap_consistency": _as_feature("contact_overlap_consistency", "rdock_derived", "proxy"), "hotspot_contact_frequency": _as_feature("hotspot_contact_frequency", "rdock_derived", "proxy"), "subpocket_match_score": _as_feature("subpocket_match_score", "rdock_derived", "proxy"), "replicate_mean_score": _as_feature("replicate_mean_score", "rdock_derived", "proxy"), "replicate_score_variance": _as_feature("replicate_score_variance", "rdock_derived", "proxy"), "replicate_consensus_score": _as_feature("replicate_consensus_score", "rdock_derived", "proxy"), } return FeatureBundle(object_id=ligand_id, features=features) def merge_bundles(object_id: str, bundles: Iterable[FeatureBundle]) -> FeatureBundle: merged: Dict[str, FeatureValue] = {} for bundle in bundles: merged.update(bundle.features) return FeatureBundle(object_id=object_id, features=merged) def bundles_to_wide_frames( bundles: List[FeatureBundle], ordered_feature_names: List[str] | None = None, ) -> Tuple[pd.DataFrame, pd.DataFrame, List[str]]: if not bundles: return pd.DataFrame(), pd.DataFrame(), [] if ordered_feature_names is None: feature_set = set() for bundle in bundles: feature_set.update(bundle.features.keys()) ordered_feature_names = sorted(feature_set) value_rows = [] mask_rows = [] for bundle in bundles: vrow = {"ligand_id": bundle.object_id} mrow = {"ligand_id": bundle.object_id} for name in ordered_feature_names: fv = bundle.features.get(name) if fv is None or not fv.available or fv.value is None: vrow[name] = np.nan mrow[f"mask_{name}"] = 0 else: vrow[name] = float(fv.value) mrow[f"mask_{name}"] = 1 value_rows.append(vrow) mask_rows.append(mrow) return pd.DataFrame(value_rows), pd.DataFrame(mask_rows), ordered_feature_names def compute_feature_diagnostics(values_df: pd.DataFrame, masks_df: pd.DataFrame, target: pd.Series | None = None) -> pd.DataFrame: if values_df.empty: return pd.DataFrame(columns=["feature", "missing_frac", "mean", "std", "min", "max", "is_constant", "corr_to_target"]) numeric_cols = [c for c in values_df.columns if c != "ligand_id"] rows = [] for col in numeric_cols: vals = pd.to_numeric(values_df[col], errors="coerce") mask_col = f"mask_{col}" if mask_col in masks_df.columns: missing_frac = 1.0 - float(pd.to_numeric(masks_df[mask_col], errors="coerce").mean()) else: missing_frac = float(vals.isna().mean()) finite_vals = vals[np.isfinite(vals)] is_constant = finite_vals.nunique(dropna=True) <= 1 if not finite_vals.empty else True if target is not None and len(target) == len(vals): target_num = pd.to_numeric(target, errors="coerce") paired = pd.concat([vals, target_num], axis=1).dropna() if paired.shape[0] >= 3 and paired.iloc[:, 0].nunique(dropna=True) > 1 and paired.iloc[:, 1].nunique(dropna=True) > 1: corr = paired.iloc[:, 0].corr(paired.iloc[:, 1]) corr_val = float(corr) if corr is not None and np.isfinite(corr) else np.nan else: corr_val = np.nan else: corr_val = np.nan rows.append( { "feature": col, "missing_frac": float(missing_frac), "mean": float(finite_vals.mean()) if not finite_vals.empty else np.nan, "std": float(finite_vals.std()) if not finite_vals.empty else np.nan, "min": float(finite_vals.min()) if not finite_vals.empty else np.nan, "max": float(finite_vals.max()) if not finite_vals.empty else np.nan, "is_constant": bool(is_constant), "corr_to_target": corr_val, } ) return pd.DataFrame(rows).sort_values(["missing_frac", "feature"], ascending=[False, True]).reset_index(drop=True)