""" Core molecular editing operations using RDKit's RWMol API. Each operation takes an RWMol and parameters, returns the modified RWMol. Each has a forward (corruption) and inverse (correction) form. """ import copy from rdkit import Chem from rdkit.Chem import AllChem, rdmolops BOND_TYPE_MAP = { "SINGLE": Chem.BondType.SINGLE, "DOUBLE": Chem.BondType.DOUBLE, "TRIPLE": Chem.BondType.TRIPLE, "AROMATIC": Chem.BondType.AROMATIC, } BOND_TYPE_NAME = {v: k for k, v in BOND_TYPE_MAP.items()} ELEM_TO_NUM = { "C": 6, "N": 7, "O": 8, "S": 16, "P": 15, "F": 9, "Cl": 17, "Br": 35, "I": 53, "B": 5, "Si": 14, "Se": 34, } NUM_TO_ELEM = {v: k for k, v in ELEM_TO_NUM.items()} FUNCTIONAL_GROUPS = { "OH": "[OH]", "NH2": "[NH2]", "F": "[F]", "Cl": "[Cl]", "Br": "[Br]", "CH3": "[CH3]", "NO2": "[N+](=O)[O-]", "COOH": "C(=O)[OH]", "CHO": "[CH]=O", } def validate_mol(mol): if mol is None: return False try: Chem.SanitizeMol(mol) return True except Exception: return False def safe_apply(func): """Decorator: returns None if the operation produces an invalid molecule.""" def wrapper(mol, **kwargs): rw = copy.deepcopy(mol) try: result = func(rw, **kwargs) if result is None: return None if not validate_mol(result): return None return result except Exception: return None return wrapper # --------------------------------------------------------------------------- # 1. change_atom_element # --------------------------------------------------------------------------- @safe_apply def change_atom_element(mol, atom_idx, to_elem): atom = mol.GetAtomWithIdx(atom_idx) atom.SetAtomicNum(ELEM_TO_NUM[to_elem]) atom.SetNoImplicit(False) atom.UpdatePropertyCache(strict=False) return mol # --------------------------------------------------------------------------- # 2. add_atom — adds a new atom bonded to anchor # --------------------------------------------------------------------------- @safe_apply def add_atom(mol, anchor_idx, new_elem, bond_type="SINGLE"): new_idx = mol.AddAtom(Chem.Atom(ELEM_TO_NUM[new_elem])) mol.AddBond(anchor_idx, new_idx, BOND_TYPE_MAP[bond_type]) return mol # --------------------------------------------------------------------------- # 3. remove_atom # --------------------------------------------------------------------------- @safe_apply def remove_atom(mol, atom_idx): mol.RemoveAtom(atom_idx) return mol # --------------------------------------------------------------------------- # 4. change_charge # --------------------------------------------------------------------------- @safe_apply def change_charge(mol, atom_idx, to_charge): atom = mol.GetAtomWithIdx(atom_idx) atom.SetFormalCharge(to_charge) atom.UpdatePropertyCache(strict=False) return mol # --------------------------------------------------------------------------- # 5. change_bond_order # --------------------------------------------------------------------------- @safe_apply def change_bond_order(mol, atom_idx1, atom_idx2, to_order): bond = mol.GetBondBetweenAtoms(atom_idx1, atom_idx2) if bond is None: return None bond.SetBondType(BOND_TYPE_MAP[to_order]) return mol # --------------------------------------------------------------------------- # 6. add_bond # --------------------------------------------------------------------------- @safe_apply def add_bond(mol, atom_idx1, atom_idx2, bond_type="SINGLE"): existing = mol.GetBondBetweenAtoms(atom_idx1, atom_idx2) if existing is not None: return None mol.AddBond(atom_idx1, atom_idx2, BOND_TYPE_MAP[bond_type]) return mol # --------------------------------------------------------------------------- # 7. remove_bond # --------------------------------------------------------------------------- @safe_apply def remove_bond(mol, atom_idx1, atom_idx2): bond = mol.GetBondBetweenAtoms(atom_idx1, atom_idx2) if bond is None: return None mol.RemoveBond(atom_idx1, atom_idx2) return mol # --------------------------------------------------------------------------- # 8. add_functional_group # --------------------------------------------------------------------------- @safe_apply def add_functional_group(mol, anchor_idx, group_name): group_smi = FUNCTIONAL_GROUPS.get(group_name) if group_smi is None: return None group_mol = Chem.MolFromSmiles(group_smi) if group_mol is None: return None combo = Chem.RWMol(rdmolops.CombineMols(mol, group_mol)) old_n = mol.GetNumAtoms() anchor = combo.GetAtomWithIdx(anchor_idx) anchor.SetNumExplicitHs(0) anchor.SetNoImplicit(False) anchor.SetNumRadicalElectrons(0) combo.AddBond(anchor_idx, old_n, Chem.BondType.SINGLE) return combo # --------------------------------------------------------------------------- # 9. remove_functional_group (removes a terminal substituent at anchor) # --------------------------------------------------------------------------- def remove_functional_group(mol, anchor_idx, group_name): """Remove atoms belonging to a terminal functional group attached at anchor_idx. Returns (new_mol, removed_atom_indices) or (None, []).""" rw = copy.deepcopy(mol) anchor = rw.GetAtomWithIdx(anchor_idx) neighbors = [n for n in anchor.GetNeighbors()] if group_name in ("F", "Cl", "Br"): target_num = ELEM_TO_NUM.get(group_name) for n in neighbors: if n.GetAtomicNum() == target_num and n.GetDegree() == 1: idx = n.GetIdx() rw.RemoveAtom(idx) try: Chem.SanitizeMol(rw) return rw, [idx] except Exception: return None, [] return None, [] if group_name == "OH": for n in neighbors: if n.GetAtomicNum() == 8 and n.GetDegree() == 1: bond = rw.GetBondBetweenAtoms(anchor_idx, n.GetIdx()) if bond and bond.GetBondType() == Chem.BondType.SINGLE: idx = n.GetIdx() rw.RemoveAtom(idx) try: Chem.SanitizeMol(rw) return rw, [idx] except Exception: return None, [] return None, [] if group_name == "NH2": for n in neighbors: if n.GetAtomicNum() == 7 and n.GetDegree() == 1: idx = n.GetIdx() rw.RemoveAtom(idx) try: Chem.SanitizeMol(rw) return rw, [idx] except Exception: return None, [] return None, [] if group_name == "CH3": for n in neighbors: if n.GetAtomicNum() == 6 and n.GetDegree() == 1 and n.GetTotalNumHs() == 3: idx = n.GetIdx() rw.RemoveAtom(idx) try: Chem.SanitizeMol(rw) return rw, [idx] except Exception: return None, [] return None, [] return None, [] # --------------------------------------------------------------------------- # 10. flip_chirality # --------------------------------------------------------------------------- @safe_apply def flip_chirality(mol, atom_idx): atom = mol.GetAtomWithIdx(atom_idx) chi = atom.GetChiralTag() if chi == Chem.ChiralType.CHI_TETRAHEDRAL_CW: atom.SetChiralTag(Chem.ChiralType.CHI_TETRAHEDRAL_CCW) elif chi == Chem.ChiralType.CHI_TETRAHEDRAL_CCW: atom.SetChiralTag(Chem.ChiralType.CHI_TETRAHEDRAL_CW) else: return None return mol # --------------------------------------------------------------------------- # 11. flip_ez — flip E/Z via SMILES-level slash inversion # --------------------------------------------------------------------------- def flip_ez(smiles): """Flip E/Z by inverting the first /-slash in the SMILES. Works at the SMILES string level since RDKit mol-level stereo doesn't round-trip reliably through MolToSmiles.""" if "/" not in smiles and "\\" not in smiles: return None chars = list(smiles) for i, c in enumerate(chars): if c == "/": chars[i] = "\\" break elif c == "\\": chars[i] = "/" break new_smi = "".join(chars) mol = Chem.MolFromSmiles(new_smi) if mol is None: return None return Chem.MolToSmiles(mol, isomericSmiles=True) # --------------------------------------------------------------------------- # Registry: maps operation type name → apply function # --------------------------------------------------------------------------- OP_REGISTRY = { "change_atom_element": change_atom_element, "add_atom": add_atom, "remove_atom": remove_atom, "change_charge": change_charge, "change_bond_order": change_bond_order, "add_bond": add_bond, "remove_bond": remove_bond, "add_functional_group": add_functional_group, "remove_functional_group": lambda mol, **kw: remove_functional_group(mol, **kw)[0], "flip_chirality": flip_chirality, "flip_ez": flip_ez, }