docking_pipeline/sdf.py

from __future__ import annotations

import csv
import math
import re
from dataclasses import dataclass
from pathlib import Path
from typing import Any, Iterable

from .provenance import RDockPipelineError, require_file

TAG_RE = re.compile(r"^>\s*<\s*([^>]+?)\s*>", flags=re.IGNORECASE)


@dataclass(frozen=True)
class SDFRecord:
    block: str
    index: int
    ligand_id: str
    score: float | None
    tags: dict[str, str]
    numeric_tags: dict[str, float]


def split_sdf_text(text: str) -> list[str]:
    blocks: list[str] = []
    for part in text.split("$$$$"):
        body = part.strip()
        if body:
            blocks.append(body + "\n$$$$\n")
    return blocks


def split_sdf_file(path: str | Path) -> list[str]:
    source = require_file(path, "SDF file")
    blocks = split_sdf_text(source.read_text(encoding="utf-8", errors="ignore"))
    if not blocks:
        raise RDockPipelineError(f"No SDF records found in {source}")
    return blocks


def parse_tags(block: str) -> dict[str, str]:
    lines = block.splitlines()
    tags: dict[str, str] = {}
    i = 0
    while i < len(lines):
        m = TAG_RE.match(lines[i].strip())
        if not m:
            i += 1
            continue
        key = m.group(1).strip()
        values: list[str] = []
        j = i + 1
        while j < len(lines) and lines[j].strip() and lines[j].strip() != "$$$$" and not TAG_RE.match(lines[j].strip()):
            values.append(lines[j].strip())
            j += 1
        tags[key] = "\n".join(values).strip()
        i = j
    return tags


def _safe_float(value: Any) -> float | None:
    try:
        out = float(str(value).strip())
    except Exception:
        return None
    if not math.isfinite(out):
        return None
    return out


def _record_name(block: str, fallback: str) -> str:
    first = block.splitlines()[0].strip() if block.splitlines() else ""
    return first or fallback


def ligand_id_from_block(block: str, tags: dict[str, str], index: int) -> str:
    for key in ("ligand_id", "LigandID", "LIGAND_ID", "ID", "Name", "_Name"):
        value = tags.get(key)
        if value:
            return value.split()[0].strip()
    return _record_name(block, f"ligand_{index:06d}").split()[0].strip()


def parse_rdock_sdf_records(path: str | Path, require_score: bool = True) -> list[SDFRecord]:
    records: list[SDFRecord] = []
    for idx, block in enumerate(split_sdf_file(path)):
        tags = parse_tags(block)
        numeric = {k: v for k, raw in tags.items() if (v := _safe_float(raw)) is not None}
        score = numeric.get("SCORE")
        if require_score and score is None:
            raise RDockPipelineError(f"Missing required rDock SCORE field in SDF record {idx} of {path}")
        records.append(
            SDFRecord(
                block=block,
                index=idx,
                ligand_id=ligand_id_from_block(block, tags, idx),
                score=score,
                tags=tags,
                numeric_tags=numeric,
            )
        )
    return records


def write_sdf_records(records: Iterable[SDFRecord], path: str | Path) -> Path:
    target = Path(path)
    target.parent.mkdir(parents=True, exist_ok=True)
    target.write_text("".join(rec.block for rec in records), encoding="utf-8")
    return target


def write_sdf_blocks(blocks: Iterable[str], path: str | Path) -> Path:
    target = Path(path)
    target.parent.mkdir(parents=True, exist_ok=True)
    target.write_text("".join(blocks), encoding="utf-8")
    return target


def best_per_ligand(records: Iterable[SDFRecord]) -> list[SDFRecord]:
    best: dict[str, SDFRecord] = {}
    for rec in records:
        if rec.score is None:
            raise RDockPipelineError(f"Cannot rank ligand {rec.ligand_id}: missing SCORE")
        prev = best.get(rec.ligand_id)
        if prev is None or float(rec.score) < float(prev.score):
            best[rec.ligand_id] = rec
    return sorted(best.values(), key=lambda r: (float(r.score), r.ligand_id, r.index))


def records_to_rows(records: Iterable[SDFRecord]) -> list[dict[str, object]]:
    rows: list[dict[str, object]] = []
    for rec in records:
        row: dict[str, object] = {
            "pose_index": rec.index,
            "ligand_id": rec.ligand_id,
            "SCORE": rec.score,
        }
        for key, value in sorted(rec.numeric_tags.items()):
            row[key] = value
        rows.append(row)
    return rows


def write_rows_csv(rows: list[dict[str, object]], path: str | Path, fieldnames: list[str] | None = None) -> Path:
    target = Path(path)
    target.parent.mkdir(parents=True, exist_ok=True)
    fields: list[str] = list(fieldnames or [])
    if not fields:
        for row in rows:
            for key in row:
                if key not in fields:
                    fields.append(key)
    with target.open("w", encoding="utf-8", newline="") as handle:
        writer = csv.DictWriter(handle, fieldnames=fields, extrasaction="ignore")
        writer.writeheader()
        writer.writerows(rows)
    return target