Python RGroupDecomposition.Process Examples

Example #1

File: test_rgroups.py Project: schrodinger/rdkit

    def test_userlabels(self):
        smis = ["C(Cl)N(N)O(O)"]
        mols = [Chem.MolFromSmiles(smi) for smi in smis]
        smarts = 'C([*:1])N([*:5])O([*:6])'
        core = Chem.MolFromSmarts(smarts)
        rg = RGroupDecomposition(core)
        for m in mols:
            rg.Add(m)
        rg.Process()
        self.assertEqual(
            rg.GetRGroupsAsColumns(asSmiles=True), {
                'Core': ['C(N(O[*:6])[*:5])[*:1]'],
                'R1': ['Cl[*:1]'],
                'R5': ['[H]N([H])[*:5]'],
                'R6': ['[H]O[*:6]']
            })

        smarts = 'C([*:4])N([*:5])O([*:6])'

        core = Chem.MolFromSmarts(smarts)
        rg = RGroupDecomposition(core)
        for m in mols:
            rg.Add(m)
        rg.Process()
        self.assertEqual(
            rg.GetRGroupsAsColumns(asSmiles=True), {
                'Core': ['C(N(O[*:6])[*:5])[*:4]'],
                'R4': ['Cl[*:4]'],
                'R5': ['[H]N([H])[*:5]'],
                'R6': ['[H]O[*:6]']
            })

Example #2

File: draw.py Project: huluxiaohuowa/jupyfuncs

def do_decomp(mols, cores, options):
    options.rgroupLabelling = RGroupLabelling.AtomMap
    decomp = RGroupDecomposition(cores, options)
    for mol in mols:
        decomp.Add(mol)
    decomp.Process()
    return decomp

Example #3

    def testRemoveAllHydrogenFlags(self):
        core = Chem.MolFromSmiles("[1*]c1ccc([2*])cn1")
        mol = Chem.MolFromSmiles("Fc1ccccn1")

        params = RGroupDecompositionParameters()
        rgd = RGroupDecomposition(core, params)
        self.assertEqual(rgd.Add(mol), 0)
        self.assertTrue(rgd.Process())
        res = rgd.GetRGroupsAsColumns(asSmiles=True)
        self.assertEqual(res, {'Core': ['c1ccc([*:1])nc1'], 'R1': ['F[*:1]']})

        # no change, as removeAllHydrogenRGroupsAndLabels is True
        params = RGroupDecompositionParameters()
        params.removeAllHydrogenRGroups = False
        rgd = RGroupDecomposition(core, params)
        self.assertEqual(rgd.Add(mol), 0)
        self.assertTrue(rgd.Process())
        res = rgd.GetRGroupsAsColumns(asSmiles=True)
        self.assertEqual(res, {'Core': ['c1ccc([*:1])nc1'], 'R1': ['F[*:1]']})

        # Unused user-defined labels retained on core
        # R groups still retained as removeAllHydrogenRGroups is True
        params = RGroupDecompositionParameters()
        params.removeAllHydrogenRGroupsAndLabels = False
        rgd = RGroupDecomposition(core, params)
        self.assertEqual(rgd.Add(mol), 0)
        self.assertTrue(rgd.Process())
        res = rgd.GetRGroupsAsColumns(asSmiles=True)
        self.assertEqual(res, {
            'Core': ['c1cc([*:1])ncc1[*:2]'],
            'R1': ['F[*:1]']
        })

        # Unused user-defined labels retained on core and in R groups
        params = RGroupDecompositionParameters()
        params.removeAllHydrogenRGroups = False
        params.removeAllHydrogenRGroupsAndLabels = False
        rgd = RGroupDecomposition(core, params)
        self.assertEqual(rgd.Add(mol), 0)
        self.assertTrue(rgd.Process())
        res = rgd.GetRGroupsAsColumns(asSmiles=True)
        self.assertEqual(res, {
            'Core': ['c1cc([*:1])ncc1[*:2]'],
            'R1': ['F[*:1]'],
            'R2': ['[H][*:2]']
        })

Example #4

File: test_rgroups.py Project: wxlsummer/rdkit

 def test_getrgrouplabels(self):
   smis = ["C(Cl)N(N)O(O)"]
   mols = [Chem.MolFromSmiles(smi) for smi in smis]
   smarts = 'C([*:1])N([*:5])O([*:6])'
   core = Chem.MolFromSmarts(smarts)
   rg = RGroupDecomposition(core)
   for m in mols:
     rg.Add(m)
   rg.Process()
   self.assertEqual(set(rg.GetRGroupLabels()), set(rg.GetRGroupsAsColumns()))

Example #5

File: test_rgroups.py Project: wxlsummer/rdkit

  def test_h_options(self):
    core = Chem.MolFromSmiles("O=c1oc2ccccc2cc1")
    smiles = ("O=c1cc(Cn2ccnc2)c2ccc(Oc3ccccc3)cc2o1", "O=c1oc2ccccc2c(Cn2ccnc2)c1-c1ccccc1",
              "COc1ccc2c(Cn3cncn3)cc(=O)oc2c1")
    params = RGroupDecompositionParameters()
    rgd = RGroupDecomposition(core, params)
    for smi in smiles:
      m = Chem.MolFromSmiles(smi)
      rgd.Add(m)
    rgd.Process()
    columns = rgd.GetRGroupsAsColumns()
    self.assertEqual(columns['R2'][0].GetNumAtoms(), 7)

    params.removeHydrogensPostMatch = False
    rgd = RGroupDecomposition(core, params)
    for smi in smiles:
      m = Chem.MolFromSmiles(smi)
      rgd.Add(m)
    rgd.Process()
    columns = rgd.GetRGroupsAsColumns()
    self.assertEqual(columns['R2'][0].GetNumAtoms(), 12)

Example #6

File: test_rgroups.py Project: vfscalfani/rdkit

 def multicorergd_test(cores, params, expected_rows, expected_items):
     mols = [Chem.MolFromSmiles(smi) for smi in ("CNC(=O)C1=CN=CN1CC", "Fc1ccc2ccc(Br)nc2n1")]
     params.removeHydrogensPostMatch = True
     params.onlyMatchAtRGroups = True
     decomp = RGroupDecomposition(cores, params)
     i = 0
     for i, m in enumerate(mols):
         res = decomp.Add(m)
         self.assertEqual(res, i)
     self.assertTrue(decomp.Process())
     rows = decomp.GetRGroupsAsRows(asSmiles=True)
     self.assertEqual(rows, expected_rows)
     items = decomp.GetRGroupsAsColumns(asSmiles=True)
     self.assertEqual(items, expected_items)

Example #7

File: test_rgroups.py Project: schrodinger/rdkit

    def test_stereo(self):
        smiles = """C1CCO[C@@H](N)1
C1CCO[C@H](N)1
C1CCO[C@@](N)(O)1
C1CCO[C@@](N)(P)1
C1CCO[C@@](N)(S)1
C1CCO[C@@H](O)1
C1CCO[C@H](O)1
C1CCO[C@@](O)(N)1
C1CCO[C@@](O)(P)1
C1CCO[C@@](O)(S)1
C1CCO[C@@H](P)1
C1CCO[C@H](P)1
C1CCO[C@@](P)(N)1
C1CCO[C@@](P)(O)1
C1CCO[C@@](P)(S)1
C1CCO[C@@H](S)1
C1CCO[C@H](S)1
C1CCO[C@@](S)(N)1
C1CCO[C@@](S)(O)1
C1CCO[C@@](S)(P)1
"""
        mols = []
        for smi in smiles.split():
            m = Chem.MolFromSmiles(smi)
            assert m, smi
            mols.append(m)
        core = Chem.MolFromSmarts("C1CCOC1")
        rgroups = RGroupDecomposition(core)
        for m in mols:
            rgroups.Add(m)
        rgroups.Process()
        columns = rgroups.GetRGroupsAsColumns()
        data = {}
        for k, v in columns.items():
            data[k] = [Chem.MolToSmiles(m, True) for m in v]

        rgroups2, unmatched = RGroupDecompose([core], mols)
        columns2, unmatched = RGroupDecompose([core], mols, asRows=False)
        data2 = {}
        for k, v in columns2.items():
            data2[k] = [Chem.MolToSmiles(m, True) for m in v]

        self.assertEqual(data, data2)
        columns3, unmatched = RGroupDecompose([core],
                                              mols,
                                              asRows=False,
                                              asSmiles=True)
        self.assertEqual(data, columns3)

Example #8

File: test_rgroups.py Project: skrsna/rdkit

    def test_stereo(self):
        smiles = """C1CCO[C@@H](N)1
C1CCO[C@H](N)1
C1CCO[C@@](N)(O)1
C1CCO[C@@](N)(P)1
C1CCO[C@@](N)(S)1
C1CCO[C@@H](O)1
C1CCO[C@H](O)1
C1CCO[C@@](O)(N)1
C1CCO[C@@](O)(P)1
C1CCO[C@@](O)(S)1
C1CCO[C@@H](P)1
C1CCO[C@H](P)1
C1CCO[C@@](P)(N)1
C1CCO[C@@](P)(O)1
C1CCO[C@@](P)(S)1
C1CCO[C@@H](S)1
C1CCO[C@H](S)1
C1CCO[C@@](S)(N)1
C1CCO[C@@](S)(O)1
C1CCO[C@@](S)(P)1
"""
        mols = []
        for smi in smiles.split():
            m = Chem.MolFromSmiles(smi)
            assert m, smi
            mols.append(m)
        core = Chem.MolFromSmarts("C1CCOC1")
        rgroups = RGroupDecomposition(core)
        for m in mols:
            print (m, Chem.MolToSmiles(m))
            rgroups.Add(m)
        rgroups.Process()
        columns = rgroups.GetRGroupsAsColumns()
        for k,v in columns.items():
            print("%s:%s"%(k, " ".join([Chem.MolToSmiles(m,True) for m in v])))