| |
| """Generate ``annotated_complexes.csv`` from Fragalysis metadata and complexes.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import os |
| from concurrent.futures import ProcessPoolExecutor |
| from pathlib import Path |
|
|
| import pandas as pd |
| from posebusters import PoseBusters |
| from rdkit import Chem |
| from tqdm import tqdm |
|
|
|
|
| CODE_COL = "Code" |
| FRAGMENT_COL = "[Series] Fragment Screen" |
| ARTEFACT_COL = "[Other] Artefact" |
| OUTPUT_COLS = ["complex_name", "smiles", "fragment_screen", "pb_valid", "artefact"] |
|
|
|
|
| def as_bool(value: object) -> bool: |
| """Parse common boolean values from Fragalysis metadata.""" |
| if pd.isna(value): |
| return False |
| if isinstance(value, bool): |
| return value |
| return str(value).strip().lower() in {"true", "t", "1", "yes", "y"} |
|
|
|
|
| def read_smiles(ligand_path: Path) -> str: |
| """Return canonical isomeric SMILES from the first ligand in an SDF file.""" |
| molecules = [mol for mol in Chem.SDMolSupplier(str(ligand_path), removeHs=False)] |
| if not molecules or molecules[0] is None: |
| raise ValueError(f"Could not read ligand: {ligand_path}") |
| return Chem.MolToSmiles(molecules[0], canonical=True, isomericSmiles=True) |
|
|
|
|
| def check_posebusters(ligand_path: Path, protein_path: Path) -> bool: |
| """Return whether all PoseBusters dock-mode checks pass.""" |
| results = PoseBusters(config="dock").bust(ligand_path, None, protein_path) |
| checks = results.select_dtypes(include="bool") |
| if checks.empty: |
| raise ValueError(f"PoseBusters returned no boolean checks for {ligand_path}") |
| return bool(checks.to_numpy().all()) |
|
|
|
|
| def process_complex(task: tuple[str, str, object, object]) -> dict[str, object]: |
| """Annotate one aligned complex.""" |
| complex_name, complexes_dir, fragment_screen, artefact = task |
| complex_dir = Path(complexes_dir) / complex_name |
| ligand_path = complex_dir / f"{complex_name}_ligand.sdf" |
| protein_path = complex_dir / f"{complex_name}_delig-desolv.pdb" |
| if not ligand_path.is_file(): |
| raise FileNotFoundError(f"Missing ligand: {ligand_path}") |
| if not protein_path.is_file(): |
| raise FileNotFoundError(f"Missing protein: {protein_path}") |
|
|
| return { |
| "complex_name": complex_name, |
| "smiles": read_smiles(ligand_path), |
| "fragment_screen": as_bool(fragment_screen), |
| "pb_valid": check_posebusters(ligand_path, protein_path), |
| "artefact": as_bool(artefact), |
| } |
|
|
|
|
| def build_parser() -> argparse.ArgumentParser: |
| """Build the command-line parser.""" |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("metadata_csv", type=Path, help="Fragalysis metadata.csv file.") |
| parser.add_argument( |
| "complexes_dir", type=Path, help="Fragalysis aligned_files directory." |
| ) |
| parser.add_argument( |
| "--output", |
| type=Path, |
| default=None, |
| help="Output CSV (default: sibling annotated_complexes.csv).", |
| ) |
| parser.add_argument( |
| "--num-workers", |
| "-j", |
| type=int, |
| default=os.cpu_count() or 1, |
| help="Number of worker processes (default: available CPUs).", |
| ) |
| return parser |
|
|
|
|
| def main() -> None: |
| """Generate the standard OpenBind annotation table.""" |
| args = build_parser().parse_args() |
| metadata_path = args.metadata_csv.expanduser().resolve() |
| complexes_dir = args.complexes_dir.expanduser().resolve() |
| if not metadata_path.is_file(): |
| raise FileNotFoundError(f"Metadata CSV not found: {metadata_path}") |
| if not complexes_dir.is_dir(): |
| raise FileNotFoundError(f"Complex directory not found: {complexes_dir}") |
| if args.num_workers < 1: |
| raise ValueError("--num-workers must be at least 1") |
|
|
| metadata = pd.read_csv(metadata_path) |
| required = {CODE_COL, FRAGMENT_COL, ARTEFACT_COL} |
| missing = required - set(metadata.columns) |
| if missing: |
| raise ValueError(f"metadata.csv is missing required columns: {sorted(missing)}") |
| if metadata[CODE_COL].duplicated().any(): |
| duplicates = metadata.loc[metadata[CODE_COL].duplicated(), CODE_COL].unique() |
| raise ValueError( |
| f"Duplicate values in '{CODE_COL}': {duplicates[:10].tolist()}" |
| ) |
|
|
| metadata = metadata.copy() |
| metadata[CODE_COL] = metadata[CODE_COL].astype(str).str.strip() |
| metadata = metadata.set_index(CODE_COL) |
| complex_names = sorted( |
| path.name for path in complexes_dir.iterdir() if path.is_dir() |
| ) |
| if not complex_names: |
| raise ValueError(f"No complex directories found in: {complexes_dir}") |
|
|
| missing_metadata = [name for name in complex_names if name not in metadata.index] |
| if missing_metadata: |
| raise ValueError( |
| f"Complex directories missing from metadata.csv: {missing_metadata[:10]}" |
| ) |
|
|
| tasks = [ |
| ( |
| complex_name, |
| str(complexes_dir), |
| metadata.at[complex_name, FRAGMENT_COL], |
| metadata.at[complex_name, ARTEFACT_COL], |
| ) |
| for complex_name in complex_names |
| ] |
|
|
| with ProcessPoolExecutor(max_workers=args.num_workers) as executor: |
| rows = list( |
| tqdm( |
| executor.map(process_complex, tasks), |
| total=len(tasks), |
| desc="Annotating complexes", |
| unit="complex", |
| ) |
| ) |
|
|
| output_path = ( |
| args.output.expanduser().resolve() |
| if args.output is not None |
| else complexes_dir.parent / "annotated_complexes.csv" |
| ) |
| output_path.parent.mkdir(parents=True, exist_ok=True) |
| pd.DataFrame(rows, columns=OUTPUT_COLS).to_csv(output_path, index=False) |
| print(f"Wrote {len(rows)} complexes to {output_path}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
