File size: 7,164 Bytes
504d922 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 | 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 # noqa: F401
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: # pragma: no cover
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)
|