| from __future__ import annotations |
|
|
| import json |
| import shutil |
| from dataclasses import dataclass, asdict |
| from pathlib import Path |
| from subprocess import TimeoutExpired |
| from typing import Any |
|
|
| from libs.utils.subprocess_utils import run_command |
|
|
|
|
| @dataclass(frozen=True) |
| class PLIPInteractionSummary: |
| available: bool |
| success: bool |
| source: str |
| interaction_score: float |
| interaction_count: int |
| hydrophobic_count: int = 0 |
| hbond_count: int = 0 |
| saltbridge_count: int = 0 |
| pistacking_count: int = 0 |
| pication_count: int = 0 |
| halogen_count: int = 0 |
| waterbridge_count: int = 0 |
| metal_count: int = 0 |
| ligand_key: str = "" |
| complex_pdb: str = "" |
| message: str = "" |
|
|
| def to_dict(self) -> dict[str, Any]: |
| return asdict(self) |
|
|
|
|
| def plip_import_available() -> bool: |
| try: |
| from plip.structure.preparation import PDBComplex |
|
|
| return True |
| except Exception: |
| return False |
|
|
|
|
| def _failed(message: str, *, available: bool | None = None) -> PLIPInteractionSummary: |
| return PLIPInteractionSummary( |
| available=plip_import_available() if available is None else bool(available), |
| success=False, |
| source="plip", |
| interaction_score=0.0, |
| interaction_count=0, |
| message=message, |
| ) |
|
|
|
|
| def _rewrite_ligand_pdb_lines(text: str) -> list[str]: |
| out: list[str] = [] |
| atom_serial = 9000 |
| for raw in text.splitlines(): |
| if not raw.startswith(("ATOM", "HETATM")): |
| continue |
| line = raw.ljust(80) |
| atom_serial += 1 |
| rewritten = ( |
| "HETATM" |
| + f"{atom_serial:5d}" |
| + line[11:17] |
| + "LIG" |
| + " Z" |
| + f"{1:4d}" |
| + line[26:] |
| ) |
| out.append(rewritten[:80]) |
| return out |
|
|
|
|
| def _receptor_pdb_lines(receptor_pdb: Path) -> list[str]: |
| lines: list[str] = [] |
| for raw in receptor_pdb.read_text(encoding="utf-8", errors="ignore").splitlines(): |
| if raw.startswith(("ATOM", "TER")): |
| lines.append(raw[:80]) |
| return lines |
|
|
|
|
| def _pose_sdf_to_pdb(pose_sdf: Path, out_pdb: Path, *, timeout_seconds: int) -> Path: |
| obabel = shutil.which("obabel") |
| if obabel is None: |
| raise RuntimeError("obabel executable is required for PLIP ligand conversion") |
| result = run_command([obabel, str(pose_sdf), "-O", str(out_pdb), "-f", "1", "-l", "1"], cwd=out_pdb.parent, timeout=timeout_seconds) |
| if result.returncode != 0 or not out_pdb.exists() or out_pdb.stat().st_size == 0: |
| raise RuntimeError(f"obabel SDF->PDB conversion failed: rc={result.returncode}, stderr={result.stderr.strip()}") |
| return out_pdb |
|
|
|
|
| def _build_complex_pdb(receptor_pdb: Path, ligand_pdb: Path, complex_pdb: Path) -> Path: |
| receptor_lines = _receptor_pdb_lines(receptor_pdb) |
| ligand_lines = _rewrite_ligand_pdb_lines(ligand_pdb.read_text(encoding="utf-8", errors="ignore")) |
| if not receptor_lines: |
| raise RuntimeError(f"PLIP receptor PDB has no ATOM/HETATM records: {receptor_pdb}") |
| if not ligand_lines: |
| raise RuntimeError(f"PLIP ligand PDB has no atom records: {ligand_pdb}") |
| complex_pdb.write_text("\n".join(receptor_lines + ["TER"] + ligand_lines + ["END", ""]) , encoding="utf-8") |
| return complex_pdb |
|
|
|
|
| def _count_attr(interaction_set: Any, attr: str) -> int: |
| return len(getattr(interaction_set, attr, []) or []) |
|
|
|
|
| def _score_counts( |
| *, |
| hydrophobic_count: int, |
| hbond_count: int, |
| saltbridge_count: int, |
| pistacking_count: int, |
| pication_count: int, |
| halogen_count: int, |
| waterbridge_count: int, |
| metal_count: int, |
| ) -> float: |
| raw = ( |
| 0.05 * hydrophobic_count |
| + 0.14 * hbond_count |
| + 0.16 * saltbridge_count |
| + 0.12 * pistacking_count |
| + 0.12 * pication_count |
| + 0.10 * halogen_count |
| + 0.06 * waterbridge_count |
| + 0.20 * metal_count |
| ) |
| return max(0.0, min(1.0, float(raw))) |
|
|
|
|
| def analyze_pose_with_plip( |
| *, |
| receptor_pdb: Path, |
| pose_sdf: Path, |
| ligand_id: str, |
| work_dir: Path, |
| timeout_seconds: int = 120, |
| ) -> PLIPInteractionSummary: |
| if not plip_import_available(): |
| return _failed("PLIP Python package is not importable", available=False) |
| try: |
| from plip.structure.preparation import PDBComplex |
| except Exception as exc: |
| return _failed(f"PLIP import failed: {exc}", available=False) |
|
|
| try: |
| work_dir.mkdir(parents=True, exist_ok=True) |
| ligand_pdb = _pose_sdf_to_pdb(pose_sdf, work_dir / f"{ligand_id}_plip_ligand.pdb", timeout_seconds=timeout_seconds) |
| complex_pdb = _build_complex_pdb(receptor_pdb, ligand_pdb, work_dir / f"{ligand_id}_plip_complex.pdb") |
| complex_obj = PDBComplex() |
| complex_obj.load_pdb(str(complex_pdb)) |
| ligand = next((item for item in complex_obj.ligands if str(getattr(item, "hetid", "")).strip() == "LIG"), None) |
| if ligand is None and complex_obj.ligands: |
| ligand = complex_obj.ligands[0] |
| if ligand is None: |
| return _failed(f"PLIP found no ligand in generated complex {complex_pdb}", available=True) |
| complex_obj.characterize_complex(ligand) |
| interaction_set = next(iter(complex_obj.interaction_sets.values()), None) |
| if interaction_set is None: |
| return _failed(f"PLIP produced no interaction set for {ligand_id}", available=True) |
|
|
| hbond_count = _count_attr(interaction_set, "hbonds_ldon") + _count_attr(interaction_set, "hbonds_pdon") |
| saltbridge_count = _count_attr(interaction_set, "saltbridges_lneg") + _count_attr(interaction_set, "saltbridges_pneg") |
| pication_count = _count_attr(interaction_set, "pication_laro") + _count_attr(interaction_set, "pication_paro") |
| counts = { |
| "hydrophobic_count": _count_attr(interaction_set, "hydrophobic_contacts"), |
| "hbond_count": hbond_count, |
| "saltbridge_count": saltbridge_count, |
| "pistacking_count": _count_attr(interaction_set, "pistacking"), |
| "pication_count": pication_count, |
| "halogen_count": _count_attr(interaction_set, "halogen_bonds"), |
| "waterbridge_count": _count_attr(interaction_set, "water_bridges"), |
| "metal_count": _count_attr(interaction_set, "metal_complexes"), |
| } |
| interaction_count = int(sum(counts.values())) |
| summary = PLIPInteractionSummary( |
| available=True, |
| success=True, |
| source="plip", |
| interaction_score=_score_counts(**counts), |
| interaction_count=interaction_count, |
| ligand_key=str(next(iter(complex_obj.interaction_sets.keys()), "")), |
| complex_pdb=str(complex_pdb), |
| **counts, |
| ) |
| (work_dir / f"{ligand_id}_plip_summary.json").write_text(json.dumps(summary.to_dict(), indent=2), encoding="utf-8") |
| return summary |
| except TimeoutExpired as exc: |
| return _failed(f"PLIP ligand conversion timed out: {exc}", available=True) |
| except Exception as exc: |
| return _failed(f"PLIP analysis failed: {exc}", available=True) |
|
|
