| from __future__ import annotations |
|
|
| from dataclasses import dataclass |
| from pathlib import Path |
| from typing import Dict, Iterable, List, Optional |
|
|
| import numpy as np |
| import pandas as pd |
| from rdkit import Chem |
| from rdkit.Chem import AllChem, Descriptors |
| from rdkit.Chem.rdFingerprintGenerator import GetMorganGenerator |
|
|
| from .graph_builders import build_ligand_graph |
| from .schemas import LigandEncoding |
|
|
|
|
| @dataclass |
| class LigandEncoderConfig: |
| radius: int = 2 |
| n_bits: int = 1024 |
| generate_3d: bool = False |
|
|
|
|
| class LigandEncoder: |
| """Encode ligands from SMILES/SDF into vectors and graph objects.""" |
|
|
| def __init__(self, config: Optional[LigandEncoderConfig] = None) -> None: |
| self.config = config or LigandEncoderConfig() |
| self._fp_gen = GetMorganGenerator(radius=self.config.radius, fpSize=self.config.n_bits) |
|
|
| def _mol_from_smiles(self, smiles: str): |
| mol = Chem.MolFromSmiles(smiles) |
| if mol is None: |
| raise ValueError(f"Invalid SMILES: {smiles}") |
| mol = Chem.AddHs(mol) |
| if self.config.generate_3d: |
| params = AllChem.ETKDGv3() |
| params.randomSeed = 42 |
| status = AllChem.EmbedMolecule(mol, params) |
| if status == 0: |
| AllChem.UFFOptimizeMolecule(mol) |
| return mol |
|
|
| def _fingerprint(self, mol) -> np.ndarray: |
| fp = self._fp_gen.GetFingerprint(mol) |
| return np.asarray(fp, dtype=float) |
|
|
| def _descriptors(self, mol) -> Dict[str, float]: |
| return { |
| "mw": float(Descriptors.MolWt(mol)), |
| "logp": float(Descriptors.MolLogP(mol)), |
| "hbd": float(Descriptors.NumHDonors(mol)), |
| "hba": float(Descriptors.NumHAcceptors(mol)), |
| "tpsa": float(Descriptors.TPSA(mol)), |
| "rot_bonds": float(Descriptors.NumRotatableBonds(mol)), |
| "ring_count": float(Descriptors.RingCount(mol)), |
| } |
|
|
| def encode_smiles(self, ligand_id: str, smiles: str) -> LigandEncoding: |
| mol = self._mol_from_smiles(smiles) |
| fp = self._fingerprint(mol) |
| desc = self._descriptors(mol) |
| graph = build_ligand_graph(mol) |
| desc_vec = np.asarray(list(desc.values()), dtype=float) |
| vector = np.concatenate([fp, desc_vec]) |
| prep = { |
| "canonical_smiles": Chem.MolToSmiles(Chem.RemoveHs(mol), canonical=True), |
| "formula": str(Descriptors.rdMolDescriptors.CalcMolFormula(mol)), |
| "mw": float(desc["mw"]), |
| } |
| return LigandEncoding( |
| ligand_id=ligand_id, |
| smiles=smiles, |
| fingerprint=fp, |
| descriptors=desc, |
| graph=graph, |
| vector=vector, |
| prep=prep, |
| ) |
|
|
| def encode_table(self, ligands: pd.DataFrame) -> List[LigandEncoding]: |
| rows = [] |
| for row in ligands.itertuples(index=False): |
| rows.append(self.encode_smiles(str(row.ligand_id), str(row.smiles))) |
| return rows |
|
|
| def encode_sdf(self, sdf_path: str | Path) -> List[LigandEncoding]: |
| suppl = Chem.SDMolSupplier(str(sdf_path), removeHs=False) |
| output: List[LigandEncoding] = [] |
| for idx, mol in enumerate(suppl): |
| if mol is None: |
| continue |
| mol_h = Chem.AddHs(Chem.RemoveHs(mol)) |
| lig_id = mol_h.GetProp("_Name") if mol_h.HasProp("_Name") else f"lig_{idx:04d}" |
| smiles = Chem.MolToSmiles(Chem.RemoveHs(mol_h), canonical=True) |
| fp = self._fingerprint(mol_h) |
| desc = self._descriptors(mol_h) |
| graph = build_ligand_graph(mol_h) |
| vector = np.concatenate([fp, np.asarray(list(desc.values()), dtype=float)]) |
| prep = { |
| "canonical_smiles": smiles, |
| "formula": str(Descriptors.rdMolDescriptors.CalcMolFormula(mol_h)), |
| "mw": float(desc["mw"]), |
| } |
| output.append( |
| LigandEncoding( |
| ligand_id=lig_id, |
| smiles=smiles, |
| fingerprint=fp, |
| descriptors=desc, |
| graph=graph, |
| vector=vector, |
| prep=prep, |
| ) |
| ) |
| return output |
|
|
