hjxdl 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

hdl/jupyfuncs/chem/norm.py

@@ -0,0 +1,268 @@
+import functools
+import logging
+
+from rdkit import Chem
+from rdkit.Chem import AllChem 
+
+
+log = logging.getLogger(__name__)
+
+
+__all__ = [
+    "Normalizer",
+    "Normalization",
+    "NORMALIZATIONS",
+]
+
+
+def memoized_property(fget):
+    """Decorator to create memoized properties."""
+    attr_name = "_{}".format(fget.__name__)
+
+    @functools.wraps(fget)
+    def fget_memoized(self):
+        if not hasattr(self, attr_name):
+            setattr(self, attr_name, fget(self))
+        return getattr(self, attr_name)
+
+    return property(fget_memoized)
+
+
+class Normalization(object):
+    """A normalization transform defined by reaction SMARTS."""
+
+    def __init__(self, name, transform):
+        """
+        :param string name: A name for this Normalization
+        :param string transform: Reaction SMARTS to define the transformation.
+        """
+        log.debug("Initializing Normalization: %s", name)
+        self.name = name
+        self.transform_str = transform
+
+    @memoized_property
+    def transform(self):
+        log.debug("Loading Normalization transform: %s", self.name)
+        return AllChem.ReactionFromSmarts(self.transform_str)
+
+    def __repr__(self):
+        return "Normalization({!r}, {!r})".format(self.name, self.transform_str)
+
+    def __str__(self):
+        return self.name
+
+
+NORMALIZATIONS = [
+    Normalization(
+        "Nitro to N+(O-)=O",
+        "[*:1][N,P,As,Sb:2](=[O,S,Se,Te:3])=[O,S,Se,Te:4]>>[*:1][*+1:2]([*-1:3])=[*:4]",
+    ),
+    Normalization(
+        "Sulfone to S(=O)(=O)", "[S+2:1]([O-:2])([O-:3])>>[S+0:1](=[O-0:2])(=[O-0:3])"
+    ),
+    Normalization("Pyridine oxide to n+O-", "[n:1]=[O:2]>>[n+:1][O-:2]"),
+    Normalization(
+        "Azide to N=N+=N-", "[*,H:1][N:2]=[N:3]#[N:4]>>[*,H:1][N:2]=[N+:3]=[N-:4]"
+    ),
+    Normalization("Diazo/azo to =N+=N-", "[*:1]=[N:2]#[N:3]>>[*:1]=[N+:2]=[N-:3]"),
+    Normalization(
+        "Sulfoxide to -S+(O-)-",
+        "[!O:1][S+0;X3:2](=[O:3])[!O:4]>>[*:1][S+1:2]([O-:3])[*:4]",
+    ),
+    Normalization(
+        "Phosphate to P(O-)=O",
+        "[O,S,Se,Te;-1:1][P+;D4:2][O,S,Se,Te;-1:3]>>[*+0:1]=[P+0;D5:2][*-1:3]",
+    ),
+    Normalization(
+        "Amidinium to C(=NH2+)NH2",
+        "[C,S;X3+1:1]([NX3:2])[NX3!H0:3]>>[*+0:1]([N:2])=[N+:3]",
+    ),
+    Normalization(
+        "Normalize hydrazine-diazonium",
+        "[CX4:1][NX3H:2]-[NX3H:3][CX4:4][NX2+:5]#[NX1:6]>>[CX4:1][NH0:2]=[NH+:3][C:4][N+0:5]=[NH:6]",
+    ),
+    Normalization(
+        "Recombine 1,3-separated charges",
+        "[N,P,As,Sb,O,S,Se,Te;-1:1]-[A:2]=[N,P,As,Sb,O,S,Se,Te;+1:3]>>[*-0:1]=[*:2]-[*+0:3]",
+    ),
+    Normalization(
+        "Recombine 1,3-separated charges",
+        "[n,o,p,s;-1:1]:[a:2]=[N,O,P,S;+1:3]>>[*-0:1]:[*:2]-[*+0:3]",
+    ),
+    Normalization(
+        "Recombine 1,3-separated charges",
+        "[N,O,P,S;-1:1]-[a:2]:[n,o,p,s;+1:3]>>[*-0:1]=[*:2]:[*+0:3]",
+    ),
+    Normalization(
+        "Recombine 1,5-separated charges",
+        "[N,P,As,Sb,O,S,Se,Te;-1:1]-[A+0:2]=[A:3]-[A:4]=[N,P,As,Sb,O,S,Se,Te;+1:5]>>[*-0:1]=[*:2]-[*:3]=[*:4]-[*+0:5]",
+    ),
+    Normalization(
+        "Recombine 1,5-separated charges",
+        "[n,o,p,s;-1:1]:[a:2]:[a:3]:[c:4]=[N,O,P,S;+1:5]>>[*-0:1]:[*:2]:[*:3]:[c:4]-[*+0:5]",
+    ),
+    Normalization(
+        "Recombine 1,5-separated charges",
+        "[N,O,P,S;-1:1]-[c:2]:[a:3]:[a:4]:[n,o,p,s;+1:5]>>[*-0:1]=[c:2]:[*:3]:[*:4]:[*+0:5]",
+    ),
+    Normalization(
+        "Normalize 1,3 conjugated cation",
+        "[N,O;+0!H0:1]-[A:2]=[N!$(*[O-]),O;+1H0:3]>>[*+1:1]=[*:2]-[*+0:3]",
+    ),
+    Normalization(
+        "Normalize 1,3 conjugated cation",
+        "[n;+0!H0:1]:[c:2]=[N!$(*[O-]),O;+1H0:3]>>[*+1:1]:[*:2]-[*+0:3]",
+    ),
+    Normalization(
+        "Normalize 1,3 conjugated cation",
+        "[N,O;+0!H0:1]-[c:2]:[n!$(*[O-]),o;+1H0:3]>>[*+1:1]=[*:2]:[*+0:3]",
+    ),
+    Normalization(
+        "Normalize 1,5 conjugated cation",
+        "[N,O;+0!H0:1]-[A:2]=[A:3]-[A:4]=[N!$(*[O-]),O;+1H0:5]>>[*+1:1]=[*:2]-[*:3]=[*:4]-[*+0:5]",
+    ),
+    Normalization(
+        "Normalize 1,5 conjugated cation",
+        "[n;+0!H0:1]:[a:2]:[a:3]:[c:4]=[N!$(*[O-]),O;+1H0:5]>>[n+1:1]:[*:2]:[*:3]:[*:4]-[*+0:5]",
+    ),
+    Normalization(
+        "Normalize 1,5 conjugated cation",
+        "[N,O;+0!H0:1]-[c:2]:[a:3]:[a:4]:[n!$(*[O-]),o;+1H0:5]>>[*+1:1]=[c:2]:[*:3]:[*:4]:[*+0:5]",
+    ),
+    Normalization(
+        "Normalize 1,5 conjugated cation",
+        "[n;+0!H0:1]1:[a:2]:[a:3]:[a:4]:[n!$(*[O-]);+1H0:5]1>>[n+1:1]1:[*:2]:[*:3]:[*:4]:[n+0:5]1",
+    ),
+    Normalization(
+        "Normalize 1,5 conjugated cation",
+        "[n;+0!H0:1]:[a:2]:[a:3]:[a:4]:[n!$(*[O-]);+1H0:5]>>[n+1:1]:[*:2]:[*:3]:[*:4]:[n+0:5]",
+    ),
+    Normalization(
+        "Charge normalization",
+        "[F,Cl,Br,I,At;-1:1]=[O:2]>>[*-0:1][O-:2]"),
+    Normalization(
+        "Charge recombination", "[N,P,As,Sb;-1:1]=[C+;v3:2]>>[*+0:1]#[C+0:2]"
+    ),
+    Normalization(
+        "Nitro to N+(O-)=O",
+        "[N;X3:1](=[O:2])=[O:3]>>[*+1:1]([*-1:2])=[*:3]"),
+    Normalization(
+        "Diazonium N",
+        "[*:1]-[N;X2:2]#[N;X1:3]>>[*:1]-[*+1:2]#[*:3]",
+    ),
+    Normalization(
+        "Quaternary N",
+        "[N;X4;v4;+0:1]>>[*+1:1]",
+    ),
+    Normalization(
+        "Trivalent O",
+        "[*:1]=[O;X2;v3;+0:2]-[#6:3]>>[*:1]=[*+1:2]-[*:3]",
+    ),
+    Normalization(
+        "Sulfoxide to -S+(O-)",
+        "[!O:1][S+0;D3:2](=[O:3])[!O:4]>>[*:1][S+1:2]([O-:3])[*:4]",
+    ),
+    Normalization(
+        "Sulfoxide to -S+(O-) 2",
+        "[!O:1][SH1+1;D3:2](=[O:3])[!O:4]>>[*:1][S+1:2]([O-:3])[*:4]",
+    ),
+    Normalization(
+        "Trivalent S",
+        "[O:1]=[S;D2;+0:2]-[#6:3]>>[*:1]=[*+1:2]-[*:3]",
+    ),
+
+    Normalization(
+        "Bad amide tautomer1",
+        "[C:1]([OH1;D1:2])=;!@[NH1:3]>>[C:1](=[OH0:2])-[NH2:3]",
+    ),
+    Normalization(
+        "Bad amide tautomer2",
+        "[C:1]([OH1;D1:2])=;!@[NH0:3]>>[C:1](=[OH0:2])-[NH1:3]",
+    ),
+    Normalization(
+        "Halogen with no neighbors", "[F,Cl,Br,I;X0;+0:1]>>[*-1:1]",
+    ),
+    Normalization(
+        "Odd pyridine/pyridazine oxide structure",
+        "[C,N;-;D2,D3:1]-[N+2;D3:2]-[O-;D1:3]>>[*-0:1]=[*+1:2]-[*-:3]",
+    ),
+    Normalization(
+        "qunimade2",
+        "[n&H0:1][n&H1:2][n&H1,c;R2:3][c&H1,n&H1:4][c,n&H1:5](=[S,N,O:7])[n&H1:6]>>[n&H0:1][n&H1:2][n&H0,c;R2:3][c&H1,n&H0:4][c,n&H0:5]([S,N,O:7])[n&H0:6]"
+    ),
+    Normalization(
+        "qunimade",
+        "[c,n&H0,n&H1:2][n&H0,n&H1,c:3][c,n&H0,n&H1:4][c,n&H0,n&H1:5](=[S,N,O:1])>>[c,n&H0:2][n&H0,c:3][c,n&H0:4][c,n&H0:5]([S,N,O:1])"
+    ),
+]
+
+
+class Normalizer(object):
+    """A class for applying Normalization transforms.
+    This class is typically used to apply a series of Normalization transforms to correct functional groups and
+    recombine charges. Each transform is repeatedly applied until no further changes occur.
+    """
+
+    def __init__(self, normalizations=NORMALIZATIONS):
+        """Initialize a Normalizer with an optional custom list of :class:`~molvs.normalize.Normalization` transforms.
+        :param normalizations: A list of  :class:`~molvs.normalize.Normalization` transforms to apply.
+        :param int max_restarts: The maximum number of times to attempt to apply the series of normalizations (default
+                                 200).
+        """
+        log.debug("Initializing Normalizer")
+        self.normalizations = normalizations
+
+    def __call__(self, mol):
+        """Calling a Normalizer instance like a function is the same as calling its normalize(mol) method."""
+        return self.normalize(mol)
+
+    def normalize(self, mol):
+        """Apply a series of Normalization transforms to correct functional groups and recombine charges.
+        A series of transforms are applied to the molecule. For each Normalization, the transform is applied repeatedly
+        until no further changes occur. If any changes occurred, we go back and start from the first Normalization
+        again, in case the changes mean an earlier transform is now applicable. The molecule is returned once the entire
+        series of Normalizations cause no further changes or if max_restarts (default 200) is reached.
+        :param mol: The molecule to normalize.
+        :type mol: :rdkit:`Mol <Chem.rdchem.Mol-class.html>`
+        :return: The normalized fragment.
+        :rtype: :rdkit:`Mol <Chem.rdchem.Mol-class.html>`
+        """
+        log.debug("Running Normalizer")
+        # Normalize each fragment separately to get around quirky RunReactants behaviour
+        fragments = []
+        for fragment in Chem.GetMolFrags(mol, asMols=True):
+            fragments.append(self._normalize_fragment(fragment))
+        # Join normalized fragments into a single molecule again
+        outmol = fragments.pop()
+        for fragment in fragments:
+            outmol = Chem.CombineMols(outmol, fragment)
+        Chem.SanitizeMol(outmol)
+        return outmol
+
+    def _normalize_fragment(self, mol):
+        for normalization in self.normalizations:
+            product = self._apply_transform(mol, normalization.transform)
+            if product:
+                mol = product
+        return mol
+
+    def _apply_transform(self, mol, rule):
+        """Repeatedly apply normalization transform to molecule until no changes occur.
+        It is possible for multiple products to be produced when a rule is applied. The rule is applied repeatedly to
+        each of the products, until no further changes occur or after 20 attempts. If there are multiple unique products
+        after the final application, the first product (sorted alphabetically by SMILES) is chosen.
+        """
+        mols = [mol]
+        for n in range(20):
+            products = {}
+            for mol in mols:
+                for product in [x[0] for x in rule.RunReactants((mol,))]:
+                    if Chem.SanitizeMol(product, catchErrors=True) == 0:
+                        products[
+                            Chem.MolToSmiles(product, isomericSmiles=True)
+                        ] = product
+            if products:
+                mols = [products[s] for s in sorted(products)]
+            else:
+                # If n == 0, the rule was not applicable and we return None
+                return mols[0] if n > 0 else None

hdl/jupyfuncs/chem/pdb_ext.py

@@ -0,0 +1,94 @@
+# Extract ligand and pdb 
+
+import sys
+from prody import *
+from rdkit import Chem
+from rdkit.Chem import AllChem
+from io import StringIO
+import pypdb
+
+
+__all__ = [
+    'get_pdb_components',
+    'process_ligand',
+    'write_pdb',
+    'write_sdf'
+]
+
+def get_pdb_components(pdb_id):
+    """
+    Split a protein-ligand pdb into protein and ligand components
+    :param pdb_id:
+    :return:
+    """
+    pdb = parsePDB(pdb_id)
+    protein = pdb.select('protein')
+    ligand = pdb.select('not protein and not water')
+    return protein, ligand
+
+
+def process_ligand(ligand, res_name):
+    """
+    Add bond orders to a pdb ligand
+    1. Select the ligand component with name "res_name"
+    2. Get the corresponding SMILES from pypdb
+    3. Create a template molecule from the SMILES in step 2
+    4. Write the PDB file to a stream
+    5. Read the stream into an RDKit molecule
+    6. Assign the bond orders from the template from step 3
+    :param ligand: ligand as generated by prody
+    :param res_name: residue name of ligand to extract
+    :return: molecule with bond orders assigned
+    """
+    output = StringIO()
+    sub_mol = ligand.select(f"resname {res_name}")
+    chem_desc = pypdb.describe_chemical(f"{res_name}")
+    sub_smiles = chem_desc["describeHet"]["ligandInfo"]["ligand"]["smiles"]
+    template = AllChem.MolFromSmiles(sub_smiles)
+    writePDBStream(output, sub_mol)
+    pdb_string = output.getvalue()
+    rd_mol = AllChem.MolFromPDBBlock(pdb_string)
+    new_mol = AllChem.AssignBondOrdersFromTemplate(template, rd_mol)
+    return new_mol
+
+
+def write_pdb(protein, pdb_name):
+    """
+    Write a prody protein to a pdb file
+    :param protein: protein object from prody
+    :param pdb_name: base name for the pdb file
+    :return: None
+    """
+    output_pdb_name = f"{pdb_name}_protein.pdb"
+    writePDB(f"{output_pdb_name}", protein)
+    print(f"wrote {output_pdb_name}")
+
+
+def write_sdf(new_mol, pdb_name, res_name):
+    """
+    Write an RDKit molecule to an SD file
+    :param new_mol:
+    :param pdb_name:
+    :param res_name:
+    :return:
+    """
+    outfile_name = f"{pdb_name}_{res_name}_ligand.sdf"
+    writer = Chem.SDWriter(f"{outfile_name}")
+    writer.write(new_mol)
+    print(f"wrote {outfile_name}")
+
+
+def main(pdb_name):
+    """
+    Read Ligand Expo data, split pdb into protein and ligands,
+    write protein pdb, write ligand sdf files
+    :param pdb_name: id from the pdb, doesn't need to have an extension
+    :return:
+    """
+    protein, ligand = get_pdb_components(pdb_name)
+    write_pdb(protein, pdb_name)
+
+    res_name_list = list(set(ligand.getResnames()))
+    for res in res_name_list:
+        new_mol = process_ligand(ligand, res)
+        write_sdf(new_mol, pdb_name, res)

hdl/jupyfuncs/chem/scaffold.py

@@ -0,0 +1,25 @@
+from rdkit.Chem.Scaffolds import rdScaffoldNetwork
+from rdkit import RDLogger
+RDLogger.DisableLog('rdApp.info')
+
+
+def create_sn(
+    mols,
+    includeGenericScaffolds=False,
+    includeGenericBondScaffolds=False,
+    includeScaffoldsWithAttachments=True,
+    includeScaffoldsWithoutAttachments=False,
+    pruneBeforeFragmenting=True,
+    keepOnlyFirstFragment=True
+):
+    RDLogger.DisableLog('rdApp.info')
+    scaffParams = rdScaffoldNetwork.ScaffoldNetworkParams()
+    scaffParams.collectMolCounts = True
+    scaffParams.includeGenericScaffolds = includeGenericScaffolds
+    scaffParams.includeScaffoldsWithoutAttachments = includeScaffoldsWithoutAttachments
+    scaffParams.keepOnlyFirstFragment = keepOnlyFirstFragment
+    scaffParams.includeGenericBondScaffolds = includeGenericBondScaffolds
+    scaffParams.includeScaffoldsWithAttachments = includeScaffoldsWithAttachments
+    scaffParams.pruneBeforeFragmenting = pruneBeforeFragmenting
+    net = rdScaffoldNetwork.CreateScaffoldNetwork(mols, scaffParams)
+    return net

hdl/jupyfuncs/chem/shape.py

@@ -0,0 +1,241 @@
+# shape
+
+import os
+import subprocess
+from copy import deepcopy
+
+from rdkit import Chem
+from rdkit.Chem import AllChem
+from pyshapeit import AlignMol
+import multiprocess as mp
+
+from rdkit import RDLogger
+
+from jupyfuncs.pbar import tqdm
+from jupyfuncs.norm import Normalizer
+
+# from rdkit.Chem.Draw import IPythonConsole
+from rdkit.Chem import PyMol
+from rdkit.Chem.Subshape import SubshapeBuilder, SubshapeObjects
+from PIL import ImageFile
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+lg = RDLogger.logger()
+lg.setLevel(4)
+
+__all__ = [
+    'get_mols_from_smi',
+    'get_aligned_mol',
+    'get_aligned_sdf',
+    'show_alignment',
+    'pymol_running'
+]
+
+
+def get_mols_from_smi(probe_smifile):
+    mols = []
+    with open(probe_smifile) as f:
+        for line in f.readlines():
+            smi = line.strip()
+            mol = None
+            try:
+                mol = Chem.MolFromSmiles(smi)
+            except Exception as e:
+                print(e)
+            if mol:
+                mols.append(mol)
+    return mols
+
+
+def get_aligned_mol(
+    ref_mol, probe_mol, num_confs, num_cpu
+):
+
+    mol1 = ref_mol
+    mol1.SetProp('_Name', 'ref')
+
+    AllChem.EmbedMultipleConfs(
+        probe_mol,
+        numConfs=num_confs,
+        numThreads=num_cpu
+    )
+
+    score = 0
+    # conf_id = -1
+    
+    aligned_mol = deepcopy(probe_mol)
+
+    for i in range(probe_mol.GetNumConformers()):
+
+        mol2 = Chem.MolFromMolBlock(
+            Chem.MolToMolBlock(probe_mol, confId=i)
+        )
+        mol2.SetProp('_Name', 'probe')
+
+        sim_score = AlignMol(mol1, mol2)
+        if sim_score > score:
+            score = sim_score
+            aligned_mol = deepcopy(mol2)
+#     pbar.update(1)
+
+    return aligned_mol
+
+
+def get_aligned_mol_mp(
+    config
+):
+    return get_aligned_mol(*config)
+
+
+def gen_configs(ref_mol, mols, num_confs, num_cpu):
+    configs = []
+    for probe_mol in mols:
+        configs.append((ref_mol, probe_mol, num_confs, num_cpu))
+    return configs
+
+
+def get_aligned_sdf(
+    ref_sdf: str,
+    probe_smifile: str,
+    num_confs=150,
+    num_cpu=5,
+    num_workers=10,
+    output_sdf=None,
+    print_info=True,
+    norm_mol=True
+):
+    ref_sdf = os.path.abspath(ref_sdf)
+    ref_mol = Chem.SDMolSupplier(ref_sdf)[0]
+    if not output_sdf:
+        output_sdf = os.path.abspath(probe_smifile) + '.sdf'
+    else:
+        output_sdf = os.path.abspath(output_sdf)
+
+    mols = get_mols_from_smi(probe_smifile)
+
+    configs = gen_configs(
+        ref_mol, mols, num_confs=num_confs, num_cpu=num_cpu
+    )
+    
+    pool = mp.Pool(num_workers)
+    aligned_mols = list(
+        tqdm(
+            pool.imap(get_aligned_mol_mp, configs),
+            total=len(mols),
+            desc='All mols'
+        )
+    )
+    if norm_mol:
+        normer = Normalizer()
+    sdwriter = Chem.SDWriter(output_sdf) 
+    for mol in aligned_mols:
+        if norm_mol:
+            mol = normer(mol)
+        sdwriter.write(mol)
+        sdwriter.flush()
+    sdwriter.close()
+    return output_sdf
+
+    # out_aligned = output_sdf + 'ali.sdf'
+    # score_file = output_sdf + 'score.csv'
+    
+    # command = f'shape-it -r {ref_sdf} -d {output_sdf} -o {out_aligned} -s {score_file}' 
+    # out_info = subprocess.getoutput(command)
+    # if print_info:
+    #     print(out_info)
+    
+    # if norm_mol:
+    #     fix_path = out_aligned + 'fix.sdf'
+    #     mols = Chem.SDMolSupplier(out_aligned)
+    #     sdwriter = Chem.SDWriter(fix_path)
+    #     for mol in mols:
+    #         mol = normer(mol)
+    #         sdwriter.write(mol)
+    #         sdwriter.flush()
+    #     sdwriter.close()
+    #     return fix_path
+    # else:
+    #     return out_aligned
+    
+    # shape-it -r ref_sdf  -d output_sdf -o out_aligned -s score_file
+
+
+def show_alignment(
+    ref_mol,
+    probe_mol,
+    gen_confs,
+    num_confs=200,
+    num_cpu=5,
+):
+    # should install pymol-open-source
+    if not pymol_running():
+        subprocess.Popen(['pymol', '-cKRQ'])  
+
+    if isinstance(ref_mol, Chem.Mol):
+        mol1 = ref_mol
+    elif isinstance(ref_mol, str) and ref_mol.endswith('.sdf'):
+        mol1 = Chem.SDMolSupplier(ref_mol)[0]
+    
+    if isinstance(probe_mol, Chem.Mol):
+        mol2 = probe_mol
+    elif isinstance(probe_mol, str) and probe_mol.endswith('.sdf'):
+        mol2 = Chem.SDMolSupplier(probe_mol)[0]
+    else:
+        mol2 = Chem.MolFromSmiles(probe_mol)
+    
+    if gen_confs:
+        AllChem.EmbedMultipleConfs(
+            mol2,
+            numConfs=num_confs,
+            numThreads=num_cpu
+        )
+
+    score = 0
+    for i in range(mol2.GetNumConformers()):
+
+        probe_mol = Chem.MolFromMolBlock(
+            Chem.MolToMolBlock(mol2, confId=i)
+        )
+
+        sim_score = AlignMol(mol1, probe_mol)
+        if sim_score > score:
+            score = sim_score
+            probe = deepcopy(probe_mol)
+
+    mol1.SetProp('_Name', 'ref')
+    probe.SetProp('_Name', 'probe')
+
+    AllChem.CanonicalizeConformer(mol1.GetConformer())
+    AllChem.CanonicalizeConformer(probe.GetConformer())
+
+    builder = SubshapeBuilder.SubshapeBuilder()
+    builder.gridDims = (20., 20., 10)
+    builder.gridSpacing = 0.5
+    builder.winRad = 4.
+
+    refShape = builder.GenerateSubshapeShape(mol1)
+    probeShape = builder.GenerateSubshapeShape(probe)
+
+    v = PyMol.MolViewer()
+
+    score = AlignMol(mol1, probe)
+
+    v.DeleteAll()
+
+    v.ShowMol(mol1, name='ref', showOnly=False)
+    SubshapeObjects.DisplaySubshape(v, refShape, 'ref_Shape')
+    v.server.do('set transparency=0.5')
+
+    v.ShowMol(probe, name='probe', showOnly=False)
+    SubshapeObjects.DisplaySubshape(v, probeShape, 'prob_Shape')
+    v.server.do('set transparency=0.5')
+
+    return v.GetPNG()
+
+
+def pymol_running() -> bool:
+    out_info = subprocess.getoutput('ps aux | grep pymol')
+    if '-cKRQ' in out_info:
+        return True
+    else:
+        return False

hdl/jupyfuncs/chem/tokenizers.py

@@ -0,0 +1,2 @@
+SMI_REGEX_PATTERN = \
+    "(\[[^\]]+]|Br?|Cl?|N|O|S|P|F|I|b|c|n|o|s|p|\(|\)|\.|=|#||\+|\\\\\/|:||@|\?|>|\*|\$|\%[0–9]{2}|[0–9])"

hdl/jupyfuncs/dbtools/pg.py

@@ -0,0 +1,42 @@
+import psycopg
+from psycopg import sql
+
+
+def connect_by_infofile(info_file: str) -> psycopg.Connection:
+    """Create a postgres connection
+
+    Args:
+        info_file (str): 
+            the path of the connection info like
+            host=127.0.0.1 dbname=dbname port=5432 user=postgres password=lala
+
+    Returns:
+        psycopg.Connection: 
+            the connection instance should be closed after committing.
+    """
+    conn = psycopg.connect(
+        open(info_file).readline()
+    )
+    return conn
+
+
+def get_item_by_idx(
+    idx: int,
+    info_file: str,
+    by: str = id,
+    table: str = 'reaction_id'
+):
+
+    conn = connect_by_infofile(
+        info_file
+    )
+
+    query_name = str(idx)
+    query = sql.SQL(
+        "select reaction_id from {table} where {by} = %s"
+    ).format(
+        table=sql.Identifier(table),
+        by=sql.Identifier(by)
+    )
+    cur = conn.execute(query, [query_name]).fetchone()
+    return cur[0]