mdprep 0.2.0__py3-none-any.whl

mdprep/structure/selectors.py

@@ -0,0 +1,204 @@
+"""Residue and atom selector parsing and resolution."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import re
+from typing import Any
+
+from mdprep.structure.models import AtomRecord, PdbStructure, ResidueRecord
+
+
+class SelectorError(ValueError):
+    """Raised when a selector cannot be resolved exactly."""
+
+
+@dataclass(frozen=True)
+class ResidueSelector:
+    chain_id: str | None
+    resid: int | None
+    resname: str | None = None
+    icode: str | None = None
+
+    def display(self) -> str:
+        chain = "*" if self.chain_id is None else self.chain_id
+        residue_number = "*" if self.resid is None else str(self.resid)
+        residue = f"{self.resname or ''}{residue_number}{self.icode or ''}"
+        return f"{chain}:{residue}"
+
+
+@dataclass(frozen=True)
+class AtomSelector:
+    residue: ResidueSelector
+    atom_name: str
+
+    def display(self) -> str:
+        return f"{self.residue.display()}@{self.atom_name}"
+
+
+_RESID_ONLY_BODY_RE = re.compile(r"^(?P<resid>-?\d+)(?P<icode>[A-Za-z]?)$")
+_RESNAME_RESID_BODY_RE = re.compile(r"^(?P<resname>[A-Za-z0-9]{1,3})(?P<resid>-?\d+)(?P<icode>[A-Za-z]?)$")
+
+
+def parse_residue_selector(text: str) -> ResidueSelector:
+    if ":" not in text:
+        raise SelectorError(f"Residue selector {text!r} must contain ':'")
+    if "@" in text:
+        raise SelectorError(f"Residue selector {text!r} must not contain '@'")
+    chain_id, body = text.split(":", 1)
+    if not body:
+        raise SelectorError(f"Residue selector {text!r} is missing a residue number")
+    stripped_body = body.strip()
+    match = _RESID_ONLY_BODY_RE.match(stripped_body)
+    if match is None:
+        match = _RESNAME_RESID_BODY_RE.match(stripped_body)
+    if match is None:
+        raise SelectorError(f"Could not parse residue selector {text!r}")
+    resname = match.groupdict().get("resname")
+    return ResidueSelector(
+        chain_id=chain_id,
+        resname=resname,
+        resid=int(match.group("resid")),
+        icode=match.group("icode") or None,
+    )
+
+
+def parse_atom_selector(text: str) -> AtomSelector:
+    if "@" not in text:
+        raise SelectorError(f"Atom selector {text!r} must contain '@'")
+    residue_text, atom_name = text.split("@", 1)
+    atom_name = atom_name.strip()
+    if not atom_name:
+        raise SelectorError(f"Atom selector {text!r} is missing an atom name")
+    return AtomSelector(residue=parse_residue_selector(residue_text), atom_name=atom_name)
+
+
+def resolve_all_residue_selector(
+    structure: PdbStructure,
+    selector: ResidueSelector | dict[str, Any] | str,
+) -> list[ResidueRecord]:
+    resolved_selector = coerce_residue_selector(selector)
+    matches = [
+        residue
+        for residue in structure.residues
+        if _matches_residue_selector(residue, resolved_selector)
+    ]
+    if not matches:
+        nearby = _nearby_residues(structure, resolved_selector)
+        suffix = f" Nearby residues: {', '.join(_format_residue(residue) for residue in nearby)}" if nearby else ""
+        raise SelectorError(f"No residue matched selector {resolved_selector.display()}.{suffix}")
+    return matches
+
+
+def resolve_residue_selector(
+    structure: PdbStructure,
+    selector: ResidueSelector | dict[str, Any] | str,
+) -> ResidueRecord:
+    resolved_selector = coerce_residue_selector(selector)
+    matches = resolve_all_residue_selector(structure, resolved_selector)
+    if len(matches) > 1:
+        formatted = ", ".join(_format_residue(residue) for residue in matches)
+        raise SelectorError(
+            f"Selector {resolved_selector.display()} matched {len(matches)} residues: {formatted}"
+        )
+    return matches[0]
+
+
+def resolve_atom_selector(
+    structure: PdbStructure,
+    selector: AtomSelector | dict[str, Any] | str,
+) -> AtomRecord:
+    resolved_selector = coerce_atom_selector(selector)
+    residue = resolve_residue_selector(structure, resolved_selector.residue)
+    matches = [atom for atom in residue.atoms if atom.name == resolved_selector.atom_name]
+    if not matches:
+        available = ", ".join(residue.atom_names())
+        raise SelectorError(
+            f"No atom matched selector {resolved_selector.display()}. Available atoms: {available}"
+        )
+    if len(matches) > 1:
+        raise SelectorError(f"Selector {resolved_selector.display()} matched {len(matches)} atoms")
+    return matches[0]
+
+
+def coerce_residue_selector(selector: ResidueSelector | dict[str, Any] | str) -> ResidueSelector:
+    if isinstance(selector, ResidueSelector):
+        return selector
+    if isinstance(selector, str):
+        return parse_residue_selector(selector)
+    if isinstance(selector, dict):
+        chain_value = selector.get("chain_id", selector.get("chain"))
+        if chain_value is not None:
+            chain_value = str(chain_value)
+        has_resid = "resid" in selector and selector.get("resid") is not None
+        resname = selector.get("resname")
+        if not has_resid and not resname:
+            raise SelectorError(f"Structured selector must include at least 'resname' or 'resid': {selector}")
+        return ResidueSelector(
+            chain_id=chain_value,
+            resname=str(resname) if resname is not None else None,
+            resid=int(selector["resid"]) if has_resid else None,
+            icode=selector.get("icode"),
+        )
+    raise SelectorError(f"Unsupported residue selector type: {type(selector).__name__}")
+
+
+def coerce_atom_selector(selector: AtomSelector | dict[str, Any] | str) -> AtomSelector:
+    if isinstance(selector, AtomSelector):
+        return selector
+    if isinstance(selector, str):
+        return parse_atom_selector(selector)
+    if isinstance(selector, dict):
+        atom_name = selector.get("atom_name", selector.get("atom"))
+        if not atom_name:
+            raise SelectorError(f"Structured atom selector is missing atom_name: {selector}")
+        residue_data = selector.get("residue", selector)
+        return AtomSelector(residue=coerce_residue_selector(residue_data), atom_name=str(atom_name).strip())
+    raise SelectorError(f"Unsupported atom selector type: {type(selector).__name__}")
+
+
+def _nearby_residues(structure: PdbStructure, selector: ResidueSelector) -> list[ResidueRecord]:
+    candidates: list[ResidueRecord] = []
+    if selector.resid is not None:
+        candidates = [
+            residue
+            for residue in structure.residues
+            if (selector.chain_id is None or residue.id.chain_id == selector.chain_id)
+            and abs(residue.id.resid - selector.resid) <= 2
+        ]
+    if not candidates and selector.resname is not None:
+        candidates = [
+            residue
+            for residue in structure.residues
+            if (selector.chain_id is None or residue.id.chain_id == selector.chain_id)
+            and residue.id.resname == selector.resname
+        ]
+    if not candidates:
+        candidates = [
+            residue
+            for residue in structure.residues
+            if selector.resid is not None and residue.id.resid == selector.resid
+        ]
+    if not candidates:
+        candidates = structure.residues
+    return candidates[:5]
+
+
+def _matches_residue_selector(residue: ResidueRecord, selector: ResidueSelector) -> bool:
+    if selector.chain_id is not None and residue.id.chain_id != selector.chain_id:
+        return False
+    if selector.resid is not None and residue.id.resid != selector.resid:
+        return False
+    if selector.resname is not None and residue.id.resname != selector.resname:
+        return False
+    if selector.icode is not None and residue.id.icode != selector.icode:
+        return False
+    if selector.resid is not None and selector.icode is None and residue.id.icode is not None:
+        return False
+    return True
+
+
+def _format_residue(residue: ResidueRecord) -> str:
+    chain = residue.id.chain_id if residue.id.chain_id else "<blank>"
+    icode = residue.id.icode or ""
+    return f"chain={chain} resname={residue.id.resname} resid={residue.id.resid}{icode}"

mdprep/structure/writer.py

@@ -0,0 +1,84 @@
+"""PDB writing helpers."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from mdprep.structure.models import AtomRecord, PdbStructure
+
+
+def write_pdb(structure: PdbStructure, path: str | Path) -> None:
+    output_path = Path(path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    lines: list[str] = []
+    previous_atom: AtomRecord | None = None
+    ter_written_after: set[int] = set()
+
+    for atom in structure.atoms:
+        if previous_atom is not None and _needs_implicit_ter(previous_atom, atom):
+            previous_serial = previous_atom.serial
+            if previous_serial is None or previous_serial not in ter_written_after:
+                lines.append("TER\n")
+        lines.append(format_atom_record(atom))
+        if atom.serial is not None and atom.serial in structure.ter_after_serials:
+            lines.append("TER\n")
+            ter_written_after.add(atom.serial)
+        previous_atom = atom
+
+    lines.extend(_format_conect_records(structure))
+    lines.append("END\n")
+    output_path.write_text("".join(lines), encoding="utf-8")
+
+
+def _needs_implicit_ter(previous: AtomRecord, current: AtomRecord) -> bool:
+    if previous.chain_id != current.chain_id:
+        return True
+    # A same-chain HETATM must not be interpreted as the next peptide residue.
+    return previous.record_name == "ATOM" and current.record_name == "HETATM"
+
+
+def _format_conect_records(structure: PdbStructure) -> list[str]:
+    serials = {atom.serial for atom in structure.atoms if atom.serial is not None}
+    neighbors: dict[int, set[int]] = {}
+    for left, right in structure.conect_bonds:
+        if left not in serials or right not in serials:
+            continue
+        neighbors.setdefault(left, set()).add(right)
+        neighbors.setdefault(right, set()).add(left)
+    lines: list[str] = []
+    for source in sorted(neighbors):
+        targets = sorted(neighbors[source])
+        for offset in range(0, len(targets), 4):
+            group = targets[offset : offset + 4]
+            lines.append(
+                "CONECT" + f"{source:5d}" + "".join(f"{target:5d}" for target in group) + "\n"
+            )
+    return lines
+
+
+def format_atom_record(atom: AtomRecord) -> str:
+    serial = atom.serial if atom.serial is not None else 0
+    atom_name = _atom_name_field(atom)
+    altloc = atom.altloc or " "
+    chain_id = atom.chain_id if atom.chain_id else " "
+    icode = atom.icode or " "
+    occupancy = atom.occupancy if atom.occupancy is not None else 1.0
+    bfactor = atom.bfactor if atom.bfactor is not None else 0.0
+    element = (atom.element or "").rjust(2)
+    return (
+        f"{atom.record_name:<6}{serial:5d} {atom_name}{altloc}{atom.resname:>3} "
+        f"{chain_id}{atom.resid:4d}{icode}   "
+        f"{atom.x:8.3f}{atom.y:8.3f}{atom.z:8.3f}"
+        f"{occupancy:6.2f}{bfactor:6.2f}          {element}\n"
+    )
+
+
+def _atom_name_field(atom: AtomRecord) -> str:
+    if len(atom.original_line) >= 16:
+        original = atom.original_line[12:16]
+        if original.strip() == atom.name:
+            return original
+    if atom.element and len(atom.element.strip()) == 1 and len(atom.name) < 4:
+        return f" {atom.name:<3}"[:4]
+    return f"{atom.name:>4}"[-4:]

mdprep/validation/__init__.py

@@ -0,0 +1,2 @@
+"""Final topology validation helpers."""
+

mdprep/validation/openmm_check.py

@@ -0,0 +1,86 @@
+"""Optional OpenMM finite-energy validation."""
+
+from __future__ import annotations
+
+from math import isfinite
+from pathlib import Path
+
+
+def openmm_available() -> bool:
+    try:
+        import openmm  # noqa: F401
+        from openmm import app  # noqa: F401
+    except Exception:
+        return False
+    return True
+
+
+def openmm_version() -> str:
+    try:
+        import openmm
+    except Exception:
+        return "not available"
+    return getattr(openmm, "__version__", "unknown")
+
+
+def run_openmm_energy_check(prmtop: str | Path, inpcrd: str | Path) -> dict[str, object]:
+    try:
+        import openmm
+        from openmm import app, unit
+    except Exception as exc:
+        return {"available": False, "status": "skipped", "warning": f"OpenMM is unavailable: {exc}"}
+    try:
+        topology = app.AmberPrmtopFile(str(prmtop))
+        coordinates = app.AmberInpcrdFile(str(inpcrd))
+        system = topology.createSystem(nonbondedMethod=app.NoCutoff, constraints=None)
+        force_classes = [force.__class__.__name__ for force in system.getForces()]
+        custom_nonbonded_expressions = [
+            force.getEnergyFunction()
+            for force in system.getForces()
+            if isinstance(force, openmm.CustomNonbondedForce)
+        ]
+        amber_12_6_4 = _prmtop_has_flag(prmtop, "LENNARD_JONES_CCOEF")
+        openmm_12_6_4 = any(
+            "r^4" in expression.replace(" ", "")
+            for expression in custom_nonbonded_expressions
+        )
+        if amber_12_6_4 and not openmm_12_6_4:
+            return {
+                "available": True,
+                "status": "error",
+                "error": (
+                    "Amber topology contains LENNARD_JONES_CCOEF, but OpenMM did not create "
+                    "a CustomNonbondedForce with the r^-4 term."
+                ),
+                "version": getattr(openmm, "__version__", "unknown"),
+                "force_classes": force_classes,
+                "custom_nonbonded_expressions": custom_nonbonded_expressions,
+                "amber_12_6_4_detected": amber_12_6_4,
+                "openmm_12_6_4_force_present": openmm_12_6_4,
+            }
+        integrator = openmm.VerletIntegrator(1.0 * unit.femtoseconds)
+        context = openmm.Context(system, integrator)
+        context.setPositions(coordinates.positions)
+        state = context.getState(getEnergy=True)
+        energy = state.getPotentialEnergy().value_in_unit(unit.kilocalories_per_mole)
+        del context
+        del integrator
+        return {
+            "available": True,
+            "status": "ok" if isfinite(energy) else "error",
+            "potential_energy_kcal_mol": energy,
+            "finite": isfinite(energy),
+            "version": getattr(openmm, "__version__", "unknown"),
+            "force_classes": force_classes,
+            "custom_nonbonded_expressions": custom_nonbonded_expressions,
+            "amber_12_6_4_detected": amber_12_6_4,
+            "openmm_12_6_4_force_present": openmm_12_6_4,
+        }
+    except Exception as exc:
+        return {"available": True, "status": "error", "error": str(exc)}
+
+
+def _prmtop_has_flag(path: str | Path, flag: str) -> bool:
+    marker = f"%FLAG {flag}"
+    with Path(path).open("r", encoding="utf-8", errors="replace") as handle:
+        return any(line.rstrip("\r\n") == marker for line in handle)

mdprep/validation/parmed_check.py

@@ -0,0 +1,43 @@
+"""Optional ParmEd validation for final Amber files."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def parmed_available() -> bool:
+    try:
+        import parmed  # noqa: F401
+    except Exception:
+        return False
+    return True
+
+
+def parmed_version() -> str:
+    try:
+        import parmed
+    except Exception:
+        return "not available"
+    return getattr(parmed, "__version__", "unknown")
+
+
+def run_parmed_check(prmtop: str | Path, inpcrd: str | Path) -> dict[str, object]:
+    try:
+        import parmed
+    except Exception as exc:
+        return {"available": False, "status": "skipped", "warning": f"ParmEd is unavailable: {exc}"}
+    try:
+        structure = parmed.load_file(str(prmtop), str(inpcrd))
+        total_charge = sum(atom.charge for atom in structure.atoms)
+        coordinates = getattr(structure, "coordinates", None)
+        return {
+            "available": True,
+            "status": "ok",
+            "atom_count": len(structure.atoms),
+            "coordinate_count": len(coordinates) if coordinates is not None else 0,
+            "total_charge": total_charge,
+            "charge_near_integer": abs(total_charge - round(total_charge)) <= 0.05,
+            "version": getattr(parmed, "__version__", "unknown"),
+        }
+    except Exception as exc:
+        return {"available": True, "status": "error", "error": str(exc)}

mdprep/validation/topology.py

@@ -0,0 +1,239 @@
+"""Final Amber output validation and reports."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from mdprep.config.models import ManifestConfig
+from mdprep.structure.classify import is_water_residue, likely_ligands_or_cofactors
+from mdprep.structure.pdb import PdbParseError, read_pdb
+from mdprep.validation.openmm_check import run_openmm_energy_check
+from mdprep.validation.parmed_check import run_parmed_check
+
+if TYPE_CHECKING:
+    from mdprep.metals.workflow import MetalStageResult
+
+
+class FinalValidationError(ValueError):
+    """Raised when final Amber outputs fail required validation."""
+
+
+def validate_final_outputs(
+    *,
+    manifest: ManifestConfig,
+    prmtop: str | Path,
+    inpcrd: str | Path,
+    pdb: str | Path,
+    metal_result: "MetalStageResult | None" = None,
+) -> dict[str, Any]:
+    warnings: list[str] = []
+    errors: list[str] = []
+    if metal_result is not None:
+        warnings.extend(metal_result.warnings)
+    paths = {
+        "prmtop": Path(prmtop),
+        "inpcrd": Path(inpcrd),
+        "pdb": Path(pdb),
+    }
+    file_checks = {}
+    for label, path in paths.items():
+        exists = path.exists()
+        size = path.stat().st_size if exists else 0
+        file_checks[label] = {"path": str(path), "exists": exists, "size_bytes": size}
+        if not exists:
+            errors.append(f"Missing final {label}: {path}")
+        elif size == 0:
+            errors.append(f"Final {label} is empty: {path}")
+
+    final_structure = None
+    if paths["pdb"].exists() and paths["pdb"].stat().st_size > 0:
+        try:
+            final_structure = read_pdb(paths["pdb"])
+        except (PdbParseError, ValueError) as exc:
+            errors.append(f"Final PDB is not parseable by mdprep: {exc}")
+
+    ligand_checks: list[dict[str, object]] = []
+    if final_structure is not None:
+        for ligand in manifest.ligands:
+            expected = ligand.selector.resname
+            accepted_resnames = {expected}
+            if metal_result is not None and metal_result.mcpb_site is not None:
+                accepted_resnames.update(
+                    str(rename["final_resname"])
+                    for rename in metal_result.mcpb_site.residue_renames
+                    if rename.get("original_resname") == expected
+                )
+            residues = [
+                residue
+                for residue in final_structure.residues
+                if residue.id.resname in accepted_resnames
+            ]
+            expected_names = _expected_ligand_atom_names(ligand.id, paths["pdb"].parent.parent)
+            atom_names_ok = bool(residues)
+            if expected_names:
+                atom_names_ok = any(residue.atom_names() == expected_names for residue in residues)
+            ok = bool(residues) and atom_names_ok
+            ligand_checks.append(
+                {
+                    "ligand_id": ligand.id,
+                    "resname": expected,
+                    "present": bool(residues),
+                    "atom_names_ok": atom_names_ok,
+                    "ok": ok,
+                }
+            )
+            if not ok:
+                errors.append(f"Configured ligand {ligand.id} ({expected}) was not preserved in final PDB.")
+
+        water_count = sum(1 for residue in final_structure.residues if is_water_residue(residue))
+        if manifest.solvation.enabled and water_count == 0:
+            errors.append("Solvation is enabled but no waters were found in final PDB.")
+        if not manifest.solvation.enabled and water_count > 0 and not manifest.structure.keep_crystal_waters:
+            errors.append("Solvation is disabled but unexpected waters were found in final PDB.")
+
+        unexpected = [
+            residue.id.to_dict()
+            for residue in likely_ligands_or_cofactors(final_structure.residues)
+            if residue.id.resname not in _allowed_final_heterogen_resnames(manifest, metal_result)
+        ]
+        if unexpected:
+            errors.append(f"Unexpected heterogen residues found in final PDB: {unexpected}")
+    else:
+        water_count = 0
+
+    parmed = run_parmed_check(paths["prmtop"], paths["inpcrd"])
+    if parmed.get("status") == "skipped":
+        warnings.append(str(parmed.get("warning")))
+    elif parmed.get("status") == "error":
+        errors.append(f"ParmEd validation failed: {parmed.get('error')}")
+    elif parmed.get("charge_near_integer") is False:
+        errors.append("ParmEd total charge is not near an integer.")
+
+    if manifest.validation.run_openmm_energy_check:
+        openmm = run_openmm_energy_check(paths["prmtop"], paths["inpcrd"])
+        if openmm.get("status") == "skipped":
+            warnings.append(str(openmm.get("warning")))
+        elif openmm.get("status") == "error":
+            warnings.append(f"OpenMM energy check failed: {openmm.get('error')}")
+        elif openmm.get("finite") is False:
+            errors.append("OpenMM potential energy is not finite.")
+    else:
+        openmm = {"available": None, "status": "disabled"}
+
+    report = {
+        "final_prmtop_path": str(paths["prmtop"]),
+        "final_inpcrd_path": str(paths["inpcrd"]),
+        "final_pdb_path": str(paths["pdb"]),
+        "file_checks": file_checks,
+        "final_atom_count": len(final_structure.atoms) if final_structure is not None else None,
+        "final_residue_count": len(final_structure.residues) if final_structure is not None else None,
+        "ligand_presence_checks": ligand_checks,
+        "water_presence": {"water_count": water_count, "solvation_enabled": manifest.solvation.enabled},
+        "parmed": parmed,
+        "openmm": openmm,
+        "warnings": warnings,
+        "errors": errors,
+    }
+    if errors:
+        raise FinalValidationError("; ".join(errors))
+    return report
+
+
+def write_validation_reports(
+    report: dict[str, Any],
+    *,
+    json_path: str | Path,
+    markdown_path: str | Path,
+) -> dict[str, Any]:
+    json_output = Path(json_path)
+    markdown_output = Path(markdown_path)
+    json_output.parent.mkdir(parents=True, exist_ok=True)
+    json_output.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    markdown_output.write_text(_render_markdown(report), encoding="utf-8")
+    return report
+
+
+def _expected_ligand_atom_names(ligand_id: str, output_dir: Path) -> list[str]:
+    identity = output_dir / "ligands" / ligand_id / "input" / "identity.json"
+    if not identity.exists():
+        return []
+    try:
+        data = json.loads(identity.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return []
+    names = data.get("atom_names", [])
+    return [str(name) for name in names] if isinstance(names, list) else []
+
+
+def _allowed_final_heterogen_resnames(
+    manifest: ManifestConfig,
+    metal_result: "MetalStageResult | None" = None,
+) -> set[str]:
+    allowed = {ligand.selector.resname for ligand in manifest.ligands}
+    allowed.update(
+        ion.selector.resname
+        for site in manifest.metals
+        for ion in site.ions
+    )
+    if metal_result is not None and metal_result.mcpb_site is not None:
+        allowed.update(
+            str(rename["final_resname"])
+            for rename in metal_result.mcpb_site.residue_renames
+        )
+    if manifest.solvation.enabled and (
+        manifest.solvation.neutralize or manifest.solvation.salt_concentration_molar > 0
+    ):
+        allowed.update(_ion_residue_name_aliases(manifest.solvation.positive_ion))
+        allowed.update(_ion_residue_name_aliases(manifest.solvation.negative_ion))
+    return allowed
+
+
+def _ion_residue_name_aliases(name: str) -> set[str]:
+    stripped = name.strip()
+    if not stripped:
+        return set()
+    no_charge = stripped.rstrip("+-")
+    aliases = {
+        stripped,
+        stripped.upper(),
+        no_charge,
+        no_charge.upper(),
+        no_charge.capitalize(),
+    }
+    if stripped.endswith("+") or stripped.endswith("-"):
+        aliases.add(no_charge.capitalize() + stripped[-1])
+        aliases.add(no_charge.upper() + stripped[-1])
+    return {alias for alias in aliases if alias}
+
+
+def _render_markdown(report: dict[str, Any]) -> str:
+    lines = [
+        "# Validation Report",
+        "",
+        f"- Final atom count: {report['final_atom_count']}",
+        f"- Final residue count: {report['final_residue_count']}",
+        f"- ParmEd status: `{report['parmed'].get('status')}`",
+        f"- OpenMM status: `{report['openmm'].get('status')}`",
+    ]
+    if report["openmm"].get("amber_12_6_4_detected"):
+        lines.append(
+            "- OpenMM 12-6-4 r^-4 force present: "
+            f"`{report['openmm'].get('openmm_12_6_4_force_present')}`"
+        )
+    lines.extend(["", "## Ligands", ""])
+    ligand_checks = report.get("ligand_presence_checks", [])
+    if ligand_checks:
+        for check in ligand_checks:
+            lines.append(f"- `{check['ligand_id']}` present={check['present']} atom_names_ok={check['atom_names_ok']}")
+    else:
+        lines.append("- None")
+    lines.extend(["", "## Warnings", ""])
+    warnings = report.get("warnings", [])
+    if warnings:
+        lines.extend(f"- {warning}" for warning in warnings)
+    else:
+        lines.append("- None")
+    lines.append("")
+    return "\n".join(lines)

mdprep/workflows/__init__.py

@@ -0,0 +1,6 @@
+"""Workflow entry points."""
+
+from __future__ import annotations
+
+__all__: list[str] = []
+