| from __future__ import annotations |
|
|
| import math |
| import re |
| from pathlib import Path |
| from typing import Any, Dict, List, Tuple |
|
|
| import numpy as np |
| from rdkit import Chem |
| from rdkit.Chem import rdMolAlign |
|
|
|
|
| TAG_RE = re.compile(r"^>\s*<\s*([^>]+?)\s*>", flags=re.IGNORECASE) |
|
|
|
|
| def _safe_float(value: object) -> float | None: |
| try: |
| v = float(value) |
| except Exception: |
| return None |
| if not np.isfinite(v): |
| return None |
| return float(v) |
|
|
|
|
| def _split_sdf_blocks(text: str) -> List[str]: |
| blocks = [] |
| for part in text.split("$$$$"): |
| block = part.strip() |
| if block: |
| blocks.append(block + "\n$$$$\n") |
| return blocks |
|
|
|
|
| def _parse_block_tags(block: str) -> Dict[str, str]: |
| lines = block.splitlines() |
| tags: Dict[str, str] = {} |
| i = 0 |
| while i < len(lines): |
| m = TAG_RE.match(lines[i].strip()) |
| if not m: |
| i += 1 |
| continue |
| tag = m.group(1).strip() |
| value = "" |
| if i + 1 < len(lines): |
| value = lines[i + 1].strip() |
| tags[tag] = value |
| i += 2 |
| return tags |
|
|
|
|
| def _pose_molecules(blocks: List[str]) -> List[Chem.Mol | None]: |
| out: List[Chem.Mol | None] = [] |
| for b in blocks: |
| mol = None |
| try: |
| mol = Chem.MolFromMolBlock(b, sanitize=False, removeHs=False, strictParsing=False) |
| except Exception: |
| mol = None |
| out.append(mol) |
| return out |
|
|
|
|
| def _pose_rmsd_stats(poses: List[Dict[str, Any]], mols: List[Chem.Mol | None], top_k: int = 5) -> Dict[str, float | None]: |
| if not poses: |
| return {"top_pose_rmsd_consistency": None, "geometry_similarity_top5": None} |
|
|
| top = sorted(poses, key=lambda x: x["score"])[: max(1, min(top_k, len(poses)))] |
| top_idx = [int(x["pose_idx"]) for x in top] |
| if not top_idx: |
| return {"top_pose_rmsd_consistency": None, "geometry_similarity_top5": None} |
|
|
| ref_idx = int(top_idx[0]) |
| ref_mol = mols[ref_idx] if 0 <= ref_idx < len(mols) else None |
| if ref_mol is None: |
| return {"top_pose_rmsd_consistency": None, "geometry_similarity_top5": None} |
|
|
| rmsds: List[float] = [] |
| for idx in top_idx[1:]: |
| if idx < 0 or idx >= len(mols): |
| continue |
| mol = mols[idx] |
| if mol is None: |
| continue |
| try: |
| if ref_mol.GetNumAtoms() != mol.GetNumAtoms(): |
| continue |
| rmsd = float(rdMolAlign.GetBestRMS(ref_mol, mol)) |
| if np.isfinite(rmsd): |
| rmsds.append(rmsd) |
| except Exception: |
| continue |
|
|
| if not rmsds: |
| return {"top_pose_rmsd_consistency": None, "geometry_similarity_top5": None} |
|
|
| mean_rmsd = float(np.mean(np.asarray(rmsds, dtype=float))) |
| geom_sim = float(1.0 / (1.0 + mean_rmsd)) |
| return {"top_pose_rmsd_consistency": mean_rmsd, "geometry_similarity_top5": geom_sim} |
|
|
|
|
| def parse_rdock_output(path: str | Path) -> Dict[str, Any]: |
| """ |
| Parse real rDock SDF output and compute native + derived multi-pose features. |
| |
| Native features are direct tags parsed from rDock output (`SCORE*`). |
| Derived features are computed from real generated poses and are explicitly marked as proxies where needed. |
| """ |
| source = Path(path) |
| if not source.exists(): |
| raise ValueError(f"rDock output file does not exist: {source}") |
| if source.stat().st_size == 0: |
| raise ValueError(f"rDock output file is empty: {source}") |
|
|
| raw = source.read_text(encoding="utf-8", errors="ignore") |
| blocks = _split_sdf_blocks(raw) |
| if not blocks: |
| raise ValueError(f"No molecule blocks found in real rDock output: {source}") |
|
|
| poses: List[Dict[str, Any]] = [] |
| for i, block in enumerate(blocks): |
| tags = _parse_block_tags(block) |
| score = _safe_float(tags.get("SCORE")) |
| if score is None: |
| continue |
| poses.append({"pose_idx": i, "pose_rank": int(tags.get("RI", i) or i) + 1, "score": score, "tags": tags}) |
|
|
| if not poses: |
| raise ValueError(f"No SCORE fields found in real rDock output: {source}") |
|
|
| poses = sorted(poses, key=lambda x: x["score"]) |
| scores = [float(p["score"]) for p in poses] |
| best = poses[0] |
| top3 = scores[:3] |
| top5 = scores[:5] |
|
|
| native = { |
| "rdock_total_score": float(best["score"]), |
| "rdock_pose_rank": int(best.get("pose_rank", 1)), |
| "n_generated_poses": int(len(scores)), |
| "best_pose_score": float(best["score"]), |
| "mean_top3_pose_score": float(np.mean(top3)), |
| "mean_top5_pose_score": float(np.mean(top5)), |
| "std_top5_pose_score": float(np.std(np.asarray(top5, dtype=float), ddof=0)), |
| "pose_score_gap_1_2": float(scores[1] - scores[0]) if len(scores) > 1 else np.nan, |
| "rdock_restraint_term": _safe_float(best["tags"].get("SCORE.RESTR")), |
| "rdock_internal_ligand_term": _safe_float(best["tags"].get("SCORE.INTRA")), |
| "rdock_polar_term": _safe_float(best["tags"].get("SCORE.INTER.POLAR")), |
| "rdock_vdw_term": _safe_float(best["tags"].get("SCORE.INTER.VDW")), |
| "rdock_inter_term": _safe_float(best["tags"].get("SCORE.INTER")), |
| "rdock_intra_vdw_term": _safe_float(best["tags"].get("SCORE.INTRA.VDW")), |
| "rdock_intra_dih_term": _safe_float(best["tags"].get("SCORE.INTRA.DIHEDRAL")), |
| "rdock_norm_score": _safe_float(best["tags"].get("SCORE.norm")), |
| "rdock_heavy_atoms": _safe_float(best["tags"].get("SCORE.heavy")), |
| } |
|
|
| mols = _pose_molecules(blocks) |
| rmsd_stats = _pose_rmsd_stats(poses=poses, mols=mols, top_k=5) |
|
|
| std5 = native["std_top5_pose_score"] |
| if std5 is None or (isinstance(std5, float) and (not np.isfinite(std5))): |
| pose_stability = None |
| else: |
| pose_stability = float(math.exp(-float(std5))) |
|
|
| inter_scores: List[float] = [] |
| for p in poses[:5]: |
| v = _safe_float(p["tags"].get("SCORE.INTER")) |
| if v is not None: |
| inter_scores.append(float(v)) |
| inter_std = float(np.std(np.asarray(inter_scores), ddof=0)) if inter_scores else np.nan |
|
|
| |
| derived = { |
| "n_valid_poses": int(len(scores)), |
| "top_pose_rmsd_consistency": rmsd_stats["top_pose_rmsd_consistency"], |
| "contact_overlap_consistency": (float(1.0 / (1.0 + inter_std)) if np.isfinite(inter_std) else np.nan), |
| "hotspot_contact_frequency": ( |
| float(np.mean([1.0 if (_safe_float(p["tags"].get("SCORE.INTER")) or 0.0) < 0.0 else 0.0 for p in poses[:5]])) |
| if poses |
| else np.nan |
| ), |
| "subpocket_match_score": pose_stability if pose_stability is not None else np.nan, |
| "consensus_contact_score": (float(-np.mean(np.asarray(inter_scores, dtype=float))) if inter_scores else np.nan), |
| "consensus_hotspot_coverage": ( |
| float(np.mean([1.0 if (_safe_float(p["tags"].get("SCORE.INTER.VDW")) or 0.0) < 0.0 else 0.0 for p in poses[:5]])) |
| if poses |
| else np.nan |
| ), |
| "pose_stability_proxy": pose_stability, |
| "geometry_similarity_top5": rmsd_stats["geometry_similarity_top5"], |
| } |
|
|
| feature_provenance: List[Dict[str, Any]] = [] |
| for name, val in native.items(): |
| feature_provenance.append( |
| { |
| "feature_name": name, |
| "feature_source": "rdock_native", |
| "pose_source": "best_pose" if name.startswith("rdock_") else "top5", |
| "raw_output_file": str(source), |
| "parsed_from": f"{source}::SDF_TAG", |
| "feature_type": "exact" if val is not None and np.isfinite(float(val)) else "unavailable", |
| "available": bool(val is not None and np.isfinite(float(val))), |
| } |
| ) |
| for name, val in derived.items(): |
| feature_provenance.append( |
| { |
| "feature_name": name, |
| "feature_source": "rdock_derived", |
| "pose_source": "top5" if ("top" in name or "consensus" in name) else "best_pose", |
| "raw_output_file": str(source), |
| "parsed_from": f"{source}::derived", |
| "feature_type": "proxy" if val is not None and np.isfinite(float(val)) else "unavailable", |
| "available": bool(val is not None and np.isfinite(float(val))), |
| } |
| ) |
|
|
| return { |
| "pose_path": str(source), |
| "score": float(native["best_pose_score"]), |
| "score_tag": "SCORE", |
| "all_scores": scores, |
| "pose_count": int(len(scores)), |
| "poses": poses, |
| "native_features": native, |
| "derived_features": derived, |
| "feature_provenance": feature_provenance, |
| } |
|
|
|
|
