rdworks 0.51.1__tar.gz → 0.53.1__tar.gz

{rdworks-0.51.1 → rdworks-0.53.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rdworks
-Version: 0.51.1
+Version: 0.53.1
 Summary: Routine tasks built on RDKit and other tools
 Author-email: Sung-Hun Bae <sunghun.bae@gmail.com>
 Maintainer-email: Sung-Hun Bae <sunghun.bae@gmail.com>

{rdworks-0.51.1 → rdworks-0.53.1}/src/rdworks/__init__.py

@@ -1,11 +1,11 @@
-__version__ = '0.51.1'
+__version__ = '0.53.1'
 
 from rdworks.conf    import Conf
 from rdworks.mol     import Mol
 from rdworks.mollibr import MolLibr
 
-from rdworks.stereoisomers import complete_stereoisomers
-from rdworks.tautomers import complete_tautomers
+from rdworks.workflow import complete_stereoisomers, complete_tautomers
+
 from rdworks.ionized import IonizedStates
 
 from rdworks.readin import read_csv, merge_csv, read_dataframe, read_smi, read_sdf, read_mae 

{rdworks-0.51.1 → rdworks-0.53.1}/src/rdworks/conf.py

@@ -355,6 +355,15 @@ class Conf:
         return True
     
 
+    def charge(self) -> int:
+        """Returns molecular formal charge.
+
+        Returns:
+            int: charge
+        """
+        return self.charge
+    
+
     def positions(self) -> np.array:
         """Returns the coordinates.
 

rdworks-0.53.1/src/rdworks/microstates.py

@@ -0,0 +1,138 @@
+import numpy as np
+import math
+import itertools
+
+from types import SimpleNamespace
+from rdworks import Conf, Mol
+from rdworks.xtb.wrapper import GFN2xTB
+
+
+kT = 0.001987 * 298.0 # (kcal/mol K), standard condition
+C = math.log(10) * kT
+
+
+
+class Microstates():
+
+    def __init__(self, origin: Mol, calculator: str = 'xTB'):
+        self.origin = origin
+        self.calculator = calculator
+        self.basic_sites = []
+        self.acidic_sites = []
+        self.states = []
+        self.mols = []
+        self.reference = None
+    
+        # read QupKake results
+        for conf in self.origin:
+            print(conf.props)
+            pka = conf.props.get('pka', None)
+            if pka is None:
+                # no protonation/deprotonation sites
+                continue
+            if isinstance(pka, str) and pka.startswith('tensor'):
+                # ex. 'tensor(9.5784)'
+                pka = float(pka.replace('tensor(','').replace(')',''))
+            if conf.props.get('pka_type') == 'basic':
+                self.basic_sites.append(conf.props.get('idx'))
+            elif conf.props.get('pka_type') == 'acidic':
+                self.acidic_sites.append(conf.props.get('idx'))
+
+        # enumerate protonation/deprotonation sites to generate microstates
+
+        np = len(self.basic_sites)
+        nd = len(self.acidic_sites)
+        P = [c for n in range(np+1) for c in itertools.combinations(self.basic_sites, n)]
+        D = [c for n in range(nd+1) for c in itertools.combinations(self.acidic_sites, n)]
+        
+        PD = list(itertools.product(P, D))
+        
+        for (p, d) in PD:
+            conf = self.origin.confs[0].copy()
+            conf = conf.protonate(p).deprotonate(d).optimize(calculator=calculator)
+            charge = len(p) - len(d)
+            self.states.append(SimpleNamespace(
+                charge=charge, 
+                protonation_sites=p, 
+                deprotonation_sites=d,
+                conf=conf,
+                smiles=Mol(conf).smiles,
+                delta_m=None,
+                PE=None))
+            
+        # sort microstates by ascending charges
+        self.states = sorted(self.states, key=lambda x: x.charge)
+
+
+    @staticmethod
+    def Boltzmann_weighted_average(potential_energies: list) -> float:
+        """Calculate Boltzmann weighted average potential energy at pH 0.
+
+        Args:
+            potential_energies (list): a list of potential energies.
+
+        Returns:
+            float: Boltzmann weighted average potential energy.
+        """
+        pe_array = np.array(potential_energies)
+        pe = pe_array - min(potential_energies)
+        Boltzmann_factors = np.exp(-pe/kT)
+        Z = np.sum(Boltzmann_factors)
+        p = Boltzmann_factors/Z
+
+        return float(np.dot(p, pe_array))
+
+
+    def potential_energy(self) -> None:
+        for microstate in self.states:
+            mol = Mol(microstate.conf).make_confs(n=4).optimize_confs()
+            # mol = mol.drop_confs(similar=True, similar_rmsd=0.3, verbose=True)
+            # mol = mol.optimize_confs(calculator=calculator)
+            # mol = mol.drop_confs(k=10, window=15.0, verbose=True)
+            PE = []
+            for conf in mol.confs:
+                conf = conf.optimize(calculator=self.calculator, verbose=True)
+                # GFN2xTB requires 3D coordinates
+                # xtb = GFN2xTB(conf.rdmol).singlepoint(water='cpcmx', verbose=True)
+                xtb = GFN2xTB(conf.rdmol).singlepoint(verbose=True)
+                PE.append(xtb.PE)
+                # SimpleNamespace(
+                #             PE = datadict['total energy'] * hartree2kcalpermol,
+                #             Gsolv = Gsolv,
+                #             charges = datadict['partial charges'],
+                #             wbo = Wiberg_bond_orders,
+                #             )
+            print("PE=", PE)
+            microstate.PE = self.Boltzmann_weighted_average(PE)
+            print("Boltzmann weighted=", microstate.PE)
+            
+            self.mols.append(mol)
+            print("microstate.energy", microstate)
+
+
+    def populations(self, pH: float) -> list[tuple]:
+        # set the lowest dG as the reference
+        self.reference = self.states[np.argmin([microstate.PE for microstate in self.states])]
+        for microstate in self.states:
+            microstate.delta_m = microstate.charge - self.reference.charge
+        dG = []
+        for microstate in self.states:
+            dG.append((microstate.PE - self.reference.PE) + microstate.delta_m * C * pH)
+        dG = np.array(dG)
+
+        print("dG=", dG)
+        Boltzmann_factors = np.exp(-dG/kT)
+        Z = np.sum(Boltzmann_factors)
+        p = Boltzmann_factors/Z
+        idx_p = sorted(list(enumerate(p)), key=lambda x: x[1], reverse=True)
+        # [(0, p0), (1, p1), ...]
+
+        return idx_p
+    
+
+    def count(self) -> int:
+        return len(self.states)
+    
+
+    def get_mol(self, idx: int) -> Mol:
+        return self.mols[idx]

{rdworks-0.51.1 → rdworks-0.53.1}/src/rdworks/mol.py

@@ -28,7 +28,6 @@ from rdkit.Chem import (
     Draw, rdDepictor, inchi,
     rdDistGeom, rdMolAlign, rdMolTransforms, rdmolops
     )
-from rdkit.Chem.Draw import rdMolDraw2D
 from rdkit.ML.Cluster import Butina
 from PIL import Image
 
@@ -43,6 +42,8 @@ from rdworks.autograph import NMRCLUST, DynamicTreeCut, RCKmeans, AutoGraph
 from rdworks.bitqt import BitQT
 from rdworks.torsion import create_torsion_fragment, get_torsion_atoms
 from rdworks.display import render_svg, render_png
+from rdworks.stereoisomers import enumerate_stereoisomers, enumerate_ring_bond_stereoisomers
+
 
 from scour.scour import scourString
 
@@ -329,6 +330,36 @@ class Mol:
         return self
 
 
+    def count_stereoisomers(self) -> int:
+        """Counts number of all possible stereoisomers ignoring the current stereochemistry.
+
+        Returns:
+            int: number of stereoisomers.
+        """
+
+        ring_bond_stereo_info = self.get_ring_bond_stereo()
+        mol = self.copy()
+        # remove stereochemistry
+        mol = mol.remove_stereo()
+        rdmols = enumerate_stereoisomers(mol.rdmol)
+        # ring bond stereo is not properly enumerated
+        # cis/trans information is lost if stereochemistry is removed,
+        # which cannot be enumerated by EnumerateStereoisomers() function
+        # so enumerate_ring_bond_stereoisomers() is introduced
+        if len(ring_bond_stereo_info) > 0:
+            ring_cis_trans = []
+            for rdmol in rdmols:
+                ring_cis_trans += enumerate_ring_bond_stereoisomers(rdmol,
+                                                        ring_bond_stereo_info,
+                                                        override=True)
+            if len(ring_cis_trans) > 0:
+                rdmols = ring_cis_trans
+        
+        unique_rdmols = set([Chem.MolToSmiles(rdmol) for rdmol in rdmols])
+        
+        return len(unique_rdmols)
+   
+
     def make_confs(self, n: int = 50, method: str = 'ETKDG', **kwargs) -> Self:
         """Generates 3D conformers.
 

{rdworks-0.51.1 → rdworks-0.53.1}/src/rdworks/readin.py

@@ -232,6 +232,7 @@ def read_sdf(path:str | Path, std:bool=False, confs:bool=False, props:bool=True,
                 # start a new molecule
                 rdmol_2d = Chem.RemoveHs(rdmol)
                 AllChem.Compute2DCoords(rdmol_2d)
+                # initialize a new molecule with the H-removed 2D
                 new_mol = Mol(rdmol_2d, isomer_name, std=False) # atom indices remain unchanged.
             new_conf = Conf(rdmol)
             new_conf.props.update(props)

rdworks-0.53.1/src/rdworks/stereoisomers.py

@@ -0,0 +1,67 @@
+from rdkit import Chem
+from rdkit.Chem.EnumerateStereoisomers import EnumerateStereoisomers, StereoEnumerationOptions
+
+
+def enumerate_stereoisomers(rdmol: Chem.Mol) -> list[Chem.Mol]:
+    """Returns enumerated stereoisomers.
+
+    Args:
+        rdmol (Chem.Mol): input molecule.
+
+    Returns:
+        List[Chem.Mol]: a list of enumerated stereoisomers.
+    """
+    return list(EnumerateStereoisomers(
+        rdmol, 
+        options=StereoEnumerationOptions(
+            tryEmbedding=False,
+            onlyUnassigned=True,
+            maxIsomers=1024,
+            rand=None,
+            unique=True,
+            onlyStereoGroups=False,
+            )))
+
+
+def enumerate_ring_bond_stereoisomers(rdmol: Chem.Mol, 
+                                      ring_bond_stereo_info: list[tuple],
+                                      override: bool = False) -> list[Chem.Mol]:
+    """Enumerates unspecified double bond stereochemistry (cis/trans).
+
+    <pre>
+    a1        a4  a1
+      \      /      \
+       a2=a3         a2=a3 
+                          \
+                          a4
+    </pre>
+
+    Args:
+        rdmol (Chem.Mol): input molecule.
+        ring_bond_stereo_info (List[Tuple]): 
+            ring_bond_stereo_info will be set when .remove_stereo() is called.
+            bond_stereo_info = [(bond_idx, bond_stereo_descriptor), ..] where
+            bond_stereo_descriptor is `Chem.StereoDescriptor.Bond_Cis` or
+            `Chem.StereoDescriptor.Bond_Trans`, or `Chem.StereoDescriptor.NoValue`.
+        override (bool, optional): _description_. Defaults to False.
+
+    Returns:
+        List[Chem.Mol]: list of enumerated stereoisomers.
+    """
+    isomers = []
+    for bond_idx, bond_stereo_desc in ring_bond_stereo_info:
+        if (bond_stereo_desc == Chem.StereoDescriptor.NoValue) or override:
+            bond = rdmol.GetBondWithIdx(bond_idx)
+            (a2,a3) = (bond.GetBeginAtom(), bond.GetEndAtom())
+            a2_idx = a2.GetIdx()
+            a3_idx = a3.GetIdx()
+            a1_idx = sorted([(a.GetIdx(), a.GetAtomicNum()) for a in a2.GetNeighbors() if a.GetIdx() != a3_idx], key=lambda x: x[1], reverse=True)[0][0]
+            a4_idx = sorted([(a.GetIdx(), a.GetAtomicNum()) for a in a3.GetNeighbors() if a.GetIdx() != a2_idx], key=lambda x: x[1], reverse=True)[0][0]
+            bond.SetStereoAtoms(a1_idx, a4_idx) # need to set reference atoms
+            # cis
+            bond.SetStereo(Chem.BondStereo.STEREOCIS)
+            isomers.append(Chem.Mol(rdmol))
+            # trans
+            bond.SetStereo(Chem.BondStereo.STEREOTRANS)
+            isomers.append(Chem.Mol(rdmol))
+    return isomers

rdworks-0.53.1/src/rdworks/workflow.py

@@ -0,0 +1,85 @@
+
+from rdworks.stereoisomers import enumerate_stereoisomers, enumerate_ring_bond_stereoisomers
+from rdworks.mol import Mol
+from rdworks.mollibr import MolLibr
+
+from rdkit import Chem
+from rdkit.Chem.MolStandardize import rdMolStandardize
+
+
+def complete_stereoisomers(molecular_input: str | Chem.Mol | Mol, 
+                           name: str | None = None, 
+                           std: bool = False, 
+                           override: bool = False, 
+                           **kwargs) -> MolLibr:
+    """Completes stereoisomers and returns a rdworks.MolLibr.
+
+    Args:
+        molecular_input (Union[Mol, str, Chem.Mol]): input molecule.
+        name (Optional[str], optional): name of the molecule. Defaults to None.
+        std (bool, optional): whether to standardize the input. Defaults to False.
+        override (bool, optional): whether to override input stereoisomers. Defaults to False.
+
+    Raises:
+        TypeError: if `molecular_input` is not rdworks.Mol, SMILES, or rdkit.Chem.Mol object.
+
+    Returns:
+        MolLibr: a library of complete stereoisomers.
+    """
+    if isinstance(molecular_input, Mol):
+        if name:
+            mol = molecular_input.rename(name)
+        else:
+            mol = molecular_input
+    elif isinstance(molecular_input, str) or isinstance(molecular_input, Chem.Mol):
+        mol = Mol(molecular_input, name, std)
+    else:
+        raise TypeError('complete_stereoisomers() expects rdworks.Mol, SMILES or rdkit.Chem.Mol object')
+    
+    ring_bond_stereo_info = mol.get_ring_bond_stereo()
+    
+    if override:
+        mol = mol.remove_stereo()
+    
+    rdmols = enumerate_stereoisomers(mol.rdmol)
+    # ring bond stereo is not properly enumerated
+    # cis/trans information is lost if stereochemistry is removed,
+    # which cannot be enumerated by EnumerateStereoisomers() function
+    # so enumerate_ring_bond_stereoisomers() is introduced
+    if len(ring_bond_stereo_info) > 0:
+        ring_cis_trans = []
+        for rdmol in rdmols:
+            ring_cis_trans += enumerate_ring_bond_stereoisomers(rdmol,
+                                                     ring_bond_stereo_info,
+                                                     override=override)
+        if len(ring_cis_trans) > 0:
+            rdmols = ring_cis_trans
+    
+    if len(rdmols) > 1:
+        libr = MolLibr(rdmols).unique().rename(mol.name, sep='.').compute(**kwargs)
+    else:
+        libr = MolLibr(rdmols).rename(mol.name).compute(**kwargs)
+    
+    for _ in libr:
+        _.props.update(mol.props)
+    
+    return libr
+
+
+
+def complete_tautomers(mol: Mol, **kwargs) -> MolLibr:
+    """Returns a library of enumerated tautomers.
+
+    Args:
+        mol (Mol): input molecule.
+
+    Returns:
+        MolLibr: a library of enumerated tautomers.
+    """
+    enumerator = rdMolStandardize.TautomerEnumerator()
+    rdmols = list(enumerator.Enumerate(mol.rdmol))
+    
+    if len(rdmols) > 1: 
+        return MolLibr(rdmols).unique().rename(mol.name, sep='.').compute(**kwargs)
+    
+    return MolLibr(rdmols).compute(**kwargs)