libs/docking/backend_smina.py

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 []