示例#1
0
def get_fragments(insmiles):
    """Get core and sidechains using Murcko fragmentation method

    Args:
        insmiles (str): SMILES for molecule

    Returns:
        core: scaffold SMILES
        side: side chain SMILES
    """

    mol_prev = Chem.MolFromSmiles(insmiles)
    
    ### get core using Murcko fragmentation ###
    core = Murcko.MurckoScaffoldSmilesFromSmiles(insmiles)
    if core != "":
        mol_core = Chem.MolFromSmiles(core)
    
        ### get sidechains ###
        mol_side = Chem.rdmolops.DeleteSubstructs(mol_prev, mol_core)
        side = Chem.MolToSmiles(mol_side).split(".")
    else:
        side = [insmiles]
        
    return core, side
示例#2
0
def main(name, argv):
    if len(argv) != 2:
        print_usage(name)
        return

    with open(argv[0], 'r') as f:
        smile = f.readline().split()[0]
    mol = Chem.MolFromSmiles(smile)
    size = mol.GetNumHeavyAtoms()
    hierarch = Recap.RecapDecompose(mol)
    children = []
    for child in hierarch.GetAllChildren().keys() + [smile]:
        new_smiles = child.replace('[*]', '[H]')
        new = Chem.MolFromSmiles(new_smiles)
        if not new == None:
            new_size = new.GetNumHeavyAtoms()
            if new_size > 7 and new_size <= 25:
                if rdMolDescriptors.CalcNumRotatableBonds(new) <= 5:
                    children.append(Chem.MolToSmiles(new, isomericSmiles=True))
                    #children.append(new_smiles)
                core_smile = MurckoScaffold.MurckoScaffoldSmilesFromSmiles(
                    new_smiles, includeChirality=True)
                core = Chem.MolFromSmiles(core_smile)
                if rdMolDescriptors.CalcNumRotatableBonds(
                        core) <= 5 and core.GetNumHeavyAtoms() > 7:
                    children.append(core_smile)
    with open(argv[1], 'w') as f:
        i = 1
        for m in set(children):
            if len(m) > 0:
                f.write(m + '\t' + str(i) + '\n')
                i += 1
示例#3
0
def build_library(in_smile,
                  frags,
                  lib,
                  rules=os.environ["COVALIB"] +
                  "/Code/Covalentizer/numbered_reaction.re",
                  linker_lib=False,
                  linker_smiles=''):
    argv = [in_smile, frags, lib]
    with open(argv[0], 'r') as f:
        smile = f.readline().split()[0]
    mol = Chem.MolFromSmiles(smile)
    if mol == None:
        return
    size = mol.GetNumHeavyAtoms()
    hierarch = Recap.RecapDecompose(mol)
    children = []
    for child in hierarch.GetAllChildren().keys() + [smile]:
        new_smiles = child.replace('[*]', '[H]')
        new = Chem.MolFromSmiles(new_smiles)
        if not new == None:
            new_size = new.GetNumHeavyAtoms()
            if new_size > 7:
                if new_size <= 25 and rdMolDescriptors.CalcNumRotatableBonds(
                        new) <= 5:
                    children.append(Chem.MolToSmiles(new, isomericSmiles=True))
                core_smile = MurckoScaffold.MurckoScaffoldSmilesFromSmiles(
                    new_smiles, includeChirality=True)
                core = Chem.MolFromSmiles(core_smile)
                if new_size <= 25 and rdMolDescriptors.CalcNumRotatableBonds(
                        core) <= 5 and core.GetNumHeavyAtoms() > 7:
                    children.append(core_smile)
    with open(argv[1], 'w') as f:
        i = 1
        for m in set(children):
            if len(m) > 0:
                f.write(m + '\t' + str(i) + '\n')
                i += 1

    if not linker_lib:
        multi_react([rules, argv[1], argv[2]])
    else:
        multi_linkers([rules, argv[1], argv[2]], linker_smiles)
示例#4
0
    def calculate_Murcko_scaffold_smiles(self, binding_sites):
        """
        Given a number of binding sites with ligands in them, returns the Murcko Scaffolds of the ligands by binding site
        :param binding_sites:
        :return:
        """
        from rdkit.Chem.Scaffolds import MurckoScaffold

        # Calculate Murcko scaffolds for each of the binding site ligands
        murcko_dict = []

        # Note: next step assumes the binding sites have unique identifiers: the output of self.get_ensemble_binding_sites() would.
        for b in binding_sites:
            murckos = [
                MurckoScaffold.MurckoScaffoldSmilesFromSmiles(l.smiles)
                for l in b.ligands
            ]
            murcko_dict[b.identifier] = murckos

        return murcko_dict
示例#5
0
 def get_scaffold(self, smile: str) -> str:
     return MS.MurckoScaffoldSmilesFromSmiles(smile)