| from __future__ import annotations |
|
|
| import math |
| import re |
| import shutil |
| import json |
| from dataclasses import dataclass |
| from pathlib import Path |
| from subprocess import TimeoutExpired |
| from typing import Any, Dict, Sequence |
|
|
| import numpy as np |
| from concurrent.futures import ThreadPoolExecutor |
|
|
| from libs.utils.subprocess_utils import run_command |
|
|
| from .base import BackendCapability, DockingBackend, DockingError, DockingResult |
| from .pocket import ( |
| PocketSpec, |
| centroid_from_pdbqt, |
| is_pose_in_pocket, |
| pose_distance_to_center, |
| resolve_pocket_spec, |
| write_pocket_spec, |
| ) |
| from .prep import prepare_ligand_sdf |
|
|
| _FLOAT_RE = re.compile(r"[-+]?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?") |
|
|
|
|
| def _resolve_executable(name: str) -> str | None: |
| direct = shutil.which(name) |
| if direct: |
| return direct |
| candidates = [ |
| Path.home() / "miniconda3" / "envs" / "docking_diag" / "bin" / name, |
| Path.home() / "miniconda3" / "bin" / name, |
| ] |
| for c in candidates: |
| if c.exists(): |
| return str(c) |
| return None |
|
|
|
|
| def parse_smina_score(text: str) -> float: |
| """ |
| Parse smina score from combined output text. |
| |
| Supported patterns: |
| - `REMARK minimizedAffinity -7.6` |
| - `REMARK VINA RESULT: -7.6 ...` |
| - score table lines: `1 -7.6 ...` |
| """ |
| best = math.nan |
| for ln in text.splitlines(): |
| low = ln.lower() |
| if "minimizedaffinity" in low or "vina result" in low or low.startswith("affinity:"): |
| nums = _FLOAT_RE.findall(ln) |
| for tok in nums: |
| try: |
| val = float(tok) |
| except Exception: |
| continue |
| if math.isfinite(val): |
| if (not math.isfinite(best)) or val < best: |
| best = val |
| break |
| continue |
| stripped = ln.strip() |
| if not stripped or stripped.startswith("#"): |
| continue |
| cols = stripped.split() |
| if len(cols) >= 2 and cols[0].isdigit(): |
| try: |
| val = float(cols[1]) |
| except Exception: |
| continue |
| if math.isfinite(val): |
| if (not math.isfinite(best)) or val < best: |
| best = val |
| return float(best) if math.isfinite(best) else float("nan") |
|
|
|
|
| @dataclass |
| class SminaConfig: |
| smina_bin: str = "smina" |
| obabel_bin: str = "obabel" |
| command_timeout_seconds: int = 120 |
| exhaustiveness: int = 8 |
| num_modes: int = 5 |
| cpu: int = 1 |
| parallel_jobs: int = 1 |
| seed: int = 20260419 |
| pocket_mode: str = "reference_complex_pocket" |
| pocket_center: tuple[float, float, float] | str | list[float] | None = None |
| pocket_box_size: tuple[float, float, float] | str | list[float] | None = None |
| pocket_radius: float | None = None |
| pocket_reference_ligand_id: str | None = None |
| pocket_relaxation_margin: float = 0.0 |
|
|
|
|
| class SminaBackend(DockingBackend): |
| """ |
| Minimal smina backend used for fixed-pocket diagnostics. |
| |
| It intentionally keeps logic compact and explicit: |
| success is true only when command succeeds, output pose exists and score is finite. |
| """ |
|
|
| def __init__(self, config: SminaConfig | None = None) -> None: |
| self.config = config or SminaConfig() |
|
|
| def check_capability(self) -> BackendCapability: |
| bins = { |
| "smina": _resolve_executable(self.config.smina_bin), |
| "obabel": _resolve_executable(self.config.obabel_bin), |
| } |
| return BackendCapability( |
| backend_name="smina", |
| available=bool(bins["smina"] and bins["obabel"]), |
| details=bins, |
| ) |
|
|
| def prepare_target(self, target_path: str | Path, work_dir: str | Path) -> Dict[str, Path]: |
| src = Path(target_path) |
| if not src.exists(): |
| raise DockingError(f"Missing target file: {src}") |
| wd = Path(work_dir) |
| wd.mkdir(parents=True, exist_ok=True) |
|
|
| receptor_pdbqt = wd / "receptor.pdbqt" |
| obabel = _resolve_executable(self.config.obabel_bin) |
| if obabel is None: |
| raise DockingError("obabel is required for smina receptor preparation") |
| conv = run_command([obabel, str(src), "-O", str(receptor_pdbqt)], cwd=wd, timeout=self.config.command_timeout_seconds) |
| if conv.returncode != 0 or (not receptor_pdbqt.exists()) or receptor_pdbqt.stat().st_size == 0: |
| raise DockingError(f"Failed to prepare receptor.pdbqt for smina: rc={conv.returncode}") |
|
|
| pocket = resolve_pocket_spec( |
| target_path=src, |
| pocket_mode=self.config.pocket_mode, |
| pocket_center=self.config.pocket_center, |
| pocket_box_size=self.config.pocket_box_size, |
| pocket_radius=self.config.pocket_radius, |
| pocket_reference_ligand_id=self.config.pocket_reference_ligand_id, |
| pocket_relaxation_margin=self.config.pocket_relaxation_margin, |
| fallback_radius=6.0, |
| ) |
| write_pocket_spec(wd / "pocket.json", pocket) |
| return { |
| "receptor_pdbqt": receptor_pdbqt, |
| "target_prepared": src, |
| "target_work_dir": wd, |
| "pocket_json": wd / "pocket.json", |
| } |
|
|
| def prepare_ligand(self, ligand_id: str, smiles: str, work_dir: str | Path) -> Path: |
| wd = Path(work_dir) |
| wd.mkdir(parents=True, exist_ok=True) |
| sdf = prepare_ligand_sdf(ligand_id, smiles, wd / f"{ligand_id}.sdf") |
| out = wd / f"{ligand_id}.pdbqt" |
| obabel = _resolve_executable(self.config.obabel_bin) |
| if obabel is None: |
| raise DockingError("obabel is required for smina ligand preparation") |
| conv = run_command([obabel, str(sdf), "-O", str(out)], cwd=wd, timeout=self.config.command_timeout_seconds) |
| if conv.returncode != 0 or (not out.exists()) or out.stat().st_size == 0: |
| raise DockingError(f"Failed to prepare ligand pdbqt for smina `{ligand_id}`: rc={conv.returncode}") |
| return out |
|
|
| def build_site_or_constraints(self, target_context: Dict[str, Path], reference_ligand: Path, work_dir: str | Path) -> Path: |
| _ = (target_context, reference_ligand, work_dir) |
| return Path() |
|
|
| def dock( |
| self, |
| target_context: Dict[str, Path], |
| ligand_files: Sequence[Path], |
| work_dir: str | Path, |
| allow_mock: bool = False, |
| require_real_backend: bool = False, |
| ) -> list[DockingResult]: |
| _ = (allow_mock, require_real_backend) |
| cap = self.check_capability() |
| if not cap.available: |
| raise DockingError(f"smina backend unavailable: {cap.details}") |
|
|
| wd = Path(work_dir) |
| wd.mkdir(parents=True, exist_ok=True) |
| receptor = target_context.get("receptor_pdbqt") |
| if receptor is None: |
| raise DockingError("Missing receptor_pdbqt in target context") |
|
|
| pocket_json = target_context.get("pocket_json") |
| if pocket_json is not None and Path(pocket_json).exists(): |
| pocket = PocketSpec.from_dict(json.loads(Path(pocket_json).read_text(encoding="utf-8"))) |
| else: |
| pocket = resolve_pocket_spec( |
| target_path=target_context.get("target_prepared", receptor), |
| pocket_mode=self.config.pocket_mode, |
| pocket_center=self.config.pocket_center, |
| pocket_box_size=self.config.pocket_box_size, |
| pocket_radius=self.config.pocket_radius, |
| pocket_reference_ligand_id=self.config.pocket_reference_ligand_id, |
| pocket_relaxation_margin=self.config.pocket_relaxation_margin, |
| fallback_radius=6.0, |
| ) |
| results: list[DockingResult] = [] |
| smina = _resolve_executable(self.config.smina_bin) |
| if smina is None: |
| raise DockingError("smina executable not found") |
|
|
| def _dock_single(lig: Path) -> DockingResult: |
| lid = lig.stem |
| out_pose = wd / f"{lid}_smina_out.pdbqt" |
| cmd = [ |
| smina, |
| "--receptor", |
| str(receptor), |
| "--ligand", |
| str(lig), |
| "--center_x", |
| f"{pocket.center[0]:.4f}", |
| "--center_y", |
| f"{pocket.center[1]:.4f}", |
| "--center_z", |
| f"{pocket.center[2]:.4f}", |
| "--size_x", |
| f"{pocket.box_size[0]:.4f}", |
| "--size_y", |
| f"{pocket.box_size[1]:.4f}", |
| "--size_z", |
| f"{pocket.box_size[2]:.4f}", |
| "--exhaustiveness", |
| str(self.config.exhaustiveness), |
| "--num_modes", |
| str(self.config.num_modes), |
| "--cpu", |
| str(self.config.cpu), |
| "--seed", |
| str(self.config.seed), |
| "--out", |
| str(out_pose), |
| ] |
| try: |
| res = run_command(cmd, cwd=wd, timeout=self.config.command_timeout_seconds) |
| except TimeoutExpired as exc: |
| return DockingResult( |
| ligand_id=lid, |
| docking_score=float("nan"), |
| pose_path=None, |
| backend_name="smina", |
| backend_mode="real-smina", |
| score_source="smina_timeout", |
| raw_output_file=str(out_pose), |
| parsed_from="timeout", |
| fallback_used=False, |
| success=False, |
| message=f"smina_timeout:{exc}", |
| command=" ".join(cmd), |
| extra={"pocket_spec": pocket.to_dict(), "pose_distance_to_pocket_center": float("nan"), "pose_in_fixed_pocket": False}, |
| ) |
| except Exception as exc: |
| return DockingResult( |
| ligand_id=lid, |
| docking_score=float("nan"), |
| pose_path=None, |
| backend_name="smina", |
| backend_mode="real-smina", |
| score_source="smina_error", |
| raw_output_file=str(out_pose), |
| parsed_from="exception", |
| fallback_used=False, |
| success=False, |
| message=f"smina_exception:{exc}", |
| command=" ".join(cmd), |
| extra={"pocket_spec": pocket.to_dict(), "pose_distance_to_pocket_center": float("nan"), "pose_in_fixed_pocket": False}, |
| ) |
| text = "\n".join([res.stdout or "", res.stderr or ""]) |
| if out_pose.exists(): |
| text = f"{text}\n{out_pose.read_text(encoding='utf-8', errors='ignore')}" |
| score = parse_smina_score(text) |
| centroid = centroid_from_pdbqt(out_pose) if out_pose.exists() else np.asarray([np.nan, np.nan, np.nan], dtype=float) |
| distance = pose_distance_to_center(centroid, pocket) |
| inside = is_pose_in_pocket(centroid, pocket) |
| success = bool(res.returncode == 0 and out_pose.exists() and np.isfinite(score)) |
| parsed_from = "stdout+stderr+pose::minimizedAffinity_or_vina_result_or_table" |
| return DockingResult( |
| ligand_id=lid, |
| docking_score=float(score) if np.isfinite(score) else float("nan"), |
| pose_path=out_pose if out_pose.exists() else None, |
| backend_name="smina", |
| backend_mode="real-smina", |
| score_source="smina_affinity", |
| raw_output_file=str(out_pose), |
| parsed_from=parsed_from, |
| fallback_used=False, |
| success=success, |
| message="" if success else f"smina_rc={res.returncode}", |
| command=" ".join(cmd), |
| extra={ |
| "pocket_spec": pocket.to_dict(), |
| "pose_distance_to_pocket_center": distance, |
| "pose_in_fixed_pocket": inside, |
| }, |
| ) |
|
|
| jobs = max(1, int(self.config.parallel_jobs)) |
| if jobs <= 1 or len(ligand_files) <= 1: |
| for lig in ligand_files: |
| results.append(_dock_single(lig)) |
| else: |
| with ThreadPoolExecutor(max_workers=min(jobs, len(ligand_files))) as ex: |
| for res in ex.map(_dock_single, ligand_files): |
| results.append(res) |
| return results |
|
|
| def parse_results(self, results: Sequence[DockingResult]) -> list[dict[str, Any]]: |
| rows: list[dict[str, Any]] = [] |
| for r in results: |
| rows.append( |
| { |
| "ligand_id": r.ligand_id, |
| "docking_score": float(r.docking_score), |
| "backend_name": r.backend_name, |
| "backend_mode": r.backend_mode, |
| "score_source": r.score_source, |
| "raw_output_file": r.raw_output_file, |
| "parsed_from": r.parsed_from, |
| "fallback_used": bool(r.fallback_used), |
| "success": bool(r.success), |
| "message": r.message, |
| "command": r.command, |
| "pose_distance_to_pocket_center": float((r.extra or {}).get("pose_distance_to_pocket_center", np.nan)), |
| "pose_in_fixed_pocket": bool((r.extra or {}).get("pose_in_fixed_pocket", False)), |
| "quantity_type": "docking_score", |
| } |
| ) |
| return rows |
|
|
| def extract_interface_features(self, parsed_results: Sequence[dict[str, Any]]) -> list[dict[str, float]]: |
| _ = parsed_results |
| return [] |
|
|
