Пример #1
0
    def test6Options(self):
        smis = ["C1OC1Cc1ccccc1"]
        ms = [Chem.MolFromSmiles(x) for x in smis]
        params = rdScaffoldNetwork.ScaffoldNetworkParams()
        net = rdScaffoldNetwork.CreateScaffoldNetwork(ms, params)
        self.assertEqual(len(net.nodes), 9)
        self.assertEqual(len(net.edges), 8)

        params = rdScaffoldNetwork.ScaffoldNetworkParams()
        params.keepOnlyFirstFragment = False
        net = rdScaffoldNetwork.CreateScaffoldNetwork(ms, params)
        self.assertEqual(len(net.nodes), 19)
        self.assertEqual(len(net.edges), 23)

        params = rdScaffoldNetwork.ScaffoldNetworkParams()
        params.includeGenericScaffolds = False
        net = rdScaffoldNetwork.CreateScaffoldNetwork(ms, params)
        self.assertEqual(len(net.nodes), 5)
        self.assertEqual(len(net.edges), 4)

        params = rdScaffoldNetwork.ScaffoldNetworkParams()
        params.includeGenericBondScaffolds = True
        net = rdScaffoldNetwork.CreateScaffoldNetwork(ms, params)
        self.assertEqual(len(net.nodes), 11)
        self.assertEqual(len(net.edges), 10)
Пример #2
0
 def test7Github3177(self):
     smis = ["C1OC1Cc1ccccc1"]
     ms = [Chem.MolFromSmiles(x) for x in smis]
     ms.append(None)
     params = rdScaffoldNetwork.ScaffoldNetworkParams()
     with self.assertRaises(ValueError):
         net = rdScaffoldNetwork.CreateScaffoldNetwork(ms, params)
Пример #3
0
    def sn_scaff_smiles(self, murcko_smiles):
        """Function to exctract the preferred scaffold based on Scaffold Tree rules from the scaffold network created from a Murcko scaffold

        Args:
            murcko_smiles(str): valdi smiles string of a Murcko scaffold

        Returns:
            str: smiles string of the preferred scaffold

        """

        if murcko_smiles is None:
            return None
        mol = Chem.MolFromSmiles(murcko_smiles)
        if mol is not None:
            # if the murcko scaffold has less or equal than the targeted number of rings, then the Murcko scaffold is already the sn_scaffold,
            # so no further decomposition is needed
            if Chem.rdMolDescriptors.CalcNumRings(mol) <= self.nrings_target:
                return murcko_smiles
            # otherwise start decomposition
            try:
                sn = rdScaffoldNetwork.CreateScaffoldNetwork([mol],
                                                             self.snparams)
            except:
                raise ValueError(
                    "failed to calculate scaffold network for {}".format(
                        murcko_smiles))
            # create data fram with n ode smiles
            node_df = pd.DataFrame({"node_smiles": [str(n) for n in sn.nodes]})
            PandasTools.AddMoleculeColumnToFrame(node_df,
                                                 "node_smiles",
                                                 "mol",
                                                 includeFingerprints=False)
            node_df["num_rings"] = node_df["mol"].apply(
                Chem.rdMolDescriptors.CalcNumRings)
            node_df["num_rings_delta"] = (node_df["num_rings"] -
                                          self.nrings_target).abs()
            node_df["num_rbonds"] = node_df["mol"].apply(
                Chem.rdMolDescriptors.CalcNumRotatableBonds, strict=False)
            node_df["num_hrings"] = node_df["mol"].apply(
                Chem.rdMolDescriptors.CalcNumHeterocycles)
            node_df["num_arings"] = node_df["mol"].apply(
                Chem.rdMolDescriptors.CalcNumAromaticRings)
            node_df["num_bridge"] = node_df["mol"].apply(
                Chem.rdMolDescriptors.CalcNumBridgeheadAtoms)
            node_df["num_spiro"] = node_df["mol"].apply(
                Chem.rdMolDescriptors.CalcNumSpiroAtoms)
            node_df["has_macrocyle"] = node_df["mol"].apply(
                self.has_macrocycle)
            node_df["has_unusual_ring_size"] = node_df["mol"].apply(
                self.has_unusual_ringsize)
            node_df.sort_values(self.priority_cols,
                                ascending=self.priority_asc,
                                inplace=True)
            return node_df.iloc[0]["node_smiles"]
        else:
            raise ValueError("murcko_smiles {} cannot be read by rdkit".format(
                murcko_smiles))
Пример #4
0
    def test4Str(self):
        smis = ["c1ccccc1CC1NC(=O)CCC1"]
        ms = [Chem.MolFromSmiles(x) for x in smis]
        params = rdScaffoldNetwork.ScaffoldNetworkParams()

        net = rdScaffoldNetwork.CreateScaffoldNetwork(ms, params)
        self.assertEqual(len(net.nodes), 9)
        self.assertEqual(len(net.edges), 8)
        self.assertEqual(str(net.edges[0]),
                         "NetworkEdge( 0->1, type:Fragment )")
Пример #5
0
 def test5FragmentationReactions(self):
     smis = ["c1c(CC2CC2)cc(NC2CC2)cc1OC1CC1"]
     ms = [Chem.MolFromSmiles(x) for x in smis]
     params = rdScaffoldNetwork.ScaffoldNetworkParams([
         "[!#0;R:1]-!@[O:2]>>[*:1]-[#0].[#0]-[*:2]",
         "[!#0;R:1]-!@[N:2]>>[*:1]-[#0].[#0]-[*:2]"
     ])
     params.includeScaffoldsWithoutAttachments = False
     params.includeGenericScaffolds = False
     net = rdScaffoldNetwork.CreateScaffoldNetwork(ms, params)
     self.assertEqual(len(net.nodes), 5)
     self.assertEqual(len(net.edges), 7)
Пример #6
0
    def test3Update(self):
        smis = ["c1ccccc1CC1NC(=O)CCC1", "c1cccnc1CC1NC(=O)CCC1"]
        ms = [Chem.MolFromSmiles(x) for x in smis]
        params = rdScaffoldNetwork.ScaffoldNetworkParams()
        net = rdScaffoldNetwork.ScaffoldNetwork()
        rdScaffoldNetwork.UpdateScaffoldNetwork(ms[0:1], net, params)
        self.assertEqual(len(net.nodes), 9)
        self.assertEqual(len(net.edges), 8)
        self.assertEqual(len(net.counts), len(net.nodes))
        self.assertEqual(list(net.counts).count(1), len(net.counts))
        rdScaffoldNetwork.UpdateScaffoldNetwork(ms[1:2], net, params)
        self.assertEqual(len(net.nodes), 12)
        self.assertEqual(len(net.edges), 13)
        self.assertEqual(len(net.counts), len(net.nodes))
        self.assertEqual(
            len([
                x for x in net.edges
                if x.type == rdScaffoldNetwork.EdgeType.Fragment
            ]), 4)
        self.assertEqual(
            len([
                x for x in net.edges
                if x.type == rdScaffoldNetwork.EdgeType.Generic
            ]), 6)
        self.assertEqual(
            len([
                x for x in net.edges
                if x.type == rdScaffoldNetwork.EdgeType.RemoveAttachment
            ]), 3)

        net = rdScaffoldNetwork.CreateScaffoldNetwork(ms[0:1], params)
        rdScaffoldNetwork.UpdateScaffoldNetwork(ms[1:2], net, params)
        self.assertEqual(len(net.nodes), 12)
        self.assertEqual(len(net.edges), 13)
        self.assertEqual(
            len([
                x for x in net.edges
                if x.type == rdScaffoldNetwork.EdgeType.Fragment
            ]), 4)
        self.assertEqual(
            len([
                x for x in net.edges
                if x.type == rdScaffoldNetwork.EdgeType.Generic
            ]), 6)
        self.assertEqual(
            len([
                x for x in net.edges
                if x.type == rdScaffoldNetwork.EdgeType.RemoveAttachment
            ]), 3)
Пример #7
0
    def test1Pickle(self):
        smis = ["c1ccccc1CC1NC(=O)CCC1", "c1cccnc1CC1NC(=O)CCC1"]
        ms = [Chem.MolFromSmiles(x) for x in smis]
        params = rdScaffoldNetwork.ScaffoldNetworkParams()
        params.includeScaffoldsWithoutAttachments = False
        net = rdScaffoldNetwork.CreateScaffoldNetwork(ms, params)
        self.assertEqual(len(net.nodes), 7)
        self.assertEqual(len(net.edges), 7)

        pkl = pickle.dumps(net)
        net2 = pickle.loads(pkl)
        self.assertEqual(len(net2.nodes), 7)
        self.assertEqual(len(net2.edges), 7)
        self.assertEqual(list(net2.nodes), list(net.nodes))
        self.assertEqual([str(x) for x in net2.edges],
                         [str(x) for x in net.edges])
Пример #8
0
 def test2Basics(self):
     smis = ["c1ccccc1CC1NC(=O)CCC1", "c1cccnc1CC1NC(=O)CCC1"]
     ms = [Chem.MolFromSmiles(x) for x in smis]
     params = rdScaffoldNetwork.ScaffoldNetworkParams()
     params.includeScaffoldsWithoutAttachments = False
     net = rdScaffoldNetwork.CreateScaffoldNetwork(ms, params)
     self.assertEqual(len(net.nodes), 7)
     self.assertEqual(len(net.edges), 7)
     self.assertEqual(
         len([
             x for x in net.edges
             if x.type == rdScaffoldNetwork.EdgeType.Fragment
         ]), 4)
     self.assertEqual(
         len([
             x for x in net.edges
             if x.type == rdScaffoldNetwork.EdgeType.Generic
         ]), 3)