Reset repository and upload final project (part 30)

.gitattributes

@@ -208,3 +208,9 @@ data/datasets/rdock_3PTB_50k_pubchem_local/ligands/all_ligands.sdf filter=lfs di
 data/datasets/rdock_3PTB_50k_pubchem_local/ligands/ligand_metadata.csv filter=lfs diff=lfs merge=lfs -text
 data/datasets/rdock_3PTB_50k_pubchem_local/target/rdock_prm/receptor.as filter=lfs diff=lfs merge=lfs -text
 dist/portable_rdock_pipeline-0.1.0-py3-none-any.whl filter=lfs diff=lfs merge=lfs -text
+portable_rdock_pipeline/data/examples/rdock_3ptb_pubchem_50k_collect_only/ligands/ligand_metadata.csv filter=lfs diff=lfs merge=lfs -text
+results/benchmark_fixes/reference_ligand_baseline/target/receptor.as filter=lfs diff=lfs merge=lfs -text
+results/benchmark_fixes/reference_sample/full_docking/poses/all_poses.sdf filter=lfs diff=lfs merge=lfs -text
+results/benchmark_fixes/reference_sample/full_docking/target/receptor.as filter=lfs diff=lfs merge=lfs -text
+results/benchmark_fixes/reference_sample/ligands/all_ligands.sdf filter=lfs diff=lfs merge=lfs -text
+results/benchmark_fixes/reference_sample/target/rdock_prm/receptor.as filter=lfs diff=lfs merge=lfs -text

libs/docking/__init__.py

@@ -1,7 +1,6 @@
 """Docking backend abstractions and backend adapters."""
 
 from .backend_rdock import RDockBackend
-from .backend_smina import SminaBackend
 from .base import BackendCapability, DockingBackend, DockingError, DockingResult
 from .comparison import build_backend_comparison_table, semantic_compatibility_notes, summarize_backend_table
 from .pocket import (
@@ -17,7 +16,6 @@ __all__ = [
     "DockingError",
     "DockingResult",
     "RDockBackend",
-    "SminaBackend",
     "PocketSpec",
     "POCKET_MODE_USER_FIXED",
     "POCKET_MODE_REFERENCE",

libs/docking/backend_rdock.py

@@ -2,7 +2,9 @@ from __future__ import annotations
 
 import json
 import os
+import re
 import shutil
+import subprocess
 import threading
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
@@ -32,6 +34,7 @@ from .pocket import (
 )
 from .pose_parsing import parse_rdock_sdf
 from .prep import prepare_ligand_sdf
+from .plip_interactions import analyze_pose_with_plip, plip_import_available
 
 
 @dataclass
@@ -47,6 +50,12 @@ class RDockConfig:
     mapper_radius: float = 6.0
     command_timeout_seconds: int = 180
     parallel_jobs: int = 1
+    auto_batch_memory: bool = True
+    memory_safety_fraction: float = 0.85
+    min_memory_per_job_mb: int = 256
+    memory_probe_ligands: int = 2
+    enable_plip_interactions: bool = True
+    plip_timeout_seconds: int = 120
     allow_partial_failures: bool = False
     pocket_mode: str = POCKET_MODE_REFERENCE
     pocket_center: tuple[float, float, float] | str | list[float] | None = None
@@ -143,6 +152,143 @@ class RDockBackend(DockingBackend):
         ]
         return any(marker in text for marker in known_error_markers)
 
+    @staticmethod
+    def _available_memory_bytes() -> int | None:
+        try:
+            pages = os.sysconf("SC_AVPHYS_PAGES")
+            page_size = os.sysconf("SC_PAGE_SIZE")
+            value = int(pages) * int(page_size)
+            return value if value > 0 else None
+        except Exception:
+            pass
+        try:
+            proc = subprocess.run(["vm_stat"], check=False, capture_output=True, text=True, timeout=5)
+            if proc.returncode != 0:
+                return None
+            page_size = 4096
+            first = proc.stdout.splitlines()[0] if proc.stdout.splitlines() else ""
+            match = re.search(r"page size of (\d+) bytes", first)
+            if match:
+                page_size = int(match.group(1))
+            page_counts: dict[str, int] = {}
+            for line in proc.stdout.splitlines()[1:]:
+                if ":" not in line:
+                    continue
+                key, value = line.split(":", 1)
+                text = value.strip().rstrip(".").replace(",", "")
+                try:
+                    page_counts[key.strip()] = int(text)
+                except Exception:
+                    continue
+            available_pages = (
+                page_counts.get("Pages free", 0)
+                + page_counts.get("Pages inactive", 0)
+                + page_counts.get("Pages speculative", 0)
+                + page_counts.get("File-backed pages", 0)
+            )
+            value = int(available_pages) * int(page_size)
+            return value if value > 0 else None
+        except Exception:
+            return None
+
+    @staticmethod
+    def _cavity_volume_from_text(text: str) -> float | None:
+        for pattern in (r"total\s+volume\s*[:=]?\s*([0-9]+(?:\.[0-9]+)?)", r"volume\s*[:=]\s*([0-9]+(?:\.[0-9]+)?)"):
+            match = re.search(pattern, text, flags=re.IGNORECASE)
+            if match:
+                try:
+                    return float(match.group(1))
+                except Exception:
+                    return None
+        return None
+
+    def _cavity_artifact_usable(self, cavity_file: Path, log_path: Path | None = None) -> bool:
+        if not cavity_file.exists() or cavity_file.stat().st_size <= 0:
+            return False
+        if log_path is not None and log_path.exists():
+            volume = self._cavity_volume_from_text(log_path.read_text(encoding="utf-8", errors="ignore"))
+            if volume is not None and volume <= 0.0:
+                return False
+        return True
+
+    def _estimate_memory_bytes_per_job(self, ligand_files: Sequence[Path]) -> int:
+        sample_n = max(1, int(self.config.memory_probe_ligands))
+        sample = list(ligand_files[:sample_n])
+        sizes = [path.stat().st_size for path in sample if path.exists()]
+        avg_size = float(sum(sizes) / len(sizes)) if sizes else 0.0
+        static_estimate = int(avg_size * 80.0 * max(1, int(self.config.n_runs)))
+        floor_estimate = int(max(1, int(self.config.min_memory_per_job_mb)) * 1024 * 1024)
+        return max(static_estimate, floor_estimate)
+
+    def _resolve_memory_limited_jobs(self, ligand_files: Sequence[Path], work_dir: Path) -> int:
+        configured_jobs = max(1, int(self.config.parallel_jobs))
+        requested_jobs = min(configured_jobs, max(1, len(ligand_files)))
+        available = self._available_memory_bytes()
+        per_job = self._estimate_memory_bytes_per_job(ligand_files)
+        memory_jobs = requested_jobs
+        if self.config.auto_batch_memory and available is not None and per_job > 0:
+            usable = max(1, int(float(available) * max(0.1, min(1.0, float(self.config.memory_safety_fraction)))))
+            memory_jobs = max(1, usable // per_job)
+        resolved = max(1, min(requested_jobs, memory_jobs))
+        plan = {
+            "parallel_jobs_configured": configured_jobs,
+            "parallel_jobs_requested_for_batch": requested_jobs,
+            "parallel_jobs_resolved": resolved,
+            "ligand_count": len(ligand_files),
+            "sampled_ligand_count": min(len(ligand_files), max(1, int(self.config.memory_probe_ligands))),
+            "available_memory_bytes": available,
+            "estimated_memory_bytes_per_job": per_job,
+            "memory_safety_fraction": float(self.config.memory_safety_fraction),
+            "auto_batch_memory": bool(self.config.auto_batch_memory),
+            "batching_policy": "memory_limited_parallel_jobs",
+        }
+        (work_dir / "memory_batch_plan.json").write_text(json.dumps(plan, indent=2), encoding="utf-8")
+        return resolved
+
+    @staticmethod
+    def _post_docking_confidence(extra: dict[str, object], score: float, success: bool) -> float:
+        if not success or not np.isfinite(score):
+            return 0.0
+        native = dict(extra.get("rdock_native", {}))
+        pose_count = float(native.get("n_generated_poses", extra.get("pose_count", 0)) or 0)
+        std_top5 = native.get("std_top5_pose_score", np.nan)
+        gap = native.get("pose_score_gap_1_2", np.nan)
+        pose_inside = bool(extra.get("pose_in_fixed_pocket", False))
+        pose_term = min(1.0, pose_count / 5.0)
+        variance_term = 0.5
+        try:
+            std_value = abs(float(std_top5))
+            if np.isfinite(std_value):
+                variance_term = 1.0 / (1.0 + std_value)
+        except Exception:
+            pass
+        gap_term = 0.5
+        try:
+            gap_value = abs(float(gap))
+            if np.isfinite(gap_value):
+                gap_term = min(1.0, gap_value / 2.0)
+        except Exception:
+            pass
+        pocket_term = 1.0 if pose_inside else 0.25
+        return float(max(0.0, min(1.0, 0.25 * pose_term + 0.25 * variance_term + 0.20 * gap_term + 0.30 * pocket_term)))
+
+    @staticmethod
+    def _biological_interaction_proxy(native: dict[str, object], derived: dict[str, object], pose_inside: bool) -> float:
+        def _finite(value: object, default: float = 0.0) -> float:
+            try:
+                out = float(value)
+            except Exception:
+                return default
+            return out if np.isfinite(out) else default
+
+        polar = abs(_finite(native.get("rdock_polar_term"), 0.0))
+        vdw = abs(_finite(native.get("rdock_vdw_term"), 0.0))
+        overlap = max(0.0, min(1.0, _finite(derived.get("contact_overlap_consistency"), 0.0)))
+        hotspot = max(0.0, min(1.0, _finite(derived.get("hotspot_contact_frequency"), 0.0)))
+        energetic = max(0.0, min(1.0, (0.04 * polar) + (0.01 * vdw)))
+        pocket_bonus = 0.15 if pose_inside else 0.0
+        return float(max(0.0, min(1.0, 0.45 * energetic + 0.20 * overlap + 0.20 * hotspot + pocket_bonus)))
+
     def check_capability(self) -> BackendCapability:
         bins = {
             "rbdock": shutil.which(self.config.rbdock_bin),
@@ -215,12 +361,35 @@ class RDockBackend(DockingBackend):
             pocket.radius,
         )
 
-        return {
+        plip_receptor_pdb: Path | None = wd / "receptor_plip.pdb"
+        if suffix == ".pdb":
+            plip_receptor_pdb.write_bytes(prepared.read_bytes())
+        else:
+            obabel = shutil.which("obabel")
+            if obabel is not None:
+                try:
+                    result = run_command([obabel, str(receptor_mol2), "-O", str(plip_receptor_pdb)], cwd=wd, timeout=120)
+                    self._record_command(
+                        stage="prepare_target_plip_pdb",
+                        result=result,
+                        cwd=wd,
+                        stdout_log=wd / "prepare_target_plip_pdb.stdout.log",
+                        stderr_log=wd / "prepare_target_plip_pdb.stderr.log",
+                    )
+                    if result.returncode != 0 or not plip_receptor_pdb.exists() or plip_receptor_pdb.stat().st_size == 0:
+                        plip_receptor_pdb = prepared if prepared.suffix.lower() == ".pdb" else None
+                except Exception:
+                    plip_receptor_pdb = prepared if prepared.suffix.lower() == ".pdb" else None
+
+        context = {
             "target_prepared": prepared,
             "receptor_mol2": receptor_mol2,
             "target_work_dir": wd,
             "pocket_spec_json": wd / "pocket_spec.json",
         }
+        if plip_receptor_pdb is not None:
+            context["plip_receptor_pdb"] = plip_receptor_pdb
+        return context
 
     def prepare_ligand(self, ligand_id: str, smiles: str, work_dir: str | Path) -> Path:
         wd = Path(work_dir)
@@ -331,7 +500,7 @@ class RDockBackend(DockingBackend):
             and cached_cavity is not None
             and cached_prm.exists()
             and cached_cavity.exists()
-            and cached_cavity.stat().st_size > 0
+            and self._cavity_artifact_usable(cached_cavity, site_dir / "rbcavity.stdout.log")
         ):
             prm_file = cached_prm
             cavity_file = cached_cavity
@@ -354,7 +523,7 @@ class RDockBackend(DockingBackend):
             )
 
             cavity_file = site_dir / f"{prm_file.stem}.as"
-            cavity_ok = cavity_file.exists() and cavity_file.stat().st_size > 0
+            cavity_ok = self._cavity_artifact_usable(cavity_file, site_dir / "rbcavity.stdout.log")
             if self._indicates_failure(cavity) or not cavity_ok:
                 msg = (
                     "rbcavity failed or did not produce cavity file. "
@@ -432,6 +601,53 @@ class RDockBackend(DockingBackend):
             pose_centroid = centroid_from_sdf(pose_file)
             pocket_distance = pose_distance_to_center(pose_centroid, pocket_spec) if pocket_spec is not None else float("nan")
             pose_inside = is_pose_in_pocket(pose_centroid, pocket_spec) if pocket_spec is not None else False
+            native_features = dict(parsed.get("native_features", {}))
+            derived_features = dict(parsed.get("derived_features", {}))
+            fallback_interaction_proxy = self._biological_interaction_proxy(native_features, derived_features, pose_inside)
+            plip_summary = None
+            plip_receptor = target_context.get("plip_receptor_pdb")
+            if (
+                self.config.enable_plip_interactions
+                and plip_receptor is not None
+                and Path(plip_receptor).exists()
+                and plip_import_available()
+            ):
+                plip_summary = analyze_pose_with_plip(
+                    receptor_pdb=Path(plip_receptor),
+                    pose_sdf=pose_file,
+                    ligand_id=ligand_id,
+                    work_dir=wd / "plip",
+                    timeout_seconds=int(self.config.plip_timeout_seconds),
+                )
+            plip_payload = plip_summary.to_dict() if plip_summary is not None else {
+                "available": plip_import_available(),
+                "success": False,
+                "source": "plip",
+                "interaction_score": 0.0,
+                "interaction_count": 0,
+                "message": "PLIP disabled or receptor PDB unavailable",
+            }
+            interaction_score = (
+                float(plip_payload.get("interaction_score", 0.0))
+                if bool(plip_payload.get("success", False))
+                else fallback_interaction_proxy
+            )
+            interaction_source = "plip" if bool(plip_payload.get("success", False)) else "rdock_energy_pose_proxy"
+            extra = {
+                "all_scores": parsed.get("all_scores", []),
+                "pose_count": parsed.get("pose_count"),
+                "rdock_native": native_features,
+                "rdock_derived": derived_features,
+                "rdock_feature_provenance": parsed.get("feature_provenance", []),
+                "pocket_spec": pocket_spec.to_dict() if pocket_spec is not None else {},
+                "pose_centroid": pose_centroid.tolist() if pose_centroid.size == 3 and np.isfinite(pose_centroid).all() else [],
+                "pose_distance_to_pocket_center": pocket_distance,
+                "pose_in_fixed_pocket": pose_inside,
+                "plip_interactions": plip_payload,
+                "biological_interaction_proxy_score": interaction_score,
+                "biological_interaction_source": interaction_source,
+            }
+            extra["post_docking_confidence_score"] = self._post_docking_confidence(extra, float(parsed["score"]), True)
 
             return DockingResult(
                 ligand_id=ligand_id,
@@ -445,21 +661,11 @@ class RDockBackend(DockingBackend):
                 fallback_used=False,
                 success=True,
                 command=" ".join(cmd),
-                extra={
-                    "all_scores": parsed.get("all_scores", []),
-                    "pose_count": parsed.get("pose_count"),
-                    "rdock_native": parsed.get("native_features", {}),
-                    "rdock_derived": parsed.get("derived_features", {}),
-                    "rdock_feature_provenance": parsed.get("feature_provenance", []),
-                    "pocket_spec": pocket_spec.to_dict() if pocket_spec is not None else {},
-                    "pose_centroid": pose_centroid.tolist() if pose_centroid.size == 3 and np.isfinite(pose_centroid).all() else [],
-                    "pose_distance_to_pocket_center": pocket_distance,
-                    "pose_in_fixed_pocket": pose_inside,
-                },
+                extra=extra,
             )
 
         results: list[DockingResult] = []
-        jobs = max(1, int(self.config.parallel_jobs))
+        jobs = self._resolve_memory_limited_jobs(ligand_files, wd)
         if jobs <= 1 or len(ligand_files) <= 1:
             for ligand_file in ligand_files:
                 results.append(_dock_single(ligand_file))
@@ -479,6 +685,10 @@ class RDockBackend(DockingBackend):
             pocket = dict((result.extra or {}).get("pocket_spec", {}))
             center = pocket.get("center", [nan, nan, nan])
             box = pocket.get("box_size", [nan, nan, nan])
+            confidence = float((result.extra or {}).get("post_docking_confidence_score", 0.0))
+            interaction_proxy = float((result.extra or {}).get("biological_interaction_proxy_score", 0.0))
+            interaction_weighted_score = float(result.docking_score) - (0.5 * interaction_proxy) if result.success else nan
+            plip_payload = dict((result.extra or {}).get("plip_interactions", {}))
             parsed.append(
                 {
                     "ligand_id": result.ligand_id,
@@ -525,6 +735,23 @@ class RDockBackend(DockingBackend):
                     "pocket_box_size_z": float(box[2]) if isinstance(box, (list, tuple)) and len(box) == 3 else nan,
                     "pose_distance_to_pocket_center": float((result.extra or {}).get("pose_distance_to_pocket_center", nan)),
                     "pose_in_fixed_pocket": bool((result.extra or {}).get("pose_in_fixed_pocket", False)),
+                    "post_docking_confidence_score": confidence,
+                    "biological_interaction_proxy_score": interaction_proxy,
+                    "interaction_weighted_docking_score": interaction_weighted_score,
+                    "interaction_filter_pass": bool(interaction_proxy > 0.0),
+                    "interaction_feature_source": str((result.extra or {}).get("biological_interaction_source", "")),
+                    "plip_available": bool(plip_payload.get("available", False)),
+                    "plip_success": bool(plip_payload.get("success", False)),
+                    "plip_interaction_count": int(plip_payload.get("interaction_count", 0) or 0),
+                    "plip_hydrophobic_count": int(plip_payload.get("hydrophobic_count", 0) or 0),
+                    "plip_hbond_count": int(plip_payload.get("hbond_count", 0) or 0),
+                    "plip_saltbridge_count": int(plip_payload.get("saltbridge_count", 0) or 0),
+                    "plip_pistacking_count": int(plip_payload.get("pistacking_count", 0) or 0),
+                    "plip_pication_count": int(plip_payload.get("pication_count", 0) or 0),
+                    "plip_halogen_count": int(plip_payload.get("halogen_count", 0) or 0),
+                    "plip_waterbridge_count": int(plip_payload.get("waterbridge_count", 0) or 0),
+                    "plip_metal_count": int(plip_payload.get("metal_count", 0) or 0),
+                    "plip_message": str(plip_payload.get("message", "")),
                 }
             )
         return parsed

libs/docking/plip_interactions.py

@@ -0,0 +1,194 @@
+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)