from __future__ import annotations import json from dataclasses import dataclass from pathlib import Path from typing import Any import numpy as np from rdkit import Chem POCKET_MODE_USER_FIXED = "user_fixed_pocket" POCKET_MODE_REFERENCE = "reference_complex_pocket" POCKET_MODE_REFERENCE_RELAXED = "reference_complex_pocket_relaxed" SUPPORTED_POCKET_MODES = { POCKET_MODE_USER_FIXED, POCKET_MODE_REFERENCE, POCKET_MODE_REFERENCE_RELAXED, } @dataclass(frozen=True) class PocketSpec: mode: str center: tuple[float, float, float] radius: float box_size: tuple[float, float, float] reference_ligand_id: str | None = None relaxation_margin: float = 0.0 source: str = "unknown" notes: str = "" def to_dict(self) -> dict[str, Any]: return { "mode": self.mode, "center": list(self.center), "radius": float(self.radius), "box_size": list(self.box_size), "reference_ligand_id": self.reference_ligand_id or "", "relaxation_margin": float(self.relaxation_margin), "source": self.source, "notes": self.notes, } @classmethod def from_dict(cls, payload: dict[str, Any]) -> "PocketSpec": center = _parse_vector3(payload.get("center"), field_name="center") box = _parse_vector3(payload.get("box_size"), field_name="box_size") return cls( mode=str(payload.get("mode", POCKET_MODE_REFERENCE)), center=center, radius=float(payload.get("radius", 6.0)), box_size=box, reference_ligand_id=str(payload.get("reference_ligand_id", "")).strip() or None, relaxation_margin=float(payload.get("relaxation_margin", 0.0)), source=str(payload.get("source", "unknown")), notes=str(payload.get("notes", "")), ) def _parse_vector3(value: Any, field_name: str) -> tuple[float, float, float]: if value is None: raise ValueError(f"{field_name} is required") if isinstance(value, str): text = value.replace(";", ",").replace(" ", "") parts = [x for x in text.split(",") if x] if len(parts) != 3: raise ValueError(f"{field_name} must contain 3 values, got: {value}") return (float(parts[0]), float(parts[1]), float(parts[2])) if isinstance(value, (tuple, list)) and len(value) == 3: return (float(value[0]), float(value[1]), float(value[2])) raise ValueError(f"{field_name} must be a length-3 sequence") def _derive_center_radius_box( coords: np.ndarray, relaxation_margin: float, fallback_radius: float, ) -> tuple[tuple[float, float, float], float, tuple[float, float, float]]: if coords.size == 0: raise ValueError("cannot derive pocket from empty coordinates") center = coords.mean(axis=0) max_dist = float(np.linalg.norm(coords - center, axis=1).max()) if coords.shape[0] > 0 else 0.0 radius = max(float(fallback_radius), max_dist + 2.0 + float(relaxation_margin)) half_box = max(radius, 8.0) box = (2.0 * half_box, 2.0 * half_box, 2.0 * half_box) return (float(center[0]), float(center[1]), float(center[2])), float(radius), box def _extract_receptor_atom_coords(target_path: str | Path) -> np.ndarray: coords: list[list[float]] = [] for ln in Path(target_path).read_text(encoding="utf-8", errors="ignore").splitlines(): if not ln.startswith("ATOM"): continue try: x = float(ln[30:38]) y = float(ln[38:46]) z = float(ln[46:54]) except Exception: continue coords.append([x, y, z]) return np.asarray(coords, dtype=float) def extract_reference_ligand_coords( target_path: str | Path, pocket_reference_ligand_id: str | None, ) -> tuple[np.ndarray, dict[str, Any]]: path = Path(target_path) ligand_filter = (pocket_reference_ligand_id or "").strip().upper() grouped: dict[tuple[str, str, str, str], list[list[float]]] = {} residues: dict[tuple[str, str, str, str], str] = {} for ln in path.read_text(encoding="utf-8", errors="ignore").splitlines(): if not ln.startswith("HETATM"): continue resn = ln[17:20].strip().upper() if not resn or resn in {"HOH", "WAT", "DOD", "SO4"}: continue if ligand_filter and resn != ligand_filter: continue try: x = float(ln[30:38]) y = float(ln[38:46]) z = float(ln[46:54]) except Exception: continue chain = ln[21:22].strip() resseq = ln[22:26].strip() ins = ln[26:27].strip() key = (resn, chain, resseq, ins) grouped.setdefault(key, []).append([x, y, z]) residues[key] = resn if not grouped: return np.asarray([], dtype=float), { "selected_resname": "", "selected_chain": "", "selected_resseq": "", "selected_atom_count": 0, } selected = max(grouped, key=lambda k: len(grouped[k])) coords = np.asarray(grouped[selected], dtype=float) return coords, { "selected_resname": residues[selected], "selected_chain": selected[1], "selected_resseq": selected[2], "selected_atom_count": int(coords.shape[0]), } def resolve_pocket_spec( *, target_path: str | Path, pocket_mode: str | None = None, pocket_center: Any = None, pocket_box_size: Any = None, pocket_radius: float | None = None, pocket_reference_ligand_id: str | None = None, pocket_relaxation_margin: float = 0.0, fallback_radius: float = 6.0, ) -> PocketSpec: mode = str(pocket_mode or POCKET_MODE_REFERENCE).strip() if mode not in SUPPORTED_POCKET_MODES: raise ValueError(f"Unsupported pocket_mode `{mode}`. Supported: {sorted(SUPPORTED_POCKET_MODES)}") # Explicit center + shape always wins over inferred modes. if pocket_center is not None and (pocket_radius is not None or pocket_box_size is not None): center = _parse_vector3(pocket_center, field_name="pocket_center") radius = float(pocket_radius) if pocket_radius is not None else float(max(_parse_vector3(pocket_box_size, "pocket_box_size")) / 2.0) box = _parse_vector3(pocket_box_size, "pocket_box_size") if pocket_box_size is not None else (2.0 * radius, 2.0 * radius, 2.0 * radius) return PocketSpec( mode=POCKET_MODE_USER_FIXED, center=center, radius=float(radius), box_size=box, reference_ligand_id=str(pocket_reference_ligand_id or "").strip() or None, relaxation_margin=0.0, source="user_explicit_override", notes="Explicit pocket center/size provided by user; inferred modes skipped.", ) if mode == POCKET_MODE_USER_FIXED: center = _parse_vector3(pocket_center, field_name="pocket_center") if pocket_radius is None and pocket_box_size is None: raise ValueError("user_fixed_pocket requires pocket_radius or pocket_box_size") radius = float(pocket_radius) if pocket_radius is not None else float(max(_parse_vector3(pocket_box_size, "pocket_box_size")) / 2.0) box = _parse_vector3(pocket_box_size, "pocket_box_size") if pocket_box_size is not None else (2.0 * radius, 2.0 * radius, 2.0 * radius) return PocketSpec( mode=POCKET_MODE_USER_FIXED, center=center, radius=float(radius), box_size=box, reference_ligand_id=str(pocket_reference_ligand_id or "").strip() or None, relaxation_margin=0.0, source="user_fixed_pocket", notes="Fixed pocket from explicit user configuration.", ) margin = float(pocket_relaxation_margin if mode == POCKET_MODE_REFERENCE_RELAXED else 0.0) coords, meta = extract_reference_ligand_coords(target_path=target_path, pocket_reference_ligand_id=pocket_reference_ligand_id) if coords.size > 0: center, derived_radius, box = _derive_center_radius_box(coords, relaxation_margin=margin, fallback_radius=fallback_radius) radius = float(pocket_radius) if pocket_radius is not None else float(derived_radius) if pocket_box_size is not None: box = _parse_vector3(pocket_box_size, "pocket_box_size") return PocketSpec( mode=mode, center=center, radius=float(radius), box_size=box, reference_ligand_id=meta.get("selected_resname") or (str(pocket_reference_ligand_id).strip() if pocket_reference_ligand_id else None), relaxation_margin=float(margin), source="reference_complex_ligand", notes=( "Fixed pocket from crystal ligand coordinates " f"(resname={meta.get('selected_resname', '')}, atoms={meta.get('selected_atom_count', 0)})." ), ) receptor_coords = _extract_receptor_atom_coords(target_path) if receptor_coords.size == 0: raise ValueError("Cannot resolve fixed pocket: no reference ligand and no receptor atom coordinates found") center = receptor_coords.mean(axis=0) radius = float(pocket_radius) if pocket_radius is not None else float(fallback_radius) box = _parse_vector3(pocket_box_size, "pocket_box_size") if pocket_box_size is not None else (2.0 * radius, 2.0 * radius, 2.0 * radius) return PocketSpec( mode=mode, center=(float(center[0]), float(center[1]), float(center[2])), radius=float(radius), box_size=box, reference_ligand_id=str(pocket_reference_ligand_id or "").strip() or None, relaxation_margin=float(margin), source="receptor_centroid_fallback", notes="Reference ligand not found; deterministic receptor-centroid fixed pocket fallback used.", ) def write_pocket_spec(path: str | Path, spec: PocketSpec) -> Path: p = Path(path) p.parent.mkdir(parents=True, exist_ok=True) p.write_text(json.dumps(spec.to_dict(), indent=2), encoding="utf-8") return p def load_pocket_spec(path: str | Path) -> PocketSpec: payload = json.loads(Path(path).read_text(encoding="utf-8")) return PocketSpec.from_dict(payload) def centroid_from_sdf(path: str | Path) -> np.ndarray: mols = Chem.SDMolSupplier(str(path), removeHs=False) mol = mols[0] if mols and len(mols) > 0 else None if mol is None or mol.GetNumConformers() == 0: return np.asarray([np.nan, np.nan, np.nan], dtype=float) conf = mol.GetConformer() pts = [] for i in range(mol.GetNumAtoms()): p = conf.GetAtomPosition(i) pts.append([p.x, p.y, p.z]) if not pts: return np.asarray([np.nan, np.nan, np.nan], dtype=float) return np.asarray(pts, dtype=float).mean(axis=0) def centroid_from_pdbqt(path: str | Path) -> np.ndarray: pts: list[list[float]] = [] text = Path(path).read_text(encoding="utf-8", errors="ignore") has_models = "MODEL" in text in_model = False for ln in text.splitlines(): if ln.startswith("MODEL"): in_model = True continue if ln.startswith("ENDMDL"): break if has_models and (not in_model): continue if not ln.startswith(("ATOM", "HETATM")): continue try: x = float(ln[30:38]) y = float(ln[38:46]) z = float(ln[46:54]) except Exception: continue pts.append([x, y, z]) if not pts: return np.asarray([np.nan, np.nan, np.nan], dtype=float) return np.asarray(pts, dtype=float).mean(axis=0) def pose_distance_to_center(centroid: np.ndarray, spec: PocketSpec) -> float: if centroid.size != 3 or not np.isfinite(centroid).all(): return float("nan") center = np.asarray(spec.center, dtype=float) return float(np.linalg.norm(centroid - center)) def is_pose_in_pocket(centroid: np.ndarray, spec: PocketSpec) -> bool: if centroid.size != 3 or not np.isfinite(centroid).all(): return False center = np.asarray(spec.center, dtype=float) box = np.asarray(spec.box_size, dtype=float) if box.size == 3 and np.isfinite(box).all(): inside_box = bool(np.all(np.abs(centroid - center) <= (box / 2.0))) else: inside_box = False if inside_box: return True dist = float(np.linalg.norm(centroid - center)) return bool(np.isfinite(dist) and dist <= float(spec.radius))