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 from datetime import UTC, datetime from pathlib import Path from subprocess import TimeoutExpired from typing import Dict, Sequence import numpy as np from libs.utils.logging_utils import get_logger from libs.utils.subprocess_utils import CommandResult, run_command from .base import BackendCapability, BackendUnavailableError, DockingBackend, DockingError, DockingResult from .constraints import write_receptor_prm, write_receptor_prm_sphere from .interface_features import extract_simple_interface_features from .pocket import ( POCKET_MODE_REFERENCE, POCKET_MODE_REFERENCE_RELAXED, POCKET_MODE_USER_FIXED, PocketSpec, centroid_from_sdf, is_pose_in_pocket, pose_distance_to_center, resolve_pocket_spec, write_pocket_spec, ) 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 class RDockConfig: rbdock_bin: str = "rbdock" rbcavity_bin: str = "rbcavity" sdtether_bin: str = "sdtether" n_runs: int = 5 seed: int | None = None protocol_prm: str | None = None rbt_root: str | None = None command_log_path: str | None = None 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 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 allow_legacy_generated_pocket: bool = False class RDockBackend(DockingBackend): """rDock adapter with strict backend validation and explicit provenance.""" def __init__(self, config: RDockConfig | None = None) -> None: self.config = config or RDockConfig() self.logger = get_logger("rdock_backend") self.default_rbt_root = Path("/opt/homebrew/opt/rdock/share") self.command_history: list[dict[str, str | int]] = [] self._log_lock = threading.Lock() def _ensure_runtime_env(self) -> None: if self.config.rbt_root: os.environ["RBT_ROOT"] = self.config.rbt_root return if "RBT_ROOT" not in os.environ and self.default_rbt_root.exists(): os.environ["RBT_ROOT"] = str(self.default_rbt_root) def _resolve_protocol_prm(self) -> Path: if self.config.protocol_prm: prm = Path(self.config.protocol_prm).expanduser().resolve() if prm.exists(): return prm raise DockingError(f"Configured protocol file does not exist: {prm}") rbt_root = os.environ.get("RBT_ROOT") if not rbt_root: raise DockingError("RBT_ROOT is not set and protocol_prm is not configured") prm = Path(rbt_root) / "data" / "scripts" / "dock.prm" if not prm.exists(): raise DockingError(f"Default rDock protocol file not found: {prm}") return prm def _append_command_log(self, payload: dict[str, str | int]) -> None: with self._log_lock: self.command_history.append(payload) if self.config.command_log_path: log_path = Path(self.config.command_log_path) log_path.parent.mkdir(parents=True, exist_ok=True) line = ( f"[{payload['timestamp']}] stage={payload['stage']} rc={payload['returncode']} cwd={payload['cwd']}\n" f" command: {payload['command']}\n" f" stdout: {payload['stdout_log']}\n" f" stderr: {payload['stderr_log']}\n" ) with log_path.open("a", encoding="utf-8") as handle: handle.write(line) def _record_command( self, stage: str, result: CommandResult, cwd: Path, stdout_log: Path, stderr_log: Path, ) -> None: stdout_log.write_text(result.stdout, encoding="utf-8") stderr_log.write_text(result.stderr, encoding="utf-8") self._append_command_log( { "timestamp": datetime.now(UTC).isoformat(), "stage": stage, "command": " ".join(result.command), "cwd": str(cwd), "returncode": result.returncode, "stdout_log": str(stdout_log), "stderr_log": str(stderr_log), } ) @staticmethod def _indicates_failure(result: CommandResult) -> bool: if result.returncode != 0: return True text = f"{result.stdout}\n{result.stderr}".lower() known_error_markers = [ "rbt_file_read_error", "bad_receptor_file", "cavity file", "inappropriate molecular file type", "fatal", ] 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), "rbcavity": shutil.which(self.config.rbcavity_bin), "sdtether": shutil.which(self.config.sdtether_bin), "obabel": shutil.which("obabel"), } available = bins["rbdock"] is not None and bins["rbcavity"] is not None and bins["obabel"] is not None return BackendCapability(backend_name="rdock", available=available, details=bins) def _resolve_target_pocket(self, target_path: Path, work_dir: Path) -> PocketSpec: spec = resolve_pocket_spec( target_path=target_path, 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=self.config.mapper_radius, ) write_pocket_spec(work_dir / "pocket_spec.json", spec) return spec def prepare_target(self, target_path: str | Path, work_dir: str | Path) -> Dict[str, Path]: source = Path(target_path) if not source.exists(): raise DockingError(f"Target file does not exist: {source}") wd = Path(work_dir) wd.mkdir(parents=True, exist_ok=True) prepared = wd / f"target_prepared{source.suffix.lower()}" prepared.write_bytes(source.read_bytes()) receptor_mol2 = wd / "receptor.mol2" suffix = source.suffix.lower() if suffix == ".mol2": receptor_mol2.write_bytes(source.read_bytes()) else: obabel = shutil.which("obabel") if obabel is None: raise DockingError("Open Babel executable `obabel` is required for receptor preparation") try: result = run_command([obabel, str(prepared), "-O", str(receptor_mol2)], cwd=wd, timeout=120) except TimeoutExpired as exc: raise DockingError(f"obabel timed out while preparing receptor: {exc}") from exc self._record_command( stage="prepare_target_obabel", result=result, cwd=wd, stdout_log=wd / "prepare_target_obabel.stdout.log", stderr_log=wd / "prepare_target_obabel.stderr.log", ) if self._indicates_failure(result) or not receptor_mol2.exists() or receptor_mol2.stat().st_size == 0: raise DockingError( "Failed to produce receptor.mol2 from target structure. " f"Return code: {result.returncode}, stderr: {result.stderr.strip()}" ) pocket = self._resolve_target_pocket(source, wd) self.logger.info( "Resolved pocket mode=%s source=%s center=(%.3f, %.3f, %.3f) radius=%.3f", pocket.mode, pocket.source, pocket.center[0], pocket.center[1], pocket.center[2], pocket.radius, ) 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) wd.mkdir(parents=True, exist_ok=True) return prepare_ligand_sdf(ligand_id, smiles, wd / f"{ligand_id}.sdf") def build_site_or_constraints( self, target_context: Dict[str, Path], reference_ligand: Path, work_dir: str | Path, ) -> Path: receptor_mol2 = target_context.get("receptor_mol2") if receptor_mol2 is None or not receptor_mol2.exists(): raise DockingError("Missing receptor_mol2 in target context") wd = Path(work_dir) wd.mkdir(parents=True, exist_ok=True) prm = wd / "receptor.prm" pocket_json = target_context.get("pocket_spec_json") if pocket_json and Path(pocket_json).exists(): pocket = PocketSpec.from_dict(json.loads(Path(pocket_json).read_text(encoding="utf-8"))) write_receptor_prm_sphere( receptor_mol2=receptor_mol2, center=pocket.center, radius=pocket.radius, out_path=prm, ) return prm if not self.config.allow_legacy_generated_pocket: raise DockingError( "Missing pocket_spec_json while strict fixed-pocket mode is active. " "Provide user_fixed_pocket or reference_complex_pocket settings." ) write_receptor_prm( receptor_mol2=receptor_mol2, reference_ligand_sdf=reference_ligand, out_path=prm, radius=self.config.mapper_radius, ) return prm @staticmethod def _failed_real_result(ligand_id: str, message: str, command: Sequence[str] | None = None) -> DockingResult: return DockingResult( ligand_id=ligand_id, docking_score=float("nan"), pose_path=None, backend_name="rdock", backend_mode="real-rdock", score_source="rdock_error", raw_output_file="", parsed_from="", fallback_used=False, success=False, message=message, command=" ".join(command) if command else "", extra={}, ) 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]: self._ensure_runtime_env() capability = self.check_capability() wd = Path(work_dir) wd.mkdir(parents=True, exist_ok=True) if allow_mock: raise DockingError( "Mock rDock fallback has been removed. Install/configure rDock and OpenBabel, " "or call with allow_mock=False to receive the actionable real-backend error." ) if not capability.available: msg = f"rDock capability check failed: {capability.details}" raise BackendUnavailableError(msg) if not ligand_files: return [] pocket_spec: PocketSpec | None = None pocket_json = target_context.get("pocket_spec_json") if pocket_json is not None and Path(pocket_json).exists(): pocket_spec = PocketSpec.from_dict(json.loads(Path(pocket_json).read_text(encoding="utf-8"))) else: target_prepared = target_context.get("target_prepared") if target_prepared is not None and Path(target_prepared).exists(): resolved = self._resolve_target_pocket(Path(target_prepared), Path(target_context.get("target_work_dir", wd))) write_pocket_spec(Path(target_context.get("target_work_dir", wd)) / "pocket_spec.json", resolved) target_context["pocket_spec_json"] = Path(target_context.get("target_work_dir", wd)) / "pocket_spec.json" pocket_spec = resolved site_dir = Path(target_context.get("target_work_dir", wd)) site_dir.mkdir(parents=True, exist_ok=True) cached_prm = Path(target_context["site_prm"]) if "site_prm" in target_context else None cached_cavity = Path(target_context["site_cavity"]) if "site_cavity" in target_context else None if ( cached_prm is not None and cached_cavity is not None and cached_prm.exists() and cached_cavity.exists() and self._cavity_artifact_usable(cached_cavity, site_dir / "rbcavity.stdout.log") ): prm_file = cached_prm cavity_file = cached_cavity else: prm_file = self.build_site_or_constraints(target_context, ligand_files[0], site_dir) try: cavity = run_command( [self.config.rbcavity_bin, "-was", "-r", str(prm_file)], cwd=site_dir, timeout=self.config.command_timeout_seconds, ) except TimeoutExpired as exc: raise DockingError(f"rbcavity timed out: {exc}") from exc self._record_command( stage="rbcavity", result=cavity, cwd=site_dir, stdout_log=site_dir / "rbcavity.stdout.log", stderr_log=site_dir / "rbcavity.stderr.log", ) cavity_file = site_dir / f"{prm_file.stem}.as" 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. " f"expected={cavity_file}, rc={cavity.returncode}, stderr={cavity.stderr.strip()}" ) raise DockingError(msg) target_context["site_prm"] = prm_file target_context["site_cavity"] = cavity_file # Keep batch-local cavity artifact for compatibility with existing validation/tests. local_prm = wd / prm_file.name if prm_file.exists() and prm_file != local_prm and not local_prm.exists(): shutil.copy2(prm_file, local_prm) local_cavity = wd / cavity_file.name if cavity_file.exists() and cavity_file != local_cavity and not local_cavity.exists(): shutil.copy2(cavity_file, local_cavity) protocol_prm = self._resolve_protocol_prm() def _dock_single(ligand_file: Path) -> DockingResult: ligand_id = ligand_file.stem out_prefix = wd / f"{ligand_id}_rdock" cmd = [ self.config.rbdock_bin, "-i", str(ligand_file), "-o", str(out_prefix), "-r", str(prm_file), "-p", str(protocol_prm), "-n", str(self.config.n_runs), ] if self.config.seed is not None: cmd.extend(["-s", str(int(self.config.seed))]) try: proc = run_command(cmd, cwd=wd, timeout=self.config.command_timeout_seconds) except TimeoutExpired as exc: msg = f"rbdock timed out for {ligand_id}: {exc}" if self.config.allow_partial_failures: return self._failed_real_result(ligand_id, msg, cmd) raise DockingError(msg) from exc self._record_command( stage=f"rbdock:{ligand_id}", result=proc, cwd=wd, stdout_log=wd / f"{ligand_id}.rbdock.stdout.log", stderr_log=wd / f"{ligand_id}.rbdock.stderr.log", ) if self._indicates_failure(proc): msg = f"rbdock failed for {ligand_id}: rc={proc.returncode}, stderr={proc.stderr.strip()}" if self.config.allow_partial_failures: return self._failed_real_result(ligand_id, msg, cmd) raise DockingError(msg) pose_candidates = sorted(wd.glob(f"{ligand_id}_rdock*.sd")) if not pose_candidates: msg = f"rbdock produced no .sd output for {ligand_id} in {wd}" if self.config.allow_partial_failures: return self._failed_real_result(ligand_id, msg, cmd) raise DockingError(msg) pose_file = pose_candidates[0] try: parsed = parse_rdock_sdf(pose_file) except Exception as exc: msg = f"Failed parsing rDock output for {ligand_id}: {exc}" if self.config.allow_partial_failures: return self._failed_real_result(ligand_id, msg, cmd) raise DockingError(msg) from exc 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, docking_score=float(parsed["score"]), pose_path=pose_file, backend_name="rdock", backend_mode="real-rdock", score_source=f"rdock_tag:{parsed['score_tag']}", raw_output_file=str(pose_file), parsed_from=f"{pose_file}::{parsed['score_tag']}", fallback_used=False, success=True, command=" ".join(cmd), extra=extra, ) results: list[DockingResult] = [] 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)) 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, object]]: parsed: list[dict[str, object]] = [] nan = float("nan") for result in results: native = dict((result.extra or {}).get("rdock_native", {})) derived = dict((result.extra or {}).get("rdock_derived", {})) 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, "docking_score": float(result.docking_score), "backend_name": result.backend_name, "backend_mode": result.backend_mode, "score_source": result.score_source, "raw_output_file": result.raw_output_file, "parsed_from": result.parsed_from, "fallback_used": bool(result.fallback_used), "success": bool(result.success), "message": result.message, "pose_path": str(result.pose_path) if result.pose_path else "", "command": result.command, "quantity_type": "docking_score", "rdock_total_score": native.get("rdock_total_score", float(result.docking_score)), "rdock_pose_rank": native.get("rdock_pose_rank", 1), "n_generated_poses": native.get("n_generated_poses", (result.extra or {}).get("pose_count", 1)), "best_pose_score": native.get("best_pose_score", float(result.docking_score)), "mean_top3_pose_score": native.get("mean_top3_pose_score", float(result.docking_score)), "mean_top5_pose_score": native.get("mean_top5_pose_score", float(result.docking_score)), "std_top5_pose_score": native.get("std_top5_pose_score", nan), "pose_score_gap_1_2": native.get("pose_score_gap_1_2", nan), "rdock_restraint_term": native.get("rdock_restraint_term", nan), "rdock_internal_ligand_term": native.get("rdock_internal_ligand_term", nan), "rdock_polar_term": native.get("rdock_polar_term", nan), "rdock_vdw_term": native.get("rdock_vdw_term", nan), "top_pose_rmsd_consistency": derived.get("top_pose_rmsd_consistency", nan), "contact_overlap_consistency": derived.get("contact_overlap_consistency", nan), "hotspot_contact_frequency": derived.get("hotspot_contact_frequency", nan), "subpocket_match_score": derived.get("subpocket_match_score", nan), "replicate_mean_score": nan, "replicate_score_variance": nan, "replicate_consensus_score": nan, "rdock_feature_provenance": json.dumps((result.extra or {}).get("rdock_feature_provenance", [])), "pocket_mode": pocket.get("mode", ""), "pocket_source": pocket.get("source", ""), "pocket_center_x": float(center[0]) if isinstance(center, (list, tuple)) and len(center) == 3 else nan, "pocket_center_y": float(center[1]) if isinstance(center, (list, tuple)) and len(center) == 3 else nan, "pocket_center_z": float(center[2]) if isinstance(center, (list, tuple)) and len(center) == 3 else nan, "pocket_radius": float(pocket.get("radius", nan)), "pocket_box_size_x": float(box[0]) if isinstance(box, (list, tuple)) and len(box) == 3 else nan, "pocket_box_size_y": float(box[1]) if isinstance(box, (list, tuple)) and len(box) == 3 else nan, "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 def extract_interface_features(self, parsed_results: Sequence[dict[str, object]]) -> list[dict[str, float]]: normalized = [{"docking_score": float(row.get("docking_score", 0.0))} for row in parsed_results] return extract_simple_interface_features(normalized)