pub_soft/rdkit
3
0
Fork 0
mirror of https://github.com/rdkit/rdkit.git synced 2026-06-03 21:44:30 +08:00
Code Issues Packages Projects Releases Wiki Activity

initial set of changes introducing python3 support

Browse Source
This commit is contained in:
Riccardo Vianello
2014-06-17 18:26:41 +02:00
parent 5a8cc10790
commit 3358ec5925
216 changed files with 4943 additions and 3994 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@@ -124,7 +124,7 @@ if(RDK_BUILD_PYTHON_WRAPPERS)
# From http://plplot.svn.sourceforge.net/viewvc/plplot/trunk/cmake/modules/python.cmake?revision=11014
execute_process(
COMMAND
${PYTHON_EXECUTABLE} -c "from distutils import sysconfig; print sysconfig.get_python_lib(1,0,prefix='${CMAKE_INSTALL_PREFIX}')"
${PYTHON_EXECUTABLE} -c "from __future__ import print_function; from distutils import sysconfig; print(sysconfig.get_python_lib(1,0,prefix='${CMAKE_INSTALL_PREFIX}'))"
OUTPUT_VARIABLE PYTHON_INSTDIR
OUTPUT_STRIP_TRAILING_WHITESPACE
)

61
Code/ChemicalFeatures/Wrap/testFeatures.py
View File

@@ -4,12 +4,13 @@
#
# @@ All Rights Reserved @@
#
from rdkit import RDConfig
from __future__ import print_function
import os
import unittest
from rdkit.six.moves import cPickle
from rdkit import RDConfig
from rdkit import Chem
from rdkit.Chem import ChemicalFeatures
import unittest
import cPickle
from rdkit.Geometry import rdGeometry as geom
def feq(v1,v2,tol2=1e-4):
@@ -36,52 +37,52 @@ class TestCase(unittest.TestCase):
ffeat = ChemicalFeatures.FreeChemicalFeature()
ffeat.SetId(123)
pos = ffeat.GetId()
self.failUnless(pos == 123)
self.assertTrue(pos == 123)
ffeat.SetFamily("HBondDonor")
self.failUnless(ffeat.GetFamily() == "HBondDonor")
self.assertTrue(ffeat.GetFamily() == "HBondDonor")
ffeat.SetPos(geom.Point3D(1.0, 2.0, 3.0))
pos = ffeat.GetPos()
self.failUnless(ptFeq(pos, geom.Point3D(1.0, 2.0, 3.0)))
self.assertTrue(ptFeq(pos, geom.Point3D(1.0, 2.0, 3.0)))
ffeat.SetType("HBondDonor1")
self.failUnless(ffeat.GetType() == "HBondDonor1")
self.assertTrue(ffeat.GetType() == "HBondDonor1")
ffeat = ChemicalFeatures.FreeChemicalFeature("HBondDonor", "HBondDonor1", geom.Point3D(1.0, 2.0, 3.0))
self.failUnless(ffeat.GetId() == -1)
self.failUnless(ffeat.GetFamily() == "HBondDonor")
self.failUnless(ffeat.GetType() == "HBondDonor1")
self.assertTrue(ffeat.GetId() == -1)
self.assertTrue(ffeat.GetFamily() == "HBondDonor")
self.assertTrue(ffeat.GetType() == "HBondDonor1")
ffeat = ChemicalFeatures.FreeChemicalFeature("HBondDonor", "HBondDonor1", geom.Point3D(1.0, 2.0, 3.0),id=123)
self.failUnless(ffeat.GetId() == 123)
self.failUnless(ffeat.GetFamily() == "HBondDonor")
self.failUnless(ffeat.GetType() == "HBondDonor1")
self.assertTrue(ffeat.GetId() == 123)
self.assertTrue(ffeat.GetFamily() == "HBondDonor")
self.assertTrue(ffeat.GetType() == "HBondDonor1")
pos = ffeat.GetPos()
self.failUnless(ptFeq(pos, geom.Point3D(1.0, 2.0, 3.0)))
self.assertTrue(ptFeq(pos, geom.Point3D(1.0, 2.0, 3.0)))
ffeat = ChemicalFeatures.FreeChemicalFeature(id = 123, type="HBondDonor1", family="HBondDonor", loc=geom.Point3D(1.0, 2.0, 3.0))
self.failUnless(ffeat.GetId() == 123)
self.failUnless(ffeat.GetFamily() == "HBondDonor")
self.failUnless(ffeat.GetType() == "HBondDonor1")
self.assertTrue(ffeat.GetId() == 123)
self.assertTrue(ffeat.GetFamily() == "HBondDonor")
self.assertTrue(ffeat.GetType() == "HBondDonor1")
pos = ffeat.GetPos()
self.failUnless(ptFeq(pos, geom.Point3D(1.0, 2.0, 3.0)))
self.assertTrue(ptFeq(pos, geom.Point3D(1.0, 2.0, 3.0)))
def testPickle(self):
ffeat = ChemicalFeatures.FreeChemicalFeature("HBondDonor", "HBondDonor1", geom.Point3D(1.0, 2.0, 3.0),123)
pkl = cPickle.dumps(ffeat)
ffeat2 = cPickle.loads(pkl)
self.failUnless(ffeat2.GetId()==ffeat.GetId());
self.failUnless(ffeat2.GetFamily()==ffeat.GetFamily())
self.failUnless(ffeat2.GetType()==ffeat.GetType())
self.failUnless(ptFeq(ffeat2.GetPos(),ffeat.GetPos()))
self.assertTrue(ffeat2.GetId()==ffeat.GetId());
self.assertTrue(ffeat2.GetFamily()==ffeat.GetFamily())
self.assertTrue(ffeat2.GetType()==ffeat.GetType())
self.assertTrue(ptFeq(ffeat2.GetPos(),ffeat.GetPos()))
# Check that the old pickled versions have not been broken
inF = file(os.path.join(RDConfig.RDBaseDir,
'Code/ChemicalFeatures/Wrap/testData/feat.pkl'),'rb')
ffeat2=cPickle.load(inF)
# this version (1.0) does not have an id in the byte stream
self.failUnless(ffeat2.GetFamily()==ffeat.GetFamily())
self.failUnless(ffeat2.GetType()==ffeat.GetType())
self.failUnless(ptFeq(ffeat2.GetPos(),ffeat.GetPos()))
self.assertTrue(ffeat2.GetFamily()==ffeat.GetFamily())
self.assertTrue(ffeat2.GetType()==ffeat.GetType())
self.assertTrue(ptFeq(ffeat2.GetPos(),ffeat.GetPos()))
# Test the new version also has the id and works as expected
@@ -91,13 +92,13 @@ class TestCase(unittest.TestCase):
inF = file(os.path.join(RDConfig.RDBaseDir,
'Code/ChemicalFeatures/Wrap/testData/featv2.pkl'),'rb')
ffeat2=cPickle.load(inF)
self.failUnless(ffeat2.GetId()==ffeat.GetId());
self.failUnless(ffeat2.GetFamily()==ffeat.GetFamily())
self.failUnless(ffeat2.GetType()==ffeat.GetType())
self.failUnless(ptFeq(ffeat2.GetPos(),ffeat.GetPos()))
self.assertTrue(ffeat2.GetId()==ffeat.GetId());
self.assertTrue(ffeat2.GetFamily()==ffeat.GetFamily())
self.assertTrue(ffeat2.GetType()==ffeat.GetType())
self.assertTrue(ptFeq(ffeat2.GetPos(),ffeat.GetPos()))
if __name__ == '__main__':
print "Testing ChemicalFeatures Wrapper code:"
print("Testing ChemicalFeatures Wrapper code:")
unittest.main()

3
Code/DataManip/MetricMatrixCalc/Wrap/rdMetricMatrixCalc.cpp
View File

@@ -15,6 +15,7 @@
#include <RDBoost/PySequenceHolder.h>
#include <RDBoost/Wrap.h>
#include <RDBoost/import_array.h>
#include <RDGeneral/types.h>
@@ -240,7 +241,7 @@ BOOST_PYTHON_MODULE(rdMetricMatrixCalc)
"e.g. similarity and distance matrices"
;
import_array();
rdkit_import_array();
python::register_exception_translator<IndexErrorException>(&translate_index_error);
python::register_exception_translator<ValueErrorException>(&translate_value_error);

7
Code/DataManip/MetricMatrixCalc/Wrap/testMatricCalc.py
View File

@@ -1,3 +1,4 @@
from __future__ import division
from rdkit import RDConfig
import unittest
from rdkit.DataManip.Metric import rdMetricMatrixCalc as rdmmc
@@ -111,7 +112,7 @@ class TestCase(unittest.TestCase):
assert numpy.shape(dmatArr) == numpy.shape(dmatLL)
for i in range(n*(n-1)/2):
for i in range(n*(n-1)//2):
assert feq(dmatArr[i], dmatLL[i])
def test4ebv(self) :
@@ -130,7 +131,7 @@ class TestCase(unittest.TestCase):
sMat = rdmmc.GetTanimotoSimMat(lst)
for i in range(n*(n-1)/2) :
for i in range(n*(n-1)//2) :
assert feq(sMat[i] + dMat[i], 1.0)
def test5sbv(self) :
@@ -149,7 +150,7 @@ class TestCase(unittest.TestCase):
sMat = rdmmc.GetTanimotoSimMat(lst)
for i in range(n*(n-1)/2) :
for i in range(n*(n-1)//2) :
assert feq(sMat[i] + dMat[i], 1.0)
if __name__ == '__main__':

5
Code/DataStructs/Wrap/DataStructs.cpp
View File

@@ -18,7 +18,8 @@
#include <boost/python/numeric.hpp>
#include <numpy/npy_common.h>
#include <numpy/arrayobject.h>
#include <RDBoost/import_array.h>
#include <RDBoost/pyint_api.h>
namespace python = boost::python;
@@ -52,7 +53,7 @@ void convertToNumpyArray(const T &v,python::object destArray){
BOOST_PYTHON_MODULE(cDataStructs)
{
import_array();
rdkit_import_array();
python::scope().attr("__doc__") =
"Module containing an assortment of functionality for basic data structures.\n"
"\n"

88
Code/DataStructs/Wrap/testBV.py
View File

@@ -1,7 +1,7 @@
from rdkit import DataStructs
from rdkit import RDConfig
import unittest
import cPickle as pickle
from rdkit.six.moves import cPickle as pickle
import random
import numpy
@@ -25,11 +25,11 @@ class TestCase(unittest.TestCase):
for i in range(1000) :
assert bv1.GetBit(i) == bv2.GetBit(i)
self.failUnless(bv1==bv2)
self.assertTrue(bv1==bv2)
bv2.SetBit(1)
self.failUnless(bv1!=bv2)
self.assertTrue(bv1!=bv2)
bv2.UnSetBit(1)
self.failUnless(bv1==bv2)
self.assertTrue(bv1==bv2)
bv2.UnSetBitsFromList(obits)
for i in range(1000) :
@@ -102,16 +102,16 @@ class TestCase(unittest.TestCase):
bv1.SetBit(i)
if i < 3*sz/4:
bv2.SetBit(i)
self.failUnless(DataStructs.AllProbeBitsMatch(bv1,bv1.ToBinary()))
self.failUnless(DataStructs.AllProbeBitsMatch(bv2,bv1.ToBinary()))
self.failIf(DataStructs.AllProbeBitsMatch(bv1,bv2.ToBinary()))
self.failUnless(DataStructs.AllProbeBitsMatch(bv2,bv2.ToBinary()))
self.assertTrue(DataStructs.AllProbeBitsMatch(bv1,bv1.ToBinary()))
self.assertTrue(DataStructs.AllProbeBitsMatch(bv2,bv1.ToBinary()))
self.assertFalse(DataStructs.AllProbeBitsMatch(bv1,bv2.ToBinary()))
self.assertTrue(DataStructs.AllProbeBitsMatch(bv2,bv2.ToBinary()))
def test5FromBitString(self):
s1 = '1010'
bv = DataStructs.CreateFromBitString(s1)
self.failUnless(len(bv)==4)
self.failUnless(list(bv.GetOnBits())==[0,2])
self.assertTrue(len(bv)==4)
self.assertTrue(list(bv.GetOnBits())==[0,2])
def test6BulkOps(self):
nbits = 10000
@@ -125,41 +125,41 @@ class TestCase(unittest.TestCase):
sims = DataStructs.BulkTanimotoSimilarity(bvs[0],bvs)
for i in range(len(bvs)):
sim = DataStructs.TanimotoSimilarity(bvs[0],bvs[i])
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sims = DataStructs.BulkDiceSimilarity(bvs[0],bvs)
for i in range(len(bvs)):
sim = DataStructs.DiceSimilarity(bvs[0],bvs[i])
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sims = DataStructs.BulkAllBitSimilarity(bvs[0],bvs)
for i in range(len(bvs)):
sim = DataStructs.AllBitSimilarity(bvs[0],bvs[i])
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sims = DataStructs.BulkOnBitSimilarity(bvs[0],bvs)
for i in range(len(bvs)):
sim = DataStructs.OnBitSimilarity(bvs[0],bvs[i])
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sims = DataStructs.BulkRogotGoldbergSimilarity(bvs[0],bvs)
for i in range(len(bvs)):
sim = DataStructs.RogotGoldbergSimilarity(bvs[0],bvs[i])
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sims = DataStructs.BulkTverskySimilarity(bvs[0],bvs,1,1)
for i in range(len(bvs)):
sim = DataStructs.TverskySimilarity(bvs[0],bvs[i],1,1)
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sim = DataStructs.TanimotoSimilarity(bvs[0],bvs[i])
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sims = DataStructs.BulkTverskySimilarity(bvs[0],bvs,.5,.5)
for i in range(len(bvs)):
sim = DataStructs.TverskySimilarity(bvs[0],bvs[i],.5,.5)
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sim = DataStructs.DiceSimilarity(bvs[0],bvs[i])
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
def test7FPS(self):
bv = DataStructs.ExplicitBitVect(32)
@@ -169,14 +169,14 @@ class TestCase(unittest.TestCase):
bv.SetBit(23)
bv.SetBit(31)
self.failUnlessEqual(DataStructs.BitVectToFPSText(bv),"03008280")
self.assertEqual(DataStructs.BitVectToFPSText(bv),"03008280")
bv2 = DataStructs.CreateFromFPSText("03008280")
self.failUnlessEqual(bv,bv2)
self.assertEqual(bv,bv2)
self.failUnlessRaises(ValueError,lambda : DataStructs.CreateFromFPSText("030082801"))
self.assertRaises(ValueError,lambda : DataStructs.CreateFromFPSText("030082801"))
bv2 = DataStructs.CreateFromFPSText("")
self.failUnlessEqual(bv2.GetNumBits(),0)
self.assertEqual(bv2.GetNumBits(),0)
def test8BinText(self):
@@ -188,10 +188,10 @@ class TestCase(unittest.TestCase):
bv.SetBit(31)
bv2 = DataStructs.CreateFromBinaryText(DataStructs.BitVectToBinaryText(bv))
self.failUnlessEqual(bv,bv2)
self.assertEqual(bv,bv2)
bv2 = DataStructs.CreateFromBinaryText("")
self.failUnlessEqual(bv2.GetNumBits(),0)
self.assertEqual(bv2.GetNumBits(),0)
def test9ToNumpy(self):
import numpy
@@ -204,7 +204,7 @@ class TestCase(unittest.TestCase):
arr = numpy.zeros((3,),'i')
DataStructs.ConvertToNumpyArray(bv,arr)
for i in range(bv.GetNumBits()):
self.failUnlessEqual(bv[i],arr[i])
self.assertEqual(bv[i],arr[i])
def test10BulkOps2(self):
nbits = 10000
@@ -219,41 +219,41 @@ class TestCase(unittest.TestCase):
sims = DataStructs.BulkTanimotoSimilarity(bvs[0],bvs)
for i in range(len(bvs)):
sim = DataStructs.TanimotoSimilarity(bvs[0],bvs[i])
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sims = DataStructs.BulkDiceSimilarity(bvs[0],bvs)
for i in range(len(bvs)):
sim = DataStructs.DiceSimilarity(bvs[0],bvs[i])
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sims = DataStructs.BulkAllBitSimilarity(bvs[0],bvs)
for i in range(len(bvs)):
sim = DataStructs.AllBitSimilarity(bvs[0],bvs[i])
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sims = DataStructs.BulkOnBitSimilarity(bvs[0],bvs)
for i in range(len(bvs)):
sim = DataStructs.OnBitSimilarity(bvs[0],bvs[i])
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sims = DataStructs.BulkRogotGoldbergSimilarity(bvs[0],bvs)
for i in range(len(bvs)):
sim = DataStructs.RogotGoldbergSimilarity(bvs[0],bvs[i])
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sims = DataStructs.BulkTverskySimilarity(bvs[0],bvs,1,1)
for i in range(len(bvs)):
sim = DataStructs.TverskySimilarity(bvs[0],bvs[i],1,1)
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sim = DataStructs.TanimotoSimilarity(bvs[0],bvs[i])
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sims = DataStructs.BulkTverskySimilarity(bvs[0],bvs,.5,.5)
for i in range(len(bvs)):
sim = DataStructs.TverskySimilarity(bvs[0],bvs[i],.5,.5)
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sim = DataStructs.DiceSimilarity(bvs[0],bvs[i])
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
def test10BulkOps3(self):
nbits = 10000
@@ -267,41 +267,41 @@ class TestCase(unittest.TestCase):
sims = DataStructs.BulkTanimotoSimilarity(bvs[0],bvs)
for i in range(len(bvs)):
sim = DataStructs.TanimotoSimilarity(bvs[0],bvs[i])
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sims = DataStructs.BulkDiceSimilarity(bvs[0],bvs)
for i in range(len(bvs)):
sim = DataStructs.DiceSimilarity(bvs[0],bvs[i])
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sims = DataStructs.BulkAllBitSimilarity(bvs[0],bvs)
for i in range(len(bvs)):
sim = DataStructs.AllBitSimilarity(bvs[0],bvs[i])
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sims = DataStructs.BulkOnBitSimilarity(bvs[0],bvs)
for i in range(len(bvs)):
sim = DataStructs.OnBitSimilarity(bvs[0],bvs[i])
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sims = DataStructs.BulkRogotGoldbergSimilarity(bvs[0],bvs)
for i in range(len(bvs)):
sim = DataStructs.RogotGoldbergSimilarity(bvs[0],bvs[i])
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sims = DataStructs.BulkTverskySimilarity(bvs[0],bvs,1,1)
for i in range(len(bvs)):
sim = DataStructs.TverskySimilarity(bvs[0],bvs[i],1,1)
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sim = DataStructs.TanimotoSimilarity(bvs[0],bvs[i])
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sims = DataStructs.BulkTverskySimilarity(bvs[0],bvs,.5,.5)
for i in range(len(bvs)):
sim = DataStructs.TverskySimilarity(bvs[0],bvs[i],.5,.5)
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
sim = DataStructs.DiceSimilarity(bvs[0],bvs[i])
self.failUnless(feq(sim,sims[i]))
self.assertTrue(feq(sim,sims[i]))
if __name__ == '__main__':

206
Code/DataStructs/Wrap/testDiscreteValueVect.py
View File

@@ -4,9 +4,12 @@
#
# @@ All Rights Reserved @@
#
from rdkit import RDConfig
import os,sys,cPickle
import os
import sys
import unittest
from rdkit import RDConfig
from rdkit.six.moves import cPickle
from rdkit import DataStructs as ds
class TestCase(unittest.TestCase):
@@ -18,66 +21,66 @@ class TestCase(unittest.TestCase):
for i in range(15):
v1[2*i] = 1;
self.failUnless(len(v1) == 30)
self.failUnless(v1.GetTotalVal() == 15)
self.assertTrue(len(v1) == 30)
self.assertTrue(v1.GetTotalVal() == 15)
for i in range(len(v1)):
self.failUnless(v1[i] == (i+1)%2)
self.assertTrue(v1[i] == (i+1)%2)
self.failUnlessRaises(ValueError, lambda : v1.__setitem__(5, 2))
self.assertRaises(ValueError, lambda : v1.__setitem__(5, 2))
v1 = ds.DiscreteValueVect(ds.DiscreteValueType.TWOBITVALUE, 30)
for i in range(len(v1)):
v1[i] = i%4;
self.failUnless(len(v1) == 30)
self.assertTrue(len(v1) == 30)
for i in range(len(v1)):
self.failUnless(v1[i] == i%4)
self.assertTrue(v1[i] == i%4)
self.failUnlessRaises(ValueError, lambda : v1.__setitem__(10, 6))
self.assertRaises(ValueError, lambda : v1.__setitem__(10, 6))
v1 = ds.DiscreteValueVect(ds.DiscreteValueType.FOURBITVALUE, 30)
for i in range(len(v1)):
v1[i] = i%16;
self.failUnless(len(v1) == 30)
self.failUnless(v1.GetTotalVal() == 211)
self.assertTrue(len(v1) == 30)
self.assertTrue(v1.GetTotalVal() == 211)
for i in range(len(v1)):
self.failUnless(v1[i] == i%16)
self.assertTrue(v1[i] == i%16)
self.failUnlessRaises(ValueError, lambda : v1.__setitem__(10, 16))
self.assertRaises(ValueError, lambda : v1.__setitem__(10, 16))
v1 = ds.DiscreteValueVect(ds.DiscreteValueType.EIGHTBITVALUE, 32)
for i in range(len(v1)):
v1[i] = i%256;
self.failUnless(len(v1) == 32)
self.failUnless(v1.GetTotalVal() == 496)
self.assertTrue(len(v1) == 32)
self.assertTrue(v1.GetTotalVal() == 496)
for i in range(len(v1)):
self.failUnless(v1[i] == i%256)
self.assertTrue(v1[i] == i%256)
self.failUnlessRaises(ValueError, lambda : v1.__setitem__(10, 256))
self.assertRaises(ValueError, lambda : v1.__setitem__(10, 256))
v1 = ds.DiscreteValueVect(ds.DiscreteValueType.SIXTEENBITVALUE, 300)
for i in range(len(v1)):
v1[i] = i%300;
self.failUnless(len(v1) == 300)
self.failUnless(v1.GetTotalVal() == 44850)
self.failUnlessRaises(ValueError, lambda : v1.__setitem__(10, 65536))
self.assertTrue(len(v1) == 300)
self.assertTrue(v1.GetTotalVal() == 44850)
self.assertRaises(ValueError, lambda : v1.__setitem__(10, 65536))
def test2VectDistances(self):
v1 = ds.DiscreteValueVect(ds.DiscreteValueType.ONEBITVALUE, 30)
v2 = ds.DiscreteValueVect(ds.DiscreteValueType.ONEBITVALUE, 30)
for i in range(15):
v1[2*i] = 1
v2[2*i] = 1
self.failUnless(ds.ComputeL1Norm(v1, v2) == 0)
self.assertTrue(ds.ComputeL1Norm(v1, v2) == 0)
for i in range(30):
if (i%3 == 0):
v2[i] = 1
else:
v2[i] = 0
self.failUnless(ds.ComputeL1Norm(v1, v2) == 15)
self.assertTrue(ds.ComputeL1Norm(v1, v2) == 15)
v1 = ds.DiscreteValueVect(ds.DiscreteValueType.TWOBITVALUE, 30)
v2 = ds.DiscreteValueVect(ds.DiscreteValueType.TWOBITVALUE, 30)
@@ -86,14 +89,14 @@ class TestCase(unittest.TestCase):
v1[i] = i%4
v2[i] = (i+1)%4
self.failUnless(ds.ComputeL1Norm(v1, v2) == 44)
self.assertTrue(ds.ComputeL1Norm(v1, v2) == 44)
v1 = ds.DiscreteValueVect(ds.DiscreteValueType.FOURBITVALUE, 16)
v2 = ds.DiscreteValueVect(ds.DiscreteValueType.FOURBITVALUE, 16)
for i in range(16):
v1[i] = i%16
v2[i] = i%5
self.failUnless(ds.ComputeL1Norm(v1, v2) == 90)
self.assertTrue(ds.ComputeL1Norm(v1, v2) == 90)
v1 = ds.DiscreteValueVect(ds.DiscreteValueType.EIGHTBITVALUE, 5)
v2 = ds.DiscreteValueVect(ds.DiscreteValueType.EIGHTBITVALUE, 5)
@@ -108,7 +111,7 @@ class TestCase(unittest.TestCase):
v2[2] = 103
v2[3] = 6
v2[4] = 228
self.failUnless(ds.ComputeL1Norm(v1, v2) == 370)
self.assertTrue(ds.ComputeL1Norm(v1, v2) == 370)
v1 = ds.DiscreteValueVect(ds.DiscreteValueType.SIXTEENBITVALUE, 3)
v2 = ds.DiscreteValueVect(ds.DiscreteValueType.SIXTEENBITVALUE, 3)
@@ -119,105 +122,108 @@ class TestCase(unittest.TestCase):
v2[0] = 1345
v2[1] = 54578
v2[2] = 10034
self.failUnless(ds.ComputeL1Norm(v1, v2) == 21000)
self.assertTrue(ds.ComputeL1Norm(v1, v2) == 21000)
def test3Pickles(self):
#outF = file('dvvs.pkl','wb+')
inF = file(os.path.join(RDConfig.RDBaseDir,
'Code/DataStructs/Wrap/testData/dvvs.pkl'),'rb')
v1 = ds.DiscreteValueVect(ds.DiscreteValueType.ONEBITVALUE, 30)
for i in range(15):
v1[2*i] = 1
v2 = cPickle.loads(cPickle.dumps(v1))
self.failUnless(ds.ComputeL1Norm(v1, v2) == 0)
#cPickle.dump(v1,outF)
v2=cPickle.load(inF)
self.failUnless(ds.ComputeL1Norm(v1, v2) == 0)
self.failUnless(v1.GetTotalVal()==v2.GetTotalVal())
self.failUnless(v2.GetTotalVal()!=0)
with open(
os.path.join(RDConfig.RDBaseDir,
'Code/DataStructs/Wrap/testData/dvvs.pkl'),
'rb'
) as inF:
v1 = ds.DiscreteValueVect(ds.DiscreteValueType.ONEBITVALUE, 30)
for i in range(15):
v1[2*i] = 1
v2 = cPickle.loads(cPickle.dumps(v1))
self.assertTrue(ds.ComputeL1Norm(v1, v2) == 0)
#cPickle.dump(v1,outF)
v2=cPickle.load(inF)
self.assertTrue(ds.ComputeL1Norm(v1, v2) == 0)
self.assertTrue(v1.GetTotalVal()==v2.GetTotalVal())
self.assertTrue(v2.GetTotalVal()!=0)
v1 = ds.DiscreteValueVect(ds.DiscreteValueType.TWOBITVALUE, 30)
for i in range(30):
v1[i] = i%4
v2 = cPickle.loads(cPickle.dumps(v1))
self.failUnless(ds.ComputeL1Norm(v1, v2) == 0)
#cPickle.dump(v1,outF)
v2=cPickle.load(inF)
self.failUnless(ds.ComputeL1Norm(v1, v2) == 0)
self.failUnless(v1.GetTotalVal()==v2.GetTotalVal())
self.failUnless(v2.GetTotalVal()!=0)
v1 = ds.DiscreteValueVect(ds.DiscreteValueType.TWOBITVALUE, 30)
for i in range(30):
v1[i] = i%4
v2 = cPickle.loads(cPickle.dumps(v1))
self.assertTrue(ds.ComputeL1Norm(v1, v2) == 0)
#cPickle.dump(v1,outF)
v2=cPickle.load(inF)
self.assertTrue(ds.ComputeL1Norm(v1, v2) == 0)
self.assertTrue(v1.GetTotalVal()==v2.GetTotalVal())
self.assertTrue(v2.GetTotalVal()!=0)
v1 = ds.DiscreteValueVect(ds.DiscreteValueType.FOURBITVALUE, 16)
for i in range(16):
v1[i] = i%16
v2 = cPickle.loads(cPickle.dumps(v1))
self.assertTrue(ds.ComputeL1Norm(v1, v2) == 0)
#cPickle.dump(v1,outF)
v2=cPickle.load(inF)
self.assertTrue(ds.ComputeL1Norm(v1, v2) == 0)
self.assertTrue(v1.GetTotalVal()==v2.GetTotalVal())
self.assertTrue(v2.GetTotalVal()!=0)
v1 = ds.DiscreteValueVect(ds.DiscreteValueType.FOURBITVALUE, 16)
for i in range(16):
v1[i] = i%16
v2 = cPickle.loads(cPickle.dumps(v1))
self.failUnless(ds.ComputeL1Norm(v1, v2) == 0)
#cPickle.dump(v1,outF)
v2=cPickle.load(inF)
self.failUnless(ds.ComputeL1Norm(v1, v2) == 0)
self.failUnless(v1.GetTotalVal()==v2.GetTotalVal())
self.failUnless(v2.GetTotalVal()!=0)
v1 = ds.DiscreteValueVect(ds.DiscreteValueType.EIGHTBITVALUE, 5)
v1[0] = 34
v1[1] = 167
v1[2] = 3
v1[3] = 56
v1[4] = 128
v2 = cPickle.loads(cPickle.dumps(v1))
self.assertTrue(ds.ComputeL1Norm(v1, v2) == 0)
#cPickle.dump(v1,outF)
v2=cPickle.load(inF)
self.assertTrue(ds.ComputeL1Norm(v1, v2) == 0)
self.assertTrue(v1.GetTotalVal()==v2.GetTotalVal())
self.assertTrue(v2.GetTotalVal()!=0)
v1 = ds.DiscreteValueVect(ds.DiscreteValueType.EIGHTBITVALUE, 5)
v1[0] = 34
v1[1] = 167
v1[2] = 3
v1[3] = 56
v1[4] = 128
v2 = cPickle.loads(cPickle.dumps(v1))
self.failUnless(ds.ComputeL1Norm(v1, v2) == 0)
#cPickle.dump(v1,outF)
v2=cPickle.load(inF)
self.failUnless(ds.ComputeL1Norm(v1, v2) == 0)
self.failUnless(v1.GetTotalVal()==v2.GetTotalVal())
self.failUnless(v2.GetTotalVal()!=0)
v1 = ds.DiscreteValueVect(ds.DiscreteValueType.SIXTEENBITVALUE, 3)
v1[0] = 2345
v1[1] = 64578
v1[2] = 34
v2 = cPickle.loads(cPickle.dumps(v1))
self.failUnless(ds.ComputeL1Norm(v1, v2) == 0)
#cPickle.dump(v1,outF)
v2=cPickle.load(inF)
self.failUnless(ds.ComputeL1Norm(v1, v2) == 0)
self.failUnless(v1.GetTotalVal()==v2.GetTotalVal())
self.failUnless(v2.GetTotalVal()!=0)
v1 = ds.DiscreteValueVect(ds.DiscreteValueType.SIXTEENBITVALUE, 3)
v1[0] = 2345
v1[1] = 64578
v1[2] = 34
v2 = cPickle.loads(cPickle.dumps(v1))
self.assertTrue(ds.ComputeL1Norm(v1, v2) == 0)
#cPickle.dump(v1,outF)
v2=cPickle.load(inF)
self.assertTrue(ds.ComputeL1Norm(v1, v2) == 0)
self.assertTrue(v1.GetTotalVal()==v2.GetTotalVal())
self.assertTrue(v2.GetTotalVal()!=0)
def test4DiscreteVectOps(self):
v1 = ds.DiscreteValueVect(ds.DiscreteValueType.TWOBITVALUE, 8)
for i in range(4):
v1[2*i] = 2
self.failUnless(v1.GetTotalVal()==8)
self.assertTrue(v1.GetTotalVal()==8)
v2 = ds.DiscreteValueVect(ds.DiscreteValueType.TWOBITVALUE, 8)
for i in range(4):
v2[2*i+1] = 2
v2[2*i] = 1
self.failUnless(v2.GetTotalVal()==12)
self.assertTrue(v2.GetTotalVal()==12)
v3 = v1|v2
self.failUnless(len(v3)==len(v2))
self.failUnless(v3.GetTotalVal()==16)
self.assertTrue(len(v3)==len(v2))
self.assertTrue(v3.GetTotalVal()==16)
v3 = v1&v2
self.failUnless(len(v3)==len(v2))
self.failUnless(v3.GetTotalVal()==4)
self.assertTrue(len(v3)==len(v2))
self.assertTrue(v3.GetTotalVal()==4)
v4 = v1+v2
self.failUnless(len(v4)==len(v2))
self.failUnless(v4.GetTotalVal()==20)
self.assertTrue(len(v4)==len(v2))
self.assertTrue(v4.GetTotalVal()==20)
v4 = v1-v2
self.failUnless(v4.GetTotalVal()==4)
self.assertTrue(v4.GetTotalVal()==4)
v4 = v2-v1
self.failUnless(v4.GetTotalVal()==8)
self.assertTrue(v4.GetTotalVal()==8)
v4 = v2
v4 -= v1
self.failUnless(v4.GetTotalVal()==8)
self.assertTrue(v4.GetTotalVal()==8)
v4 -= v4
self.failUnless(v4.GetTotalVal()==0)
self.assertTrue(v4.GetTotalVal()==0)
def testIterator(self):
"""
@@ -228,10 +234,10 @@ class TestCase(unittest.TestCase):
for i in range(15):
v1[2*i] = 1;
l1 = list(v1)
self.failUnless(len(l1)==len(v1))
self.assertTrue(len(l1)==len(v1))
for i,v in enumerate(v1):
self.failUnless(l1[i]==v)
self.failUnlessRaises(IndexError,lambda :v1[40])
self.assertTrue(l1[i]==v)
self.assertRaises(IndexError,lambda :v1[40])
def test9ToNumpy(self):
import numpy
@@ -244,7 +250,7 @@ class TestCase(unittest.TestCase):
arr = numpy.zeros((3,),'i')
ds.ConvertToNumpyArray(bv,arr)
for i in range(len(bv)):
self.failUnlessEqual(bv[i],arr[i])
self.assertEqual(bv[i],arr[i])

105
Code/DataStructs/Wrap/testSparseIntVect.py
View File

@@ -4,9 +4,10 @@
#
# @@ All Rights Reserved @@
#
from rdkit import RDConfig
import os,sys,cPickle
import os,sys
import unittest
from rdkit.six.moves import cPickle
from rdkit import RDConfig
from rdkit import DataStructs as ds
def feq(v1,v2,tol=1e-4):
@@ -20,111 +21,119 @@ class TestCase(unittest.TestCase):
"""
v1 = ds.IntSparseIntVect(5)
self.failUnlessRaises(IndexError,lambda:v1[5])
self.assertRaises(IndexError,lambda:v1[5])
v1[0]=1
v1[2]=2
v1[3]=3
self.failUnless(v1==v1)
self.failUnless(v1.GetLength()==5)
self.assertTrue(v1==v1)
self.assertTrue(v1.GetLength()==5)
v2= ds.IntSparseIntVect(5)
self.failUnless(v1!=v2)
self.assertTrue(v1!=v2)
v2|=v1
self.failUnless(v2==v1)
self.assertTrue(v2==v1)
v3=v2|v1
self.failUnless(v3==v1)
self.assertTrue(v3==v1)
onVs = v1.GetNonzeroElements()
self.failUnless(onVs=={0:1,2:2,3:3})
self.assertTrue(onVs=={0:1,2:2,3:3})
def test2Long(self):
"""
"""
l=1L<<42
l=1<<42
v1 = ds.LongSparseIntVect(l)
self.failUnlessRaises(IndexError,lambda:v1[l])
self.assertRaises(IndexError,lambda:v1[l])
v1[0]=1
v1[2]=2
v1[1L<<35]=3
self.failUnless(v1==v1)
self.failUnless(v1.GetLength()==l)
v1[1<<35]=3
self.assertTrue(v1==v1)
self.assertTrue(v1.GetLength()==l)
v2= ds.LongSparseIntVect(l)
self.failUnless(v1!=v2)
self.assertTrue(v1!=v2)
v2|=v1
self.failUnless(v2==v1)
self.assertTrue(v2==v1)
v3=v2|v1
self.failUnless(v3==v1)
self.assertTrue(v3==v1)
onVs = v1.GetNonzeroElements()
self.failUnless(onVs=={0L:1,2L:2,1L<<35:3})
self.assertTrue(onVs=={0:1,2:2,1<<35:3})
def test3Pickle1(self):
"""
"""
l=1L<<42
l=1<<42
v1 = ds.LongSparseIntVect(l)
self.failUnlessRaises(IndexError,lambda:v1[l+1])
self.assertRaises(IndexError,lambda:v1[l+1])
v1[0]=1
v1[2]=2
v1[1L<<35]=3
self.failUnless(v1==v1)
v1[1<<35]=3
self.assertTrue(v1==v1)
v2= cPickle.loads(cPickle.dumps(v1))
self.failUnless(v2==v1)
self.assertTrue(v2==v1)
v3= ds.LongSparseIntVect(v2.ToBinary())
self.failUnless(v2==v3)
self.failUnless(v1==v3)
self.assertTrue(v2==v3)
self.assertTrue(v1==v3)
#cPickle.dump(v1,file('lsiv.pkl','wb+'))
v3 = cPickle.load(file(os.path.join(RDConfig.RDBaseDir,
'Code/DataStructs/Wrap/testData/lsiv.pkl'),'rb'))
self.failUnless(v3==v1)
with open(
os.path.join(RDConfig.RDBaseDir,
'Code/DataStructs/Wrap/testData/lsiv.pkl'),
'rb'
) as f:
v3 = cPickle.load(f)
self.assertTrue(v3==v1)
def test3Pickle2(self):
"""
"""
l=1L<<21
l=1<<21
v1 = ds.IntSparseIntVect(l)
self.failUnlessRaises(IndexError,lambda:v1[l+1])
self.assertRaises(IndexError,lambda:v1[l+1])
v1[0]=1
v1[2]=2
v1[1<<12]=3
self.failUnless(v1==v1)
self.assertTrue(v1==v1)
v2= cPickle.loads(cPickle.dumps(v1))
self.failUnless(v2==v1)
self.assertTrue(v2==v1)
v3= ds.IntSparseIntVect(v2.ToBinary())
self.failUnless(v2==v3)
self.failUnless(v1==v3)
self.assertTrue(v2==v3)
self.assertTrue(v1==v3)
#cPickle.dump(v1,file('isiv.pkl','wb+'))
v3 = cPickle.load(file(os.path.join(RDConfig.RDBaseDir,
'Code/DataStructs/Wrap/testData/isiv.pkl'),'rb'))
self.failUnless(v3==v1)
with open(
os.path.join(RDConfig.RDBaseDir,
'Code/DataStructs/Wrap/testData/isiv.pkl'),
'rb'
) as f:
v3 = cPickle.load(f)
self.assertTrue(v3==v1)
def test4Update(self):
"""
"""
v1 = ds.IntSparseIntVect(5)
self.failUnlessRaises(IndexError,lambda:v1[6])
self.assertRaises(IndexError,lambda:v1[6])
v1[0]=1
v1[2]=2
v1[3]=3
self.failUnless(v1==v1)
self.assertTrue(v1==v1)
v2 = ds.IntSparseIntVect(5)
v2.UpdateFromSequence((0,2,3,3,2,3))
self.failUnless(v1==v2)
self.assertTrue(v1==v2)
def test5Dice(self):
"""
@@ -134,7 +143,7 @@ class TestCase(unittest.TestCase):
v1[4]=4;
v1[0]=2;
v1[3]=1;
self.failUnless(feq(ds.DiceSimilarity(v1,v1),1.0))
self.assertTrue(feq(ds.DiceSimilarity(v1,v1),1.0))
v1 = ds.IntSparseIntVect(5)
v1[0]=2;
@@ -146,8 +155,8 @@ class TestCase(unittest.TestCase):
v2[2]=3;
v2[3]=4;
v2[4]=4;
self.failUnless(feq(ds.DiceSimilarity(v1,v2),18.0/26.))
self.failUnless(feq(ds.DiceSimilarity(v2,v1),18.0/26.))
self.assertTrue(feq(ds.DiceSimilarity(v1,v2),18.0/26.))
self.assertTrue(feq(ds.DiceSimilarity(v2,v1),18.0/26.))
def test6BulkDice(self):
"""
@@ -167,7 +176,7 @@ class TestCase(unittest.TestCase):
baseDs = [ds.DiceSimilarity(vs[0],vs[x]) for x in range(1,nVs)]
bulkDs = ds.BulkDiceSimilarity(vs[0],vs[1:])
for i in range(len(baseDs)):
self.failUnless(feq(baseDs[i],bulkDs[i]))
self.assertTrue(feq(baseDs[i],bulkDs[i]))
def test6BulkTversky(self):
"""
@@ -188,16 +197,16 @@ class TestCase(unittest.TestCase):
bulkDs = ds.BulkTverskySimilarity(vs[0],vs[1:],0.5,0.5)
diceDs = [ds.DiceSimilarity(vs[0],vs[x]) for x in range(1,nVs)]
for i in range(len(baseDs)):
self.failUnless(feq(baseDs[i],bulkDs[i]))
self.failUnless(feq(baseDs[i],diceDs[i]))
self.assertTrue(feq(baseDs[i],bulkDs[i]))
self.assertTrue(feq(baseDs[i],diceDs[i]))
bulkDs = ds.BulkTverskySimilarity(vs[0],vs[1:],1.0,1.0)
taniDs = [ds.TanimotoSimilarity(vs[0],vs[x]) for x in range(1,nVs)]
for i in range(len(bulkDs)):
self.failUnless(feq(bulkDs[i],taniDs[i]))
self.assertTrue(feq(bulkDs[i],taniDs[i]))
taniDs = ds.BulkTanimotoSimilarity(vs[0],vs[1:])
for i in range(len(bulkDs)):
self.failUnless(feq(bulkDs[i],taniDs[i]))
self.assertTrue(feq(bulkDs[i],taniDs[i]))
if __name__ == '__main__':

4
Code/DistGeom/Wrap/DistGeom.cpp
View File

@@ -14,6 +14,8 @@
#define PY_ARRAY_UNIQUE_SYMBOL DistGeom_array_API
#include "numpy/arrayobject.h"
#include <RDBoost/Wrap.h>
#include <RDBoost/pyint_api.h>
#include <RDBoost/import_array.h>
#include <Geometry/point.h>
#include <Numerics/Matrix.h>
@@ -169,7 +171,7 @@ BOOST_PYTHON_MODULE(DistGeom) {
"Module containing functions for basic distance geometry operations"
;
import_array();
rdkit_import_array();
python::register_exception_translator<ValueErrorException>(&translate_value_error);
std::string docString;

52
Code/DistGeom/Wrap/rough_test.py
View File

@@ -22,50 +22,50 @@ class TestCase(unittest.TestCase):
arr = Numeric.array([[0,1.0,5.0],
[1.0,0,1.0],
[0.0,1.0,0]],Numeric.Float)
self.failUnless(DG.DoTriangleSmoothing(arr))
self.failUnless(feq(arr[0,2],2.0))
self.failUnless(feq(arr[2,0],0.0))
self.failUnless(feq(arr[0,1],1.0))
self.failUnless(feq(arr[1,0],1.0))
self.failUnless(feq(arr[1,2],1.0))
self.assertTrue(DG.DoTriangleSmoothing(arr))
self.assertTrue(feq(arr[0,2],2.0))
self.assertTrue(feq(arr[2,0],0.0))
self.assertTrue(feq(arr[0,1],1.0))
self.assertTrue(feq(arr[1,0],1.0))
self.assertTrue(feq(arr[1,2],1.0))
def test2SmoothFail(self):
arr = Numeric.array([[0,1.0,5.0],
[1.0,0,1.0],
[3.0,1.0,0]],Numeric.Float)
self.failIf(DG.DoTriangleSmoothing(arr))
self.assertFalse(DG.DoTriangleSmoothing(arr))
def test3SmoothPass(self):
arr = Numeric.array([[0,1.1,5.0],
[0.9,0,1.1],
[0.0,0.9,0]],Numeric.Float)
self.failUnless(DG.DoTriangleSmoothing(arr))
self.failUnless(feq(arr[0,2],2.2))
self.failUnless(feq(arr[2,0],0.0))
self.failUnless(feq(arr[0,1],1.1))
self.failUnless(feq(arr[1,0],0.9))
self.failUnless(feq(arr[1,2],1.1))
self.assertTrue(DG.DoTriangleSmoothing(arr))
self.assertTrue(feq(arr[0,2],2.2))
self.assertTrue(feq(arr[2,0],0.0))
self.assertTrue(feq(arr[0,1],1.1))
self.assertTrue(feq(arr[1,0],0.9))
self.assertTrue(feq(arr[1,2],1.1))
def test4Embed(self):
arr = Numeric.array([[0,1.0,5.0],
[1.0,0,1.0],
[0.0,1.0,0]],Numeric.Float)
self.failUnless(DG.DoTriangleSmoothing(arr))
self.assertTrue(DG.DoTriangleSmoothing(arr))
coords = DG.EmbedBoundsMatrix(arr,randomSeed=100);
v1 = coords[0]-coords[1]
v2 = coords[1]-coords[2]
d1 = Numeric.dot(v1,v1)
self.failUnless(feq(d1,1.0, 0.001));
self.assertTrue(feq(d1,1.0, 0.001));
d2 = Numeric.dot(v2,v2)
self.failUnless(feq(d2,1.0, 0.001));
self.assertTrue(feq(d2,1.0, 0.001));
def test5EmbedFail(self):
arr = Numeric.array([[0,1.0,5.0],
[1.0,0,1.0],
[3.0,1.0,0]],Numeric.Float)
self.failUnlessRaises(ValueError,lambda : DG.EmbedBoundsMatrix(arr))
self.assertRaises(ValueError,lambda : DG.EmbedBoundsMatrix(arr))
#DG.EmbedBoundsMatrix(arr,randomizeOnFailure=0,randomSeed=1)
DG.EmbedBoundsMatrix(arr,randomizeOnFailure=1);
@@ -74,28 +74,28 @@ class TestCase(unittest.TestCase):
[1.0,0.0,1.0],
[0.99,1.0,0.0]],
Numeric.Float)
self.failUnless(DG.DoTriangleSmoothing(arr))
self.assertTrue(DG.DoTriangleSmoothing(arr))
coords = DG.EmbedBoundsMatrix(arr, randomSeed=100)
v1 = coords[0]-coords[1]
v2 = coords[1]-coords[2]
d1 = Numeric.dot(v1,v1)
self.failUnless(feq(d1,1.0,2e-3));
self.assertTrue(feq(d1,1.0,2e-3));
d2 = Numeric.dot(v2,v2)
self.failUnless(feq(d2,1.0,2e-3));
self.assertTrue(feq(d2,1.0,2e-3));
arr = Numeric.array([[0.0,1.0,1.0,1.01],
[1.0,0.0,1.0,1.0],
[1.0,1.0,0.0,1.0],
[0.99,1.0,1.0,0.0],
],Numeric.Float)
self.failUnless(DG.DoTriangleSmoothing(arr))
self.assertTrue(DG.DoTriangleSmoothing(arr))
coords = DG.EmbedBoundsMatrix(arr)
v1 = coords[0]-coords[1]
v2 = coords[1]-coords[2]
d1 = Numeric.dot(v1,v1)
self.failUnless(feq(d1,1.0,1e-3));
self.assertTrue(feq(d1,1.0,1e-3));
d2 = Numeric.dot(v2,v2)
self.failUnless(feq(d2,1.0,1e-3));
self.assertTrue(feq(d2,1.0,1e-3));
return
# this test is currently (rev:4769) passing on windows and
@@ -106,14 +106,14 @@ class TestCase(unittest.TestCase):
[1.0,1.0,0.0,1.0],
[1.0,1.0,1.0,0.0],
],Numeric.Float)
self.failUnless(DG.DoTriangleSmoothing(arr))
self.assertTrue(DG.DoTriangleSmoothing(arr))
coords = DG.EmbedBoundsMatrix(arr,randomSeed=100)
v1 = coords[0]-coords[1]
v2 = coords[1]-coords[2]
d1 = Numeric.dot(v1,v1)
self.failUnless(feq(d1,1.0,1e-3));
self.assertTrue(feq(d1,1.0,1e-3));
d2 = Numeric.dot(v2,v2)
self.failUnless(feq(d2,1.0,1e-3));
self.assertTrue(feq(d2,1.0,1e-3));

96
Code/ForceField/Wrap/testConstraints.py
View File

@@ -49,171 +49,171 @@ M END"""
def testUFFDistanceConstraints(self) :
m = Chem.MolFromMolBlock(self.molB, True, False)
ff = ChemicalForceFields.UFFGetMoleculeForceField(m)
self.failUnless(ff)
self.assertTrue(ff)
ff.UFFAddDistanceConstraint(1, 3, False, 2.0, 2.0, 1.0e5)
r = ff.Minimize()
self.failUnless(r == 0)
self.assertTrue(r == 0)
conf = m.GetConformer()
dist = rdMolTransforms.GetBondLength(conf, 1, 3)
self.failUnless(dist > 1.99)
self.assertTrue(dist > 1.99)
ff = ChemicalForceFields.UFFGetMoleculeForceField(m)
self.failUnless(ff)
self.assertTrue(ff)
ff.UFFAddDistanceConstraint(1, 3, True, -0.2, 0.2, 1.0e5)
r = ff.Minimize()
self.failUnless(r == 0)
self.assertTrue(r == 0)
conf = m.GetConformer()
dist = rdMolTransforms.GetBondLength(conf, 1, 3)
self.failUnless(dist > 1.79)
self.assertTrue(dist > 1.79)
def testUFFAngleConstraints(self) :
m = Chem.MolFromMolBlock(self.molB, True, False)
ff = ChemicalForceFields.UFFGetMoleculeForceField(m)
self.failUnless(ff)
self.assertTrue(ff)
ff.UFFAddAngleConstraint(1, 3, 6, False, 90.0, 90.0, 1.0e5)
r = ff.Minimize()
self.failUnless(r == 0)
self.assertTrue(r == 0)
conf = m.GetConformer()
angle = rdMolTransforms.GetAngleDeg(conf, 1, 3, 6)
self.failUnless(int(angle) == 90)
self.assertTrue(int(angle) == 90)
ff = ChemicalForceFields.UFFGetMoleculeForceField(m)
self.failUnless(ff)
self.assertTrue(ff)
ff.UFFAddAngleConstraint(1, 3, 6, True, -10.0, 10.0, 1.0e5)
r = ff.Minimize()
self.failUnless(r == 0)
self.assertTrue(r == 0)
conf = m.GetConformer()
angle = rdMolTransforms.GetAngleDeg(conf, 1, 3, 6)
self.failUnless(int(angle) == 100)
self.assertTrue(int(angle) == 100)
def testUFFTorsionConstraints(self) :
m = Chem.MolFromMolBlock(self.molB, True, False)
ff = ChemicalForceFields.UFFGetMoleculeForceField(m)
self.failUnless(ff)
self.assertTrue(ff)
conf = m.GetConformer()
rdMolTransforms.SetDihedralDeg(conf, 1, 3, 6, 8, 60.0);
ff.UFFAddTorsionConstraint(1, 3, 6, 8, False, 30.0, 30.0, 1.0e5)
r = ff.Minimize()
self.failUnless(r == 0)
self.assertTrue(r == 0)
dihedral = rdMolTransforms.GetDihedralDeg(conf, 1, 3, 6, 8)
self.failUnless(int(dihedral) == 30)
self.assertTrue(int(dihedral) == 30)
ff = ChemicalForceFields.UFFGetMoleculeForceField(m)
self.failUnless(ff)
self.assertTrue(ff)
ff.UFFAddTorsionConstraint(1, 3, 6, 8, True, -10.0, 10.0, 1.0e5)
r = ff.Minimize()
self.failUnless(r == 0)
self.assertTrue(r == 0)
conf = m.GetConformer()
dihedral = rdMolTransforms.GetDihedralDeg(conf, 1, 3, 6, 8)
self.failUnless(int(dihedral) == 40)
self.assertTrue(int(dihedral) == 40)
def testUFFPositionConstraints(self) :
m = Chem.MolFromMolBlock(self.molB, True, False)
ff = ChemicalForceFields.UFFGetMoleculeForceField(m)
self.failUnless(ff)
self.assertTrue(ff)
conf = m.GetConformer()
p = conf.GetAtomPosition(1)
ff.UFFAddPositionConstraint(1, 0.3, 1.0e5)
r = ff.Minimize()
self.failUnless(r == 0)
self.assertTrue(r == 0)
q = conf.GetAtomPosition(1)
self.failUnless((p - q).Length() < 0.3)
self.assertTrue((p - q).Length() < 0.3)
def testUFFFixedAtoms(self) :
m = Chem.MolFromMolBlock(self.molB, True, False)
ff = ChemicalForceFields.UFFGetMoleculeForceField(m)
self.failUnless(ff)
self.assertTrue(ff)
conf = m.GetConformer()
fp = conf.GetAtomPosition(1)
ff.AddFixedPoint(1)
r = ff.Minimize()
self.failUnless(r == 0)
self.assertTrue(r == 0)
fq = conf.GetAtomPosition(1)
self.failUnless((fp - fq).Length() < 0.01)
self.assertTrue((fp - fq).Length() < 0.01)
def testMMFFDistanceConstraints(self) :
m = Chem.MolFromMolBlock(self.molB, True, False)
mp = ChemicalForceFields.MMFFGetMoleculeProperties(m)
ff = ChemicalForceFields.MMFFGetMoleculeForceField(m, mp)
self.failUnless(ff)
self.assertTrue(ff)
ff.MMFFAddDistanceConstraint(1, 3, False, 2.0, 2.0, 1.0e5)
r = ff.Minimize()
self.failUnless(r == 0)
self.assertTrue(r == 0)
conf = m.GetConformer()
dist = rdMolTransforms.GetBondLength(conf, 1, 3)
self.failUnless(dist > 1.99)
self.assertTrue(dist > 1.99)
ff = ChemicalForceFields.MMFFGetMoleculeForceField(m, mp)
self.failUnless(ff)
self.assertTrue(ff)
ff.MMFFAddDistanceConstraint(1, 3, True, -0.2, 0.2, 1.0e5)
r = ff.Minimize()
self.failUnless(r == 0)
self.assertTrue(r == 0)
conf = m.GetConformer()
dist = rdMolTransforms.GetBondLength(conf, 1, 3)
self.failUnless(dist > 1.79)
self.assertTrue(dist > 1.79)
def testMMFFAngleConstraints(self) :
m = Chem.MolFromMolBlock(self.molB, True, False)
mp = ChemicalForceFields.MMFFGetMoleculeProperties(m)
ff = ChemicalForceFields.MMFFGetMoleculeForceField(m, mp)
self.failUnless(ff)
self.assertTrue(ff)
ff.MMFFAddAngleConstraint(1, 3, 6, False, 90.0, 90.0, 1.0e5)
r = ff.Minimize()
self.failUnless(r == 0)
self.assertTrue(r == 0)
conf = m.GetConformer()
angle = rdMolTransforms.GetAngleDeg(conf, 1, 3, 6)
self.failUnless(int(angle) == 90)
self.assertTrue(int(angle) == 90)
ff = ChemicalForceFields.MMFFGetMoleculeForceField(m, mp)
self.failUnless(ff)
self.assertTrue(ff)
ff.MMFFAddAngleConstraint(1, 3, 6, True, -10.0, 10.0, 1.0e5)
r = ff.Minimize()
self.failUnless(r == 0)
self.assertTrue(r == 0)
conf = m.GetConformer()
angle = rdMolTransforms.GetAngleDeg(conf, 1, 3, 6)
self.failUnless(int(angle) == 100)
self.assertTrue(int(angle) == 100)
def testMMFFTorsionConstraints(self) :
m = Chem.MolFromMolBlock(self.molB, True, False)
mp = ChemicalForceFields.MMFFGetMoleculeProperties(m)
ff = ChemicalForceFields.MMFFGetMoleculeForceField(m, mp)
self.failUnless(ff)
self.assertTrue(ff)
conf = m.GetConformer()
rdMolTransforms.SetDihedralDeg(conf, 1, 3, 6, 8, 60.0);
ff.MMFFAddTorsionConstraint(1, 3, 6, 8, False, 30.0, 30.0, 1.0e5)
r = ff.Minimize()
self.failUnless(r == 0)
self.assertTrue(r == 0)
dihedral = rdMolTransforms.GetDihedralDeg(conf, 1, 3, 6, 8)
self.failUnless(int(dihedral) == 30)
self.assertTrue(int(dihedral) == 30)
ff = ChemicalForceFields.MMFFGetMoleculeForceField(m, mp)
self.failUnless(ff)
self.assertTrue(ff)
ff.MMFFAddTorsionConstraint(1, 3, 6, 8, True, -10.0, 10.0, 1.0e5)
r = ff.Minimize()
self.failUnless(r == 0)
self.assertTrue(r == 0)
conf = m.GetConformer()
dihedral = rdMolTransforms.GetDihedralDeg(conf, 1, 3, 6, 8)
self.failUnless(int(dihedral) == 40)
self.assertTrue(int(dihedral) == 40)
def testMMFFPositionConstraints(self) :
m = Chem.MolFromMolBlock(self.molB, True, False)
mp = ChemicalForceFields.MMFFGetMoleculeProperties(m)
ff = ChemicalForceFields.MMFFGetMoleculeForceField(m, mp)
self.failUnless(ff)
self.assertTrue(ff)
conf = m.GetConformer()
p = conf.GetAtomPosition(1)
ff.MMFFAddPositionConstraint(1, 0.3, 1.0e5)
r = ff.Minimize()
self.failUnless(r == 0)
self.assertTrue(r == 0)
q = conf.GetAtomPosition(1)
self.failUnless((p - q).Length() < 0.3)
self.assertTrue((p - q).Length() < 0.3)
def testMMFFFixedAtoms(self) :
m = Chem.MolFromMolBlock(self.molB, True, False)
mp = ChemicalForceFields.MMFFGetMoleculeProperties(m)
ff = ChemicalForceFields.MMFFGetMoleculeForceField(m, mp)
self.failUnless(ff)
self.assertTrue(ff)
conf = m.GetConformer()
fp = conf.GetAtomPosition(1)
ff.AddFixedPoint(1)
r = ff.Minimize()
self.failUnless(r == 0)
self.assertTrue(r == 0)
fq = conf.GetAtomPosition(1)
self.failUnless((fp - fq).Length() < 0.01)
self.assertTrue((fp - fq).Length() < 0.01)

326
Code/Geometry/Wrap/testGeometry.py
View File

@@ -1,10 +1,14 @@
from rdkit import RDConfig
from __future__ import print_function
import os,sys
import unittest
import copy
import math
from rdkit.six.moves import cPickle
from rdkit import RDConfig
from rdkit import DataStructs
from rdkit.Geometry import rdGeometry as geom
import cPickle,copy
import math
def feq(v1, v2, tol=1.0e-4):
return abs(v1-v2) < tol
@@ -15,150 +19,150 @@ class TestCase(unittest.TestCase):
def test1aPoint3D(self):
pt = geom.Point3D();
self.failUnless(feq(pt.x, 0.0))
self.failUnless(feq(pt.y, 0.0))
self.failUnless(feq(pt.z, 0.0))
self.assertTrue(feq(pt.x, 0.0))
self.assertTrue(feq(pt.y, 0.0))
self.assertTrue(feq(pt.z, 0.0))
pt = geom.Point3D(3., 4., 5.)
self.failUnless(feq(pt.x, 3.0))
self.failUnless(feq(pt.y, 4.0))
self.failUnless(feq(pt.z, 5.0))
self.failUnless(feq(pt[0], 3.0))
self.failUnless(feq(pt[1], 4.0))
self.failUnless(feq(pt[2], 5.0))
self.failUnless(feq(pt[-3], 3.0))
self.failUnless(feq(pt[-2], 4.0))
self.failUnless(feq(pt[-1], 5.0))
self.assertTrue(feq(pt.x, 3.0))
self.assertTrue(feq(pt.y, 4.0))
self.assertTrue(feq(pt.z, 5.0))
self.assertTrue(feq(pt[0], 3.0))
self.assertTrue(feq(pt[1], 4.0))
self.assertTrue(feq(pt[2], 5.0))
self.assertTrue(feq(pt[-3], 3.0))
self.assertTrue(feq(pt[-2], 4.0))
self.assertTrue(feq(pt[-1], 5.0))
lst = list(pt)
self.failUnless(feq(lst[0], 3.0))
self.failUnless(feq(lst[1], 4.0))
self.failUnless(feq(lst[2], 5.0))
self.assertTrue(feq(lst[0], 3.0))
self.assertTrue(feq(lst[1], 4.0))
self.assertTrue(feq(lst[2], 5.0))
pt2 = geom.Point3D(1., 1., 1.)
pt3 = pt+pt2
self.failUnless(feq(pt3.x, 4.0))
self.failUnless(feq(pt3.y, 5.0))
self.failUnless(feq(pt3.z, 6.0))
self.assertTrue(feq(pt3.x, 4.0))
self.assertTrue(feq(pt3.y, 5.0))
self.assertTrue(feq(pt3.z, 6.0))
pt += pt2
self.failUnless(feq(pt.x, 4.0))
self.failUnless(feq(pt.y, 5.0))
self.failUnless(feq(pt.z, 6.0))
self.assertTrue(feq(pt.x, 4.0))
self.assertTrue(feq(pt.y, 5.0))
self.assertTrue(feq(pt.z, 6.0))
pt3 = pt-pt2
self.failUnless(feq(pt3.x, 3.0))
self.failUnless(feq(pt3.y, 4.0))
self.failUnless(feq(pt3.z, 5.0))
self.assertTrue(feq(pt3.x, 3.0))
self.assertTrue(feq(pt3.y, 4.0))
self.assertTrue(feq(pt3.z, 5.0))
pt -= pt2
self.failUnless(feq(pt.x, 3.0))
self.failUnless(feq(pt.y, 4.0))
self.failUnless(feq(pt.z, 5.0))
self.assertTrue(feq(pt.x, 3.0))
self.assertTrue(feq(pt.y, 4.0))
self.assertTrue(feq(pt.z, 5.0))
pt *= 2.0
self.failUnless(feq(pt.x, 6.0))
self.failUnless(feq(pt.y, 8.0))
self.failUnless(feq(pt.z, 10.0))
self.assertTrue(feq(pt.x, 6.0))
self.assertTrue(feq(pt.y, 8.0))
self.assertTrue(feq(pt.z, 10.0))
pt /= 2
self.failUnless(feq(pt.x, 3.0))
self.failUnless(feq(pt.y, 4.0))
self.failUnless(feq(pt.z, 5.0))
self.failUnless(feq(pt.Length(), 7.0711))
self.failUnless(feq(pt.LengthSq(), 50.0))
self.assertTrue(feq(pt.x, 3.0))
self.assertTrue(feq(pt.y, 4.0))
self.assertTrue(feq(pt.z, 5.0))
self.assertTrue(feq(pt.Length(), 7.0711))
self.assertTrue(feq(pt.LengthSq(), 50.0))
pt.Normalize()
self.failUnless(feq(pt.Length(), 1.0))
self.assertTrue(feq(pt.Length(), 1.0))
pt1 = geom.Point3D(1.0, 0.0, 0.0)
pt2 = geom.Point3D(2.0*math.cos(math.pi/6), 2.0*math.sin(math.pi/6), 0.0)
ang = pt1.AngleTo(pt2)
self.failUnless(feq(ang, math.pi/6))
self.assertTrue(feq(ang, math.pi/6))
prod = pt1.DotProduct(pt2)
self.failUnless(feq(prod, 2.0*math.cos(math.pi/6)))
self.assertTrue(feq(prod, 2.0*math.cos(math.pi/6)))
pt3 = pt1.CrossProduct(pt2)
self.failUnless(feq(pt3.x, 0.0))
self.failUnless(feq(pt3.y, 0.0))
self.failUnless(feq(pt3.z, 1.0))
self.assertTrue(feq(pt3.x, 0.0))
self.assertTrue(feq(pt3.y, 0.0))
self.assertTrue(feq(pt3.z, 1.0))
def test1bPoint2D(self):
pt = geom.Point2D();
self.failUnless(feq(pt.x, 0.0))
self.failUnless(feq(pt.y, 0.0))
self.assertTrue(feq(pt.x, 0.0))
self.assertTrue(feq(pt.y, 0.0))
pt = geom.Point2D(3., 4.)
self.failUnless(feq(pt.x, 3.0))
self.failUnless(feq(pt.y, 4.0))
self.assertTrue(feq(pt.x, 3.0))
self.assertTrue(feq(pt.y, 4.0))
self.failUnless(feq(pt.x, 3.0))
self.failUnless(feq(pt.y, 4.0))
self.failUnless(feq(pt[0], 3.0))
self.failUnless(feq(pt[1], 4.0))
self.failUnless(feq(pt[-2], 3.0))
self.failUnless(feq(pt[-1], 4.0))
self.assertTrue(feq(pt.x, 3.0))
self.assertTrue(feq(pt.y, 4.0))
self.assertTrue(feq(pt[0], 3.0))
self.assertTrue(feq(pt[1], 4.0))
self.assertTrue(feq(pt[-2], 3.0))
self.assertTrue(feq(pt[-1], 4.0))
lst = list(pt)
self.failUnless(feq(lst[0], 3.0))
self.failUnless(feq(lst[1], 4.0))
self.assertTrue(feq(lst[0], 3.0))
self.assertTrue(feq(lst[1], 4.0))
pt2 = geom.Point2D(1., 1.)
pt3 = pt+pt2
self.failUnless(feq(pt3.x, 4.0))
self.failUnless(feq(pt3.y, 5.0))
self.assertTrue(feq(pt3.x, 4.0))
self.assertTrue(feq(pt3.y, 5.0))
pt += pt2
self.failUnless(feq(pt.x, 4.0))
self.failUnless(feq(pt.y, 5.0))
self.assertTrue(feq(pt.x, 4.0))
self.assertTrue(feq(pt.y, 5.0))
pt3 = pt-pt2
self.failUnless(feq(pt3.x, 3.0))
self.failUnless(feq(pt3.y, 4.0))
self.assertTrue(feq(pt3.x, 3.0))
self.assertTrue(feq(pt3.y, 4.0))
pt -= pt2
self.failUnless(feq(pt.x, 3.0))
self.failUnless(feq(pt.y, 4.0))
self.assertTrue(feq(pt.x, 3.0))
self.assertTrue(feq(pt.y, 4.0))
pt *= 2.0
self.failUnless(feq(pt.x, 6.0))
self.failUnless(feq(pt.y, 8.0))
self.assertTrue(feq(pt.x, 6.0))
self.assertTrue(feq(pt.y, 8.0))
pt /= 2
self.failUnless(feq(pt.x, 3.0))
self.failUnless(feq(pt.y, 4.0))
self.failUnless(feq(pt.Length(), 5.0))
self.failUnless(feq(pt.LengthSq(), 25.0))
self.assertTrue(feq(pt.x, 3.0))
self.assertTrue(feq(pt.y, 4.0))
self.assertTrue(feq(pt.Length(), 5.0))
self.assertTrue(feq(pt.LengthSq(), 25.0))
pt.Normalize()
self.failUnless(feq(pt.Length(), 1.0))
self.assertTrue(feq(pt.Length(), 1.0))
pt1 = geom.Point2D(1.0, 0.0)
pt2 = geom.Point2D(2.0*math.cos(math.pi/6), 2.0*math.sin(math.pi/6))
ang = pt1.AngleTo(pt2)
self.failUnless(feq(ang, math.pi/6))
self.assertTrue(feq(ang, math.pi/6))
prod = pt1.DotProduct(pt2)
self.failUnless(feq(prod, 2.0*math.cos(math.pi/6)))
self.assertTrue(feq(prod, 2.0*math.cos(math.pi/6)))
def test1cPointND(self):
dim=4
pt = geom.PointND(4);
for i in range(dim):
self.failUnless(feq(pt[i], 0.0))
self.assertTrue(feq(pt[i], 0.0))
pt[0]=3
pt[3]=4
self.failUnless(feq(pt[0], 3.0))
self.failUnless(feq(pt[3], 4.0))
self.failUnless(feq(pt[-4], 3.0))
self.failUnless(feq(pt[-1], 4.0))
self.assertTrue(feq(pt[0], 3.0))
self.assertTrue(feq(pt[3], 4.0))
self.assertTrue(feq(pt[-4], 3.0))
self.assertTrue(feq(pt[-1], 4.0))
lst = list(pt)
self.failUnless(feq(lst[0], 3.0))
self.failUnless(feq(lst[3], 4.0))
self.assertTrue(feq(lst[0], 3.0))
self.assertTrue(feq(lst[3], 4.0))
pt2 = geom.PointND(4)
@@ -166,58 +170,58 @@ class TestCase(unittest.TestCase):
pt2[2]=1.
pt3 = pt+pt2
self.failUnless(feq(pt3[0], 4.0))
self.failUnless(feq(pt3[2], 1.0))
self.failUnless(feq(pt3[3], 4.0))
self.assertTrue(feq(pt3[0], 4.0))
self.assertTrue(feq(pt3[2], 1.0))
self.assertTrue(feq(pt3[3], 4.0))
pt += pt2
self.failUnless(feq(pt[0], 4.0))
self.failUnless(feq(pt[2], 1.0))
self.failUnless(feq(pt[3], 4.0))
self.assertTrue(feq(pt[0], 4.0))
self.assertTrue(feq(pt[2], 1.0))
self.assertTrue(feq(pt[3], 4.0))
pt3 = pt-pt2
self.failUnless(feq(pt3[0], 3.0))
self.failUnless(feq(pt3[2], 0.0))
self.failUnless(feq(pt3[3], 4.0))
self.assertTrue(feq(pt3[0], 3.0))
self.assertTrue(feq(pt3[2], 0.0))
self.assertTrue(feq(pt3[3], 4.0))
pt -= pt2
self.failUnless(feq(pt[0], 3.0))
self.failUnless(feq(pt[2], 0.0))
self.failUnless(feq(pt[3], 4.0))
self.assertTrue(feq(pt[0], 3.0))
self.assertTrue(feq(pt[2], 0.0))
self.assertTrue(feq(pt[3], 4.0))
pt *= 2.0
self.failUnless(feq(pt[0], 6.0))
self.failUnless(feq(pt[1], 0.0))
self.failUnless(feq(pt[2], 0.0))
self.failUnless(feq(pt[3], 8.0))
self.assertTrue(feq(pt[0], 6.0))
self.assertTrue(feq(pt[1], 0.0))
self.assertTrue(feq(pt[2], 0.0))
self.assertTrue(feq(pt[3], 8.0))
pt /= 2
self.failUnless(feq(pt[0], 3.0))
self.failUnless(feq(pt[1], 0.0))
self.failUnless(feq(pt[2], 0.0))
self.failUnless(feq(pt[3], 4.0))
self.assertTrue(feq(pt[0], 3.0))
self.assertTrue(feq(pt[1], 0.0))
self.assertTrue(feq(pt[2], 0.0))
self.assertTrue(feq(pt[3], 4.0))
self.failUnless(feq(pt.Length(), 5.0))
self.failUnless(feq(pt.LengthSq(), 25.0))
self.assertTrue(feq(pt.Length(), 5.0))
self.assertTrue(feq(pt.LengthSq(), 25.0))
pt.Normalize()
self.failUnless(feq(pt.Length(), 1.0))
self.assertTrue(feq(pt.Length(), 1.0))
pkl = cPickle.dumps(pt)
pt2 = cPickle.loads(pkl)
self.failUnless(len(pt)==len(pt2))
self.assertTrue(len(pt)==len(pt2))
for i in range(len(pt)):
self.failUnless(feq(pt2[i],pt[i]))
self.assertTrue(feq(pt2[i],pt[i]))
def test3UniformGrid(self):
ugrid = geom.UniformGrid3D(20, 18, 15)
self.failUnless(ugrid.GetNumX() == 40)
self.failUnless(ugrid.GetNumY() == 36)
self.failUnless(ugrid.GetNumZ() == 30)
self.assertTrue(ugrid.GetNumX() == 40)
self.assertTrue(ugrid.GetNumY() == 36)
self.assertTrue(ugrid.GetNumZ() == 30)
dvect = ugrid.GetOccupancyVect()
ugrid = geom.UniformGrid3D(20, 18, 15, 0.5, DataStructs.DiscreteValueType.TWOBITVALUE)
dvect = ugrid.GetOccupancyVect()
self.failUnless(dvect.GetValueType() == DataStructs.DiscreteValueType.TWOBITVALUE)
self.assertTrue(dvect.GetValueType() == DataStructs.DiscreteValueType.TWOBITVALUE)
grd = geom.UniformGrid3D(10.0, 10.0, 10.0, 0.5)
grd.SetSphereOccupancy(geom.Point3D(-2.0, -2.0, 0.0), 1.5, 0.25)
@@ -232,23 +236,23 @@ class TestCase(unittest.TestCase):
grd2.SetSphereOccupancy(geom.Point3D(2.0, -2.0, 0.0), 1.5, 0.25)
dist = geom.TanimotoDistance(grd, grd2)
self.failUnless(dist == 0.25)
self.assertTrue(dist == 0.25)
dist = geom.ProtrudeDistance(grd, grd2)
self.failUnless(dist == 0.25)
self.assertTrue(dist == 0.25)
dist = geom.ProtrudeDistance(grd2, grd)
self.failUnless(dist==0.0)
self.assertTrue(dist==0.0)
grd2 = geom.UniformGrid3D(10.0, 10.0, 10.0, 0.5, DataStructs.DiscreteValueType.FOURBITVALUE)
grd2.SetSphereOccupancy(geom.Point3D(-2.0, -2.0, 0.0), 1.5, 0.25, 3)
grd2.SetSphereOccupancy(geom.Point3D(-2.0, 2.0, 0.0), 1.5, 0.25, 3)
grd2.SetSphereOccupancy(geom.Point3D(2.0, -2.0, 0.0), 1.5, 0.25, 3)
self.failUnlessRaises(ValueError, lambda : geom.TanimotoDistance(grd, grd2))
self.assertRaises(ValueError, lambda : geom.TanimotoDistance(grd, grd2))
grd2 = geom.UniformGrid3D(10.0, 10.0, 10.0, 1.0)
self.failUnlessRaises(ValueError, lambda : geom.TanimotoDistance(grd, grd2))
self.assertRaises(ValueError, lambda : geom.TanimotoDistance(grd, grd2))
grd2 = geom.UniformGrid3D(11.0, 10.0, 10.0, 1.0)
self.failUnlessRaises(ValueError, lambda : geom.TanimotoDistance(grd, grd2))
self.assertRaises(ValueError, lambda : geom.TanimotoDistance(grd, grd2))
def testSymmetry(self):
grd = geom.UniformGrid3D(10.0, 10.0, 10.0, 0.5)
@@ -266,7 +270,7 @@ class TestCase(unittest.TestCase):
for i in range(8) :
bPt1 += geom.Point3D(0.5, 0.0, 0.0)
bPt2 -= geom.Point3D(0.5, 0.0, 0.0)
self.failUnless(grd.GetValPoint(bPt1) == grd.GetValPoint(bPt2))
self.assertTrue(grd.GetValPoint(bPt1) == grd.GetValPoint(bPt2))
bPt1.x = -4.0
bPt2.x = 4.0
@@ -276,32 +280,32 @@ class TestCase(unittest.TestCase):
def testPointPickles(self):
pt = geom.Point3D(2.0,-3.0,1.0)
pt2 = cPickle.loads(cPickle.dumps(pt))
self.failUnless(feq(pt.x,pt2.x,1e-6))
self.failUnless(feq(pt.y,pt2.y,1e-6))
self.failUnless(feq(pt.z,pt2.z,1e-6))
self.assertTrue(feq(pt.x,pt2.x,1e-6))
self.assertTrue(feq(pt.y,pt2.y,1e-6))
self.assertTrue(feq(pt.z,pt2.z,1e-6))
pt = geom.Point2D(2.0,-4.0)
pt2 = cPickle.loads(cPickle.dumps(pt))
self.failUnless(feq(pt.x,pt2.x,1e-6))
self.failUnless(feq(pt.y,pt2.y,1e-6))
self.assertTrue(feq(pt.x,pt2.x,1e-6))
self.assertTrue(feq(pt.y,pt2.y,1e-6))
def test4GridPickles(self):
grd = geom.UniformGrid3D(10.0, 9.0, 8.0, 0.5)
self.failUnless(grd.GetNumX() == 20)
self.failUnless(grd.GetNumY() == 18)
self.failUnless(grd.GetNumZ() == 16)
self.assertTrue(grd.GetNumX() == 20)
self.assertTrue(grd.GetNumY() == 18)
self.assertTrue(grd.GetNumZ() == 16)
grd.SetSphereOccupancy(geom.Point3D(-2.0, -2.0, 0.0), 1.5, 0.25)
grd.SetSphereOccupancy(geom.Point3D(-2.0, 2.0, 0.0), 1.5, 0.25)
grd.SetSphereOccupancy(geom.Point3D(2.0, -2.0, 0.0), 1.5, 0.25)
grd.SetSphereOccupancy(geom.Point3D(2.0, 2.0, 0.0), 1.5, 0.25)
self.failUnless(geom.TanimotoDistance(grd,grd)==0.0)
self.assertTrue(geom.TanimotoDistance(grd,grd)==0.0)
grd2 = cPickle.loads(cPickle.dumps(grd))
self.failUnless(grd2.GetNumX() == 20)
self.failUnless(grd2.GetNumY() == 18)
self.failUnless(grd2.GetNumZ() == 16)
self.failUnless(geom.TanimotoDistance(grd,grd2)==0.0)
self.assertTrue(grd2.GetNumX() == 20)
self.assertTrue(grd2.GetNumY() == 18)
self.assertTrue(grd2.GetNumZ() == 16)
self.assertTrue(geom.TanimotoDistance(grd,grd2)==0.0)
def test5GridOps(self):
grd = geom.UniformGrid3D(10, 10, 10)
@@ -312,33 +316,33 @@ class TestCase(unittest.TestCase):
grd2.SetSphereOccupancy(geom.Point3D(2.0, -2.0, 0.0), 1.0, 0.25)
grd2.SetSphereOccupancy(geom.Point3D(2.0, 2.0, 0.0), 1.0, 0.25)
self.failUnless(geom.TanimotoDistance(grd,grd)==0.0)
self.failUnless(geom.TanimotoDistance(grd,grd2)==1.0)
self.assertTrue(geom.TanimotoDistance(grd,grd)==0.0)
self.assertTrue(geom.TanimotoDistance(grd,grd2)==1.0)
grd3 = copy.deepcopy(grd)
grd3 |= grd2
self.failUnless(geom.TanimotoDistance(grd3,grd)==.5)
self.failUnless(geom.TanimotoDistance(grd3,grd2)==.5)
self.assertTrue(geom.TanimotoDistance(grd3,grd)==.5)
self.assertTrue(geom.TanimotoDistance(grd3,grd2)==.5)
grd3 = copy.deepcopy(grd)
grd3 += grd2
self.failUnless(geom.TanimotoDistance(grd3,grd)==.5)
self.failUnless(geom.TanimotoDistance(grd3,grd2)==.5)
self.assertTrue(geom.TanimotoDistance(grd3,grd)==.5)
self.assertTrue(geom.TanimotoDistance(grd3,grd2)==.5)
grd3 -= grd
self.failUnless(geom.TanimotoDistance(grd3,grd)==1.0)
self.failUnless(geom.TanimotoDistance(grd3,grd2)==0)
self.assertTrue(geom.TanimotoDistance(grd3,grd)==1.0)
self.assertTrue(geom.TanimotoDistance(grd3,grd2)==0)
grd4 = geom.UniformGrid3D(10, 10, 10)
grd4.SetSphereOccupancy(geom.Point3D(-2.0, -2.0, 0.0), 1.0, 0.25)
grd4.SetSphereOccupancy(geom.Point3D(-2.0, 2.0, 0.0), 1.0, 0.25)
grd4.SetSphereOccupancy(geom.Point3D(2.0, -2.0, 0.0), 1.0, 0.25)
self.failUnless(feq(geom.TanimotoDistance(grd4,grd),.3333))
self.failUnless(feq(geom.TanimotoDistance(grd4,grd2),.75))
self.assertTrue(feq(geom.TanimotoDistance(grd4,grd),.3333))
self.assertTrue(feq(geom.TanimotoDistance(grd4,grd2),.75))
grd4&=grd2
self.failUnless(feq(geom.TanimotoDistance(grd4,grd),1.0))
self.failUnless(feq(geom.TanimotoDistance(grd4,grd2),.5))
self.assertTrue(feq(geom.TanimotoDistance(grd4,grd),1.0))
self.assertTrue(feq(geom.TanimotoDistance(grd4,grd2),.5))
def test6Dihedrals(self):
@@ -348,60 +352,60 @@ class TestCase(unittest.TestCase):
p4 = geom.Point3D(.5,1,.5)
ang = geom.ComputeDihedralAngle(p1,p2,p3,p4)
self.failUnlessAlmostEqual(ang,math.pi/4,4)
self.assertAlmostEqual(ang,math.pi/4,4)
ang = geom.ComputeSignedDihedralAngle(p1,p2,p3,p4)
self.failUnlessAlmostEqual(ang,-math.pi/4,4)
self.assertAlmostEqual(ang,-math.pi/4,4)
p4 = geom.Point3D(-.5,1,.5)
ang = geom.ComputeDihedralAngle(p1,p2,p3,p4)
self.failUnlessAlmostEqual(ang,3*math.pi/4,4)
self.assertAlmostEqual(ang,3*math.pi/4,4)
ang = geom.ComputeSignedDihedralAngle(p1,p2,p3,p4)
self.failUnlessAlmostEqual(ang,-3*math.pi/4,4)
self.assertAlmostEqual(ang,-3*math.pi/4,4)
p4 = geom.Point3D(.5,1,-.5)
ang = geom.ComputeDihedralAngle(p1,p2,p3,p4)
self.failUnlessAlmostEqual(ang,math.pi/4,4)
self.assertAlmostEqual(ang,math.pi/4,4)
ang = geom.ComputeSignedDihedralAngle(p1,p2,p3,p4)
self.failUnlessAlmostEqual(ang,math.pi/4,4)
self.assertAlmostEqual(ang,math.pi/4,4)
p4 = geom.Point3D(-.5,1,-.5)
ang = geom.ComputeDihedralAngle(p1,p2,p3,p4)
self.failUnlessAlmostEqual(ang,3*math.pi/4,4)
self.assertAlmostEqual(ang,3*math.pi/4,4)
ang = geom.ComputeSignedDihedralAngle(p1,p2,p3,p4)
self.failUnlessAlmostEqual(ang,3*math.pi/4,4)
self.assertAlmostEqual(ang,3*math.pi/4,4)
p4 = geom.Point3D(0,1,1)
ang = geom.ComputeDihedralAngle(p1,p2,p3,p4)
self.failUnlessAlmostEqual(ang,math.pi/2,4)
self.assertAlmostEqual(ang,math.pi/2,4)
ang = geom.ComputeSignedDihedralAngle(p1,p2,p3,p4)
self.failUnlessAlmostEqual(ang,-math.pi/2,4)
self.assertAlmostEqual(ang,-math.pi/2,4)
p4 = geom.Point3D(0,1,-1)
ang = geom.ComputeDihedralAngle(p1,p2,p3,p4)
self.failUnlessAlmostEqual(ang,math.pi/2,4)
self.assertAlmostEqual(ang,math.pi/2,4)
ang = geom.ComputeSignedDihedralAngle(p1,p2,p3,p4)
self.failUnlessAlmostEqual(ang,math.pi/2,4)
self.assertAlmostEqual(ang,math.pi/2,4)
p4 = geom.Point3D(1,1,0)
ang = geom.ComputeDihedralAngle(p1,p2,p3,p4)
self.failUnlessAlmostEqual(ang,0,4)
self.assertAlmostEqual(ang,0,4)
ang = geom.ComputeSignedDihedralAngle(p1,p2,p3,p4)
self.failUnlessAlmostEqual(ang,0,4)
self.assertAlmostEqual(ang,0,4)
p4 = geom.Point3D(-1,1,0)
ang = geom.ComputeDihedralAngle(p1,p2,p3,p4)
self.failUnlessAlmostEqual(ang,math.pi,4)
self.assertAlmostEqual(ang,math.pi,4)
ang = geom.ComputeSignedDihedralAngle(p1,p2,p3,p4)
self.failUnlessAlmostEqual(ang,math.pi,4)
self.assertAlmostEqual(ang,math.pi,4)
def test7UniformGridIndices(self):
ugrid = geom.UniformGrid3D(20, 18, 15)
idx = ugrid.GetGridIndex(3,2,1)
xi,yi,zi=ugrid.GetGridIndices(idx)
self.failUnlessEqual(xi,3)
self.failUnlessEqual(yi,2)
self.failUnlessEqual(zi,1)
self.assertEqual(xi,3)
self.assertEqual(yi,2)
self.assertEqual(zi,1)
if __name__=='__main__':
print "Testing Geometry wrapper"
print("Testing Geometry wrapper")
unittest.main()

253
Code/GraphMol/ChemReactions/Wrap/testReactionWrapper.py
View File

@@ -29,14 +29,18 @@
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
from __future__ import print_function
import unittest
import os,sys
from rdkit.six.moves import cPickle
from rdkit import rdBase
from rdkit import Chem
from rdkit.Chem import rdChemReactions
from rdkit import Geometry
from rdkit import RDConfig
import unittest
import os,sys
import cPickle
def feq(v1,v2,tol2=1e-4):
return abs(v1-v2)<=tol2
@@ -51,83 +55,84 @@ class TestCase(unittest.TestCase) :
def test1Basics(self):
rxn = rdChemReactions.ChemicalReaction()
self.failUnless(rxn.GetNumReactantTemplates()==0)
self.failUnless(rxn.GetNumProductTemplates()==0)
self.assertTrue(rxn.GetNumReactantTemplates()==0)
self.assertTrue(rxn.GetNumProductTemplates()==0)
r1= Chem.MolFromSmarts('[C:1](=[O:2])O')
rxn.AddReactantTemplate(r1)
self.failUnless(rxn.GetNumReactantTemplates()==1)
self.assertTrue(rxn.GetNumReactantTemplates()==1)
r1= Chem.MolFromSmarts('[N:3]')
rxn.AddReactantTemplate(r1)
self.failUnless(rxn.GetNumReactantTemplates()==2)
self.assertTrue(rxn.GetNumReactantTemplates()==2)
r1= Chem.MolFromSmarts('[C:1](=[O:2])[N:3]')
rxn.AddProductTemplate(r1)
self.failUnless(rxn.GetNumProductTemplates()==1)
self.assertTrue(rxn.GetNumProductTemplates()==1)
reacts = (Chem.MolFromSmiles('C(=O)O'),Chem.MolFromSmiles('N'))
ps = rxn.RunReactants(reacts)
self.failUnless(len(ps)==1)
self.failUnless(len(ps[0])==1)
self.failUnless(ps[0][0].GetNumAtoms()==3)
self.assertTrue(len(ps)==1)
self.assertTrue(len(ps[0])==1)
self.assertTrue(ps[0][0].GetNumAtoms()==3)
ps = rxn.RunReactants(list(reacts))
self.failUnless(len(ps)==1)
self.failUnless(len(ps[0])==1)
self.failUnless(ps[0][0].GetNumAtoms()==3)
self.assertTrue(len(ps)==1)
self.assertTrue(len(ps[0])==1)
self.assertTrue(ps[0][0].GetNumAtoms()==3)
def test2DaylightParser(self):
rxn = rdChemReactions.ReactionFromSmarts('[C:1](=[O:2])O.[N:3]>>[C:1](=[O:2])[N:3]')
self.failUnless(rxn)
self.failUnless(rxn.GetNumReactantTemplates()==2)
self.failUnless(rxn.GetNumProductTemplates()==1)
self.failUnless(rxn._getImplicitPropertiesFlag())
self.assertTrue(rxn)
self.assertTrue(rxn.GetNumReactantTemplates()==2)
self.assertTrue(rxn.GetNumProductTemplates()==1)
self.assertTrue(rxn._getImplicitPropertiesFlag())
reacts = (Chem.MolFromSmiles('C(=O)O'),Chem.MolFromSmiles('N'))
ps = rxn.RunReactants(reacts)
self.failUnless(len(ps)==1)
self.failUnless(len(ps[0])==1)
self.failUnless(ps[0][0].GetNumAtoms()==3)
self.assertTrue(len(ps)==1)
self.assertTrue(len(ps[0])==1)
self.assertTrue(ps[0][0].GetNumAtoms()==3)
reacts = (Chem.MolFromSmiles('CC(=O)OC'),Chem.MolFromSmiles('CN'))
ps = rxn.RunReactants(reacts)
self.failUnless(len(ps)==1)
self.failUnless(len(ps[0])==1)
self.failUnless(ps[0][0].GetNumAtoms()==5)
self.assertTrue(len(ps)==1)
self.assertTrue(len(ps[0])==1)
self.assertTrue(ps[0][0].GetNumAtoms()==5)
def test3MDLParsers(self):
fileN = os.path.join(self.dataDir,'AmideBond.rxn')
rxn = rdChemReactions.ReactionFromRxnFile(fileN)
self.failUnless(rxn)
self.failIf(rxn._getImplicitPropertiesFlag())
self.assertTrue(rxn)
self.assertFalse(rxn._getImplicitPropertiesFlag())
self.failUnless(rxn.GetNumReactantTemplates()==2)
self.failUnless(rxn.GetNumProductTemplates()==1)
self.assertTrue(rxn.GetNumReactantTemplates()==2)
self.assertTrue(rxn.GetNumProductTemplates()==1)
reacts = (Chem.MolFromSmiles('C(=O)O'),Chem.MolFromSmiles('N'))
ps = rxn.RunReactants(reacts)
self.failUnless(len(ps)==1)
self.failUnless(len(ps[0])==1)
self.failUnless(ps[0][0].GetNumAtoms()==3)
self.assertTrue(len(ps)==1)
self.assertTrue(len(ps[0])==1)
self.assertTrue(ps[0][0].GetNumAtoms()==3)
rxnBlock = file(fileN,'r').read()
with open(fileN, 'r') as rxnF:
rxnBlock = rxnF.read()
rxn = rdChemReactions.ReactionFromRxnBlock(rxnBlock)
self.failUnless(rxn)
self.assertTrue(rxn)
self.failUnless(rxn.GetNumReactantTemplates()==2)
self.failUnless(rxn.GetNumProductTemplates()==1)
self.assertTrue(rxn.GetNumReactantTemplates()==2)
self.assertTrue(rxn.GetNumProductTemplates()==1)
reacts = (Chem.MolFromSmiles('C(=O)O'),Chem.MolFromSmiles('N'))
ps = rxn.RunReactants(reacts)
self.failUnless(len(ps)==1)
self.failUnless(len(ps[0])==1)
self.failUnless(ps[0][0].GetNumAtoms()==3)
self.assertTrue(len(ps)==1)
self.assertTrue(len(ps[0])==1)
self.assertTrue(ps[0][0].GetNumAtoms()==3)
def test4ErrorHandling(self):
self.failUnlessRaises(ValueError,lambda x='[C:1](=[O:2])Q.[N:3]>>[C:1](=[O:2])[N:3]':rdChemReactions.ReactionFromSmarts(x))
self.failUnlessRaises(ValueError,lambda x='[C:1](=[O:2])O.[N:3]>>[C:1](=[O:2])[N:3]Q':rdChemReactions.ReactionFromSmarts(x))
self.failUnlessRaises(ValueError,lambda x='[C:1](=[O:2])O.[N:3]>>[C:1](=[O:2])[N:3]>>CC':rdChemReactions.ReactionFromSmarts(x))
self.assertRaises(ValueError,lambda x='[C:1](=[O:2])Q.[N:3]>>[C:1](=[O:2])[N:3]':rdChemReactions.ReactionFromSmarts(x))
self.assertRaises(ValueError,lambda x='[C:1](=[O:2])O.[N:3]>>[C:1](=[O:2])[N:3]Q':rdChemReactions.ReactionFromSmarts(x))
self.assertRaises(ValueError,lambda x='[C:1](=[O:2])O.[N:3]>>[C:1](=[O:2])[N:3]>>CC':rdChemReactions.ReactionFromSmarts(x))
block="""$RXN
@@ -164,7 +169,7 @@ $MOL
2 3 2 0 0 0 0
M END
"""
self.failUnlessRaises(ValueError,lambda x=block:rdChemReactions.ReactionFromRxnBlock(x))
self.assertRaises(ValueError,lambda x=block:rdChemReactions.ReactionFromRxnBlock(x))
block="""$RXN
@@ -201,7 +206,7 @@ $MOL
2 3 2 0 0 0 0
M END
"""
#self.failUnlessRaises(ValueError,lambda x=block:rdChemReactions.ReactionFromRxnBlock(x))
#self.assertRaises(ValueError,lambda x=block:rdChemReactions.ReactionFromRxnBlock(x))
block="""$RXN
@@ -238,99 +243,99 @@ $MOL
2 3 2 0 0 0 0
M END
"""
#self.failUnlessRaises(ValueError,lambda x=block:rdChemReactions.ReactionFromRxnBlock(x))
#self.assertRaises(ValueError,lambda x=block:rdChemReactions.ReactionFromRxnBlock(x))
def test5Validation(self):
rxn = rdChemReactions.ReactionFromSmarts('[C:1](=[O:2])O.[N:3]>>[C:1](=[O:2])[N:3]')
self.failUnless(rxn)
self.failUnless(rxn.Validate()==(0,0))
self.assertTrue(rxn)
self.assertTrue(rxn.Validate()==(0,0))
rxn = rdChemReactions.ReactionFromSmarts('[C:1](=[O:1])O.[N:3]>>[C:1](=[O:2])[N:3]')
self.failUnless(rxn)
self.failUnless(rxn.Validate()==(1,1))
self.assertTrue(rxn)
self.assertTrue(rxn.Validate()==(1,1))
rxn = rdChemReactions.ReactionFromSmarts('[C:1](=[O:2])[O:4].[N:3]>>[C:1](=[O:2])[N:3]')
self.failUnless(rxn)
self.failUnless(rxn.Validate()==(1,0))
self.assertTrue(rxn)
self.assertTrue(rxn.Validate()==(1,0))
rxn = rdChemReactions.ReactionFromSmarts('[C:1](=[O:2])O.[N:3]>>[C:1](=[O:2])[N:3][C:5]')
self.failUnless(rxn)
self.failUnless(rxn.Validate()==(1,0))
self.assertTrue(rxn)
self.assertTrue(rxn.Validate()==(1,0))
def test6Exceptions(self):
rxn = rdChemReactions.ReactionFromSmarts('[C:1]Cl>>[C:1]')
self.failUnless(rxn)
self.failUnlessRaises(ValueError,lambda x=rxn:x.RunReactants(()))
self.failUnlessRaises(ValueError,lambda x=rxn:x.RunReactants((Chem.MolFromSmiles('CC'),Chem.MolFromSmiles('C'))))
self.assertTrue(rxn)
self.assertRaises(ValueError,lambda x=rxn:x.RunReactants(()))
self.assertRaises(ValueError,lambda x=rxn:x.RunReactants((Chem.MolFromSmiles('CC'),Chem.MolFromSmiles('C'))))
ps=rxn.RunReactants((Chem.MolFromSmiles('CCCl'),))
self.failUnless(len(ps)==1)
self.failUnless(len(ps[0])==1)
self.assertTrue(len(ps)==1)
self.assertTrue(len(ps[0])==1)
def _test7Leak(self):
rxn = rdChemReactions.ReactionFromSmarts('[C:1]Cl>>[C:1]')
self.failUnless(rxn)
print 'running: '
self.assertTrue(rxn)
print('running: ')
for i in range(1e5):
ps=rxn.RunReactants((Chem.MolFromSmiles('CCCl'),))
self.failUnless(len(ps)==1)
self.failUnless(len(ps[0])==1)
if not i%1000: print i
self.assertTrue(len(ps)==1)
self.assertTrue(len(ps[0])==1)
if not i%1000: print(i)
def test8Properties(self):
rxn = rdChemReactions.ReactionFromSmarts('[O:1]>>[O:1][3#0]')
self.failUnless(rxn)
self.assertTrue(rxn)
ps=rxn.RunReactants((Chem.MolFromSmiles('CO'),))
self.failUnless(len(ps)==1)
self.failUnless(len(ps[0])==1)
self.assertTrue(len(ps)==1)
self.assertTrue(len(ps[0])==1)
Chem.SanitizeMol(ps[0][0])
self.failUnlessEqual(ps[0][0].GetAtomWithIdx(1).GetIsotope(),3);
self.assertEqual(ps[0][0].GetAtomWithIdx(1).GetIsotope(),3);
def test9AromaticityTransfer(self):
# this was issue 2664121
mol = Chem.MolFromSmiles('c1ccc(C2C3(Cc4c(cccc4)C2)CCCC3)cc1')
rxn = rdChemReactions.ReactionFromSmarts('[A:1]1~[*:2]~[*:3]~[*:4]~[*:5]~[A:6]-;@1>>[*:1]~[*:2]~[*:3]~[*:4]~[*:5]~[*:6]')
products = rxn.RunReactants([mol])
self.failUnlessEqual(len(products),6)
self.assertEqual(len(products),6)
for p in products:
self.failUnlessEqual(len(p),1)
self.assertEqual(len(p),1)
Chem.SanitizeMol(p[0])
def test10DotSeparation(self):
rxn = rdChemReactions.ReactionFromSmarts('[C:1]1[O:2][N:3]1>>[C:1]1[O:2].[N:3]1')
mol = Chem.MolFromSmiles('C1ON1')
products = rxn.RunReactants([mol])
self.failUnlessEqual(len(products),1)
self.assertEqual(len(products),1)
for p in products:
self.failUnlessEqual(len(p),1)
self.failUnlessEqual(p[0].GetNumAtoms(),3)
self.failUnlessEqual(p[0].GetNumBonds(),2)
self.assertEqual(len(p),1)
self.assertEqual(p[0].GetNumAtoms(),3)
self.assertEqual(p[0].GetNumBonds(),2)
def test11ImplicitProperties(self):
rxn = rdChemReactions.ReactionFromSmarts('[C:1]O>>[C:1]')
mol = Chem.MolFromSmiles('CCO')
products = rxn.RunReactants([mol])
self.failUnlessEqual(len(products),1)
self.assertEqual(len(products),1)
for p in products:
self.failUnlessEqual(len(p),1)
self.failUnlessEqual(Chem.MolToSmiles(p[0]),'CC')
self.assertEqual(len(p),1)
self.assertEqual(Chem.MolToSmiles(p[0]),'CC')
mol2 = Chem.MolFromSmiles('C[CH-]O')
products = rxn.RunReactants([mol2])
self.failUnlessEqual(len(products),1)
self.assertEqual(len(products),1)
for p in products:
self.failUnlessEqual(len(p),1)
self.failUnlessEqual(Chem.MolToSmiles(p[0]),'[CH2-]C')
self.assertEqual(len(p),1)
self.assertEqual(Chem.MolToSmiles(p[0]),'[CH2-]C')
rxn._setImplicitPropertiesFlag(False)
products = rxn.RunReactants([mol])
self.failUnlessEqual(len(products),1)
self.assertEqual(len(products),1)
for p in products:
self.failUnlessEqual(len(p),1)
self.failUnlessEqual(Chem.MolToSmiles(p[0]),'CC')
self.assertEqual(len(p),1)
self.assertEqual(Chem.MolToSmiles(p[0]),'CC')
products = rxn.RunReactants([mol2])
self.failUnlessEqual(len(products),1)
self.assertEqual(len(products),1)
for p in products:
self.failUnlessEqual(len(p),1)
self.failUnlessEqual(Chem.MolToSmiles(p[0]),'CC')
self.assertEqual(len(p),1)
self.assertEqual(Chem.MolToSmiles(p[0]),'CC')
def test12Pickles(self):
@@ -339,102 +344,102 @@ M END
rxn = cPickle.loads(pkl)
mol = Chem.MolFromSmiles('C1ON1')
products = rxn.RunReactants([mol])
self.failUnlessEqual(len(products),1)
self.assertEqual(len(products),1)
for p in products:
self.failUnlessEqual(len(p),1)
self.failUnlessEqual(p[0].GetNumAtoms(),3)
self.failUnlessEqual(p[0].GetNumBonds(),2)
self.assertEqual(len(p),1)
self.assertEqual(p[0].GetNumAtoms(),3)
self.assertEqual(p[0].GetNumBonds(),2)
rxn = rdChemReactions.ChemicalReaction(rxn.ToBinary())
products = rxn.RunReactants([mol])
self.failUnlessEqual(len(products),1)
self.assertEqual(len(products),1)
for p in products:
self.failUnlessEqual(len(p),1)
self.failUnlessEqual(p[0].GetNumAtoms(),3)
self.failUnlessEqual(p[0].GetNumBonds(),2)
self.assertEqual(len(p),1)
self.assertEqual(p[0].GetNumAtoms(),3)
self.assertEqual(p[0].GetNumBonds(),2)
def test13GetTemplates(self):
rxn = rdChemReactions.ReactionFromSmarts('[C:1]1[O:2][N:3]1>>[C:1][O:2].[N:3]')
r1 = rxn.GetReactantTemplate(0)
sma=Chem.MolToSmarts(r1)
self.failUnlessEqual(sma,'[C:1]1-,:[O:2]-,:[N:3]-,:1')
self.assertEqual(sma,'[C:1]1-,:[O:2]-,:[N:3]-,:1')
p1 = rxn.GetProductTemplate(0)
sma=Chem.MolToSmarts(p1)
self.failUnlessEqual(sma,'[C:1]-,:[O:2]')
self.assertEqual(sma,'[C:1]-,:[O:2]')
p2 = rxn.GetProductTemplate(1)
sma=Chem.MolToSmarts(p2)
self.failUnlessEqual(sma,'[N:3]')
self.assertEqual(sma,'[N:3]')
self.failUnlessRaises(ValueError,lambda :rxn.GetProductTemplate(2))
self.failUnlessRaises(ValueError,lambda :rxn.GetReactantTemplate(1))
self.assertRaises(ValueError,lambda :rxn.GetProductTemplate(2))
self.assertRaises(ValueError,lambda :rxn.GetReactantTemplate(1))
def test14Matchers(self):
rxn = rdChemReactions.ReactionFromSmarts('[C;!$(C(-O)-O):1](=[O:2])[O;H,-1].[N;!H0:3]>>[C:1](=[O:2])[N:3]')
self.failUnless(rxn)
self.assertTrue(rxn)
rxn.Initialize()
self.failUnless(rxn.IsMoleculeReactant(Chem.MolFromSmiles('OC(=O)C')))
self.failIf(rxn.IsMoleculeReactant(Chem.MolFromSmiles('OC(=O)O')))
self.failUnless(rxn.IsMoleculeReactant(Chem.MolFromSmiles('CNC')))
self.failIf(rxn.IsMoleculeReactant(Chem.MolFromSmiles('CN(C)C')))
self.failUnless(rxn.IsMoleculeProduct(Chem.MolFromSmiles('NC(=O)C')))
self.failUnless(rxn.IsMoleculeProduct(Chem.MolFromSmiles('CNC(=O)C')))
self.failIf(rxn.IsMoleculeProduct(Chem.MolFromSmiles('COC(=O)C')))
self.assertTrue(rxn.IsMoleculeReactant(Chem.MolFromSmiles('OC(=O)C')))
self.assertFalse(rxn.IsMoleculeReactant(Chem.MolFromSmiles('OC(=O)O')))
self.assertTrue(rxn.IsMoleculeReactant(Chem.MolFromSmiles('CNC')))
self.assertFalse(rxn.IsMoleculeReactant(Chem.MolFromSmiles('CN(C)C')))
self.assertTrue(rxn.IsMoleculeProduct(Chem.MolFromSmiles('NC(=O)C')))
self.assertTrue(rxn.IsMoleculeProduct(Chem.MolFromSmiles('CNC(=O)C')))
self.assertFalse(rxn.IsMoleculeProduct(Chem.MolFromSmiles('COC(=O)C')))
def test15Replacements(self):
rxn = rdChemReactions.ReactionFromSmarts('[{amine}:1]>>[*:1]-C',
replacements={'{amine}':'$([N;!H0;$(N-[#6]);!$(N-[!#6;!#1]);!$(N-C=[O,N,S])])'})
self.failUnless(rxn)
self.assertTrue(rxn)
rxn.Initialize()
reactants = (Chem.MolFromSmiles('CCN'),)
ps = rxn.RunReactants(reactants)
self.failUnlessEqual(len(ps),1)
self.failUnlessEqual(len(ps[0]),1)
self.failUnlessEqual(ps[0][0].GetNumAtoms(),4)
self.assertEqual(len(ps),1)
self.assertEqual(len(ps[0]),1)
self.assertEqual(ps[0][0].GetNumAtoms(),4)
def test16GetReactingAtoms(self):
rxn = rdChemReactions.ReactionFromSmarts("[O:1][C:2].[N:3]>>[N:1][C:2].[N:3]")
self.failUnless(rxn)
self.assertTrue(rxn)
rxn.Initialize()
rAs = rxn.GetReactingAtoms()
self.failUnlessEqual(len(rAs),2)
self.failUnlessEqual(len(rAs[0]),1)
self.failUnlessEqual(len(rAs[1]),0)
self.assertEqual(len(rAs),2)
self.assertEqual(len(rAs[0]),1)
self.assertEqual(len(rAs[1]),0)
rxn = rdChemReactions.ReactionFromSmarts("[O:1]C>>[O:1]C")
self.failUnless(rxn)
self.assertTrue(rxn)
rxn.Initialize()
rAs = rxn.GetReactingAtoms()
self.failUnlessEqual(len(rAs),1)
self.failUnlessEqual(len(rAs[0]),2)
self.assertEqual(len(rAs),1)
self.assertEqual(len(rAs[0]),2)
rAs = rxn.GetReactingAtoms(True)
self.failUnlessEqual(len(rAs),1)
self.failUnlessEqual(len(rAs[0]),1)
self.assertEqual(len(rAs),1)
self.assertEqual(len(rAs[0]),1)
def test17AddRecursiveQueriesToReaction(self):
rxn = rdChemReactions.ReactionFromSmarts("[C:1][O:2].[N:3]>>[C:1][N:2]")
self.failUnless(rxn)
self.assertTrue(rxn)
rxn.Initialize()
qs = {'aliphatic':Chem.MolFromSmiles('CC')}
rxn.GetReactantTemplate(0).GetAtomWithIdx(0).SetProp('query', 'aliphatic')
rxn.AddRecursiveQueriesToReaction(qs,'query')
q = rxn.GetReactantTemplate(0)
m = Chem.MolFromSmiles('CCOC')
self.failUnless(m.HasSubstructMatch(q))
self.assertTrue(m.HasSubstructMatch(q))
m = Chem.MolFromSmiles('CO')
self.failIf(m.HasSubstructMatch(q))
self.assertFalse(m.HasSubstructMatch(q))
rxn = rdChemReactions.ReactionFromSmarts("[C:1][O:2].[N:3]>>[C:1][N:2]")
rxn.Initialize()
rxn.GetReactantTemplate(0).GetAtomWithIdx(0).SetProp('query', 'aliphatic')
labels = rxn.AddRecursiveQueriesToReaction(qs,'query', getLabels=True)
self.failUnless(len(labels), 1)
self.assertTrue(len(labels), 1)
def test18GithubIssue16(self):
rxn = rdChemReactions.ReactionFromSmarts("[F:1]>>[Cl:1]")
self.failUnless(rxn)
self.assertTrue(rxn)
rxn.Initialize()
self.failUnlessRaises(ValueError,lambda : rxn.RunReactants((None,)))
self.assertRaises(ValueError,lambda : rxn.RunReactants((None,)))
if __name__ == '__main__':
unittest.main()

3
Code/GraphMol/Depictor/Wrap/rdDepictor.cpp
View File

@@ -13,6 +13,7 @@
#define PY_ARRAY_UNIQUE_SYMBOL Depictor_array_API
#include "numpy/oldnumeric.h"
#include <RDBoost/Wrap.h>
#include <RDBoost/import_array.h>
#include <GraphMol/Depictor/RDDepictor.h>
#include <GraphMol/Depictor/EmbeddedFrag.h>
@@ -113,7 +114,7 @@ BOOST_PYTHON_MODULE(rdDepictor)
"Module containing the functionality to compute 2D coordinates for a molecule"
;
import_array();
rdkit_import_array();
std::string docString;

43
Code/GraphMol/Depictor/Wrap/testDepictor.py
View File

@@ -3,13 +3,15 @@
#
# $Id$
#
from __future__ import division
import unittest
import os,sys
from rdkit.six.moves import cPickle as pickle
from rdkit import Chem
from rdkit.Chem import rdDepictor
from rdkit import Geometry
from rdkit import RDConfig
import unittest
import os,sys
import cPickle as pickle
from rdkit.Chem.ChemUtils import AlignDepict
import numpy.oldnumeric as Numeric
@@ -22,12 +24,12 @@ def ptEq(pt1, pt2, tol=1e-4):
def getDistMat(mol):
conf = mol.GetConformer()
nat = mol.GetNumAtoms()
nl = nat*(nat-1)/2
nl = nat*(nat-1)//2
res = Numeric.zeros(nl, Numeric.Float)
for i in range(1,nat):
pi = conf.GetAtomPosition(i)
id = i*(i-1)/2
id = i*(i-1)//2
for j in range(i):
pj = conf.GetAtomPosition(j)
pj -= pi
@@ -129,9 +131,10 @@ class TestCase(unittest.TestCase) :
rdDepictor.Compute2DCoords(m1,coordMap=coordMap)
conf = m1.GetConformer(0)
for i in range(4):
self.failUnless(ptEq(conf.GetAtomPosition(i),Geometry.Point3D(coordMap[i].x,
coordMap[i].y,
0.0)))
self.assertTrue(ptEq(conf.GetAtomPosition(i),
Geometry.Point3D(coordMap[i].x,
coordMap[i].y,
0.0)))
m1 = Chem.MolFromSmiles('CCC')
try:
@@ -139,7 +142,7 @@ class TestCase(unittest.TestCase) :
ok = 0
except ValueError:
ok=1
self.failUnless(ok)
self.assertTrue(ok)
def test3IssueSF1526844(self):
t = Chem.MolFromSmiles('c1nc(N)ccc1')
@@ -161,7 +164,7 @@ class TestCase(unittest.TestCase) :
conf = m2.GetConformer()
for i in range(nat) :
pos = conf.GetAtomPosition(i)
self.failUnless(ptEq(pos, expected[i], 0.001))
self.assertTrue(ptEq(pos, expected[i], 0.001))
def test4SamplingSpread(self):
mol= Chem.MolFromMolFile(os.path.join(RDConfig.RDBaseDir,'Code/GraphMol/Depictor','test_data/7UPJ_xtal.mol'))
@@ -169,13 +172,13 @@ class TestCase(unittest.TestCase) :
# default mode
rdDepictor.Compute2DCoords(mol,canonOrient=False)
self.failUnless(compareCoords(mol, os.path.join(RDConfig.RDBaseDir,'Code/GraphMol/Depictor','test_data/7UPJ_default.mol')))
self.assertTrue(compareCoords(mol, os.path.join(RDConfig.RDBaseDir,'Code/GraphMol/Depictor','test_data/7UPJ_default.mol')))
# spread the structure as much as possible by sampling
rdDepictor.Compute2DCoords(mol,canonOrient=False, nFlipsPerSample=3, nSample=100,
sampleSeed=100, permuteDeg4Nodes=1)
self.failUnless(compareCoords(mol, os.path.join(RDConfig.RDBaseDir,'Code/GraphMol/Depictor','test_data/7UPJ_spread.mol')))
self.assertTrue(compareCoords(mol, os.path.join(RDConfig.RDBaseDir,'Code/GraphMol/Depictor','test_data/7UPJ_spread.mol')))
def test5SamplingMimic3D(self):
@@ -184,11 +187,11 @@ class TestCase(unittest.TestCase) :
# now mimic the coordinate with a very small weight
rdDepictor.Compute2DCoordsMimicDistmat(mol, dmat3D, weightDistMat=0.001)
self.failUnless(compareCoords(mol, os.path.join(RDConfig.RDBaseDir,'Code/GraphMol/Depictor','test_data/7UPJ_mimic3D_1.mol')))
self.assertTrue(compareCoords(mol, os.path.join(RDConfig.RDBaseDir,'Code/GraphMol/Depictor','test_data/7UPJ_mimic3D_1.mol')))
# now mimic the coordinate with a very small weight
rdDepictor.Compute2DCoordsMimicDistmat(mol, dmat3D, weightDistMat=0.003)
self.failUnless(compareCoords(mol, os.path.join(RDConfig.RDBaseDir,'Code/GraphMol/Depictor','test_data/7UPJ_mimic3D_2.mol')))
self.assertTrue(compareCoords(mol, os.path.join(RDConfig.RDBaseDir,'Code/GraphMol/Depictor','test_data/7UPJ_mimic3D_2.mol')))
#mb = Chem.MolToMolBlock(mol)
#ofile = open('../test_data/7UPJ_mimic3D_2.mol', 'w')
@@ -199,15 +202,15 @@ class TestCase(unittest.TestCase) :
m =Chem.MolFromSmiles('CC')
rdDepictor.Compute2DCoords(m)
conf = m.GetConformer()
self.failUnlessAlmostEqual(conf.GetAtomPosition(0).x,-0.750,3)
self.failUnlessAlmostEqual(conf.GetAtomPosition(1).x,0.750,3)
self.assertAlmostEqual(conf.GetAtomPosition(0).x,-0.750,3)
self.assertAlmostEqual(conf.GetAtomPosition(1).x,0.750,3)
rdDepictor.Compute2DCoords(m,bondLength=1.0)
conf = m.GetConformer()
self.failUnlessAlmostEqual(conf.GetAtomPosition(0).x,-0.500,3)
self.failUnlessAlmostEqual(conf.GetAtomPosition(1).x,0.500,3)
self.assertAlmostEqual(conf.GetAtomPosition(0).x,-0.500,3)
self.assertAlmostEqual(conf.GetAtomPosition(1).x,0.500,3)
rdDepictor.Compute2DCoords(m)
conf = m.GetConformer()
self.failUnlessAlmostEqual(conf.GetAtomPosition(0).x,-0.750,3)
self.failUnlessAlmostEqual(conf.GetAtomPosition(1).x,0.750,3)
self.assertAlmostEqual(conf.GetAtomPosition(0).x,-0.750,3)
self.assertAlmostEqual(conf.GetAtomPosition(1).x,0.750,3)
if __name__ == '__main__':
unittest.main()

190
Code/GraphMol/Descriptors/Wrap/testMolDescriptors.py
View File

@@ -17,23 +17,23 @@ class TestCase(unittest.TestCase) :
def testAtomPairTypes(self):
params = rdMD.AtomPairsParameters
mol = Chem.MolFromSmiles("C=C");
self.failUnless(rdMD.GetAtomPairAtomCode(mol.GetAtomWithIdx(0))==\
self.assertTrue(rdMD.GetAtomPairAtomCode(mol.GetAtomWithIdx(0))==\
rdMD.GetAtomPairAtomCode(mol.GetAtomWithIdx(1)))
self.failUnless(rdMD.GetAtomPairAtomCode(mol.GetAtomWithIdx(0))==\
self.assertTrue(rdMD.GetAtomPairAtomCode(mol.GetAtomWithIdx(0))==\
1 | (1 | 1<<params.numPiBits)<<params.numBranchBits)
mol = Chem.MolFromSmiles("C#CO");
self.failUnless(rdMD.GetAtomPairAtomCode(mol.GetAtomWithIdx(0))!=\
self.assertTrue(rdMD.GetAtomPairAtomCode(mol.GetAtomWithIdx(0))!=\
rdMD.GetAtomPairAtomCode(mol.GetAtomWithIdx(1)))
self.failUnless(rdMD.GetAtomPairAtomCode(mol.GetAtomWithIdx(0))==\
self.assertTrue(rdMD.GetAtomPairAtomCode(mol.GetAtomWithIdx(0))==\
1 | (2 | 1<<params.numPiBits)<<params.numBranchBits)
self.failUnless(rdMD.GetAtomPairAtomCode(mol.GetAtomWithIdx(1))==\
self.assertTrue(rdMD.GetAtomPairAtomCode(mol.GetAtomWithIdx(1))==\
2 | (2 | 1<<params.numPiBits)<<params.numBranchBits)
self.failUnless(rdMD.GetAtomPairAtomCode(mol.GetAtomWithIdx(2))==\
self.assertTrue(rdMD.GetAtomPairAtomCode(mol.GetAtomWithIdx(2))==\
1 | (0 | 3<<params.numPiBits)<<params.numBranchBits)
self.failUnless(rdMD.GetAtomPairAtomCode(mol.GetAtomWithIdx(1),1)==\
self.assertTrue(rdMD.GetAtomPairAtomCode(mol.GetAtomWithIdx(1),1)==\
1 | (2 | 1<<params.numPiBits)<<params.numBranchBits)
self.failUnless(rdMD.GetAtomPairAtomCode(mol.GetAtomWithIdx(1),2)==\
self.assertTrue(rdMD.GetAtomPairAtomCode(mol.GetAtomWithIdx(1),2)==\
0 | (2 | 1<<params.numPiBits)<<params.numBranchBits)
def testAtomPairs(self):
@@ -41,27 +41,27 @@ class TestCase(unittest.TestCase) :
fp1 = rdMD.GetAtomPairFingerprint(m)
fp2 = rdMD.GetAtomPairFingerprint(m,minLength=1,maxLength=2)
nz1 = fp1.GetNonzeroElements()
self.failUnlessEqual(len(nz1),2)
self.assertEqual(len(nz1),2)
nz2 = fp2.GetNonzeroElements()
self.failUnlessEqual(len(nz2),2)
self.assertEqual(len(nz2),2)
fp2 = rdMD.GetAtomPairFingerprint(m,minLength=1,maxLength=1)
nz2 = fp2.GetNonzeroElements()
self.failUnlessEqual(len(nz2),1)
self.assertEqual(len(nz2),1)
def testHashedAtomPairs(self):
m = Chem.MolFromSmiles('c1ccccc1')
fp1 = rdMD.GetHashedAtomPairFingerprint(m,2048)
fp2 = rdMD.GetHashedAtomPairFingerprint(m,2048,1,3)
self.failUnless(fp1==fp2)
self.assertTrue(fp1==fp2)
fp2 = rdMD.GetHashedAtomPairFingerprint(m,2048,1,2)
sim= DataStructs.DiceSimilarity(fp1,fp2)
self.failUnless(sim>0.0 and sim<1.0)
self.assertTrue(sim>0.0 and sim<1.0)
m = Chem.MolFromSmiles('c1ccccn1')
fp2 = rdMD.GetHashedAtomPairFingerprint(m,2048)
sim= DataStructs.DiceSimilarity(fp1,fp2)
self.failUnless(sim>0.0 and sim<1.0)
self.assertTrue(sim>0.0 and sim<1.0)
m = Chem.MolFromSmiles('c1ccccc1')
@@ -69,7 +69,7 @@ class TestCase(unittest.TestCase) :
m = Chem.MolFromSmiles('c1ccccn1')
fp2 = rdMD.GetHashedAtomPairFingerprintAsBitVect(m,2048)
sim= DataStructs.DiceSimilarity(fp1,fp2)
self.failUnless(sim>0.0 and sim<1.0)
self.assertTrue(sim>0.0 and sim<1.0)
def testRootedAtomPairs(self):
@@ -78,36 +78,36 @@ class TestCase(unittest.TestCase) :
fp2 = rdMD.GetAtomPairFingerprint(m,fromAtoms=(0,))
nz1 = fp1.GetNonzeroElements()
nz2 = fp2.GetNonzeroElements()
for k,v in nz2.iteritems():
self.failUnless(v<=nz1[k])
for k,v in nz2.items():
self.assertTrue(v<=nz1[k])
def testTopologicalTorsions(self):
mol = Chem.MolFromSmiles("CC");
fp = rdMD.GetTopologicalTorsionFingerprint(mol)
self.failUnless(fp.GetTotalVal()==0)
self.assertTrue(fp.GetTotalVal()==0)
mol = Chem.MolFromSmiles("CCCC");
fp = rdMD.GetTopologicalTorsionFingerprint(mol)
self.failUnless(fp.GetTotalVal()==1)
self.assertTrue(fp.GetTotalVal()==1)
fp = rdMD.GetTopologicalTorsionFingerprint(mol,3)
self.failUnless(fp.GetTotalVal()==2)
self.assertTrue(fp.GetTotalVal()==2)
mol = Chem.MolFromSmiles("CCCO");
fp = rdMD.GetTopologicalTorsionFingerprint(mol)
self.failUnless(fp.GetTotalVal()==1)
self.assertTrue(fp.GetTotalVal()==1)
fp = rdMD.GetTopologicalTorsionFingerprint(mol,3)
self.failUnless(fp.GetTotalVal()==2)
self.assertTrue(fp.GetTotalVal()==2)
mol = Chem.MolFromSmiles("CCCCCCCCCCC");
fp = rdMD.GetTopologicalTorsionFingerprint(mol,7)
self.failUnlessRaises(ValueError,lambda : rdMD.GetTopologicalTorsionFingerprint(mol,8))
self.assertRaises(ValueError,lambda : rdMD.GetTopologicalTorsionFingerprint(mol,8))
def testHashedTopologicalTorsions(self):
mol = Chem.MolFromSmiles("c1ncccc1");
fp1 = rdMD.GetHashedTopologicalTorsionFingerprint(mol)
mol = Chem.MolFromSmiles("n1ccccc1");
fp2 = rdMD.GetHashedTopologicalTorsionFingerprint(mol)
self.failUnlessEqual(DataStructs.DiceSimilarity(fp1,fp2),1.0)
self.assertEqual(DataStructs.DiceSimilarity(fp1,fp2),1.0)
def testRootedTorsions(self):
m = Chem.MolFromSmiles('Oc1ccccc1')
@@ -115,146 +115,146 @@ class TestCase(unittest.TestCase) :
fp2 = rdMD.GetTopologicalTorsionFingerprint(m,fromAtoms=(0,))
nz1 = fp1.GetNonzeroElements()
nz2 = fp2.GetNonzeroElements()
for k,v in nz2.iteritems():
self.failUnless(v<=nz1[k])
for k,v in nz2.items():
self.assertTrue(v<=nz1[k])
m = Chem.MolFromSmiles('COCC')
fp1 = rdMD.GetTopologicalTorsionFingerprint(m)
self.failUnlessEqual(len(fp1.GetNonzeroElements()),1)
self.assertEqual(len(fp1.GetNonzeroElements()),1)
fp1 = rdMD.GetTopologicalTorsionFingerprint(m,fromAtoms=(0,))
self.failUnlessEqual(len(fp1.GetNonzeroElements()),1)
self.assertEqual(len(fp1.GetNonzeroElements()),1)
fp1 = rdMD.GetTopologicalTorsionFingerprint(m,fromAtoms=(1,))
self.failUnlessEqual(len(fp1.GetNonzeroElements()),0)
self.assertEqual(len(fp1.GetNonzeroElements()),0)
def testMorganFingerprints(self):
mol = Chem.MolFromSmiles('CC(F)(Cl)C(F)(Cl)C')
fp = rdMD.GetMorganFingerprint(mol,0)
self.failUnless(len(fp.GetNonzeroElements())==4)
self.assertTrue(len(fp.GetNonzeroElements())==4)
mol = Chem.MolFromSmiles('CC')
fp = rdMD.GetMorganFingerprint(mol,0)
self.failUnless(len(fp.GetNonzeroElements())==1)
self.failUnless(fp.GetNonzeroElements().values()[0]==2)
self.assertTrue(len(fp.GetNonzeroElements())==1)
self.assertTrue(list(fp.GetNonzeroElements().values())[0]==2)
fp = rdMD.GetMorganFingerprint(mol,0,useCounts=False)
self.failUnless(len(fp.GetNonzeroElements())==1)
self.failUnless(fp.GetNonzeroElements().values()[0]==1)
self.assertTrue(len(fp.GetNonzeroElements())==1)
self.assertTrue(list(fp.GetNonzeroElements().values())[0]==1)
mol = Chem.MolFromSmiles('CC(F)(Cl)C(F)(Cl)C')
fp = rdMD.GetHashedMorganFingerprint(mol,0)
self.failUnless(len(fp.GetNonzeroElements())==4)
self.assertTrue(len(fp.GetNonzeroElements())==4)
fp = rdMD.GetMorganFingerprint(mol,1)
self.failUnless(len(fp.GetNonzeroElements())==8)
self.assertTrue(len(fp.GetNonzeroElements())==8)
fp = rdMD.GetHashedMorganFingerprint(mol,1)
self.failUnless(len(fp.GetNonzeroElements())==8)
self.assertTrue(len(fp.GetNonzeroElements())==8)
fp = rdMD.GetMorganFingerprint(mol,2)
self.failUnless(len(fp.GetNonzeroElements())==9)
self.assertTrue(len(fp.GetNonzeroElements())==9)
mol = Chem.MolFromSmiles('CC(F)(Cl)[C@](F)(Cl)C')
fp = rdMD.GetMorganFingerprint(mol,0)
self.failUnless(len(fp.GetNonzeroElements())==4)
self.assertTrue(len(fp.GetNonzeroElements())==4)
fp = rdMD.GetMorganFingerprint(mol,1)
self.failUnless(len(fp.GetNonzeroElements())==8)
self.assertTrue(len(fp.GetNonzeroElements())==8)
fp = rdMD.GetMorganFingerprint(mol,2)
self.failUnless(len(fp.GetNonzeroElements())==9)
self.assertTrue(len(fp.GetNonzeroElements())==9)
fp = rdMD.GetMorganFingerprint(mol,0,useChirality=True)
self.failUnless(len(fp.GetNonzeroElements())==4)
self.assertTrue(len(fp.GetNonzeroElements())==4)
fp = rdMD.GetMorganFingerprint(mol,1,useChirality=True)
self.failUnless(len(fp.GetNonzeroElements())==9)
self.assertTrue(len(fp.GetNonzeroElements())==9)
fp = rdMD.GetMorganFingerprint(mol,2,useChirality=True)
self.failUnless(len(fp.GetNonzeroElements())==10)
self.assertTrue(len(fp.GetNonzeroElements())==10)
mol = Chem.MolFromSmiles('CCCCC')
fp = rdMD.GetMorganFingerprint(mol,0,fromAtoms=(0,))
self.failUnless(len(fp.GetNonzeroElements())==1)
self.assertTrue(len(fp.GetNonzeroElements())==1)
mol = Chem.MolFromSmiles('CC1CC1')
vs1 = rdMD.GetConnectivityInvariants(mol)
self.failUnlessEqual(len(vs1),mol.GetNumAtoms())
self.assertEqual(len(vs1),mol.GetNumAtoms())
fp1 = rdMD.GetMorganFingerprint(mol,2,invariants=vs1)
fp2 = rdMD.GetMorganFingerprint(mol,2)
self.failUnlessEqual(fp1,fp2)
self.assertEqual(fp1,fp2)
vs2 = rdMD.GetConnectivityInvariants(mol,False)
self.failUnlessEqual(len(vs2),mol.GetNumAtoms())
self.failIfEqual(vs1,vs2)
self.assertEqual(len(vs2),mol.GetNumAtoms())
self.assertNotEqual(vs1,vs2)
fp1 = rdMD.GetMorganFingerprint(mol,2,invariants=vs2)
self.failIfEqual(fp1,fp2)
self.assertNotEqual(fp1,fp2)
mol = Chem.MolFromSmiles('Cc1ccccc1')
vs1 = rdMD.GetFeatureInvariants(mol)
self.failUnlessEqual(len(vs1),mol.GetNumAtoms())
self.failUnlessEqual(vs1[0],0)
self.failIfEqual(vs1[1],0)
self.failUnlessEqual(vs1[1],vs1[2])
self.failUnlessEqual(vs1[1],vs1[3])
self.failUnlessEqual(vs1[1],vs1[4])
self.assertEqual(len(vs1),mol.GetNumAtoms())
self.assertEqual(vs1[0],0)
self.assertNotEqual(vs1[1],0)
self.assertEqual(vs1[1],vs1[2])
self.assertEqual(vs1[1],vs1[3])
self.assertEqual(vs1[1],vs1[4])
mol = Chem.MolFromSmiles('FCCCl')
vs1 = rdMD.GetFeatureInvariants(mol)
self.failUnlessEqual(len(vs1),mol.GetNumAtoms())
self.failUnlessEqual(vs1[1],0)
self.failUnlessEqual(vs1[2],0)
self.failIfEqual(vs1[0],0)
self.failUnlessEqual(vs1[0],vs1[3])
self.assertEqual(len(vs1),mol.GetNumAtoms())
self.assertEqual(vs1[1],0)
self.assertEqual(vs1[2],0)
self.assertNotEqual(vs1[0],0)
self.assertEqual(vs1[0],vs1[3])
fp1 = rdMD.GetMorganFingerprint(mol,0,invariants=vs1)
fp2 = rdMD.GetMorganFingerprint(mol,0,useFeatures=True)
self.failUnlessEqual(fp1,fp2)
self.assertEqual(fp1,fp2)
def testCrippen(self):
mol = Chem.MolFromSmiles("n1ccccc1CO");
contribs = rdMD._CalcCrippenContribs(mol)
self.failUnlessEqual(len(contribs),mol.GetNumAtoms());
self.assertEqual(len(contribs),mol.GetNumAtoms());
ts = [0]*mol.GetNumAtoms()
contribs = rdMD._CalcCrippenContribs(mol,force=True,atomTypes=ts)
self.failUnlessEqual(ts,[59, 25, 25, 25, 25, 28, 17, 69])
self.assertEqual(ts,[59, 25, 25, 25, 25, 28, 17, 69])
ls = ['']*mol.GetNumAtoms()
contribs = rdMD._CalcCrippenContribs(mol,force=True,atomTypeLabels=ls)
self.failUnlessEqual(ls,['N11', 'C18', 'C18', 'C18', 'C18', 'C21', 'C10', 'O2'])
self.assertEqual(ls,['N11', 'C18', 'C18', 'C18', 'C18', 'C21', 'C10', 'O2'])
def testMolWt(self):
mol = Chem.MolFromSmiles("C");
amw = rdMD._CalcMolWt(mol);
self.failUnless(feq(amw,16.043,.001));
self.assertTrue(feq(amw,16.043,.001));
amw = rdMD._CalcMolWt(mol,True);
self.failUnless(feq(amw,12.011,.001));
self.assertTrue(feq(amw,12.011,.001));
mol2 = Chem.AddHs(mol);
amw = rdMD._CalcMolWt(mol2);
self.failUnless(feq(amw,16.043,.001));
self.assertTrue(feq(amw,16.043,.001));
amw = rdMD._CalcMolWt(mol2,True);
self.failUnless(feq(amw,12.011,.001));
self.assertTrue(feq(amw,12.011,.001));
mol = Chem.MolFromSmiles("C");
amw = rdMD.CalcExactMolWt(mol);
self.failUnless(feq(amw,16.031,.001));
self.assertTrue(feq(amw,16.031,.001));
def testPairValues(self):
import base64
testD=(('CCCO','AQAAAAQAAAAAAIAABgAAACGECAABAAAAIoQIAAEAAABBhAgAAQAAACNEGAABAAAAQUQYAAEAAABC\nRBgAAQAAAA==\n'),
('CNc1ccco1','AQAAAAQAAAAAAIAAEAAAACOECgABAAAAJIQKAAIAAABBhQoAAgAAAEKFCgABAAAAIsQKAAEAAABB\nxQoAAQAAAELFCgACAAAAIYQQAAEAAABChRAAAQAAAEOFEAACAAAAYYUQAAEAAAAjhBoAAQAAAEGF\nGgABAAAAQoUaAAIAAABhhRoAAQAAAEKIGgABAAAA\n'),
testD=(('CCCO',b'AQAAAAQAAAAAAIAABgAAACGECAABAAAAIoQIAAEAAABBhAgAAQAAACNEGAABAAAAQUQYAAEAAABC\nRBgAAQAAAA==\n'),
('CNc1ccco1',b'AQAAAAQAAAAAAIAAEAAAACOECgABAAAAJIQKAAIAAABBhQoAAgAAAEKFCgABAAAAIsQKAAEAAABB\nxQoAAQAAAELFCgACAAAAIYQQAAEAAABChRAAAQAAAEOFEAACAAAAYYUQAAEAAAAjhBoAAQAAAEGF\nGgABAAAAQoUaAAIAAABhhRoAAQAAAEKIGgABAAAA\n'),
)
for smi,txt in testD:
pkl = base64.decodestring(txt)
fp = rdMD.GetAtomPairFingerprint(Chem.MolFromSmiles(smi))
fp2 = DataStructs.IntSparseIntVect(pkl)
self.failUnlessEqual(DataStructs.DiceSimilarity(fp,fp2),1.0)
self.failUnlessEqual(fp,fp2)
self.assertEqual(DataStructs.DiceSimilarity(fp,fp2),1.0)
self.assertEqual(fp,fp2)
def testTorsionValues(self):
import base64
testD=(('CCCO','AQAAAAgAAAD/////DwAAAAEAAAAAAAAAIECAAAMAAAABAAAA\n'),
('CNc1ccco1','AQAAAAgAAAD/////DwAAAAkAAAAAAAAAIICkSAEAAAABAAAAKVKgSQEAAAABAAAAKVCgUAEAAAAB\nAAAAKVCgUQEAAAABAAAAKVCkCAIAAAABAAAAKdCkCAIAAAABAAAAKVCgSAMAAAABAAAAKVCkSAMA\nAAABAAAAIICkSAMAAAABAAAA\n'),
testD=(('CCCO',b'AQAAAAgAAAD/////DwAAAAEAAAAAAAAAIECAAAMAAAABAAAA\n'),
('CNc1ccco1',b'AQAAAAgAAAD/////DwAAAAkAAAAAAAAAIICkSAEAAAABAAAAKVKgSQEAAAABAAAAKVCgUAEAAAAB\nAAAAKVCgUQEAAAABAAAAKVCkCAIAAAABAAAAKdCkCAIAAAABAAAAKVCgSAMAAAABAAAAKVCkSAMA\nAAABAAAAIICkSAMAAAABAAAA\n'),
)
for smi,txt in testD:
pkl = base64.decodestring(txt)
fp = rdMD.GetTopologicalTorsionFingerprint(Chem.MolFromSmiles(smi))
fp2 = DataStructs.LongSparseIntVect(pkl)
self.failUnlessEqual(DataStructs.DiceSimilarity(fp,fp2),1.0)
self.failUnlessEqual(fp,fp2)
self.assertEqual(DataStructs.DiceSimilarity(fp,fp2),1.0)
self.assertEqual(fp,fp2)
def testAtomPairOptions(self):
m1 = Chem.MolFromSmiles('c1ccccc1')
@@ -262,66 +262,66 @@ class TestCase(unittest.TestCase) :
fp1 = rdMD.GetAtomPairFingerprint(m1)
fp2 = rdMD.GetAtomPairFingerprint(m2)
self.failIfEqual(fp1,fp2)
self.assertNotEqual(fp1,fp2)
fp1 = rdMD.GetAtomPairFingerprint(m1,atomInvariants=[1]*6)
fp2 = rdMD.GetAtomPairFingerprint(m2,atomInvariants=[1]*6)
self.failUnlessEqual(fp1,fp2)
self.assertEqual(fp1,fp2)
fp1 = rdMD.GetAtomPairFingerprint(m1,atomInvariants=[1]*6)
fp2 = rdMD.GetAtomPairFingerprint(m2,atomInvariants=[2]*6)
self.failIfEqual(fp1,fp2)
self.assertNotEqual(fp1,fp2)
fp1 = rdMD.GetHashedAtomPairFingerprintAsBitVect(m1)
fp2 = rdMD.GetHashedAtomPairFingerprintAsBitVect(m2)
self.failIfEqual(fp1,fp2)
self.assertNotEqual(fp1,fp2)
fp1 = rdMD.GetHashedAtomPairFingerprintAsBitVect(m1,atomInvariants=[1]*6)
fp2 = rdMD.GetHashedAtomPairFingerprintAsBitVect(m2,atomInvariants=[1]*6)
self.failUnlessEqual(fp1,fp2)
self.assertEqual(fp1,fp2)
fp1 = rdMD.GetHashedAtomPairFingerprintAsBitVect(m1,atomInvariants=[1]*6)
fp2 = rdMD.GetHashedAtomPairFingerprintAsBitVect(m2,atomInvariants=[2]*6)
self.failIfEqual(fp1,fp2)
self.assertNotEqual(fp1,fp2)
fp1 = rdMD.GetTopologicalTorsionFingerprint(m1)
fp2 = rdMD.GetTopologicalTorsionFingerprint(m2)
self.failIfEqual(fp1,fp2)
self.assertNotEqual(fp1,fp2)
fp1 = rdMD.GetTopologicalTorsionFingerprint(m1,atomInvariants=[1]*6)
fp2 = rdMD.GetTopologicalTorsionFingerprint(m2,atomInvariants=[1]*6)
self.failUnlessEqual(fp1,fp2)
self.assertEqual(fp1,fp2)
fp1 = rdMD.GetTopologicalTorsionFingerprint(m1,atomInvariants=[1]*6)
fp2 = rdMD.GetTopologicalTorsionFingerprint(m2,atomInvariants=[2]*6)
self.failIfEqual(fp1,fp2)
self.assertNotEqual(fp1,fp2)
fp1 = rdMD.GetHashedTopologicalTorsionFingerprintAsBitVect(m1)
fp2 = rdMD.GetHashedTopologicalTorsionFingerprintAsBitVect(m2)
self.failIfEqual(fp1,fp2)
self.assertNotEqual(fp1,fp2)
fp1 = rdMD.GetHashedTopologicalTorsionFingerprintAsBitVect(m1,atomInvariants=[1]*6)
fp2 = rdMD.GetHashedTopologicalTorsionFingerprintAsBitVect(m2,atomInvariants=[1]*6)
self.failUnlessEqual(fp1,fp2)
self.assertEqual(fp1,fp2)
fp1 = rdMD.GetHashedTopologicalTorsionFingerprintAsBitVect(m1,atomInvariants=[1]*6)
fp2 = rdMD.GetHashedTopologicalTorsionFingerprintAsBitVect(m2,atomInvariants=[2]*6)
self.failIfEqual(fp1,fp2)
self.assertNotEqual(fp1,fp2)
def testMolFormula(self):
m = Chem.MolFromSmiles("[2H]C([3H])O")
formula = rdMD.CalcMolFormula(m)
self.failUnlessEqual(formula,'CH4O')
self.assertEqual(formula,'CH4O')
formula = rdMD.CalcMolFormula(m,separateIsotopes=True)
self.failUnlessEqual(formula,'CH2DTO')
self.assertEqual(formula,'CH2DTO')
formula = rdMD.CalcMolFormula(m,separateIsotopes=True,abbreviateHIsotopes=False)
self.failUnlessEqual(formula,'CH2[2H][3H]O')
self.assertEqual(formula,'CH2[2H][3H]O')
m = Chem.MolFromSmiles("[2H][13CH2]CO")
formula = rdMD.CalcMolFormula(m)
self.failUnlessEqual(formula,'C2H6O')
self.assertEqual(formula,'C2H6O')
formula = rdMD.CalcMolFormula(m,separateIsotopes=True)
self.failUnlessEqual(formula,'C[13C]H5DO')
self.assertEqual(formula,'C[13C]H5DO')

3
Code/GraphMol/DistGeomHelpers/Wrap/rdDistGeom.cpp
View File

@@ -15,6 +15,7 @@
#include <GraphMol/GraphMol.h>
#include <RDBoost/Wrap.h>
#include <RDBoost/import_array.h>
#include <GraphMol/DistGeomHelpers/BoundsMatrixBuilder.h>
#include <GraphMol/DistGeomHelpers/Embedder.h>
@@ -105,7 +106,7 @@ BOOST_PYTHON_MODULE(rdDistGeom) {
"Module containing functions to compute atomic coordinates in 3D using distance geometry"
;
import_array();
rdkit_import_array();
//RegisterListConverter<RDKit::Atom*>();

115
Code/GraphMol/DistGeomHelpers/Wrap/testDistGeom.py
View File

@@ -1,11 +1,14 @@
from __future__ import print_function
import unittest
import os,copy
import math
import numpy
from rdkit.six.moves import cPickle as pickle
from rdkit.six import next
from rdkit import Chem
from rdkit.Chem import rdDistGeom,ChemicalForceFields,rdMolAlign
from rdkit import RDConfig
import unittest
import os,copy
import cPickle as pickle
import math
import numpy
from rdkit.Geometry import rdGeometry as geom
from rdkit.RDLogger import logger
logger=logger()
@@ -92,7 +95,7 @@ class TestCase(unittest.TestCase) :
ofile = os.path.join(RDConfig.RDBaseDir,'Code','GraphMol','DistGeomHelpers',
'test_data','embedDistOpti.sdf')
self.failUnless(compareWithOld(fileN, ofile))
self.assertTrue(compareWithOld(fileN, ofile))
def test1Small(self):
#writer = Chem.SDWriter("test.sdf")
@@ -100,22 +103,22 @@ class TestCase(unittest.TestCase) :
mol = Chem.MolFromSmiles('O')
rdDistGeom.EmbedMolecule(mol,10,1)
conf = mol.GetConformer()
self.failUnless(lstEq(conf.GetAtomPosition(0), [0.0, 0.0, 0.0]))
self.assertTrue(lstEq(conf.GetAtomPosition(0), [0.0, 0.0, 0.0]))
#writer.write(mol)
mol = Chem.MolFromSmiles('CO')
rdDistGeom.EmbedMolecule(mol, 10,1)
conf = mol.GetConformer()
self.failUnless(lstEq(conf.GetAtomPosition(0), [0.69192, 0.0, 0.0]))
self.failUnless(lstEq(conf.GetAtomPosition(1), [-0.69192, 0.0, 0.0]))
self.assertTrue(lstEq(conf.GetAtomPosition(0), [0.69192, 0.0, 0.0]))
self.assertTrue(lstEq(conf.GetAtomPosition(1), [-0.69192, 0.0, 0.0]))
#writer.write(mol)
mol = Chem.MolFromSmiles('CCC')
rdDistGeom.EmbedMolecule(mol,10,1)
conf = mol.GetConformer()
self.failUnless(lstEq(conf.GetAtomPosition(0), [-1.21676, -0.2989, 0.0]))
self.failUnless(lstEq(conf.GetAtomPosition(1), [-0.00604, 0.59337, 0.0]))
self.failUnless(lstEq(conf.GetAtomPosition(2), [1.22281, -0.29446, 0.0]))
self.assertTrue(lstEq(conf.GetAtomPosition(0), [-1.21676, -0.2989, 0.0]))
self.assertTrue(lstEq(conf.GetAtomPosition(1), [-0.00604, 0.59337, 0.0]))
self.assertTrue(lstEq(conf.GetAtomPosition(2), [1.22281, -0.29446, 0.0]))
#writer.write(mol)
mol = Chem.MolFromSmiles('O=C=O')
@@ -123,9 +126,9 @@ class TestCase(unittest.TestCase) :
conf = mol.GetConformer()
#writer.write(mol)
self.failUnless(lstEq(conf.GetAtomPosition(0), [-1.2180, -0.06088, 0.0]))
self.failUnless(lstEq(conf.GetAtomPosition(1), [-0.00408, 0.12116, 0.0]))
self.failUnless(lstEq(conf.GetAtomPosition(2), [1.22207, -0.060276, 0.0]))
self.assertTrue(lstEq(conf.GetAtomPosition(0), [-1.2180, -0.06088, 0.0]))
self.assertTrue(lstEq(conf.GetAtomPosition(1), [-0.00408, 0.12116, 0.0]))
self.assertTrue(lstEq(conf.GetAtomPosition(2), [1.22207, -0.060276, 0.0]))
mol = Chem.MolFromSmiles('C=C=C=C')
rdDistGeom.EmbedMolecule(mol,10,1)
@@ -134,26 +137,26 @@ class TestCase(unittest.TestCase) :
#writer.write(mol)
d1 = computeDist(conf.GetAtomPosition(0), conf.GetAtomPosition(1))
self.failUnless(feq(d1, 1.31, 0.01))
self.assertTrue(feq(d1, 1.31, 0.01))
d2 = computeDist(conf.GetAtomPosition(0), conf.GetAtomPosition(2))
self.failUnless(feq(d2, 2.59, 0.05))
self.assertTrue(feq(d2, 2.59, 0.05))
d3 = computeDist(conf.GetAtomPosition(0), conf.GetAtomPosition(3))
self.failUnless(feq(d3, 3.84, 0.1))
self.assertTrue(feq(d3, 3.84, 0.1))
d4 = computeDist(conf.GetAtomPosition(1), conf.GetAtomPosition(2))
self.failUnless(feq(d4, 1.29, 0.01))
self.assertTrue(feq(d4, 1.29, 0.01))
d5 = computeDist(conf.GetAtomPosition(1), conf.GetAtomPosition(3))
self.failUnless(feq(d5, 2.54, 0.1))
self.assertTrue(feq(d5, 2.54, 0.1))
d6 = computeDist(conf.GetAtomPosition(2), conf.GetAtomPosition(3))
self.failUnless(feq(d6, 1.31, 0.01))
self.assertTrue(feq(d6, 1.31, 0.01))
def test2Utils(self):
mol = Chem.MolFromSmiles('CC')
bm = rdDistGeom.GetMoleculeBoundsMatrix(mol)
self.failUnless(bm[1,0]>0)
self.failUnless(bm[0,1]>0)
self.failUnless(bm[0,1]>=bm[1,0])
self.failUnless(bm[1,0]<1.510)
self.failUnless(bm[0,1]>1.510)
self.assertTrue(bm[1,0]>0)
self.assertTrue(bm[0,1]>0)
self.assertTrue(bm[0,1]>=bm[1,0])
self.assertTrue(bm[1,0]<1.510)
self.assertTrue(bm[0,1]>1.510)
def test3MultiConf(self):
mol = Chem.MolFromSmiles("CC(C)(C)c(cc12)n[n]2C(=O)/C=C(N1)/COC")
@@ -165,18 +168,18 @@ class TestCase(unittest.TestCase) :
ff = ChemicalForceFields.UFFGetMoleculeForceField(mol, 10.0, cid)
ee = ff.CalcEnergy()
nenergies.append(ee)
#print ['%.2f'%x for x in nenergies]
#print nenergies
self.failUnless(lstEq(energies, nenergies,tol=1e-2))
#print(['%.2f'%x for x in nenergies])
#print(nenergies)
self.assertTrue(lstEq(energies, nenergies,tol=1e-2))
def test4OrderDependence(self) :
self.failUnless(compareOrder("CC(C)(C)C(=O)NC(C1)CC(N2C)CCC12",
self.assertTrue(compareOrder("CC(C)(C)C(=O)NC(C1)CC(N2C)CCC12",
"CN1C2CCC1CC(NC(=O)C(C)(C)C)C2"))
#issue 230
self.failUnless(compareOrder("C#CC(C)(C)N(CN1)C\N=C/1SC",
self.assertTrue(compareOrder("C#CC(C)(C)N(CN1)C\\N=C/1SC",
"CSC1=NCN(C(C)(C)C#C)CN1"))
#issue 232
self.failUnless(compareOrder("CC(C)(C)C(=O)NC(C1)CC(N2C)CCC12",
self.assertTrue(compareOrder("CC(C)(C)C(=O)NC(C1)CC(N2C)CCC12",
"CN1C2CCC1CC(NC(=O)C(C)(C)C)C2"))
def test5Issue285(self):
@@ -185,7 +188,7 @@ class TestCase(unittest.TestCase) :
for i,ci in enumerate(cs):
for j in range(i+1,len(cs)):
cj = cs[j]
self.failUnless(Chem.MolToMolBlock(m,confId=ci)!=Chem.MolToMolBlock(m,confId=cj))
self.assertTrue(Chem.MolToMolBlock(m,confId=ci)!=Chem.MolToMolBlock(m,confId=cj))
def test6RmsPruning(self):
smiles = ['CC(C)CC(NC(C1[N+]CCC1)=O)C([O-])=O',
@@ -206,7 +209,7 @@ class TestCase(unittest.TestCase) :
d = [abs(x-y) for x,y in zip(expected,nconfs)]
self.failUnless(max(d)<=1)
self.assertTrue(max(d)<=1)
def test6Chirality(self):
# turn on chirality and we should get chiral volume that is pretty consistent and
@@ -216,21 +219,21 @@ class TestCase(unittest.TestCase) :
mol = Chem.MolFromSmiles(smiles)
cids = rdDistGeom.EmbedMultipleConfs(mol, 30, maxAttempts=30,
randomSeed=100)
self.failUnless(len(cids)==30)
self.assertTrue(len(cids)==30)
for cid in cids:
conf = mol.GetConformer(cid)
vol = computeChiralVol(conf.GetAtomPosition(0),
conf.GetAtomPosition(2),
conf.GetAtomPosition(3),
conf.GetAtomPosition(4))
self.failUnless(abs(vol-tgtVol)<1)
self.assertTrue(abs(vol-tgtVol)<1)
# turn of chirality and now we should see both chiral forms
smiles = "ClC(C)(F)Br"
mol = Chem.MolFromSmiles(smiles)
cids = rdDistGeom.EmbedMultipleConfs(mol, 30, maxAttempts=30,
randomSeed=120)
self.failUnless(len(cids)==30)
self.assertTrue(len(cids)==30)
nPos=0
nNeg=0
for cid in cids:
@@ -239,11 +242,11 @@ class TestCase(unittest.TestCase) :
conf.GetAtomPosition(2),
conf.GetAtomPosition(3),
conf.GetAtomPosition(4))
self.failUnless(abs(vol-tgtVol)<1 or abs(vol+tgtVol)<1)
self.assertTrue(abs(vol-tgtVol)<1 or abs(vol+tgtVol)<1)
if vol<0: nNeg+=1
else: nPos+=1
self.failUnless(nPos>0)
self.failUnless(nNeg>0)
self.assertTrue(nPos>0)
self.assertTrue(nNeg>0)
tgtVol=5.0
for i in range(10):
@@ -255,7 +258,7 @@ class TestCase(unittest.TestCase) :
conf.GetAtomPosition(1),
conf.GetAtomPosition(2),
conf.GetAtomPosition(3))
self.failUnless(abs(vol-tgtVol)<1,"%s %s"%(vol,tgtVol))
self.assertTrue(abs(vol-tgtVol)<1,"%s %s"%(vol,tgtVol))
tgtVol=3.5
expected = [-3.62, -3.67, -3.72, 3.91, 3.95, 3.98, 3.90, 3.94, 3.98, 3.91]
@@ -270,19 +273,19 @@ class TestCase(unittest.TestCase) :
conf.GetAtomPosition(1),
conf.GetAtomPosition(2),
conf.GetAtomPosition(3))
self.failUnless(abs(vol-tgtVol)<1 or abs(vol+tgtVol)<1)
self.assertTrue(abs(vol-tgtVol)<1 or abs(vol+tgtVol)<1)
if vol<0: nNeg+=1
else: nPos+=1
self.failUnless(nPos>0)
self.failUnless(nNeg>0)
self.assertTrue(nPos>0)
self.assertTrue(nNeg>0)
smiles = "Cl[C@H](F)Br"
m = Chem.MolFromSmiles(smiles)
mol = Chem.AddHs(m)
cids = rdDistGeom.EmbedMultipleConfs(mol, 10, maxAttempts=30,
randomSeed=100)
self.failUnless(len(cids)==10)
self.assertTrue(len(cids)==10)
tgtVol=10.5
for cid in cids:
conf = mol.GetConformer(cid)
@@ -290,7 +293,7 @@ class TestCase(unittest.TestCase) :
conf.GetAtomPosition(2),
conf.GetAtomPosition(3),
conf.GetAtomPosition(4))
self.failUnless(abs(vol-tgtVol)<2.)
self.assertTrue(abs(vol-tgtVol)<2.)
# let's try a little more complicated system
expectedV1 = -2.0
@@ -308,7 +311,7 @@ class TestCase(unittest.TestCase) :
conf.GetAtomPosition(3),
conf.GetAtomPosition(7),
conf.GetAtomPosition(13))
self.failUnless(abs(vol1-expectedV1)<1 or abs(vol1+expectedV1)<1)
self.assertTrue(abs(vol1-expectedV1)<1 or abs(vol1+expectedV1)<1)
if vol1<0: nNeg+=1
else: nPos+=1
@@ -317,15 +320,15 @@ class TestCase(unittest.TestCase) :
conf.GetAtomPosition(16),
conf.GetAtomPosition(18),
conf.GetAtomPosition(19))
self.failUnless(abs(vol2-expectedV2)<1 or abs(vol2+expectedV2)<1)
self.assertTrue(abs(vol2-expectedV2)<1 or abs(vol2+expectedV2)<1)
# remove the chiral specification and we should see other chiral
# forms of the compound
expectedV1 = 2.0 #[-2.30, -2.31, -2.30, 2.30, -1.77]
expectedV2 = 2.8 #[2.90, 2.89, 2.69, -2.90, -2.93]
self.failUnless(nPos>0)
self.failUnless(nNeg>0)
self.assertTrue(nPos>0)
self.assertTrue(nNeg>0)
for i in range(5):
smi = "C1=CC=C(C=C1)C(OC1=C[NH]N=C1)C(=O)[NH]CC(Cl)C1=CC=NC=C1"
mol = Chem.MolFromSmiles(smi)
@@ -342,26 +345,26 @@ class TestCase(unittest.TestCase) :
conf.GetAtomPosition(16),
conf.GetAtomPosition(18),
conf.GetAtomPosition(19))
self.failUnless(abs(abs(vol1)-expectedV1)<1.0)
self.failUnless(abs(abs(vol2)-expectedV2)<1.0)
self.assertTrue(abs(abs(vol1)-expectedV1)<1.0)
self.assertTrue(abs(abs(vol2)-expectedV2)<1.0)
def test7ConstrainedEmbedding(self):
ofile = os.path.join(RDConfig.RDBaseDir,'Code','GraphMol','DistGeomHelpers',
'test_data','constrain1.sdf')
suppl = Chem.SDMolSupplier(ofile);
ref = suppl.next()
ref = next(suppl)
probe = copy.deepcopy(ref)
cMap={}
for i in range(5):
cMap[i]=ref.GetConformer().GetAtomPosition(i)
ci = rdDistGeom.EmbedMolecule(probe,coordMap=cMap,randomSeed=23)
self.failUnless(ci>-1);
self.assertTrue(ci>-1);
algMap = zip(range(5),range(5))
ssd = rdMolAlign.AlignMol(probe,ref,atomMap=algMap)
print 'ssd:',ssd
self.failUnless(ssd<0.1)
print('ssd:',ssd)
self.assertTrue(ssd<0.1)
if __name__ == '__main__':
unittest.main()

11
Code/GraphMol/FragCatalog/Wrap/rough_test.py
View File

@@ -9,13 +9,13 @@ it's intended to be shallow, but broad
"""
import unittest,os
from rdkit.six.moves import cPickle
from rdkit import RDConfig
from rdkit.RDLogger import logger
logger=logger()
from rdkit import Chem
from rdkit.Chem import FragmentCatalog
from rdkit import DataStructs
import cPickle
class TestCase(unittest.TestCase):
@@ -65,7 +65,8 @@ class TestCase(unittest.TestCase):
assert tuple(fcat.GetEntryFuncGroupIds(id))==tuple(fcat.GetBitFuncGroupIds(id))
def test3FPgenerator(self) :
smiLines = open(self.smiName,'r').readlines()
with open(self.smiName,'r') as smiF:
smiLines = smiF.readlines()
fparams = FragmentCatalog.FragCatParams(1, 6, self.fName)
fcat = FragmentCatalog.FragCatalog(fparams)
fgen = FragmentCatalog.FragCatGenerator()
@@ -92,7 +93,8 @@ class TestCase(unittest.TestCase):
def test4Serialize(self) :
smiLines = open(self.smiName,'r').readlines()
with open(self.smiName,'r') as smiF:
smiLines = smiF.readlines()
fparams = FragmentCatalog.FragCatParams(1, 6, self.fName)
fcat = FragmentCatalog.FragCatalog(fparams)
fgen = FragmentCatalog.FragCatGenerator()
@@ -120,7 +122,8 @@ class TestCase(unittest.TestCase):
def test5FPsize(self) :
smiLines = open(self.smiName,'r').readlines()
with open(self.smiName,'r') as smiF:
smiLines = smiF.readlines()
fparams = FragmentCatalog.FragCatParams(6, 6, self.fName)
fcat = FragmentCatalog.FragCatalog(fparams)
fgen = FragmentCatalog.FragCatGenerator()

3
Code/GraphMol/MolAlign/Wrap/rdMolAlign.cpp
View File

@@ -21,6 +21,7 @@
#include <GraphMol/Descriptors/Crippen.h>
#include <RDBoost/PySequenceHolder.h>
#include <RDBoost/Wrap.h>
#include <RDBoost/import_array.h>
#include <GraphMol/ROMol.h>
@@ -363,7 +364,7 @@ namespace RDKit {
}
BOOST_PYTHON_MODULE(rdMolAlign) {
import_array();
rdkit_import_array();
python::scope().attr("__doc__") =
"Module containing functions to align a molecule to a second molecule";

47
Code/GraphMol/MolAlign/Wrap/testMolAlign.py
View File

@@ -4,6 +4,7 @@
#
# @@ All Rights Reserved @@
#
from __future__ import print_function
from rdkit import RDConfig
import os,sys,copy
import unittest
@@ -36,7 +37,7 @@ class TestCase(unittest.TestCase):
mol2 = Chem.MolFromMolFile(file2)
rmsd = rdMolAlign.AlignMol(mol2, mol1)
self.failUnless(feq(rmsd, 0.6578))
self.assertTrue(feq(rmsd, 0.6578))
file3 = os.path.join(RDConfig.RDBaseDir,'Code','GraphMol',
'MolAlign', 'test_data', '1oir_trans.mol')
@@ -45,10 +46,10 @@ class TestCase(unittest.TestCase):
conf3 = mol3.GetConformer()
for i in range(mol2.GetNumAtoms()):
self.failUnless(lstFeq(conf2.GetAtomPosition(i), conf3.GetAtomPosition(i)))
self.assertTrue(lstFeq(conf2.GetAtomPosition(i), conf3.GetAtomPosition(i)))
rmsd, trans = rdMolAlign.GetAlignmentTransform(mol2, mol1)
self.failUnlessAlmostEqual(rmsd, 0.6579,4)
self.assertAlmostEqual(rmsd, 0.6579,4)
def test2AtomMap(self) :
atomMap = ((18,27), (13,23), (21,14), (24,7), (9,19), (16,30))
@@ -60,7 +61,7 @@ class TestCase(unittest.TestCase):
mol1 = Chem.MolFromMolFile(file1)
mol2 = Chem.MolFromMolFile(file2)
rmsd = rdMolAlign.AlignMol(mol2, mol1, 0, 0, atomMap)
self.failUnlessAlmostEqual(rmsd, 0.8525,4)
self.assertAlmostEqual(rmsd, 0.8525,4)
def test3Weights(self):
atomMap = ((18,27), (13,23), (21,14), (24,7), (9,19), (16,30))
@@ -73,7 +74,7 @@ class TestCase(unittest.TestCase):
mol2 = Chem.MolFromMolFile(file2)
wts = (1.0, 1.0, 1.0, 1.0, 1.0, 2.0)
rmsd = rdMolAlign.AlignMol(mol2, mol1, 0, 0, atomMap, wts)
self.failUnlessAlmostEqual(rmsd, 0.9513,4)
self.assertAlmostEqual(rmsd, 0.9513,4)
def test4AlignConfs(self):
mol = Chem.MolFromSmiles('C1CC1CNc(n2)nc(C)cc2Nc(cc34)ccc3[nH]nc4')
@@ -104,7 +105,7 @@ class TestCase(unittest.TestCase):
else :
pos = list(conf.GetAtomPosition(aid))
self.failUnless(lstFeq(mpos, pos, .5))
self.assertTrue(lstFeq(mpos, pos, .5))
def test5MMFFO3A(self):
sdf = os.path.join(RDConfig.RDBaseDir,'Code','GraphMol',
@@ -126,8 +127,8 @@ class TestCase(unittest.TestCase):
cumMsd += rmsd * rmsd
# molW.write(prbMol)
cumMsd /= len(molS)
self.failUnlessAlmostEqual(cumScore,6942,0)
self.failUnlessAlmostEqual(math.sqrt(cumMsd),.345,3)
self.assertAlmostEqual(cumScore,6942,0)
self.assertAlmostEqual(math.sqrt(cumMsd),.345,3)
def test6MMFFO3A(self):
" now test where the mmff parameters are generated on call "
@@ -144,8 +145,8 @@ class TestCase(unittest.TestCase):
rmsd = pyO3A.Align()
cumMsd += rmsd * rmsd
cumMsd /= len(molS)
self.failUnlessAlmostEqual(cumScore,6942,0)
self.failUnlessAlmostEqual(math.sqrt(cumMsd),.345,3)
self.assertAlmostEqual(cumScore,6942,0)
self.assertAlmostEqual(math.sqrt(cumMsd),.345,3)
def test7MMFFO3A(self):
" make sure we generate an error if parameters are missing (github issue 158) "
@@ -155,8 +156,8 @@ class TestCase(unittest.TestCase):
m2 = Chem.MolFromSmiles('c1ccccc1B(O)O')
rdDistGeom.EmbedMolecule(m1)
self.failUnlessRaises(ValueError,lambda :rdMolAlign.GetO3A(m1, m2))
self.failUnlessRaises(ValueError,lambda :rdMolAlign.GetO3A(m2, m1))
self.assertRaises(ValueError,lambda :rdMolAlign.GetO3A(m1, m2))
self.assertRaises(ValueError,lambda :rdMolAlign.GetO3A(m2, m1))
def test8MMFFO3A(self):
" test MMFFO3A with constraints "
@@ -184,12 +185,12 @@ class TestCase(unittest.TestCase):
pyO3A.Align()
d = m2.GetConformer().GetAtomPosition(cIdx). \
Distance(m1.GetConformer().GetAtomPosition(cIdx))
self.failUnlessAlmostEqual(d, 0, 0)
self.assertAlmostEqual(d, 0, 0)
pyO3A = rdMolAlign.GetO3A(m3, m1, constraintMap = [[cIdx, nIdx]])
pyO3A.Align()
d = m3.GetConformer().GetAtomPosition(cIdx). \
Distance(m1.GetConformer().GetAtomPosition(cIdx))
self.failUnlessAlmostEqual(d, 7, 0)
self.assertAlmostEqual(d, 7, 0)
#alignedSdf = os.path.join(RDConfig.RDBaseDir,'Code','GraphMol',
# 'MolAlign', 'test_data',
# '4-phenylpyridines_MMFFO3A.sdf')
@@ -231,7 +232,7 @@ class TestCase(unittest.TestCase):
# molW.write(prbMol)
d = prbMol.GetConformer().GetAtomPosition(prbOIdx). \
Distance(refMol.GetConformer().GetAtomPosition(refSIdx))
self.failUnlessAlmostEqual(d, distOS[i], 1)
self.assertAlmostEqual(d, distOS[i], 1)
# molW.close()
def test10CrippenO3A(self):
@@ -254,8 +255,8 @@ class TestCase(unittest.TestCase):
cumMsd += rmsd * rmsd
molW.write(prbMol)
cumMsd /= len(molS)
self.failUnlessAlmostEqual(cumScore,4918,0)
self.failUnlessAlmostEqual(math.sqrt(cumMsd),.304,3)
self.assertAlmostEqual(cumScore,4918,0)
self.assertAlmostEqual(math.sqrt(cumMsd),.304,3)
def test11CrippenO3A(self):
" now test where the Crippen parameters are generated on call "
@@ -272,8 +273,8 @@ class TestCase(unittest.TestCase):
rmsd = pyO3A.Trans()[0]
cumMsd += rmsd * rmsd
cumMsd /= len(molS)
self.failUnlessAlmostEqual(cumScore,4918,0)
self.failUnlessAlmostEqual(math.sqrt(cumMsd),.304,3)
self.assertAlmostEqual(cumScore,4918,0)
self.assertAlmostEqual(math.sqrt(cumMsd),.304,3)
def test12CrippenO3A(self):
" test CrippenO3A with constraints "
@@ -301,12 +302,12 @@ class TestCase(unittest.TestCase):
pyO3A.Align()
d = m2.GetConformer().GetAtomPosition(cIdx). \
Distance(m1.GetConformer().GetAtomPosition(cIdx))
self.failUnlessAlmostEqual(d, 0, 0)
self.assertAlmostEqual(d, 0, 0)
pyO3A = rdMolAlign.GetCrippenO3A(m3, m1, constraintMap = [[cIdx, nIdx]])
pyO3A.Align()
d = m3.GetConformer().GetAtomPosition(cIdx). \
Distance(m1.GetConformer().GetAtomPosition(cIdx))
self.failUnlessAlmostEqual(d, 7, 0)
self.assertAlmostEqual(d, 7, 0)
#alignedSdf = os.path.join(RDConfig.RDBaseDir,'Code','GraphMol',
# 'MolAlign', 'test_data',
# '4-phenylpyridines_CrippenO3A.sdf')
@@ -347,10 +348,10 @@ class TestCase(unittest.TestCase):
# molW.write(prbMol)
d = prbMol.GetConformer().GetAtomPosition(prbOIdx). \
Distance(refMol.GetConformer().GetAtomPosition(refSIdx))
self.failUnlessAlmostEqual(d, distOS[i], 1)
self.assertAlmostEqual(d, distOS[i], 1)
# molW.close()
if __name__ == '__main__':
print "Testing MolAlign Wrappers"
print("Testing MolAlign Wrappers")
unittest.main()

22
Code/GraphMol/MolCatalog/Wrap/rough_test.py
View File

@@ -3,10 +3,10 @@
# Copyright (C) 2006 Greg Landrum
#
import unittest,os,sys
from rdkit.six.moves import cPickle
from rdkit import RDConfig
from rdkit import Chem
from rdkit import DataStructs
import cPickle
from rdkit.Chem import MolCatalog
class TestCase(unittest.TestCase):
@@ -17,24 +17,24 @@ class TestCase(unittest.TestCase):
m = Chem.MolFromSmiles(smi)
entry = MolCatalog.MolCatalogEntry()
entry.SetMol(m)
self.failUnless(entry.GetMol())
self.assertTrue(entry.GetMol())
eSmi = Chem.MolToSmiles(entry.GetMol())
self.failUnless(eSmi==Chem.MolToSmiles(m))
self.assertTrue(eSmi==Chem.MolToSmiles(m))
entry.SetDescription(smi)
self.failUnless(entry.GetDescription()==smi)
self.assertTrue(entry.GetDescription()==smi)
es.append(entry)
v=cat.AddEntry(es[0])
self.failUnless(v==0)
self.failUnless(cat.GetNumEntries()==1)
self.assertTrue(v==0)
self.assertTrue(cat.GetNumEntries()==1)
v=cat.AddEntry(es[1])
self.failUnless(v==1)
self.failUnless(cat.GetNumEntries()==2)
self.assertTrue(v==1)
self.assertTrue(cat.GetNumEntries()==2)
v=cat.AddEntry(es[2])
self.failUnless(v==2)
self.failUnless(cat.GetNumEntries()==3)
self.assertTrue(v==2)
self.assertTrue(cat.GetNumEntries()==3)
cat.AddEdge(0,1)
cat.AddEdge(0,2)
@@ -46,7 +46,7 @@ class TestCase(unittest.TestCase):
cat=None
cat = cPickle.loads(d)
self.failUnless(cat.GetNumEntries()==3)
self.assertTrue(cat.GetNumEntries()==3)
cat=None

3
Code/GraphMol/MolChemicalFeatures/Wrap/MolChemicalFeature.cpp
View File

@@ -11,8 +11,9 @@
#define NO_IMPORT_ARRAY
#include <boost/python.hpp>
#include <GraphMol/RDKitBase.h>
#include <RDGeneral/types.h>
#include <RDBoost/pyint_api.h>
#include <GraphMol/RDKitBase.h>
#include <GraphMol/MolChemicalFeatures/MolChemicalFeature.h>
#include <GraphMol/MolChemicalFeatures/MolChemicalFeatureFactory.h>

3
Code/GraphMol/MolTransforms/Wrap/rdMolTransforms.cpp
View File

@@ -13,6 +13,7 @@
#include "numpy/arrayobject.h"
#include <GraphMol/ROMol.h>
#include <RDBoost/Wrap.h>
#include <RDBoost/import_array.h>
#include <GraphMol/Conformer.h>
#include <GraphMol/MolTransforms/MolTransforms.h>
#include <Geometry/Transform3D.h>
@@ -58,7 +59,7 @@ BOOST_PYTHON_MODULE(rdMolTransforms) {
python::scope().attr("__doc__") =
"Module containing functions to perform 3D operations like rotate and translate conformations";
import_array();
rdkit_import_array();
std::string docString = "Compute the centroid of the conformation - hydrogens are ignored and no attention\n\
if paid to the difference in sizes of the heavy atoms\n";

32
Code/GraphMol/PartialCharges/Wrap/testPartialCharges.py
View File

@@ -1,9 +1,12 @@
from __future__ import print_function
import unittest
import os
from rdkit.six.moves import cPickle as pickle
from rdkit import Chem
from rdkit.Chem import rdPartialCharges
from rdkit import RDConfig
import unittest
import os
import cPickle as pickle
def feq(v1,v2,tol2=1e-4):
return abs(v1-v2)<=tol2
@@ -16,10 +19,9 @@ class TestCase(unittest.TestCase):
smiSup = Chem.SmilesMolSupplier(os.path.join(RDConfig.RDBaseDir,'Code','GraphMol','PartialCharges','Wrap','test_data','halgren.smi'),delimiter='\t')
#parse the original file
infil = file(os.path.join(RDConfig.RDBaseDir,'Code','GraphMol','PartialCharges','Wrap','test_data','halgren_out.txt'),
'r')
lines = infil.readlines()
infil.close()
with open(os.path.join(RDConfig.RDBaseDir,'Code','GraphMol','PartialCharges','Wrap','test_data','halgren_out.txt'),
'r') as infil:
lines = infil.readlines()
tab = Chem.GetPeriodicTable()
@@ -39,8 +41,8 @@ class TestCase(unittest.TestCase):
i = 0
for line in lines:
self.failUnless(line.strip() == olst[i])
i += 1
self.assertTrue(line.strip() == olst[i])
i += 1
def test1PPDataset(self):
fileN = os.path.join(RDConfig.RDBaseDir,'Code','GraphMol','PartialCharges','Wrap','test_data', 'PP_descrs_regress.2.csv')
@@ -49,8 +51,8 @@ class TestCase(unittest.TestCase):
infil.close()
infile = os.path.join(RDConfig.RDBaseDir,'Code','GraphMol','PartialCharges','Wrap','test_data', 'PP_combi_charges.pkl')
cchFile = open(infile, 'rb')
combiCharges = pickle.load(cchFile)
with open(infile, 'rb') as cchFile:
combiCharges = pickle.load(cchFile)
for lin in lines :
if (lin[0] == '#') :
@@ -66,9 +68,9 @@ class TestCase(unittest.TestCase):
rdch = float(rdmol.GetAtomWithIdx(ai).GetProp('_GasteigerCharge'))
if not feq(rdch, combiCharges[smi][ai], 1.e-2) :
failed=True
print smi, ai, rdch, combiCharges[smi][ai]
print(smi, ai, rdch, combiCharges[smi][ai])
if failed: rdmol.Debug()
self.failIf(failed)
self.assertFalse(failed)
def test2Params(self):
""" tests handling of Issue187 """
@@ -84,7 +86,7 @@ class TestCase(unittest.TestCase):
for i in range(m1.GetNumAtoms()):
c1 = float(m1.GetAtomWithIdx(i).GetProp('_GasteigerCharge'))
c2 = float(m2.GetAtomWithIdx(i).GetProp('_GasteigerCharge'))
self.failUnless(feq(c1,c2,1e-4))
self.assertTrue(feq(c1,c2,1e-4))
def test3Params(self):
@@ -105,7 +107,7 @@ class TestCase(unittest.TestCase):
chgs=[-0.030,0.448,-0.427,-0.427]
for i in range(m1.GetNumAtoms()):
c1 = float(m1.GetAtomWithIdx(i).GetProp('_GasteigerCharge'))
self.failUnlessAlmostEqual(c1,chgs[i],3)
self.assertAlmostEqual(c1,chgs[i],3)
if __name__== '__main__':
unittest.main()

3
Code/GraphMol/ShapeHelpers/Wrap/rdShapeHelpers.cpp
View File

@@ -13,6 +13,7 @@
#include "numpy/oldnumeric.h"
#include <GraphMol/ROMol.h>
#include <RDBoost/Wrap.h>
#include <RDBoost/import_array.h>
#include <Geometry/Transform3D.h>
#include <Geometry/UniformGrid3D.h>
@@ -129,7 +130,7 @@ BOOST_PYTHON_MODULE(rdShapeHelpers) {
"Module containing functions to encode and compare the shapes of molecules"
;
import_array();
rdkit_import_array();
//RegisterListConverter<RDKit::Atom*>();

38
Code/GraphMol/ShapeHelpers/Wrap/testShapeHelpers.py
View File

@@ -1,13 +1,15 @@
from rdkit import RDConfig
from __future__ import print_function
import os,sys
import unittest
import math
from rdkit import RDConfig
from rdkit import DataStructs
from rdkit import Chem
from rdkit.Chem import rdMolAlign
from rdkit.Geometry import rdGeometry as geom
from rdkit.Chem import rdShapeHelpers as rdshp
from rdkit.Chem import rdMolTransforms as rdmt
import math
def feq(v1, v2, tol=1.0e-4):
return abs(v1-v2) < tol
@@ -25,21 +27,21 @@ class TestCase(unittest.TestCase):
grd = geom.UniformGrid3D(30.0, 16.0, 10.0)
rdshp.EncodeShape(m, grd, 0);
ovect = grd.GetOccupancyVect()
self.failUnless(ovect.GetTotalVal() == 9250)
self.assertTrue(ovect.GetTotalVal() == 9250)
m = Chem.MolFromMolFile(fileN)
trans = rdmt.ComputeCanonicalTransform(m.GetConformer())
dims, offset = rdshp.ComputeConfDimsAndOffset(m.GetConformer(), trans=trans)
dims -= dims1
offset -= offset1;
self.failUnless(feq(dims.Length(), 0.0))
self.failUnless(feq(offset.Length(), 0.0))
self.assertTrue(feq(dims.Length(), 0.0))
self.assertTrue(feq(offset.Length(), 0.0))
grd1 = geom.UniformGrid3D(30.0, 16.0, 10.0)
rdshp.EncodeShape(m, grd1, 0, trans)
ovect = grd1.GetOccupancyVect()
self.failUnless(ovect.GetTotalVal() == 9250)
self.assertTrue(ovect.GetTotalVal() == 9250)
grd2 = geom.UniformGrid3D(30.0, 16.0, 10.0)
rdshp.EncodeShape(m, grd2, 0)
@@ -49,11 +51,11 @@ class TestCase(unittest.TestCase):
m2 = Chem.MolFromMolFile(fileN2)
rmsd = rdMolAlign.AlignMol(m, m2)
self.failUnless(feq(rdshp.ShapeTanimotoDist(m, m2),0.2813))
self.assertTrue(feq(rdshp.ShapeTanimotoDist(m, m2),0.2813))
dist = rdshp.ShapeTanimotoDist(mol1=m, mol2=m2, confId1=0, confId2=0,
gridSpacing=0.25, stepSize=0.125)
self.failUnless(feq(dist,0.3021))
self.assertTrue(feq(dist,0.3021))
m = Chem.MolFromMolFile(fileN)
cpt = rdmt.ComputeCentroid(m.GetConformer())
@@ -64,13 +66,13 @@ class TestCase(unittest.TestCase):
offset)
dims -= geom.Point3D(13.927, 16.97, 9.775)
offset -= geom.Point3D(-4.353, 16.829, 2.782)
self.failUnless(feq(dims.Length(), 0.0))
self.failUnless(feq(offset.Length(), 0.0))
self.assertTrue(feq(dims.Length(), 0.0))
self.assertTrue(feq(offset.Length(), 0.0))
rdshp.EncodeShape(m, grd, 0)
ovect = grd.GetOccupancyVect()
self.failUnless(ovect.GetTotalVal() == 9275)
self.assertTrue(ovect.GetTotalVal() == 9275)
geom.WriteGridToFile(grd, '1oir_shape.grd')
m = Chem.MolFromMolFile(fileN)
@@ -81,19 +83,19 @@ class TestCase(unittest.TestCase):
lc2, uc2 = rdshp.ComputeUnionBox((lc, uc), (lc1, uc1))
lc -= geom.Point3D(-4.353, 16.829, 2.782)
uc -= geom.Point3D(9.574, 33.799, 12.557)
self.failUnless(feq(lc.Length(), 0.0))
self.failUnless(feq(uc.Length(), 0.0))
self.assertTrue(feq(lc.Length(), 0.0))
self.assertTrue(feq(uc.Length(), 0.0))
lc1 -= geom.Point3D(-10.7519, -6.0778, -3.0123)
uc1 -= geom.Point3D(8.7163, 5.3279, 3.1621)
self.failUnless(feq(lc1.Length(), 0.0))
self.failUnless(feq(uc1.Length(), 0.0))
self.assertTrue(feq(lc1.Length(), 0.0))
self.assertTrue(feq(uc1.Length(), 0.0))
lc2 -= geom.Point3D(-10.7519, -6.0778, -3.01226)
uc2 -= geom.Point3D(9.574, 33.799, 12.557)
self.failUnless(feq(lc2.Length(), 0.0))
self.failUnless(feq(uc2.Length(), 0.0))
self.assertTrue(feq(lc2.Length(), 0.0))
self.assertTrue(feq(uc2.Length(), 0.0))
if __name__=='__main__':
print "Testing Shape Helpers wrapper"
print("Testing Shape Helpers wrapper")
unittest.main()

4
Code/GraphMol/Wrap/ForwardSDMolSupplier.cpp
View File

@@ -19,6 +19,7 @@
#include <GraphMol/FileParsers/MolSupplier.h>
#include <GraphMol/RDKitBase.h>
#include <RDBoost/python_streambuf.h>
#include <RDBoost/iterator_next.h>
#include "MolSupplier.h"
@@ -116,7 +117,8 @@ namespace RDKit {
python::arg("sanitize")=true,
python::arg("removeHs")=true,
python::arg("strictParsing")=true)))
.def("next", (ROMol *(*)(LocalForwardSDMolSupplier *))&MolSupplNext,
.def(NEXT_METHOD,
(ROMol *(*)(LocalForwardSDMolSupplier *))&MolSupplNext,
"Returns the next molecule in the file. Raises _StopIteration_ on EOF.\n",
python::return_value_policy<python::manage_new_object>())
.def("atEnd", &ForwardSDMolSupplier::atEnd,

1
Code/GraphMol/Wrap/Mol.cpp
View File

@@ -15,6 +15,7 @@
#include "rdchem.h"
#include "seqs.hpp"
// ours
#include <RDBoost/pyint_api.h>
#include <GraphMol/RDKitBase.h>
#include <GraphMol/QueryOps.h>
#include <GraphMol/MolPickler.h>

3
Code/GraphMol/Wrap/SDMolSupplier.cpp
View File

@@ -17,6 +17,7 @@
#include <GraphMol/FileParsers/MolSupplier.h>
#include <GraphMol/RDKitBase.h>
#include <RDBoost/PySequenceHolder.h>
#include <RDBoost/iterator_next.h>
#include "MolSupplier.h"
@@ -79,7 +80,7 @@ namespace RDKit {
python::arg("strictParsing")=true)))
.def("__iter__", (SDMolSupplier *(*)(SDMolSupplier *))&MolSupplIter,
python::return_internal_reference<1>() )
.def("next", (ROMol *(*)(SDMolSupplier *))&MolSupplNextAcceptNullLastMolecule,
.def(NEXT_METHOD, (ROMol *(*)(SDMolSupplier *))&MolSupplNextAcceptNullLastMolecule,
"Returns the next molecule in the file. Raises _StopIteration_ on EOF.\n",
python::return_value_policy<python::manage_new_object>())
.def("__getitem__", (ROMol *(*)(SDMolSupplier *,int))&MolSupplGetItem,

5
Code/GraphMol/Wrap/SmilesMolSupplier.cpp
View File

@@ -8,10 +8,11 @@
// which is included in the file license.txt, found at the root
// of the RDKit source tree.
//
#include <string>
#define NO_IMPORT_ARRAY
#include <boost/python.hpp>
#include <string>
#include <RDBoost/iterator_next.h>
//ours
#include <GraphMol/FileParsers/MolSupplier.h>
@@ -100,7 +101,7 @@ namespace RDKit {
.def(python::init<>())
.def("__iter__", (SmilesMolSupplier *(*)(SmilesMolSupplier *))&MolSupplIter,
python::return_internal_reference<1>() )
.def("next", (ROMol *(*)(SmilesMolSupplier *))&MolSupplNext,
.def(NEXT_METHOD, (ROMol *(*)(SmilesMolSupplier *))&MolSupplNext,
"Returns the next molecule in the file. Raises _StopIteration_ on EOF.\n",
python::return_value_policy<python::manage_new_object>())
.def("__getitem__", (ROMol *(*)(SmilesMolSupplier *,int))&MolSupplGetItem,

3
Code/GraphMol/Wrap/TDTMolSupplier.cpp
View File

@@ -15,6 +15,7 @@
//ours
#include <GraphMol/FileParsers/MolSupplier.h>
#include <GraphMol/RDKitBase.h>
#include <RDBoost/iterator_next.h>
#include "MolSupplier.h"
namespace python = boost::python;
@@ -61,7 +62,7 @@ namespace RDKit {
python::arg("sanitize")=true)))
.def("__iter__", (TDTMolSupplier *(*)(TDTMolSupplier *))&MolSupplIter,
python::return_internal_reference<1>() )
.def("next", (ROMol *(*)(TDTMolSupplier *))&MolSupplNext,
.def(NEXT_METHOD, (ROMol *(*)(TDTMolSupplier *))&MolSupplNext,
"Returns the next molecule in the file. Raises _StopIteration_ on EOF.\n",
python::return_value_policy<python::manage_new_object>())
.def("__getitem__", (ROMol *(*)(TDTMolSupplier *,int))&MolSupplGetItem,

8
Code/GraphMol/Wrap/rdchem.cpp
View File

@@ -14,6 +14,8 @@
#include <GraphMol/RDKitBase.h>
#include <numpy/oldnumeric.h>
#include <GraphMol/SanitException.h>
#include <RDBoost/import_array.h>
#include <RDBoost/iterator_next.h>
#include <sstream>
@@ -55,7 +57,7 @@ BOOST_PYTHON_MODULE(rdchem)
;
RegisterListConverter<RDKit::Atom*>();
RegisterListConverter<RDKit::Bond*>();
import_array();
rdkit_import_array();
python::register_exception_translator<IndexErrorException>(&translate_index_error);
python::register_exception_translator<ValueErrorException>(&translate_value_error);
python::register_exception_translator<RDKit::MolSanitizeException>(&rdSanitExceptionTranslator);
@@ -72,7 +74,7 @@ BOOST_PYTHON_MODULE(rdchem)
.def("__iter__",&AtomIterSeq::__iter__,
python::return_internal_reference<1,
python::with_custodian_and_ward_postcall<0,1> >())
.def("next",&AtomIterSeq::next,
.def(NEXT_METHOD,&AtomIterSeq::next,
python::return_value_policy<python::reference_existing_object>())
.def("__len__",&AtomIterSeq::len)
@@ -85,7 +87,7 @@ BOOST_PYTHON_MODULE(rdchem)
.def("__iter__",&QueryAtomIterSeq::__iter__,
python::return_internal_reference<1,
python::with_custodian_and_ward_postcall<0,1> >())
.def("next",&QueryAtomIterSeq::next,
.def(NEXT_METHOD,&QueryAtomIterSeq::next,
python::return_value_policy<python::reference_existing_object>())
.def("__len__",&QueryAtomIterSeq::len)
.def("__getitem__",&QueryAtomIterSeq::get_item,

3
Code/GraphMol/Wrap/rdmolops.cpp
View File

@@ -17,6 +17,7 @@
#include <RDGeneral/types.h>
#include <RDBoost/Wrap.h>
#include <RDBoost/import_array.h>
#include <RDBoost/Exceptions.h>
#include <GraphMol/SanitException.h>
@@ -38,7 +39,7 @@ BOOST_PYTHON_MODULE(rdmolops)
python::scope().attr("__doc__") =
"Module containing RDKit functionality for manipulating molecules."
;
import_array();
rdkit_import_array();
python::register_exception_translator<IndexErrorException>(&translate_index_error);
python::register_exception_translator<ValueErrorException>(&translate_value_error);
python::register_exception_translator<RDKit::MolSanitizeException>(&rdSanitExceptionTranslator);

1657
Code/GraphMol/Wrap/rough_test.py
View File

File diff suppressed because it is too large Load Diff

34
Code/GraphMol/Wrap/testConformer.py
View File

@@ -36,20 +36,20 @@ class TestCase(unittest.TestCase):
conf.SetId(0)
cid = mol.AddConformer(conf)
self.failUnless(cid == 0)
self.assertTrue(cid == 0)
conf2 = mol.GetConformer(0)
self.failUnless(conf2.GetId() == cid)
self.assertTrue(conf2.GetId() == cid)
pt1 = conf2.GetAtomPosition(0)
self.failUnless(ptEq(pt1, Point3D(-0.5, 0.0, 0.0)))
self.assertTrue(ptEq(pt1, Point3D(-0.5, 0.0, 0.0)))
pt2 = conf2.GetAtomPosition(1)
self.failUnless(ptEq(pt2, Point3D(1.0, 0.0, 0.0)))
self.assertTrue(ptEq(pt2, Point3D(1.0, 0.0, 0.0)))
#changing conf should not change conf2 - related to issue 217
conf.SetAtomPosition(1, Point3D(2.0, 0.0, 0.0))
pt2 = conf2.GetAtomPosition(1)
self.failUnless(feq(pt2[0], 1.0))
self.assertTrue(feq(pt2[0], 1.0))
conf = Chem.Conformer(2)
conf.SetAtomPosition(0, Point3D(-0.5, 0.0, 0.0))
@@ -57,7 +57,7 @@ class TestCase(unittest.TestCase):
conf.SetId(2)
cid = mol.AddConformer(conf, 0)
self.failUnless(cid == 2)
self.assertTrue(cid == 2)
conf3 = mol.GetConformer(2)
def test0AddHds(self) :
@@ -68,12 +68,12 @@ class TestCase(unittest.TestCase):
cid = mol.AddConformer(conf)
conf2 = mol.GetConformer()
self.failUnless(conf2.GetNumAtoms() == 2)
self.assertTrue(conf2.GetNumAtoms() == 2)
nmol = Chem.AddHs(mol, 0,1)
conf3 = nmol.GetConformer()
self.failUnless(conf3.GetNumAtoms() == 8)
self.failUnless(conf2.GetNumAtoms() == 2)
self.assertTrue(conf3.GetNumAtoms() == 8)
self.assertTrue(conf2.GetNumAtoms() == 2)
targetCoords = [[-0.5, 0.0, 0.0],
[1.0, 0.0, 0.0],
@@ -86,21 +86,21 @@ class TestCase(unittest.TestCase):
for i in range(8) :
pt = conf3.GetAtomPosition(i)
self.failUnless(ptEq(pt, apply(Point3D,tuple(targetCoords[i]))))
self.assertTrue(ptEq(pt, Point3D(*tuple(targetCoords[i]))))
def test2Issue217(self) :
smi = 'c1ccccc1'
m = Chem.MolFromSmiles(smi)
addConf(m)
self.failUnless(m.GetNumConformers()==1);
self.assertTrue(m.GetNumConformers()==1);
mb2 = Chem.MolToMolBlock(m)
def test3Exceptions(self) :
smi = 'c1ccccc1'
m = Chem.MolFromSmiles(smi)
addConf(m)
self.failUnless(m.GetNumConformers()==1)
self.failUnlessRaises(ValueError,lambda:m.GetConformer(2))
self.assertTrue(m.GetNumConformers()==1)
self.assertRaises(ValueError,lambda:m.GetConformer(2))
def test4ConfTuple(self):
smi = 'c1ccccc1'
@@ -109,17 +109,17 @@ class TestCase(unittest.TestCase):
addConf(m)
confs = m.GetConformers()
self.failUnless(len(confs) == 10)
self.assertTrue(len(confs) == 10)
for conf in confs:
for i in range(6):
pt = conf.GetAtomPosition(i)
self.failUnless(ptEq(pt, Point3D(0.0, 0.0, 0.0)))
self.assertTrue(ptEq(pt, Point3D(0.0, 0.0, 0.0)))
m.RemoveAllConformers()
self.failUnless(m.GetNumConformers() == 0)
self.assertTrue(m.GetNumConformers() == 0)
confs = m.GetConformers()
self.failUnless(confs == ())
self.assertTrue(confs == ())
if __name__ == '__main__':
unittest.main()

4
Code/ML/Cluster/Murtagh/Clustering.cpp
View File

@@ -16,6 +16,8 @@ namespace python = boost::python;
#include <numpy/arrayobject.h>
#include <RDBoost/import_array.h>
typedef double real;
extern "C"
@@ -153,7 +155,7 @@ Clustering_MurtaghDistCluster(python::object data, int nPts, int option)
BOOST_PYTHON_MODULE(Clustering) {
import_array();
rdkit_import_array();
python::def("MurtaghCluster", Clustering_MurtaghCluster,
( python::arg("data"), python::arg("nPts"),

8
Code/ML/Data/cQuantize.cpp
View File

@@ -7,12 +7,14 @@
// which is included in the file license.txt, found at the root
// of the RDKit source tree.
//
#include <cstring>
#include <RDBoost/Wrap.h>
#include <numpy/oldnumeric.h>
#include <RDBoost/import_array.h>
namespace python = boost::python;
#include <cstring>
#include <numpy/oldnumeric.h>
#include <ML/InfoTheory/InfoGainFuncs.h>
/***********************************************
@@ -340,7 +342,7 @@ cQuantize_FindStartPoints(python::object values, python::object results,
BOOST_PYTHON_MODULE(cQuantize) {
import_array();
rdkit_import_array();
python::def("_RecurseOnBounds", cQuantize_RecurseOnBounds,
( python::arg("vals"), python::arg("pyCuts"),

3
Code/ML/InfoTheory/Wrap/rdInfoTheory.cpp
View File

@@ -10,6 +10,7 @@
#define PY_ARRAY_UNIQUE_SYMBOL rdinfotheory_array_API
#include <RDBoost/Wrap.h>
#include "numpy/oldnumeric.h"
#include <RDBoost/import_array.h>
#include <ML/InfoTheory/InfoBitRanker.h>
#include <ML/InfoTheory/InfoGainFuncs.h>
@@ -119,7 +120,7 @@ BOOST_PYTHON_MODULE(rdInfoTheory)
"Module containing bunch of functions for information metrics and a ranker to rank bits"
;
import_array();
rdkit_import_array();
python::register_exception_translator<IndexErrorException>(&translate_index_error);
python::register_exception_translator<ValueErrorException>(&translate_value_error);

49
Code/ML/InfoTheory/Wrap/testRanker.py
View File

@@ -1,9 +1,12 @@
from rdkit import RDConfig,RDRandom
import unittest
import numpy
import os
from rdkit.six.moves import cPickle
from rdkit import RDConfig,RDRandom
from rdkit.ML.InfoTheory import rdInfoTheory as rdit
from rdkit import DataStructs
import numpy
import os,cPickle
def feq(a,b,tol=1e-4):
return abs(a-b)<tol
@@ -15,37 +18,37 @@ class TestCase(unittest.TestCase):
def test0GainFuns(self):
arr = numpy.array([9,5])
self.failUnless(feq(rdit.InfoEntropy(arr),0.9403))
self.assertTrue(feq(rdit.InfoEntropy(arr),0.9403))
arr = numpy.array([9,9])
self.failUnless(feq(rdit.InfoEntropy(arr),1.0000))
self.assertTrue(feq(rdit.InfoEntropy(arr),1.0000))
arr = numpy.array([5,5])
self.failUnless(feq(rdit.InfoEntropy(arr),1.0000))
self.assertTrue(feq(rdit.InfoEntropy(arr),1.0000))
arr = numpy.array([5,0])
self.failUnless(feq(rdit.InfoEntropy(arr),0.0000))
self.assertTrue(feq(rdit.InfoEntropy(arr),0.0000))
arr = numpy.array([5,5,5])
self.failUnless(feq(rdit.InfoEntropy(arr),1.5850))
self.assertTrue(feq(rdit.InfoEntropy(arr),1.5850))
arr = numpy.array([2,5,5])
self.failUnless(feq(rdit.InfoEntropy(arr),1.4834))
self.assertTrue(feq(rdit.InfoEntropy(arr),1.4834))
mat2 = numpy.array([[6,2],[3,3]])
self.failUnless(feq(rdit.InfoGain(mat2),0.0481))
self.failUnless(feq(rdit.ChiSquare(mat2),0.9333))
self.assertTrue(feq(rdit.InfoGain(mat2),0.0481))
self.assertTrue(feq(rdit.ChiSquare(mat2),0.9333))
mat3 = numpy.array([[1,1],[2,1]])
self.failUnless(feq(rdit.InfoGain(mat3),0.0200))
self.assertTrue(feq(rdit.InfoGain(mat3),0.0200))
mat4 = numpy.array([[2,0],[1,2]])
self.failUnless(feq(rdit.InfoGain(mat4),0.4200))
self.assertTrue(feq(rdit.InfoGain(mat4),0.4200))
mat5 = numpy.array([[0,0],[0,0]])
self.failUnless(feq(rdit.InfoGain(mat5),0.0000))
self.assertTrue(feq(rdit.InfoGain(mat5),0.0000))
mat6 = numpy.array([[1,0],[1,0]])
self.failUnless(feq(rdit.InfoGain(mat6),0.0000))
self.assertTrue(feq(rdit.InfoGain(mat6),0.0000))
@@ -82,7 +85,7 @@ class TestCase(unittest.TestCase):
rn2.AccumulateVotes(fp[0], fp[1])
res2 = rn2.GetTopN(50)
self.failUnless((res==res2).all())
self.assertTrue((res==res2).all())
rn3 = rdit.InfoBitRanker(nbits, nc, rdit.InfoType.BIASENTROPY)
#rn3.SetBiasList([0])
@@ -93,7 +96,7 @@ class TestCase(unittest.TestCase):
for i in range(50) :
fan = res3[i,2]/na
fin = res3[i,3]/ni
self.failUnless(fan > fin)
self.assertTrue(fan > fin)
def test2ranker(self) :
nbits = 100
@@ -122,14 +125,14 @@ class TestCase(unittest.TestCase):
res = rn.GetTopN(5)
ids = [int(x[0]) for x in res]
ids.sort()
self.failUnless(ids==[10,15,25,63,70])
self.assertTrue(ids==[10,15,25,63,70])
try:
res = rn.GetTopN(10)
except:
ok = 1
else:
ok = 0
self.failUnless(ok)
self.assertTrue(ok)
def test3Issue140(self) :
nbits = 2
@@ -145,18 +148,18 @@ class TestCase(unittest.TestCase):
res = rn.GetTopN(1)
except:
res = None
self.failUnless(res is not None)
self.assertTrue(res is not None)
def test4Issue237(self) :
inF = open(os.path.join(RDConfig.RDBaseDir,'Code','ML','InfoTheory','Wrap','testData','Issue237.pkl'),'rb')
examples,avail,bias,nB,nPoss = cPickle.load(inF)
with open(os.path.join(RDConfig.RDBaseDir,'Code','ML','InfoTheory','Wrap','testData','Issue237.pkl'),'rb') as inF:
examples,avail,bias,nB,nPoss = cPickle.load(inF)
ranker = rdit.InfoBitRanker(nB,nPoss,rdit.InfoType.BIASENTROPY)
ranker.SetMaskBits(avail)
for ex in examples:
ranker.AccumulateVotes(ex[1],ex[-1])
# this dumps core on linux if the bug isn't fixed:
v=ranker.GetTopN(1)
self.failUnless(int(v[0][0])==12)
self.assertTrue(int(v[0][0])==12)
if __name__ == '__main__':
unittest.main()

5
Code/Numerics/Alignment/Wrap/rdAlignment.cpp
View File

@@ -12,6 +12,7 @@
#include <boost/python.hpp>
#include <boost/python/numeric.hpp>
#include "numpy/arrayobject.h"
#include <RDBoost/import_array.h>
#include <RDBoost/PySequenceHolder.h>
#include <RDBoost/Wrap.h>
@@ -157,13 +158,11 @@ namespace RDNumeric {
BOOST_PYTHON_MODULE(rdAlignment) {
import_array();
rdkit_import_array();
python::scope().attr("__doc__") =
"Module containing functions to align pairs of points in 3D"
;
import_array();
std::string docString = "Compute the optimal alignment (minimum RMSD) between two set of points \n\n\
\n\
ARGUMENTS:\n\n\

57
Code/Numerics/Alignment/Wrap/testAlignment.py
View File

@@ -1,4 +1,5 @@
## Automatically adapted for numpy.oldnumeric Jun 27, 2008 by -c
from __future__ import print_function
import rdkit.Numerics.rdAlignment as rdAlg
from rdkit import Geometry
@@ -44,29 +45,29 @@ class TestCase(unittest.TestCase):
prbPts[1,1] = 3.0
res = rdAlg.GetAlignmentTransform(refPts, prbPts)
self.failUnless(feq(res[0], 0.0))
self.assertTrue(feq(res[0], 0.0))
refLst = list(refPts)
cnt = 0
for item in list(prbPts):
self.failUnless(lstFeq(transformPoint(res[1], item), refLst[cnt]))
self.assertTrue(lstFeq(transformPoint(res[1], item), refLst[cnt]))
cnt+= 1
# repeat with with lists or tuples
refPts = ((0.0, 0.0, 0.0), (1.0, 0.0, 0.0))
prbPts = ((2.0, 2.0, 0.0), (2.0, 3.0, 0.0))
res = rdAlg.GetAlignmentTransform(refPts, prbPts)
self.failUnless(feq(res[0], 0.0))
self.assertTrue(feq(res[0], 0.0))
refPts = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]]
prbPts = [[2.0, 2.0, 0.0], [2.0, 3.0, 0.0]]
res = rdAlg.GetAlignmentTransform(refPts, prbPts)
self.failUnless(feq(res[0], 0.0))
self.assertTrue(feq(res[0], 0.0))
# mix it up
refPts = Numeric.zeros((2,3), Numeric.Float)
refPts[1,0] = 1.0
res = rdAlg.GetAlignmentTransform(refPts, prbPts)
self.failUnless(feq(res[0], 0.0))
self.assertTrue(feq(res[0], 0.0))
def test2Weights(self) :
refPts = Numeric.array([[-math.cos(math.pi/6), -math.sin(math.pi/6), 0.0],
@@ -76,32 +77,32 @@ class TestCase(unittest.TestCase):
[-2*math.sin(math.pi/6) + 3.0, -2*math.cos(math.pi/6), 4.0],
[5.0, 0.0, 4.0]], Numeric.Float)
res = rdAlg.GetAlignmentTransform(refPts, prbPts)
self.failUnless(feq(res[0], 3.0))
self.assertTrue(feq(res[0], 3.0))
target = [[-1.732, -1., 0.],
[1.732, -1., 0.],
[0., 2., 0.]]
cnt = 0
for item in list(prbPts):
self.failUnless(lstFeq(transformPoint(res[1], item), target[cnt]))
self.assertTrue(lstFeq(transformPoint(res[1], item), target[cnt]))
cnt += 1
weights = Numeric.array([1.0, 1.0, 2.0], Numeric.Float)
res = rdAlg.GetAlignmentTransform(refPts, prbPts, weights)
self.failUnless(feq(res[0], 3.75))
self.assertTrue(feq(res[0], 3.75))
cnt = 0
target = [[-1.732, -1.25, 0.],
[1.732, -1.25, 0.],
[0., 1.75, 0.]]
for item in list(prbPts):
self.failUnless(lstFeq(transformPoint(res[1], item), target[cnt]))
self.assertTrue(lstFeq(transformPoint(res[1], item), target[cnt]))
cnt += 1
weights = [1.0, 1.0, 2.0]
res = rdAlg.GetAlignmentTransform(refPts, prbPts, weights)
self.failUnless(feq(res[0], 3.75))
self.assertTrue(feq(res[0], 3.75))
weights = [1.0, 2.0, 2.0]
res = rdAlg.GetAlignmentTransform(refPts, prbPts, weights)
self.failUnless(feq(res[0], 4.8))
self.assertTrue(feq(res[0], 4.8))
def test3tetra(self) :
refPts = Numeric.array([[0.0, 0.0, 0.0],
@@ -111,21 +112,21 @@ class TestCase(unittest.TestCase):
prbPts = Numeric.array([[2.0, 2.0, 3.0],
[3.0, 2.0, 3.0],
[2.0, 3.0, 3.0]], Numeric.Float)
self.failUnlessRaises(ValueError,lambda : rdAlg.GetAlignmentTransform(refPts, prbPts))
self.assertRaises(ValueError,lambda : rdAlg.GetAlignmentTransform(refPts, prbPts))
prbPts = Numeric.array([[2.0, 2.0, 3.0],
[3.0, 2.0, 3.0],
[2.0, 3.0, 3.0],
[2.0, 2.0, 4.0]], Numeric.Float)
res = rdAlg.GetAlignmentTransform(refPts, prbPts)
self.failUnless(feq(res[0], 0.0))
self.assertTrue(feq(res[0], 0.0))
wts = [1.0, 1.0, 1.0]
self.failUnlessRaises(ValueError,lambda : rdAlg.GetAlignmentTransform(refPts, prbPts, wts))
self.assertRaises(ValueError,lambda : rdAlg.GetAlignmentTransform(refPts, prbPts, wts))
wts = [1.0, 1.0, 1.0, 1.0]
res = rdAlg.GetAlignmentTransform(refPts, prbPts, wts)
self.failUnless(feq(res[0], 0.0))
self.assertTrue(feq(res[0], 0.0))
# test reflection
prbPts = Numeric.array([[2.0, 2.0, 3.0],
@@ -133,14 +134,14 @@ class TestCase(unittest.TestCase):
[2.0, 2.0, 4.0],
[2.0, 3.0, 3.0]], Numeric.Float)
res = rdAlg.GetAlignmentTransform(refPts, prbPts, wts)
self.failUnless(feq(res[0], 1.0))
self.assertTrue(feq(res[0], 1.0))
res = rdAlg.GetAlignmentTransform(refPts, prbPts, wts, 1)
self.failUnless(feq(res[0], 0.0))
self.assertTrue(feq(res[0], 0.0))
cnt = 0
refLst = list(refPts)
for item in list(prbPts):
self.failUnless(lstFeq(transformPoint(res[1], item), refLst[cnt]))
self.assertTrue(lstFeq(transformPoint(res[1], item), refLst[cnt]))
cnt += 1
def test4points(self) :
@@ -156,7 +157,7 @@ class TestCase(unittest.TestCase):
)
res = rdAlg.GetAlignmentTransform(refPts, prbPts)
self.failUnless(feq(res[0], 0.0))
self.assertTrue(feq(res[0], 0.0))
def test5errorHandling(self) :
refPts = (Geometry.Point3D(0.0, 0.0, 0.0),
@@ -165,26 +166,26 @@ class TestCase(unittest.TestCase):
Geometry.Point3D(0.0, 0.0, 1.0),
)
prbPts = (1,2,3,4,)
self.failUnlessRaises(ValueError,
lambda : rdAlg.GetAlignmentTransform(refPts, prbPts))
self.assertRaises(ValueError,
lambda : rdAlg.GetAlignmentTransform(refPts, prbPts))
prbPts = ()
self.failUnlessRaises(ValueError,
lambda : rdAlg.GetAlignmentTransform(refPts, prbPts))
self.assertRaises(ValueError,
lambda : rdAlg.GetAlignmentTransform(refPts, prbPts))
prbPts = 1
self.failUnlessRaises(ValueError,
lambda : rdAlg.GetAlignmentTransform(refPts, prbPts))
self.assertRaises(ValueError,
lambda : rdAlg.GetAlignmentTransform(refPts, prbPts))
prbPts = (Geometry.Point3D(2.0, 2.0, 3.0),
Geometry.Point3D(3.0, 2.0, 3.0),
Geometry.Point3D(2.0, 3.0, 3.0),
(2.0, 2.0, 5.0),
)
self.failUnlessRaises(ValueError,
lambda : rdAlg.GetAlignmentTransform(refPts, prbPts))
self.assertRaises(ValueError,
lambda : rdAlg.GetAlignmentTransform(refPts, prbPts))
if __name__ == '__main__':
print "Testing Alignment Wrapper code:"
print("Testing Alignment Wrapper code:")
unittest.main()

1
Code/RDBoost/Wrap.cpp
View File

@@ -14,6 +14,7 @@
//
#define RDKIT_WRAP_SOURCE
#include "Wrap.h"
#include "pyint_api.h"
#include "Exceptions.h"
#include <sstream>
#include <iostream>

18
Code/RDBoost/import_array.h Normal file
View File

@@ -0,0 +1,18 @@
#ifndef RDKIT_IMPORT_ARRAY_INCLUDED
#define RDKIT_IMPORT_ARRAY_INCLUDED
#if PY_MAJOR_VERSION >= 3
inline void * rdkit_import_array()
#else
inline void rdkit_import_array()
#endif
{
// numpy's import_array is defined as a macro that expands into a block
// statement that inlines a return. In python3 it returns a NULL value
// (to comply with the Py_InitModule signature) so it can't be called
// directly from within the BOOST_PYTHON_MODULE init function (that
// returns void)
import_array();
}
#endif

11
Code/RDBoost/iterator_next.h Normal file
View File

@@ -0,0 +1,11 @@
#ifndef RDKIT_ITERATOR_NEXT_INCLUDED
#define RDKIT_ITERATOR_NEXT_INCLUDED
#if PY_MAJOR_VERSION >= 3
#define NEXT_METHOD "__next__"
#else
#define NEXT_METHOD "next"
#endif
#endif

2
Code/RDBoost/list_indexing_suite.hpp
View File

@@ -14,6 +14,8 @@
# include <boost/python/suite/indexing/container_utils.hpp>
# include <boost/python/iterator.hpp>
#include "pyint_api.h"
namespace boost { namespace python {
// Forward declaration

9
Code/RDBoost/pyint_api.h Normal file
View File

@@ -0,0 +1,9 @@
#ifndef RDKIT_PYINT_API_INCLUDED
#define RDKIT_PYINT_API_INCLUDED
#if PY_MAJOR_VERSION >= 3
#define PyInt_FromLong PyLong_FromLong
#define PyInt_AsLong PyLong_AsLong
#endif
#endif

6
Code/RDBoost/python_streambuf.h
View File

@@ -219,8 +219,14 @@ class streambuf : public std::basic_streambuf<char>
read_buffer = py_read(buffer_size);
char *read_buffer_data;
bp::ssize_t py_n_read;
#if PY_MAJOR_VERSION >= 3
// TODO review this.
if (PyBytes_AsStringAndSize(read_buffer.ptr(),
&read_buffer_data, &py_n_read) == -1) {
#else
if (PyString_AsStringAndSize(read_buffer.ptr(),
&read_buffer_data, &py_n_read) == -1) {
#endif
setg(0, 0, 0);
throw std::invalid_argument(
"The method 'read' of the Python file object "

4
Code/SimDivPickers/Wrap/rdSimDivPickers.cpp
View File

@@ -11,7 +11,7 @@
#define PY_ARRAY_UNIQUE_SYMBOL rdpicker_array_API
#include <RDBoost/Wrap.h>
#include "numpy/oldnumeric.h"
#include <RDBoost/import_array.h>
namespace python = boost::python;
@@ -24,7 +24,7 @@ BOOST_PYTHON_MODULE(rdSimDivPickers)
"Module containing the diversity and similarity pickers"
;
import_array();
rdkit_import_array();
python::register_exception_translator<IndexErrorException>(&translate_index_error);
python::register_exception_translator<ValueErrorException>(&translate_value_error);

93
External/AvalonTools/Wrap/testAvalonTools.py vendored
View File

@@ -29,9 +29,9 @@ class TestCase(unittest.TestCase):
def test1(self):
m1 = Chem.MolFromSmiles('c1cccnc1')
smi = pyAvalonTools.GetCanonSmiles(m1)
self.failUnless(smi=='c1ccncc1')
self.assertTrue(smi=='c1ccncc1')
smi = pyAvalonTools.GetCanonSmiles('c1cccnc1',True)
self.failUnless(smi=='c1ccncc1')
self.assertTrue(smi=='c1ccncc1')
def test2(self):
tgts=['CC1=CC(=O)C=CC1=O','c2ccc1SC(=Nc1c2)SSC4=Nc3ccccc3S4','[O-][N+](=O)c1cc(Cl)c(O)c(c1)[N+]([O-])=O',
@@ -39,97 +39,98 @@ class TestCase(unittest.TestCase):
'OC(=O)c1ccccc1C3=C2C=CC(=O)C(Br)=C2Oc4c3ccc(O)c4Br','CN(C)C2C(=O)c1ccccc1C(=O)C=2Cl',
'Cc3ccc2C(=O)c1ccccc1C(=O)c2c3[N+]([O-])=O',r'C/C(=N\O)/C(/C)=N/O',
'c1ccc(cc1)P(c2ccccc2)c3ccccc3']
d= file(os.path.join(RDConfig.RDDataDir,'NCI','first_200.props.sdf'),'r').read()
with open(os.path.join(RDConfig.RDDataDir,'NCI','first_200.props.sdf'),'r') as f:
d = f.read()
mbs = d.split('$$$$\n')[:10]
smis = [pyAvalonTools.GetCanonSmiles(mb,False) for mb in mbs]
self.failUnless(smis==tgts)
self.assertTrue(smis==tgts)
smis = [pyAvalonTools.GetCanonSmiles(smi,True) for smi in smis]
self.failUnless(smis==tgts)
self.assertTrue(smis==tgts)
def test3(self):
bv = pyAvalonTools.GetAvalonFP(Chem.MolFromSmiles('c1ccccn1'))
self.failUnlessEqual(len(bv),512)
self.failUnlessEqual(bv.GetNumOnBits(),20)
self.assertEqual(len(bv),512)
self.assertEqual(bv.GetNumOnBits(),20)
bv = pyAvalonTools.GetAvalonFP(Chem.MolFromSmiles('c1ccccc1'))
self.failUnlessEqual(bv.GetNumOnBits(),8)
self.assertEqual(bv.GetNumOnBits(),8)
bv = pyAvalonTools.GetAvalonFP(Chem.MolFromSmiles('c1nnccc1'))
self.failUnlessEqual(bv.GetNumOnBits(),30)
self.assertEqual(bv.GetNumOnBits(),30)
bv = pyAvalonTools.GetAvalonFP(Chem.MolFromSmiles('c1ncncc1'))
self.failUnlessEqual(bv.GetNumOnBits(),27)
self.assertEqual(bv.GetNumOnBits(),27)
bv = pyAvalonTools.GetAvalonFP(Chem.MolFromSmiles('c1ncncc1'),nBits=1024)
self.failUnlessEqual(len(bv),1024)
self.failUnless(bv.GetNumOnBits()>27)
self.assertEqual(len(bv),1024)
self.assertTrue(bv.GetNumOnBits()>27)
def test4(self):
bv = pyAvalonTools.GetAvalonFP('c1ccccn1',True)
self.failUnlessEqual(bv.GetNumOnBits(),20)
self.assertEqual(bv.GetNumOnBits(),20)
bv = pyAvalonTools.GetAvalonFP('c1ccccc1',True)
self.failUnlessEqual(bv.GetNumOnBits(),8)
self.assertEqual(bv.GetNumOnBits(),8)
bv = pyAvalonTools.GetAvalonFP('c1nnccc1',True)
self.failUnlessEqual(bv.GetNumOnBits(),30)
self.assertEqual(bv.GetNumOnBits(),30)
bv = pyAvalonTools.GetAvalonFP('c1ncncc1',True)
self.failUnlessEqual(bv.GetNumOnBits(),27)
self.assertEqual(bv.GetNumOnBits(),27)
bv = pyAvalonTools.GetAvalonFP('c1ncncc1',True,nBits=1024)
self.failUnlessEqual(len(bv),1024)
self.failUnless(bv.GetNumOnBits()>27)
self.assertEqual(len(bv),1024)
self.assertTrue(bv.GetNumOnBits()>27)
bv = pyAvalonTools.GetAvalonFP(Chem.MolToMolBlock(Chem.MolFromSmiles('c1ccccn1')),False)
self.failUnlessEqual(len(bv),512)
self.failUnlessEqual(bv.GetNumOnBits(),20)
self.assertEqual(len(bv),512)
self.assertEqual(bv.GetNumOnBits(),20)
bv = pyAvalonTools.GetAvalonFP(Chem.MolToMolBlock(Chem.MolFromSmiles('c1ccccc1')),False)
self.failUnlessEqual(bv.GetNumOnBits(),8)
self.assertEqual(bv.GetNumOnBits(),8)
def test4b(self):
words = pyAvalonTools.GetAvalonFPAsWords(Chem.MolFromSmiles('c1ccccn1'))
words2 = pyAvalonTools.GetAvalonFPAsWords(Chem.MolFromSmiles('Cc1ccccn1'))
self.failUnlessEqual(len(words),len(words2))
self.assertEqual(len(words),len(words2))
for i,word in enumerate(words):
self.failUnlessEqual(word&words2[i],word)
self.assertEqual(word&words2[i],word)
def test5(self):
m = Chem.MolFromSmiles('c1ccccc1C1(CC1)N')
pyAvalonTools.Generate2DCoords(m)
self.failUnlessEqual(m.GetNumConformers(),1)
self.failUnless(m.GetConformer(0).Is3D()==False)
self.assertEqual(m.GetNumConformers(),1)
self.assertTrue(m.GetConformer(0).Is3D()==False)
def test6(self):
mb=pyAvalonTools.Generate2DCoords('c1ccccc1C1(CC1)N',True)
m = Chem.MolFromMolBlock(mb)
self.failUnlessEqual(m.GetNumConformers(),1)
self.failUnless(m.GetConformer(0).Is3D()==False)
self.assertEqual(m.GetNumConformers(),1)
self.assertTrue(m.GetConformer(0).Is3D()==False)
def testRDK151(self):
smi="C[C@H](F)Cl"
m = Chem.MolFromSmiles(smi)
temp = pyAvalonTools.GetCanonSmiles(smi,True)
self.failUnlessEqual(temp,smi)
self.assertEqual(temp,smi)
temp = pyAvalonTools.GetCanonSmiles(m)
self.failUnlessEqual(temp,smi)
self.assertEqual(temp,smi)
def testStruChk(self):
smi_good='c1ccccc1C1(CC-C(C)C1)C'
smi_bad='c1c(R)cccc1C1(CC-C(C)C1)C'
r = pyAvalonTools.InitializeCheckMol(STRUCHK_INIT)
self.failUnlessEqual(r, 0)
self.assertEqual(r, 0)
(err, fixed_mol) = pyAvalonTools.CheckMolecule(smi_good, True)
self.failUnlessEqual(err, 0)
self.assertEqual(err, 0)
mol = Chem.MolFromSmiles(smi_good)
(err, fixed_mol)=pyAvalonTools.CheckMolecule(mol)
self.failUnlessEqual(err, 0)
self.assertEqual(err, 0)
(err, fixed_mol)=pyAvalonTools.CheckMoleculeString(smi_good,True)
self.failUnlessEqual(err, 0)
self.failIfEqual(fixed_mol,"")
self.failUnless(fixed_mol.find('M END')>0)
self.assertEqual(err, 0)
self.assertNotEqual(fixed_mol,"")
self.assertTrue(fixed_mol.find('M END')>0)
(err, fixed_mol)=pyAvalonTools.CheckMolecule(smi_bad, False)
self.failIfEqual(err, 0)
self.failIf(fixed_mol)
self.assertNotEqual(err, 0)
self.assertFalse(fixed_mol)
(err, fixed_mol)=pyAvalonTools.CheckMoleculeString(smi_bad, False)
self.failIfEqual(err, 0)
self.failIf(fixed_mol)
self.assertNotEqual(err, 0)
self.assertFalse(fixed_mol)
pyAvalonTools.CloseCheckMolFiles()
# def testIsotopeBug(self):
@@ -148,7 +149,7 @@ class TestCase(unittest.TestCase):
# M END
# """
# csmi = pyAvalonTools.GetCanonSmiles(mb,False)
# self.failUnlessEqual(csmi,'[2H]C(C)C')
# self.assertEqual(csmi,'[2H]C(C)C')
# mb="""D isotope problem.mol
# Mrv0541 08141217122D
@@ -164,7 +165,7 @@ class TestCase(unittest.TestCase):
# M END
# """
# csmi = pyAvalonTools.GetCanonSmiles(mb,False)
# self.failUnlessEqual(csmi,'[2H]C(C)C')
# self.assertEqual(csmi,'[2H]C(C)C')
# mb="""D isotope problem.mol
# Mrv0541 08141217122D
@@ -180,7 +181,7 @@ class TestCase(unittest.TestCase):
# M END
# """
# csmi = pyAvalonTools.GetCanonSmiles(mb,False)
# self.failUnlessEqual(csmi,'[2H]C(C)C')
# self.assertEqual(csmi,'[2H]C(C)C')
# def testChiralPBug(self):
# mb="""Untitled Document-1
@@ -199,11 +200,11 @@ class TestCase(unittest.TestCase):
# M END
# """
# r = pyAvalonTools.InitializeCheckMol(STRUCHK_INIT)
# self.failUnlessEqual(r, 0)
# self.assertEqual(r, 0)
# (err, fixed_mol) = pyAvalonTools.CheckMolecule(mb, False)
# self.failUnlessEqual(err, 0)
# self.failUnless(fixed_mol)
# self.failIfEqual(fixed_mol.GetAtomWithIdx(0).GetChiralTag(),Chem.rdchem.ChiralType.CHI_UNSPECIFIED)
# self.assertEqual(err, 0)
# self.assertTrue(fixed_mol)
# self.assertNotEqual(fixed_mol.GetAtomWithIdx(0).GetChiralTag(),Chem.rdchem.ChiralType.CHI_UNSPECIFIED)
if __name__ == '__main__':
unittest.main()

7
External/INCHI-API/python/inchi.py vendored
View File

@@ -32,8 +32,9 @@
INCHI_AVAILABLE = True
import rdinchi
import logging
from rdkit.Chem import rdinchi
from rdkit import RDLogger
logger = RDLogger.logger()
@@ -68,7 +69,7 @@ def MolFromInchi(inchi, sanitize=True, removeHs=True, logLevel=None,
"""
try:
mol, retcode, message, log = rdinchi.InchiToMol(inchi, sanitize, removeHs)
except ValueError,e :
except ValueError as e :
logger.error(str(e))
return None
@@ -138,7 +139,7 @@ def MolToInchi(mol, options="", logLevel=None, treatWarningAsError=False):
try:
inchi, aux = MolToInchiAndAuxInfo(mol, options, logLevel=logLevel,
treatWarningAsError=treatWarningAsError)
except InchiReadWriteError,inst:
except InchiReadWriteError as inst:
inchi, aux, message = inst
raise InchiReadWriteError(inchi, message)
return inchi

13
Projects/DbCLI/CreateDb.py
View File

@@ -62,7 +62,8 @@ from rdkit.RDLogger import logger
from rdkit.Chem.MolDb import Loader
logger = logger()
import cPickle,sys,os
import sys,os
from rdkit.six.moves import cPickle
from rdkit.Chem.MolDb.FingerprintUtils import BuildSigFactory,LayeredOptions
from rdkit.Chem.MolDb import FingerprintUtils
@@ -158,10 +159,10 @@ parser.add_option('--nameColumn','--nameCol',default=1,type='int',
def CreateDb(options,dataFilename='',supplier=None):
if not dataFilename and supplier is None:
raise ValueError,'Please provide either a data filename or a supplier'
raise ValueError('Please provide either a data filename or a supplier')
if options.errFilename:
errFile=file(os.path.join(options.outDir,options.errFilename),'w+')
errFile=open(os.path.join(options.outDir,options.errFilename),'w+')
else:
errFile=None
@@ -186,7 +187,7 @@ def CreateDb(options,dataFilename='',supplier=None):
# guess the delimiter
import csv
sniffer = csv.Sniffer()
dlct=sniffer.sniff(file(dataFilename,'r').read(2000))
dlct=sniffer.sniff(open(dataFilename,'r').read(2000))
options.delimiter=dlct.delimiter
if not options.silent:
logger.info('Guessing that delimiter is %s. Use --delimiter argument if this is wrong.'%repr(options.delimiter))
@@ -275,7 +276,7 @@ def CreateDb(options,dataFilename='',supplier=None):
if options.doDescriptors:
descrConn=DbConnect(os.path.join(options.outDir,options.descrDbName))
calc = cPickle.load(file(options.descriptorCalcFilename,'rb'))
calc = cPickle.load(open(options.descriptorCalcFilename,'rb'))
nms = [x for x in calc.GetDescriptorNames()]
descrCurs = descrConn.GetCursor()
descrs = ['guid integer not null primary key','%s varchar not null unique'%options.molIdName]
@@ -439,7 +440,7 @@ if __name__=='__main__':
parser.error('please provide a filename argument')
dataFilename = args[0]
try:
dataFile = file(dataFilename,'r')
dataFile = open(dataFilename,'r')
except IOError:
logger.error('input file %s does not exist'%(dataFilename))
sys.exit(0)

2
Projects/DbCLI/SearchDb.py
View File

@@ -223,7 +223,7 @@ def RunSearch(options,queryFilename):
elif options.outF=='':
outF=None
else:
outF = file(options.outF,'w+')
outF = open(options.outF,'w+')
molsOut=False
if options.sdfOut:

312
Projects/DbCLI/TestDbCLI.py
View File

@@ -13,75 +13,75 @@ class TestCase(unittest.TestCase):
p = subprocess.Popen(('python', 'CreateDb.py','--dbDir=testData/bzr','--molFormat=smiles',
'testData/bzr.smi'))
res=p.wait()
self.failIf(res)
self.assertFalse(res)
p=None
self.failUnless(os.path.exists('testData/bzr/Compounds.sqlt'))
self.failUnless(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.failUnless(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.failUnless(os.path.exists('testData/bzr/Fingerprints.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Compounds.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Fingerprints.sqlt'))
conn = DbConnect('testData/bzr/Compounds.sqlt')
d = conn.GetData('molecules',fields='count(*)')
self.failUnless(d[0][0]==10)
self.assertTrue(d[0][0]==10)
conn = DbConnect('testData/bzr/AtomPairs.sqlt')
d = conn.GetData('atompairs',fields='count(*)')
self.failUnless(d[0][0]==10)
self.assertTrue(d[0][0]==10)
conn = DbConnect('testData/bzr/Descriptors.sqlt')
d = conn.GetData('descriptors_v1',fields='count(*)')
self.failUnless(d[0][0]==10)
self.assertTrue(d[0][0]==10)
conn = DbConnect('testData/bzr/Fingerprints.sqlt')
d = conn.GetData('rdkitfps',fields='count(*)')
self.failUnless(d[0][0]==10)
self.assertTrue(d[0][0]==10)
p = subprocess.Popen(('python', 'CreateDb.py','--dbDir=testData/bzr','--molFormat=sdf',
'--doGobbi2D',
'testData/bzr.sdf'))
res=p.wait()
self.failIf(res)
self.assertFalse(res)
p=None
self.failUnless(os.path.exists('testData/bzr/Compounds.sqlt'))
self.failUnless(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.failUnless(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.failUnless(os.path.exists('testData/bzr/Fingerprints.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Compounds.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Fingerprints.sqlt'))
conn = DbConnect('testData/bzr/Compounds.sqlt')
d = conn.GetData('molecules',fields='count(*)')
self.failUnless(d[0][0]==163)
self.assertTrue(d[0][0]==163)
conn = DbConnect('testData/bzr/AtomPairs.sqlt')
d = conn.GetData('atompairs',fields='count(*)')
self.failUnless(d[0][0]==163)
self.assertTrue(d[0][0]==163)
conn = DbConnect('testData/bzr/Descriptors.sqlt')
d = conn.GetData('descriptors_v1',fields='count(*)')
self.failUnless(d[0][0]==163)
self.assertTrue(d[0][0]==163)
conn = DbConnect('testData/bzr/Fingerprints.sqlt')
d = conn.GetData('rdkitfps',fields='count(*)')
self.failUnless(d[0][0]==163)
self.assertTrue(d[0][0]==163)
def test2_1SearchFPs(self):
self.failUnless(os.path.exists('testData/bzr/Compounds.sqlt'))
self.failUnless(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.failUnless(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.failUnless(os.path.exists('testData/bzr/Fingerprints.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Compounds.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Fingerprints.sqlt'))
p = subprocess.Popen(('python', 'SearchDb.py','--dbDir=testData/bzr','--molFormat=sdf',
'--topN=5','--outF=testData/bzr/search.out','testData/bzr.sdf'))
res=p.wait()
self.failIf(res)
self.assertFalse(res)
p=None
self.failUnless(os.path.exists('testData/bzr/search.out'))
self.assertTrue(os.path.exists('testData/bzr/search.out'))
inF = file('testData/bzr/search.out','r')
lines=inF.readlines()
inF=None
self.failUnless(len(lines)==163)
self.assertTrue(len(lines)==163)
splitLs=[x.strip().split(',') for x in lines]
for line in splitLs:
lbl = line[0]
@@ -90,31 +90,31 @@ class TestCase(unittest.TestCase):
lastVal=1.0
while i<len(line):
nbrs[line[i]]=line[i+1]
self.failUnless(float(line[i+1])<=lastVal)
self.assertTrue(float(line[i+1])<=lastVal)
lastVal=float(line[i+1])
i+=2
self.failUnless(nbrs.has_key(lbl))
self.failUnless(nbrs[lbl]=='1.000',nbrs[lbl])
self.assertTrue(nbrs.has_key(lbl))
self.assertTrue(nbrs[lbl]=='1.000',nbrs[lbl])
os.unlink('testData/bzr/search.out')
def test2_2SearchAtomPairs(self):
self.failUnless(os.path.exists('testData/bzr/Compounds.sqlt'))
self.failUnless(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.failUnless(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.failUnless(os.path.exists('testData/bzr/Fingerprints.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Compounds.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Fingerprints.sqlt'))
p = subprocess.Popen(('python', 'SearchDb.py','--dbDir=testData/bzr','--molFormat=sdf',
'--topN=5','--outF=testData/bzr/search.out','--similarityType=AtomPairs',
'testData/bzr.sdf'))
res=p.wait()
self.failIf(res)
self.assertFalse(res)
p=None
self.failUnless(os.path.exists('testData/bzr/search.out'))
self.assertTrue(os.path.exists('testData/bzr/search.out'))
inF = file('testData/bzr/search.out','r')
lines=inF.readlines()
inF=None
self.failUnless(len(lines)==163)
self.assertTrue(len(lines)==163)
splitLs=[x.strip().split(',') for x in lines]
for line in splitLs:
lbl = line[0]
@@ -123,31 +123,31 @@ class TestCase(unittest.TestCase):
lastVal=1.0
while i<len(line):
nbrs[line[i]]=line[i+1]
self.failUnless(float(line[i+1])<=lastVal)
self.assertTrue(float(line[i+1])<=lastVal)
lastVal=float(line[i+1])
i+=2
self.failUnless(nbrs.has_key(lbl))
self.failUnless(nbrs[lbl]=='1.000')
self.assertTrue(nbrs.has_key(lbl))
self.assertTrue(nbrs[lbl]=='1.000')
os.unlink('testData/bzr/search.out')
def test2_3SearchTorsions(self):
self.failUnless(os.path.exists('testData/bzr/Compounds.sqlt'))
self.failUnless(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.failUnless(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.failUnless(os.path.exists('testData/bzr/Fingerprints.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Compounds.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Fingerprints.sqlt'))
p = subprocess.Popen(('python', 'SearchDb.py','--dbDir=testData/bzr','--molFormat=sdf','--topN=5',
'--outF=testData/bzr/search.out','--similarityType=TopologicalTorsions',
'testData/bzr.sdf'))
res=p.wait()
self.failIf(res)
self.assertFalse(res)
p=None
self.failUnless(os.path.exists('testData/bzr/search.out'))
self.assertTrue(os.path.exists('testData/bzr/search.out'))
inF = file('testData/bzr/search.out','r')
lines=inF.readlines()
inF=None
self.failUnless(len(lines)==163)
self.assertTrue(len(lines)==163)
splitLs=[x.strip().split(',') for x in lines]
for line in splitLs:
lbl = line[0]
@@ -156,46 +156,46 @@ class TestCase(unittest.TestCase):
lastVal=1.0
while i<len(line):
nbrs[line[i]]=line[i+1]
self.failUnless(float(line[i+1])<=lastVal)
self.assertTrue(float(line[i+1])<=lastVal)
lastVal=float(line[i+1])
i+=2
self.failUnless(nbrs.has_key(lbl))
self.failUnless(nbrs[lbl]=='1.000')
self.assertTrue(nbrs.has_key(lbl))
self.assertTrue(nbrs[lbl]=='1.000')
os.unlink('testData/bzr/search.out')
def test2_4SearchProps(self):
self.failUnless(os.path.exists('testData/bzr/Compounds.sqlt'))
self.failUnless(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.failUnless(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.failUnless(os.path.exists('testData/bzr/Fingerprints.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Compounds.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Fingerprints.sqlt'))
p = subprocess.Popen(('python', 'SearchDb.py','--dbDir=testData/bzr',
'--outF=testData/bzr/search.out','--query=activity<6.5'))
res=p.wait()
self.failIf(res)
self.assertFalse(res)
p=None
self.failUnless(os.path.exists('testData/bzr/search.out'))
self.assertTrue(os.path.exists('testData/bzr/search.out'))
inF = file('testData/bzr/search.out','r')
lines=inF.readlines()
inF=None
self.failUnless(len(lines)==30)
self.assertTrue(len(lines)==30)
os.unlink('testData/bzr/search.out')
p = subprocess.Popen(('python', 'SearchDb.py','--dbDir=testData/bzr',
'--outF=testData/bzr/search.out','--query=activity<6.5'))
res=p.wait()
self.failIf(res)
self.assertFalse(res)
p=None
self.failUnless(os.path.exists('testData/bzr/search.out'))
self.assertTrue(os.path.exists('testData/bzr/search.out'))
inF = file('testData/bzr/search.out','r')
lines=inF.readlines()
inF=None
self.failUnless(len(lines)==30)
self.assertTrue(len(lines)==30)
os.unlink('testData/bzr/search.out')
def test2_5SearchSmarts(self):
@@ -203,14 +203,14 @@ class TestCase(unittest.TestCase):
'--outF=testData/bzr/search.out','--smarts=cncncc',))
res=p.wait()
self.failIf(res)
self.assertFalse(res)
p=None
self.failUnless(os.path.exists('testData/bzr/search.out'))
self.assertTrue(os.path.exists('testData/bzr/search.out'))
inF = file('testData/bzr/search.out','r')
lines=inF.readlines()
inF=None
self.failUnlessEqual(len(lines),49)
self.assertEqual(len(lines),49)
os.unlink('testData/bzr/search.out')
if os.path.exists('/dev/null'):
@@ -224,14 +224,14 @@ class TestCase(unittest.TestCase):
'--smilesOut=testData/bzr/search.out',
'--smarts=cncncc',))
res=p.wait()
self.failIf(res)
self.assertFalse(res)
p=None
self.failUnless(os.path.exists('testData/bzr/search.out'))
self.assertTrue(os.path.exists('testData/bzr/search.out'))
inF = file('testData/bzr/search.out','r')
lines=inF.readlines()
inF=None
self.failUnlessEqual(len(lines),49)
self.assertEqual(len(lines),49)
os.unlink('testData/bzr/search.out')
if os.path.exists('testData/crud.out'):
os.unlink('testData/crud.out')
@@ -240,14 +240,14 @@ class TestCase(unittest.TestCase):
'--outF=testData/bzr/search.out','--negate','--smarts=cncncc',))
res=p.wait()
self.failIf(res)
self.assertFalse(res)
p=None
self.failUnless(os.path.exists('testData/bzr/search.out'))
self.assertTrue(os.path.exists('testData/bzr/search.out'))
inF = file('testData/bzr/search.out','r')
lines=inF.readlines()
inF=None
self.failUnlessEqual(len(lines),114)
self.assertEqual(len(lines),114)
os.unlink('testData/bzr/search.out')
def test2_6SearchBoth(self):
@@ -255,14 +255,14 @@ class TestCase(unittest.TestCase):
'--outF=testData/bzr/search.out','--query=activity<6.5','--smarts=cncncc'))
res=p.wait()
self.failIf(res)
self.assertFalse(res)
p=None
self.failUnless(os.path.exists('testData/bzr/search.out'))
self.assertTrue(os.path.exists('testData/bzr/search.out'))
inF = file('testData/bzr/search.out','r')
lines=inF.readlines()
inF=None
self.failUnlessEqual(len(lines),5)
self.assertEqual(len(lines),5)
os.unlink('testData/bzr/search.out')
p = subprocess.Popen(('python', 'SearchDb.py','--dbDir=testData/bzr',
@@ -270,34 +270,34 @@ class TestCase(unittest.TestCase):
'--smarts=cncncc','--negate'))
res=p.wait()
self.failIf(res)
self.assertFalse(res)
p=None
self.failUnless(os.path.exists('testData/bzr/search.out'))
self.assertTrue(os.path.exists('testData/bzr/search.out'))
inF = file('testData/bzr/search.out','r')
lines=inF.readlines()
inF=None
self.failUnlessEqual(len(lines),25)
self.assertEqual(len(lines),25)
os.unlink('testData/bzr/search.out')
def test2_7SearchGobbi(self):
self.failUnless(os.path.exists('testData/bzr/Compounds.sqlt'))
self.failUnless(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.failUnless(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.failUnless(os.path.exists('testData/bzr/Fingerprints.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Compounds.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Fingerprints.sqlt'))
p = subprocess.Popen(('python', 'SearchDb.py','--dbDir=testData/bzr','--molFormat=sdf','--topN=5',
'--outF=testData/bzr/search.out','--similarityType=Gobbi2D',
'testData/bzr.sdf'))
res=p.wait()
self.failIf(res)
self.assertFalse(res)
p=None
self.failUnless(os.path.exists('testData/bzr/search.out'))
self.assertTrue(os.path.exists('testData/bzr/search.out'))
inF = file('testData/bzr/search.out','r')
lines=inF.readlines()
inF=None
self.failUnless(len(lines)==163)
self.assertTrue(len(lines)==163)
splitLs=[x.strip().split(',') for x in lines]
for line in splitLs:
lbl = line[0]
@@ -306,38 +306,38 @@ class TestCase(unittest.TestCase):
lastVal=1.0
while i<len(line):
nbrs[line[i]]=line[i+1]
self.failUnless(float(line[i+1])<=lastVal)
self.assertTrue(float(line[i+1])<=lastVal)
lastVal=float(line[i+1])
i+=2
self.failUnless(nbrs.has_key(lbl))
self.failUnless(nbrs[lbl]=='1.000')
self.failUnlessEqual(splitLs[0][0],'Adinazolam')
self.failUnlessEqual(splitLs[0][3],'alpha-hydroxytriazolam')
self.failUnlessEqual(splitLs[0][4],'0.631')
self.assertTrue(nbrs.has_key(lbl))
self.assertTrue(nbrs[lbl]=='1.000')
self.assertEqual(splitLs[0][0],'Adinazolam')
self.assertEqual(splitLs[0][3],'alpha-hydroxytriazolam')
self.assertEqual(splitLs[0][4],'0.631')
os.unlink('testData/bzr/search.out')
def test2_8SearchThresh(self):
self.failUnless(os.path.exists('testData/bzr/Compounds.sqlt'))
self.failUnless(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.failUnless(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.failUnless(os.path.exists('testData/bzr/Fingerprints.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Compounds.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Fingerprints.sqlt'))
p = subprocess.Popen(('python', 'SearchDb.py','--dbDir=testData/bzr','--molFormat=sdf',
'--simThresh=0.7','--outF=testData/bzr/search.out','testData/bzr_q1.mol'))
res=p.wait()
self.failIf(res)
self.assertFalse(res)
p=None
self.failUnless(os.path.exists('testData/bzr/search.out'))
self.assertTrue(os.path.exists('testData/bzr/search.out'))
inF = file('testData/bzr/search.out','r')
lines=inF.readlines()
inF=None
self.failUnless(len(lines)==1)
self.assertTrue(len(lines)==1)
splitL=lines[0].strip().split(',')
splitL.pop(0)
for i in range(0,len(splitL),2):
v = float(splitL[i+1])
self.failUnless(v>0.7)
self.assertTrue(v>0.7)
os.unlink('testData/bzr/search.out')
@@ -357,21 +357,21 @@ class TestCase(unittest.TestCase):
'testData/bzr.smi'))
res=p.wait()
self.failIf(res)
self.assertFalse(res)
p=None
self.failUnless(os.path.exists('testData/bzr/Compounds.sqlt'))
self.failIf(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.failIf(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.failIf(os.path.exists('testData/bzr/Fingerprints.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Compounds.sqlt'))
self.assertFalse(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.assertFalse(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.assertFalse(os.path.exists('testData/bzr/Fingerprints.sqlt'))
conn = DbConnect('testData/bzr/Compounds.sqlt')
d = conn.GetData('molecules',fields='count(*)')
self.failUnlessEqual(d[0][0],10)
self.assertEqual(d[0][0],10)
d = conn.GetData('molecules',fields='*')
self.failUnlessEqual(len(d),10)
self.assertEqual(len(d),10)
cns = [x.lower() for x in d.GetColumnNames()]
self.failIf('smiles' in cns)
self.assertFalse('smiles' in cns)
conn=None
d=None
@@ -389,62 +389,62 @@ class TestCase(unittest.TestCase):
'--noSmiles','--noFingerprints','--noLayeredFps','--noMorganFps','--noPairs','--noDescriptors',
'testData/bzr.smi'))
res=p.wait()
self.failIf(res)
self.assertFalse(res)
p=None
self.failUnless(os.path.exists('testData/bzr/Compounds.sqlt'))
self.failIf(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.failIf(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.failIf(os.path.exists('testData/bzr/Fingerprints.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Compounds.sqlt'))
self.assertFalse(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.assertFalse(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.assertFalse(os.path.exists('testData/bzr/Fingerprints.sqlt'))
conn = DbConnect('testData/bzr/Compounds.sqlt')
d = conn.GetData('molecules',fields='count(*)')
self.failUnless(d[0][0]==10)
self.assertTrue(d[0][0]==10)
d = conn.GetData('molecules',fields='*')
self.failUnless(len(d)==10)
self.assertTrue(len(d)==10)
cns = [x.lower() for x in d.GetColumnNames()]
self.failIf('smiles' in cns)
self.assertFalse('smiles' in cns)
p = subprocess.Popen(('python', 'CreateDb.py','--dbDir=testData/bzr','--molFormat=smiles',
'--noProps','--noFingerprints','--noLayeredFps','--noMorganFps','--noPairs','--noDescriptors',
'testData/bzr.smi'))
res=p.wait()
self.failIf(res)
self.assertFalse(res)
p=None
self.failUnless(os.path.exists('testData/bzr/Compounds.sqlt'))
self.failIf(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.failIf(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.failIf(os.path.exists('testData/bzr/Fingerprints.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Compounds.sqlt'))
self.assertFalse(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.assertFalse(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.assertFalse(os.path.exists('testData/bzr/Fingerprints.sqlt'))
conn = DbConnect('testData/bzr/Compounds.sqlt')
d = conn.GetData('molecules',fields='count(*)')
self.failUnlessEqual(d[0][0],10)
self.assertEqual(d[0][0],10)
d = conn.GetData('molecules',fields='*')
self.failUnlessEqual(len(d),10)
self.assertEqual(len(d),10)
cns = [x.lower() for x in d.GetColumnNames()]
self.failUnless('smiles' in cns)
self.assertTrue('smiles' in cns)
p = subprocess.Popen(('python', 'CreateDb.py','--dbDir=testData/bzr','--molFormat=smiles',
'--noFingerprints','--noLayeredFps','--noMorganFps','--noPairs','--noDescriptors',
'--maxRowsCached=4',
'testData/bzr.smi'))
res=p.wait()
self.failIf(res)
self.assertFalse(res)
p=None
self.failUnless(os.path.exists('testData/bzr/Compounds.sqlt'))
self.failIf(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.failIf(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.failIf(os.path.exists('testData/bzr/Fingerprints.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Compounds.sqlt'))
self.assertFalse(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.assertFalse(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.assertFalse(os.path.exists('testData/bzr/Fingerprints.sqlt'))
conn = DbConnect('testData/bzr/Compounds.sqlt')
d = conn.GetData('molecules',fields='count(*)')
self.failUnlessEqual(d[0][0],10)
self.assertEqual(d[0][0],10)
d = conn.GetData('molecules',fields='*')
self.failUnlessEqual(len(d),10)
self.assertEqual(len(d),10)
cns = [x.lower() for x in d.GetColumnNames()]
self.failUnless('smiles' in cns)
self.assertTrue('smiles' in cns)
p = subprocess.Popen(('python', 'CreateDb.py','--dbDir=testData/bzr','--molFormat=smiles',
'--noFingerprints',
@@ -452,13 +452,13 @@ class TestCase(unittest.TestCase):
'--maxRowsCached=4',
'testData/bzr.smi'))
res=p.wait()
self.failIf(res)
self.assertFalse(res)
p=None
self.failUnless(os.path.exists('testData/bzr/Compounds.sqlt'))
self.failIf(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.failIf(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.failUnless(os.path.exists('testData/bzr/Fingerprints.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Compounds.sqlt'))
self.assertFalse(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.assertFalse(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Fingerprints.sqlt'))
def test5TestBackwardsCompat(self):
if os.path.exists('testData/bzr/Compounds.sqlt'):
@@ -474,7 +474,7 @@ class TestCase(unittest.TestCase):
'--noFingerprints','--noDescriptors',
'testData/bzr.sdf'))
res=p.wait()
self.failIf(res)
self.assertFalse(res)
p=None
conn = DbConnect('testData/bzr/AtomPairs.sqlt')
@@ -485,14 +485,14 @@ class TestCase(unittest.TestCase):
'--pairTableName=tmp',
'testData/bzr.sdf'))
res=p.wait()
self.failIf(res)
self.assertFalse(res)
p=None
self.failUnless(os.path.exists('testData/bzr/search.out'))
self.assertTrue(os.path.exists('testData/bzr/search.out'))
inF = file('testData/bzr/search.out','r')
lines=inF.readlines()
inF=None
self.failUnlessEqual(len(lines),163)
self.assertEqual(len(lines),163)
splitLs=[x.strip().split(',') for x in lines]
for line in splitLs:
lbl = line[0]
@@ -501,73 +501,73 @@ class TestCase(unittest.TestCase):
lastVal=1.0
while i<len(line):
nbrs[line[i]]=line[i+1]
self.failUnless(float(line[i+1])<=lastVal)
self.assertTrue(float(line[i+1])<=lastVal)
lastVal=float(line[i+1])
i+=2
self.failUnless(nbrs.has_key(lbl))
self.failUnless(nbrs[lbl]=='1.000')
self.assertTrue(nbrs.has_key(lbl))
self.assertTrue(nbrs[lbl]=='1.000')
os.unlink('testData/bzr/search.out')
def test6Update(self):
p = subprocess.Popen(('python', 'CreateDb.py','--dbDir=testData/bzr','--molFormat=smiles',
'testData/bzr.smi'))
res=p.wait()
self.failIf(res)
self.assertFalse(res)
p=None
self.failUnless(os.path.exists('testData/bzr/Compounds.sqlt'))
self.failUnless(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.failUnless(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.failUnless(os.path.exists('testData/bzr/Fingerprints.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Compounds.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Fingerprints.sqlt'))
conn = DbConnect('testData/bzr/Compounds.sqlt')
d = conn.GetData('molecules',fields='count(*)')
self.failUnlessEqual(d[0][0],10)
self.assertEqual(d[0][0],10)
conn = DbConnect('testData/bzr/AtomPairs.sqlt')
d = conn.GetData('atompairs',fields='count(*)')
self.failUnlessEqual(d[0][0],10)
self.assertEqual(d[0][0],10)
conn = DbConnect('testData/bzr/Descriptors.sqlt')
d = conn.GetData('descriptors_v1',fields='count(*)')
self.failUnlessEqual(d[0][0],10)
self.assertEqual(d[0][0],10)
conn = DbConnect('testData/bzr/Fingerprints.sqlt')
d = conn.GetData('rdkitfps',fields='count(*)')
self.failUnlessEqual(d[0][0],10)
self.assertEqual(d[0][0],10)
p = subprocess.Popen(('python', 'CreateDb.py','--dbDir=testData/bzr','--molFormat=smiles',
'--updateDb',
'testData/bzr.2.smi'))
res=p.wait()
self.failIf(res)
self.assertFalse(res)
p=None
self.failUnless(os.path.exists('testData/bzr/Compounds.sqlt'))
self.failUnless(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.failUnless(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.failUnless(os.path.exists('testData/bzr/Fingerprints.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Compounds.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/AtomPairs.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Descriptors.sqlt'))
self.assertTrue(os.path.exists('testData/bzr/Fingerprints.sqlt'))
conn = DbConnect('testData/bzr/Compounds.sqlt')
d = conn.GetData('molecules',fields='count(*)')
self.failUnlessEqual(d[0][0],20)
self.assertEqual(d[0][0],20)
conn = DbConnect('testData/bzr/AtomPairs.sqlt')
d = conn.GetData('atompairs',fields='count(*)')
self.failUnlessEqual(d[0][0],20)
self.assertEqual(d[0][0],20)
conn = DbConnect('testData/bzr/Descriptors.sqlt')
d = conn.GetData('descriptors_v1',fields='count(*)')
self.failUnlessEqual(d[0][0],20)
self.assertEqual(d[0][0],20)
conn = DbConnect('testData/bzr/Fingerprints.sqlt')
d = conn.GetData('rdkitfps',fields='count(*)')
self.failUnlessEqual(d[0][0],20)
self.assertEqual(d[0][0],20)

23
rdkit/Chem/AllChem.py
View File

@@ -108,10 +108,10 @@ def GenerateDepictionMatching2DStructure(mol,reference,confId=-1,
"""
if reference and referencePattern:
if not reference.GetNumAtoms(onlyExplicit=True)==referencePattern.GetNumAtoms(onlyExplicit=True):
raise ValueError,'When a pattern is provided, it must have the same number of atoms as the reference'
raise ValueError('When a pattern is provided, it must have the same number of atoms as the reference')
referenceMatch = reference.GetSubstructMatch(referencePattern)
if not referenceMatch:
raise ValueError,"Reference does not map to itself"
raise ValueError("Reference does not map to itself")
else:
referenceMatch = range(reference.GetNumAtoms(onlyExplicit=True))
if referencePattern:
@@ -121,7 +121,7 @@ def GenerateDepictionMatching2DStructure(mol,reference,confId=-1,
if not match:
if not acceptFailure:
raise ValueError,'Substructure match with reference not found.'
raise ValueError('Substructure match with reference not found.')
else:
coordMap={}
else:
@@ -179,8 +179,8 @@ def GetBestRMS(ref,probe,refConfId=-1,probeConfId=-1,maps=None):
if not maps:
matches = ref.GetSubstructMatches(probe,uniquify=False)
if not matches:
raise ValueError,'mol %s does not match mol %s'%(ref.GetProp('_Name'),
probe.GetProp('_Name'))
raise ValueError('mol %s does not match mol %s'%(ref.GetProp('_Name'),
probe.GetProp('_Name')))
maps = [list(enumerate(match)) for match in matches]
bestRMS=1000.
for amap in maps:
@@ -226,7 +226,8 @@ def EnumerateLibraryFromReaction(reaction,sidechainSets) :
"""
if len(sidechainSets) != reaction.GetNumReactantTemplates():
raise ValueError,'%d sidechains provided, %d required'%(len(sidechainSets),reaction.GetNumReactantTemplates())
raise ValueError('%d sidechains provided, %d required' %
(len(sidechainSets),reaction.GetNumReactantTemplates()))
def _combiEnumerator(items,depth=0):
for item in items[depth]:
@@ -287,7 +288,7 @@ def ConstrainedEmbed(mol,core,useTethers=True,coreConfId=-1,
"""
match = mol.GetSubstructMatch(core)
if not match:
raise ValueError,"molecule doesn't match the core"
raise ValueError("molecule doesn't match the core")
coordMap={}
coreConf = core.GetConformer(coreConfId)
for i,idxI in enumerate(match):
@@ -296,7 +297,7 @@ def ConstrainedEmbed(mol,core,useTethers=True,coreConfId=-1,
ci = EmbedMolecule(mol,coordMap=coordMap,randomSeed=randomseed,**kwargs)
if ci<0:
raise ValueError,'Could not embed molecule.'
raise ValueError('Could not embed molecule.')
algMap=[(j,i) for i,j in enumerate(match)]
@@ -349,14 +350,14 @@ def AssignBondOrdersFromTemplate(refmol, mol):
>>> from rdkit.Chem import AllChem
>>> template = AllChem.MolFromSmiles("CN1C(=NC(C1=O)(c2ccccc2)c3ccccc3)N")
>>> mol = AllChem.MolFromPDBFile(os.path.join(RDConfig.RDCodeDir, 'Chem', 'test_data', '4DJU_lig.pdb'))
>>> print len([1 for b in template.GetBonds() if b.GetBondTypeAsDouble() == 1.0])
>>> len([1 for b in template.GetBonds() if b.GetBondTypeAsDouble() == 1.0])
8
>>> print len([1 for b in mol.GetBonds() if b.GetBondTypeAsDouble() == 1.0])
>>> len([1 for b in mol.GetBonds() if b.GetBondTypeAsDouble() == 1.0])
22
Now assign the bond orders based on the template molecule
>>> newMol = AllChem.AssignBondOrdersFromTemplate(template, mol)
>>> print len([1 for b in newMol.GetBonds() if b.GetBondTypeAsDouble() == 1.0])
>>> len([1 for b in newMol.GetBonds() if b.GetBondTypeAsDouble() == 1.0])
8
Note that the template molecule should have no explicit hydrogens

2
rdkit/Chem/AtomPairs/Pairs.py
View File

@@ -28,7 +28,7 @@ GetAtomPairFingerprintAsIntVect=rdMolDescriptors.GetAtomPairFingerprint
numPathBits=rdMolDescriptors.AtomPairsParameters.numPathBits
_maxPathLen=(1<<numPathBits)-1
numFpBits=numPathBits+2*rdMolDescriptors.AtomPairsParameters.codeSize
fpLen=1L<<numFpBits
fpLen=1<<numFpBits
def pyScorePair(at1,at2,dist,atomCodes=None):
""" Returns a score for an individual atom pair.

20
rdkit/Chem/AtomPairs/Torsions.py
View File

@@ -24,10 +24,10 @@ def pyScorePath(mol,path,size,atomCodes=None):
""" Returns a score for an individual path.
>>> m = Chem.MolFromSmiles('CCCCC')
>>> c1 = long(Utils.GetAtomCode(m.GetAtomWithIdx(0),1))
>>> c2 = long(Utils.GetAtomCode(m.GetAtomWithIdx(1),2))
>>> c3 = long(Utils.GetAtomCode(m.GetAtomWithIdx(2),2))
>>> c4 = long(Utils.GetAtomCode(m.GetAtomWithIdx(3),1))
>>> c1 = Utils.GetAtomCode(m.GetAtomWithIdx(0),1)
>>> c2 = Utils.GetAtomCode(m.GetAtomWithIdx(1),2)
>>> c3 = Utils.GetAtomCode(m.GetAtomWithIdx(2),2)
>>> c4 = Utils.GetAtomCode(m.GetAtomWithIdx(3),1)
>>> t = c1 | (c2 << rdMolDescriptors.AtomPairsParameters.codeSize) | (c3 << (rdMolDescriptors.AtomPairsParameters.codeSize*2)) | (c4 << (rdMolDescriptors.AtomPairsParameters.codeSize*3))
>>> pyScorePath(m,(0,1,2,3),4)==t
1
@@ -38,10 +38,10 @@ def pyScorePath(mol,path,size,atomCodes=None):
>>> m = Chem.MolFromSmiles('C=CC(=O)O')
>>> c1 = long(Utils.GetAtomCode(m.GetAtomWithIdx(0),1))
>>> c2 = long(Utils.GetAtomCode(m.GetAtomWithIdx(1),2))
>>> c3 = long(Utils.GetAtomCode(m.GetAtomWithIdx(2),2))
>>> c4 = long(Utils.GetAtomCode(m.GetAtomWithIdx(4),1))
>>> c1 = Utils.GetAtomCode(m.GetAtomWithIdx(0),1)
>>> c2 = Utils.GetAtomCode(m.GetAtomWithIdx(1),2)
>>> c3 = Utils.GetAtomCode(m.GetAtomWithIdx(2),2)
>>> c4 = Utils.GetAtomCode(m.GetAtomWithIdx(4),1)
>>> t = c1 | (c2 << rdMolDescriptors.AtomPairsParameters.codeSize) | (c3 << (rdMolDescriptors.AtomPairsParameters.codeSize*2)) | (c4 << (rdMolDescriptors.AtomPairsParameters.codeSize*3))
>>> pyScorePath(m,(0,1,2,4),4)==t
1
@@ -71,9 +71,9 @@ def pyScorePath(mol,path,size,atomCodes=None):
end -= 1
else:
break
accum = 0L
accum = 0
for i in range(size):
accum |= long(codes[i]) << (rdMolDescriptors.AtomPairsParameters.codeSize*i)
accum |= codes[i] << (rdMolDescriptors.AtomPairsParameters.codeSize*i)
return accum
def ExplainPathScore(score,size=4):

22
rdkit/Chem/AtomPairs/UnitTestDescriptors.py
View File

@@ -8,7 +8,9 @@
# which is included in the file license.txt, found at the root
# of the RDKit source tree.
#
import unittest,cPickle,os,gzip
from __future__ import print_function
import unittest,os,gzip
from rdkit.six.moves import cPickle
from rdkit import Chem
from rdkit import RDConfig
from rdkit.Chem.AtomPairs import Pairs,Torsions
@@ -38,8 +40,8 @@ class TestCase(unittest.TestCase):
# if pd[k]!=v: print '>>>3',k,v,pd[k]
# else:
# print '>>>4',k,v
self.failUnless(ap==atomPairs[i])
self.failUnless(ap!=atomPairs[i-1])
self.assertTrue(ap==atomPairs[i])
self.assertTrue(ap!=atomPairs[i-1])
def testTorsionsRegression(self):
inF = gzip.open(os.path.join(self.testDataPath,'mols1000.tts.pkl.gz'),'rb')
@@ -47,22 +49,22 @@ class TestCase(unittest.TestCase):
for i,m in enumerate(self.mols):
tt = Torsions.GetTopologicalTorsionFingerprintAsIntVect(m)
if tt!=torsions[i]:
print Chem.MolToSmiles(m)
print(Chem.MolToSmiles(m))
pd=tt.GetNonzeroElements()
rd=torsions[i].GetNonzeroElements()
for k,v in pd.iteritems():
if rd.has_key(k):
if rd[k]!=v: print '>>>1',k,v,rd[k]
if rd[k]!=v: print('>>>1',k,v,rd[k])
else:
print '>>>2',k,v
print('>>>2',k,v)
for k,v in rd.iteritems():
if pd.has_key(k):
if pd[k]!=v: print '>>>3',k,v,pd[k]
if pd[k]!=v: print('>>>3',k,v,pd[k])
else:
print '>>>4',k,v
print('>>>4',k,v)
self.failUnless(tt==torsions[i])
self.failUnless(tt!=torsions[i-1])
self.assertTrue(tt==torsions[i])
self.assertTrue(tt!=torsions[i-1])
if __name__ == '__main__':

17
rdkit/Chem/AtomPairs/Utils.py
View File

@@ -8,6 +8,7 @@
# which is included in the file license.txt, found at the root
# of the RDKit source tree.
#
from __future__ import print_function
from rdkit import Chem
from rdkit.Chem import rdMolDescriptors
import math
@@ -47,12 +48,12 @@ def ExplainAtomCode(code,branchSubtract=0):
piMask = (1<<rdMolDescriptors.AtomPairsParameters.numPiBits)-1
nBranch = int(code&branchMask)
#print code,
#print(code,end='')
code = code>>rdMolDescriptors.AtomPairsParameters.numBranchBits
nPi = int(code&piMask)
#print code,
#print(code,end='')
code = code>>rdMolDescriptors.AtomPairsParameters.numPiBits
#print code,
#print(code,end='')
typeIdx=int(code&typeMask)
if typeIdx<len(rdMolDescriptors.AtomPairsParameters.atomTypes):
atomNum = rdMolDescriptors.AtomPairsParameters.atomTypes[typeIdx]
@@ -263,15 +264,15 @@ def CosineSimilarity(v1,v2):
- the vectors must be sorted
>>> print '%.3f'%CosineSimilarity( (1,2,3,4,10), (2,4,6) )
>>> print('%.3f'%CosineSimilarity( (1,2,3,4,10), (2,4,6) ))
0.516
>>> print '%.3f'%CosineSimilarity( (1,2,2,3,4), (2,2,4,5,6) )
>>> print('%.3f'%CosineSimilarity( (1,2,2,3,4), (2,2,4,5,6) ))
0.714
>>> print '%.3f'%CosineSimilarity( (1,2,2,3,4), (1,2,2,3,4) )
>>> print('%.3f'%CosineSimilarity( (1,2,2,3,4), (1,2,2,3,4) ))
1.000
>>> print '%.3f'%CosineSimilarity( (1,2,2,3,4), (5,6,7) )
>>> print('%.3f'%CosineSimilarity( (1,2,2,3,4), (5,6,7) ))
0.000
>>> print '%.3f'%CosineSimilarity( (1,2,2,3,4), () )
>>> print('%.3f'%CosineSimilarity( (1,2,2,3,4), () ))
0.000
"""

25
rdkit/Chem/BRICS.py
View File

@@ -34,9 +34,12 @@
""" Implementation of the BRICS algorithm from Degen et al. ChemMedChem *3* 1503-7 (2008)
"""
from __future__ import print_function
import sys,re,random
from rdkit import Chem
from rdkit.Chem import rdChemReactions as Reactions
import sys,re,random
from rdkit.six import iteritems, iterkeys, next
from rdkit.six.moves import range
# These are the definitions that will be applied to fragment molecules:
environs = {
@@ -204,11 +207,11 @@ for gp in smartsGps:
t=Reactions.ReactionFromSmarts(defn)
t.Initialize()
except:
print defn
print(defn)
raise
environMatchers={}
for env,sma in environs.iteritems():
for env,sma in iteritems(environs):
environMatchers[env]=Chem.MolFromSmarts(sma)
bondMatchers=[]
@@ -279,12 +282,12 @@ def FindBRICSBonds(mol,randomizeOrder=False,silent=True):
"""
letter = re.compile('[a-z,A-Z]')
indices = range(len(bondMatchers))
indices = list(range(len(bondMatchers)))
bondsDone=set()
if randomizeOrder: random.shuffle(indices)
envMatches={}
for env,patt in environMatchers.iteritems():
for env,patt in iteritems(environMatchers):
envMatches[env]=mol.HasSubstructMatch(patt)
for gpIdx in indices:
if randomizeOrder:
@@ -388,7 +391,7 @@ def BRICSDecompose(mol,allNodes=None,minFragmentSize=1,onlyUseReactions=None,
>>> sorted(res)
['[14*]c1ccccn1', '[16*]c1cccc([16*])c1', '[3*]O[3*]', '[4*]CCC', '[4*]C[8*]']
>>> res = BRICSDecompose(m,returnMols=True)
>>> res = list(BRICSDecompose(m,returnMols=True))
>>> res[0]
<rdkit.Chem.rdchem.Mol object ...>
>>> smis = [Chem.MolToSmiles(x,True) for x in res]
@@ -449,17 +452,17 @@ def BRICSDecompose(mol,allNodes=None,minFragmentSize=1,onlyUseReactions=None,
newPool = {}
while activePool:
matched=False
nSmi = activePool.keys()[0]
nSmi = next(iterkeys(activePool))
mol = activePool.pop(nSmi)
for rxnIdx,reaction in enumerate(reactionGp):
if onlyUseReactions and (gpIdx,rxnIdx) not in onlyUseReactions:
continue
if not silent:
print '--------'
print smartsGps[gpIdx][rxnIdx]
print('--------')
print(smartsGps[gpIdx][rxnIdx])
ps = reaction.RunReactants((mol,))
if ps:
if not silent: print nSmi,'->',len(ps),'products'
if not silent: print(nSmi,'->',len(ps),'products')
for prodSeq in ps:
seqOk=True
# we want to disqualify small fragments, so sort the product sequence by size
@@ -481,7 +484,7 @@ def BRICSDecompose(mol,allNodes=None,minFragmentSize=1,onlyUseReactions=None,
matched=True
for nats,prod in prodSeq:
pSmi = prod.pSmi
#print '\t',nats,pSmi
#print('\t',nats,pSmi)
if pSmi not in allNodes:
if not singlePass:
activePool[pSmi] = prod

25
rdkit/Chem/BuildFragmentCatalog.py
View File

@@ -63,7 +63,10 @@
- --nBits=-1: specify the maximum number of bits to show details for
"""
import sys,os,cPickle
from __future__ import print_function
import sys,os
from rdkit.six.moves import cPickle
from rdkit.six import next
from rdkit import Chem
from rdkit import RDConfig
from rdkit.Chem import FragmentCatalog
@@ -230,7 +233,7 @@ def ScoreFromLists(bitLists,suppl,catalog,maxPts=-1,actName='',acts=None,
actName = suppl[0].GetPropNames()[-1]
suppl.reset()
for i in range(1,nPts+1):
mol = suppl.next()
mol = next(suppl)
if not acts:
act = int(mol.GetProp(actName))
else:
@@ -284,7 +287,7 @@ def CalcGains(suppl,catalog,topN=-1,actName='',acts=None,
except KeyError:
message('ERROR: Molecule has no property: %s\n'%(actName))
message('\tAvailable properties are: %s\n'%(str(mol.GetPropNames())))
raise KeyError,actName
raise KeyError(actName)
else:
act = acts[i]
if i and not i%reportFreq:
@@ -330,7 +333,7 @@ def CalcGainsFromFps(suppl,fps,topN=-1,actName='',acts=None,
except KeyError:
message('ERROR: Molecule has no property: %s\n'%(actName))
message('\tAvailable properties are: %s\n'%(str(mol.GetPropNames())))
raise KeyError,actName
raise KeyError(actName)
else:
act = acts[i]
if i and not i%reportFreq:
@@ -404,23 +407,23 @@ def SupplierFromDetails(details):
titleLine=details.hasTitle)
if type(details.actCol)==types.IntType:
suppl.reset()
m = suppl.next()
m = next(suppl)
actName = m.GetPropNames()[details.actCol]
details.actCol = actName
if type(details.nameCol)==types.IntType:
suppl.reset()
m = suppl.next()
m = next(suppl)
nameName = m.GetPropNames()[details.nameCol]
details.nameCol = nameName
suppl.reset()
if type(details.actCol)==types.IntType:
suppl.reset()
m = suppl.next()
m = next(suppl)
actName = m.GetPropNames()[details.actCol]
details.actCol = actName
if type(details.nameCol)==types.IntType:
suppl.reset()
m = suppl.next()
m = next(suppl)
nameName = m.GetPropNames()[details.nameCol]
details.nameCol = nameName
suppl.reset()
@@ -428,9 +431,9 @@ def SupplierFromDetails(details):
def Usage():
print "This is BuildFragmentCatalog version %s"%(__VERSION_STRING)
print 'usage error'
#print __doc__
print("This is BuildFragmentCatalog version %s"%(__VERSION_STRING))
print('usage error')
#print(__doc__)
sys.exit(-1)
class RunDetails(object):

6
rdkit/Chem/ChemUtils/AlignDepict.py
View File

@@ -21,10 +21,10 @@ def AlignDepict(mol,core,corePattern=None,acceptFailure=False):
"""
if core and corePattern:
if not core.GetNumAtoms(onlyExplicit=True)==corePattern.GetNumAtoms(onlyExplicit=True):
raise ValueError,'When a pattern is provided, it must have the same number of atoms as the core'
raise ValueError('When a pattern is provided, it must have the same number of atoms as the core')
coreMatch = core.GetSubstructMatch(corePattern)
if not coreMatch:
raise ValueError,"Core does not map to itself"
raise ValueError("Core does not map to itself")
else:
coreMatch = range(core.GetNumAtoms(onlyExplicit=True))
if corePattern:
@@ -34,7 +34,7 @@ def AlignDepict(mol,core,corePattern=None,acceptFailure=False):
if not match:
if not acceptFailure:
raise ValueError,'Substructure match with core not found.'
raise ValueError('Substructure match with core not found.')
else:
coordMap={}
else:

18
rdkit/Chem/ChemUtils/SDFToCSV.py
View File

@@ -61,7 +61,7 @@ class TestCase(unittest.TestCase):
pass
def test1(self):
import os
from cStringIO import StringIO
from rdkit.six.moves import cStringIO as StringIO
fName = os.path.join(RDConfig.RDDataDir,'NCI','first_200.props.sdf')
suppl = Chem.SDMolSupplier(fName)
io = StringIO()
@@ -75,13 +75,13 @@ class TestCase(unittest.TestCase):
lines = txt.split('\n')
if not lines[-1]:
del lines[-1]
self.failUnless(len(lines)==201,'bad num lines: %d'%len(lines))
self.assertTrue(len(lines)==201,'bad num lines: %d'%len(lines))
line0 = lines[0].split(',')
self.failUnlessEqual(len(line0),20)
self.failUnless(line0[0]=='SMILES')
self.assertEqual(len(line0),20)
self.assertTrue(line0[0]=='SMILES')
def test2(self):
import os
from cStringIO import StringIO
from rdkit.six.moves import cStringIO as StringIO
fName = os.path.join(RDConfig.RDDataDir,'NCI','first_200.props.sdf')
suppl = Chem.SDMolSupplier(fName)
io = StringIO()
@@ -95,11 +95,11 @@ class TestCase(unittest.TestCase):
lines = txt.split('\n')
if not lines[-1]:
del lines[-1]
self.failUnless(len(lines)==6,'bad num lines: %d'%len(lines))
self.assertTrue(len(lines)==6,'bad num lines: %d'%len(lines))
line0 = lines[0].split(',')
self.failUnlessEqual(len(line0),20)
self.failUnless(line0[0]=='AMW')
self.failUnless(line0[1]=='SMILES')
self.assertEqual(len(line0),20)
self.assertTrue(line0[0]=='AMW')
self.assertTrue(line0[1]=='SMILES')

4
rdkit/Chem/ChemicalFeatures.py
View File

@@ -8,8 +8,8 @@
# which is included in the file license.txt, found at the root
# of the RDKit source tree.
#
from rdMolChemicalFeatures import *
from rdChemicalFeatures import *
from rdkit.Chem.rdMolChemicalFeatures import *
from rdkit.Chem.rdChemicalFeatures import *
def MCFF_GetFeaturesForMol(self,mol,includeOnly=""):
res = []

21
rdkit/Chem/Crippen.py
View File

@@ -16,6 +16,7 @@
"""
from __future__ import print_function
import os
from rdkit import RDConfig
from rdkit import Chem
@@ -35,7 +36,9 @@ def _ReadPatts(fileName):
"""
patts = {}
order = []
for line in open(fileName,'r').xreadlines():
with open(fileName,'r') as f:
lines = f.readlines()
for line in lines:
if line[0] != '#':
splitLine = line.split('\t')
if len(splitLine)>=4 and splitLine[0] != '':
@@ -63,7 +66,7 @@ def _ReadPatts(fileName):
l.append((sma,p,logP,mr))
patts[cha] = l
else:
print 'Problems parsing smarts: %s'%(sma)
print('Problems parsing smarts: %s'%(sma))
return order,patts
_GetAtomContribs=rdMolDescriptors._CalcCrippenContribs
@@ -94,14 +97,14 @@ def _pyGetAtomContribs(mol,patts=None,order=None,verbose=0,force=0):
for cha in order:
pattVect = patts[cha]
for sma,patt,logp,mr in pattVect:
#print 'try:',entry[0]
#print('try:',entry[0])
for match in mol.GetSubstructMatches(patt,False,False):
firstIdx = match[0]
if not doneAtoms[firstIdx]:
doneAtoms[firstIdx]=1
atomContribs[firstIdx] = (logp,mr)
if verbose:
print '\tAtom %d: %s %4.4f %4.4f'%(match[0],sma,logp,mr)
print('\tAtom %d: %s %4.4f %4.4f'%(match[0],sma,logp,mr))
nAtomsFound+=1
if nAtomsFound>=nAtoms:
done=True
@@ -201,13 +204,13 @@ if __name__=='__main__':
ms.append((smi,Chem.MolFromSmiles(smi)))
for smi,m in ms:
print 'Mol: %s'%(smi)
print('Mol: %s'%(smi))
logp = MolLogP(m,verbose=verbose)
print '----'
print('----')
mr = MolMR(m,verbose=verbose)
print 'Res:',logp,mr
print('Res:',logp,mr)
newM = Chem.AddHs(m)
logp = MolLogP(newM,addHs=0)
mr = MolMR(newM,addHs=0)
print '\t',logp,mr
print '-*-*-*-*-*-*-*-*'
print('\t',logp,mr)
print('-*-*-*-*-*-*-*-*')

2
rdkit/Chem/Descriptors.py
View File

@@ -25,7 +25,7 @@ def _setupDescriptors(namespace):
otherMods = [Chem]
for nm,thing in namespace.iteritems():
for nm,thing in namespace.items():
if nm[0]!='_' and _isCallable(thing):
_descList.append((nm,thing))

56
rdkit/Chem/Draw/UnitTestDraw.py
View File

@@ -31,7 +31,7 @@ class TestCase(unittest.TestCase):
foo,fn=tempfile.mkstemp(suffix='.png')
foo=None
self.failUnlessEqual(os.path.getsize(fn),0)
self.assertEqual(os.path.getsize(fn),0)
Draw.MolToFile(self.mol,fn)
@@ -51,7 +51,7 @@ class TestCase(unittest.TestCase):
foo,fn=tempfile.mkstemp(suffix='.png')
foo=None
self.failUnlessEqual(os.path.getsize(fn),0)
self.assertEqual(os.path.getsize(fn),0)
Draw.MolToFile(self.mol,fn)
@@ -71,7 +71,7 @@ class TestCase(unittest.TestCase):
foo,fn=tempfile.mkstemp(suffix='.png')
foo=None
self.failUnlessEqual(os.path.getsize(fn),0)
self.assertEqual(os.path.getsize(fn),0)
Draw.MolToFile(self.mol,fn)
@@ -89,9 +89,9 @@ class TestCase(unittest.TestCase):
os.environ['RDKIT_CANVAS']='cairo'
img=Draw.MolToImage(self.mol,size=(300,300))
self.failUnless(img)
self.failUnlessEqual(img.size[0],300)
self.failUnlessEqual(img.size[1],300)
self.assertTrue(img)
self.assertEqual(img.size[0],300)
self.assertEqual(img.size[1],300)
def testAggImage(self):
try:
@@ -100,9 +100,9 @@ class TestCase(unittest.TestCase):
return
os.environ['RDKIT_CANVAS']='agg'
img=Draw.MolToImage(self.mol,size=(300,300))
self.failUnless(img)
self.failUnlessEqual(img.size[0],300)
self.failUnlessEqual(img.size[1],300)
self.assertTrue(img)
self.assertEqual(img.size[0],300)
self.assertEqual(img.size[1],300)
def testSpingImage(self):
try:
@@ -111,9 +111,9 @@ class TestCase(unittest.TestCase):
return
os.environ['RDKIT_CANVAS']='sping'
img=Draw.MolToImage(self.mol,size=(300,300))
self.failUnless(img)
self.failUnlessEqual(img.size[0],300)
self.failUnlessEqual(img.size[1],300)
self.assertTrue(img)
self.assertEqual(img.size[0],300)
self.assertEqual(img.size[1],300)
def testCairoImageDash(self):
try:
@@ -123,9 +123,9 @@ class TestCase(unittest.TestCase):
os.environ['RDKIT_CANVAS']='cairo'
img=Draw.MolToImage(self.mol,size=(300,300),kekulize=False)
self.failUnless(img)
self.failUnlessEqual(img.size[0],300)
self.failUnlessEqual(img.size[1],300)
self.assertTrue(img)
self.assertEqual(img.size[0],300)
self.assertEqual(img.size[1],300)
def testAggImageDash(self):
try:
@@ -134,9 +134,9 @@ class TestCase(unittest.TestCase):
return
os.environ['RDKIT_CANVAS']='agg'
img=Draw.MolToImage(self.mol,size=(300,300),kekulize=False)
self.failUnless(img)
self.failUnlessEqual(img.size[0],300)
self.failUnlessEqual(img.size[1],300)
self.assertTrue(img)
self.assertEqual(img.size[0],300)
self.assertEqual(img.size[1],300)
def testSpingImageDash(self):
try:
@@ -145,9 +145,9 @@ class TestCase(unittest.TestCase):
return
os.environ['RDKIT_CANVAS']='sping'
img=Draw.MolToImage(self.mol,size=(300,300),kekulize=False)
self.failUnless(img)
self.failUnlessEqual(img.size[0],300)
self.failUnlessEqual(img.size[1],300)
self.assertTrue(img)
self.assertEqual(img.size[0],300)
self.assertEqual(img.size[1],300)
def testGithubIssue54(self):
try:
@@ -157,24 +157,24 @@ class TestCase(unittest.TestCase):
os.environ['RDKIT_CANVAS']='sping'
mol = Chem.MolFromSmiles('c1([O])ccc(O)cc1')
img = Draw.MolToImage(mol)
self.failUnless(img)
self.assertTrue(img)
def testGithubIssue86(self):
mol = Chem.MolFromSmiles('F[C@H](Cl)Br')
for b in mol.GetBonds():
self.failUnlessEqual(b.GetBondDir(),Chem.BondDir.NONE)
self.assertEqual(b.GetBondDir(),Chem.BondDir.NONE)
img = Draw.MolToImage(mol,kekulize=False)
self.failUnless(img)
self.assertTrue(img)
for b in mol.GetBonds():
self.failUnlessEqual(b.GetBondDir(),Chem.BondDir.NONE)
self.assertEqual(b.GetBondDir(),Chem.BondDir.NONE)
Chem.WedgeMolBonds(mol,mol.GetConformer())
obds = [x.GetBondDir() for x in mol.GetBonds()]
self.failUnlessEqual(obds.count(Chem.BondDir.NONE),2)
self.assertEqual(obds.count(Chem.BondDir.NONE),2)
img = Draw.MolToImage(mol,kekulize=False)
self.failUnless(img)
self.assertTrue(img)
nbds = [x.GetBondDir() for x in mol.GetBonds()]
self.failUnlessEqual(obds,nbds)
self.assertEqual(obds,nbds)

10
rdkit/Chem/Draw/__init__.py
View File

@@ -4,7 +4,7 @@
# All Rights Reserved
#
import os
from MolDrawing import MolDrawing,DrawingOptions
from rdkit.Chem.Draw.MolDrawing import MolDrawing,DrawingOptions
def _getCanvas():
useAGG=False
@@ -61,7 +61,7 @@ def MolToImage(mol, size=(300,300), kekulize=True, wedgeBonds=True,
highlightBonds -- list of bonds to highlight (default [])
"""
if not mol:
raise ValueError,'Null molecule provided'
raise ValueError('Null molecule provided')
if canvas is None:
img,canvas=_createCanvas(size)
else:
@@ -114,9 +114,9 @@ def MolToFile(mol,fileName,size=(300,300),kekulize=True, wedgeBonds=True,
"""
# original contribution from Uwe Hoffmann
if not fileName:
raise ValueError,'no fileName provided'
raise ValueError('no fileName provided')
if not mol:
raise ValueError,'Null molecule provided'
raise ValueError('Null molecule provided')
if imageType is None:
imageType=os.path.splitext(fileName)[1][1:]
@@ -189,7 +189,7 @@ def MolToMPL(mol,size=(300,300),kekulize=True, wedgeBonds=True,
""" Generates a drawing of a molecule on a matplotlib canvas
"""
if not mol:
raise ValueError,'Null molecule provided'
raise ValueError('Null molecule provided')
from mplCanvas import Canvas
canvas = Canvas(size)
if options is None:

4
rdkit/Chem/Draw/aggCanvas.py
View File

@@ -38,7 +38,7 @@ class Canvas(CanvasBase):
except ImportError:
from PIL import Image
if size is None:
raise ValueError,'please provide either an image or a size'
raise ValueError('please provide either an image or a size')
img = Image.new('RGBA',size,"white")
self.image = img
self.draw = Draw(img)
@@ -48,7 +48,7 @@ class Canvas(CanvasBase):
else:
self.size = size
if imageType and imageType not in ('png','jpg'):
raise ValueError,'unsupported image type for agg canvas'
raise ValueError('unsupported image type for agg canvas')
self.drawType=imageType
self.fileName=fileName

8
rdkit/Chem/Draw/cairoCanvas.py
View File

@@ -16,7 +16,7 @@ except ImportError:
import cairocffi as cairo
if not hasattr(cairo.ImageSurface,'get_data') and \
not hasattr(cairo.ImageSurface,'get_data_as_rgba'):
raise ImportError,'cairo version too old'
raise ImportError('cairo version too old')
import math
@@ -65,8 +65,8 @@ class Canvas(CanvasBase):
try:
imgd = image.tostring("raw","BGRA")
except SystemError:
r,g,b,a = image.split()
imgd = Image.merge("RGBA",(b,g,r,a)).tostring("raw","RGBA")
r,g,b,a = image.split()
imgd = Image.merge("RGBA",(b,g,r,a)).tostring("raw","RGBA")
a = array.array('B',imgd)
stride=image.size[0]*4
@@ -86,7 +86,7 @@ class Canvas(CanvasBase):
elif imageType == "png":
surface = cairo.ImageSurface (cairo.FORMAT_ARGB32, size[0], size[1])
else:
raise ValueError, "Unrecognized file type. Valid choices are pdf, svg, ps, and png"
raise ValueError("Unrecognized file type. Valid choices are pdf, svg, ps, and png")
ctx = cairo.Context(surface)
ctx.set_source_rgb(1,1,1)
ctx.paint()

2
rdkit/Chem/Draw/spingCanvas.py
View File

@@ -34,7 +34,7 @@ class Canvas(CanvasBase):
elif imageType=="png":
from rdkit.sping.PIL.pidPIL import PILCanvas as Canvas
else:
raise ValueError,'unrecognized format: %s'%imageType
raise ValueError('unrecognized format: %s'%imageType)
self.canvas = Canvas(size=size, name=name)
if hasattr(self.canvas,'_image'):
self._image = self.canvas._image

5
rdkit/Chem/EState/EState.py
View File

@@ -11,6 +11,7 @@
""" Basic EState definitions
"""
from __future__ import print_function
import numpy
from rdkit import Chem
@@ -81,7 +82,7 @@ if __name__ =='__main__':
smis = ['CCCC','CCCCC','CCCCCC','CC(N)C(=O)O','CC(N)C(=O)[O-].[Na+]']
for smi in smis:
m = Chem.MolFromSmiles(smi)
print smi
print(smi)
inds = EStateIndices(m)
print '\t',inds
print('\t',inds)

11
rdkit/Chem/EState/Fingerprinter.py
View File

@@ -13,6 +13,7 @@
""" EState fingerprinting
"""
from __future__ import print_function
import numpy
from rdkit.Chem.EState import EStateIndices
from rdkit.Chem.EState import AtomTypes
@@ -49,16 +50,16 @@ if __name__ == '__main__':
smis = ['CC','CCC','c1[nH]cnc1CC(N)C(O)=O','NCCc1ccc(O)c(O)c1']
for smi in smis:
m = Chem.MolFromSmiles(smi)
print smi,Chem.MolToSmiles(m)
print(smi,Chem.MolToSmiles(m))
types = AtomTypes.TypeAtoms(m)
for i in range(m.GetNumAtoms()):
print '%d %4s: %s'%(i+1,m.GetAtomWithIdx(i).GetSymbol(),str(types[i]))
print('%d %4s: %s'%(i+1,m.GetAtomWithIdx(i).GetSymbol(),str(types[i])))
es = EStateIndices(m)
counts,sums = FingerprintMol(m)
for i in range(len(AtomTypes.esPatterns)):
if counts[i]:
name,patt = AtomTypes.esPatterns[i]
print '%6s, % 2d, % 5.4f'%(name,counts[i],sums[i])
print('%6s, % 2d, % 5.4f'%(name,counts[i],sums[i]))
for i in range(len(es)):
print '% 2d, % 5.4f'%(i+1,es[i])
print '--------'
print('% 2d, % 5.4f'%(i+1,es[i]))
print('--------')

3
rdkit/Chem/EState/UnitTestEState.py
View File

@@ -13,6 +13,7 @@
validation values are from the paper (JCICS _31_ 76-81 (1991))
"""
from __future__ import print_function
import unittest
import numpy
from rdkit import Chem
@@ -30,7 +31,7 @@ class TestCase(unittest.TestCase):
inds = EState.EStateIndices(mol)
maxV = max(abs(ans-inds))
if show: print inds
if show: print(inds)
assert maxV<tol,'bad EStates for smiles: %s'%(smi)

5
rdkit/Chem/EState/UnitTestFingerprints.py
View File

@@ -13,6 +13,7 @@
validation values are from the paper (JCICS _35_ 1039-1045 (1995))
"""
from __future__ import print_function
import unittest
import numpy
from rdkit import Chem
@@ -30,8 +31,8 @@ class TestCase(unittest.TestCase):
counts = counts[numpy.nonzero(counts)]
vals = vals[numpy.nonzero(vals)]
if show:
print counts
print vals
print(counts)
print(vals)
assert len(c)==len(counts),'bad count len for smiles: %s'%(smi)
assert len(v)==len(vals),'bad val len for smiles: %s'%(smi)
c = numpy.array(c)

3
rdkit/Chem/EState/UnitTestTypes.py
View File

@@ -13,6 +13,7 @@
validation values are from the paper (JCICS _35_ 1039-1045 (1995))
"""
from __future__ import print_function
import unittest
from rdkit import Chem
from rdkit.Chem import EState
@@ -26,7 +27,7 @@ class TestCase(unittest.TestCase):
for smi,ans in vals:
mol = Chem.MolFromSmiles(smi)
types = AtomTypes.TypeAtoms(mol)
if show: print types
if show: print(types)
assert len(ans)==len(types),'bad type len for smiles: %s'%(smi)
lens = [len(x) for x in types]
assert max(lens)==1,'atom matched multiple types for smiles: %s'%(smi)

7
rdkit/Chem/EState/UnitTestVSA.py
View File

@@ -11,6 +11,7 @@
""" unit testing code for MOE-type descriptors with EStates
"""
from __future__ import print_function
from rdkit import RDConfig
import unittest,os
from rdkit import Chem
@@ -23,7 +24,7 @@ def feq(n1,n2,tol=1e-4):
class TestCase(unittest.TestCase):
def setUp(self):
if doLong:
print '\n%s: '%self.shortDescription(),
print('\n%s: '%self.shortDescription(), end='')
def test1(self):
inName = os.path.join(RDConfig.RDCodeDir,'Chem','EState','test_data',
'EState_VSA.csv')
@@ -31,13 +32,13 @@ class TestCase(unittest.TestCase):
names = [x.strip() for x in inL.split(',')[1:]]
suppl = Chem.SmilesMolSupplier(inName,delimiter=',',nameColumn=-1)
for mol in suppl:
self.failUnless(mol)
self.assertTrue(mol)
smi = Chem.MolToSmiles(mol)
for name in names:
prop = float(mol.GetProp(name))
func = getattr(EState_VSA,name)
v = func(mol)
self.failUnless(feq(v,prop),'%s: %.4f!=%.4f'%(smi,v,prop))
self.assertTrue(feq(v,prop),'%s: %.4f!=%.4f'%(smi,v,prop))
if __name__ == '__main__':

16
rdkit/Chem/FeatMaps/FeatMapParser.py
View File

@@ -81,7 +81,7 @@ class FeatMapParser(object):
elif keyword=='beginparams':
featMap.params=self.ParseParamBlock()
else:
raise FeatMapParseError,'Unrecognized keyword %s on line %d'%(keyword,self._lineNum)
raise FeatMapParseError('Unrecognized keyword %s on line %d'%(keyword,self._lineNum))
else:
keyword = splitL[0].strip().lower()
val = splitL[1].strip()
@@ -89,14 +89,14 @@ class FeatMapParser(object):
try:
featMap.scoreMode=getattr(FeatMaps.FeatMapScoreMode,val)
except AttributeError:
raise FeatMapParseError,'ScoreMode %s not recognized on line %d'%(val,self._lineNum)
raise FeatMapParseError('ScoreMode %s not recognized on line %d'%(val,self._lineNum))
elif keyword=='dirscoremode':
try:
featMap.dirScoreMode=getattr(FeatMaps.FeatDirScoreMode,val)
except AttributeError:
raise FeatMapParseError,'DirScoreMode %s not recognized on line %d'%(val,self._lineNum)
raise FeatMapParseError('DirScoreMode %s not recognized on line %d'%(val,self._lineNum))
else:
raise FeatMapParseError,'Unrecognized keyword %s on line %d'%(keyword,self._lineNum)
raise FeatMapParseError('Unrecognized keyword %s on line %d'%(keyword,self._lineNum))
l = self._NextLine().strip()
return featMap
@@ -120,9 +120,9 @@ class FeatMapParser(object):
try:
param.featProfile=getattr(param.FeatProfile,val)
except AttributeError:
raise FeatMapParseError,'Profile %s not recognized on line %d'%(val,self._lineNum)
raise FeatMapParseError('Profile %s not recognized on line %d'%(val,self._lineNum))
else:
raise FeatMapParseError,'FeatMapParam option %s not recognized on line %d'%(name,self._lineNum)
raise FeatMapParseError('FeatMapParam option %s not recognized on line %d'%(name,self._lineNum))
params[family]=param
l = self._NextLine()
@@ -142,7 +142,7 @@ class FeatMapParser(object):
txt = txt[startP:endP]
splitL = txt.split(',')
if len(splitL) != 3:
raise ValueError,'Bad location string'
raise ValueError('Bad location string')
vs = [float(x) for x in splitL]
pt = Geometry.Point3D(vs[0],vs[1],vs[2])
return pt
@@ -180,7 +180,7 @@ class FeatMapParser(object):
pos = self._parsePoint(val)
p.featDirs.append(pos)
else:
raise FeatMapParseError,'FeatPoint option %s not recognized on line %d'%(name,self._lineNum)
raise FeatMapParseError('FeatPoint option %s not recognized on line %d'%(name,self._lineNum))
i+=1
feats.append(p)
l = self._NextLine()

9
rdkit/Chem/FeatMaps/FeatMapUtils.py
View File

@@ -10,8 +10,9 @@
# which is included in the file license.txt, found at the root
# of the RDKit source tree.
#
from rdkit.Chem.FeatMaps import FeatMaps
import copy
from rdkit.six.moves import range
from rdkit.Chem.FeatMaps import FeatMaps
class MergeMethod(object):
WeightedAverage=0
@@ -87,7 +88,7 @@ def GetFeatFeatDistMatrix(fm,mergeMetric,mergeTol,dirMergeMode,compatFunc):
dists[i][j]=score
dists[j][i]=score
else:
raise ValueError,'unrecognized mergeMetric'
raise ValueError('unrecognized mergeMetric')
return dists
@@ -130,7 +131,7 @@ def MergeFeatPoints(fm,mergeMetric=MergeMetric.NoMerge,mergeTol=1.5,
# progressively merge nearest neighbors until there
# are no more points left to merge
featsInPlay=range(fm.GetNumFeatures())
featsInPlay=list(range(fm.GetNumFeatures()))
featsToRemove = []
#print '--------------------------------'
while featsInPlay:
@@ -184,7 +185,7 @@ def MergeFeatPoints(fm,mergeMetric=MergeMetric.NoMerge,mergeTol=1.5,
newPos=nbrFeat.GetPos()
newWeight = nbrFeat.weight
else:
raise ValueError,"bad mergeMethod"
raise ValueError("bad mergeMethod")
featI.SetPos(newPos)
featI.weight = newWeight

22
rdkit/Chem/FeatMaps/FeatMaps.py
View File

@@ -79,13 +79,13 @@ class FeatMap(object):
self._feats = []
if feats:
if len(feats)!=len(weights):
raise ValueError,'feats and weights lists must be the same length'
raise ValueError('feats and weights lists must be the same length')
for feat,weight in zip(feats,weights):
self.AddFeature(feat,weight)
def AddFeature(self,feat,weight=None):
if self.params and not self.params.has_key(feat.GetFamily()):
raise ValueError,'feature family %s not found in params'%feat.GetFamily()
if self.params and not feat.GetFamily() in self.params:
raise ValueError('feature family %s not found in params'%feat.GetFamily())
newFeat = FeatMapPoint()
newFeat.initFromFeat(feat)
@@ -95,9 +95,9 @@ class FeatMap(object):
def AddFeatPoint(self,featPt):
if not isinstance(featPt,FeatMapPoint):
raise ValueError,'addFeatPoint() must be called with a FeatMapPoint instance'
if self.params and not self.params.has_key(featPt.GetFamily()):
raise ValueError,'feature family %s not found in params'%featPt.GetFamily()
raise ValueError('addFeatPoint() must be called with a FeatMapPoint instance')
if self.params and not featPt.GetFamily() in self.params:
raise ValueError('feature family %s not found in params'%featPt.GetFamily())
self._feats.append(featPt)
@@ -149,7 +149,7 @@ class FeatMap(object):
if self.dirScoreMode==FeatDirScoreMode.DotPosRange:
dirScore = (dirScore + 1.0)/2.0
elif self.dirScoreMode!=FeatDirScoreMode.DotFullRange:
raise NotImplementedError,'bad feature dir score mode'
raise NotImplementedError('bad feature dir score mode')
score *= dirScore
return score
@@ -158,12 +158,12 @@ class FeatMap(object):
featsToFeatMapIdx=[]):
nFeats = len(self._feats)
if mapScoreVect and len(mapScoreVect)!=nFeats:
raise ValueError,'if provided, len(mapScoreVect) should equal numFeats'
raise ValueError('if provided, len(mapScoreVect) should equal numFeats')
nToScore = len(featsToScore)
if featsScoreVect and len(featsScoreVect)!=nToScore:
raise ValueError,'if provided, len(featsScoreVect) should equal len(featsToScore)'
raise ValueError('if provided, len(featsScoreVect) should equal len(featsToScore)')
if featsToFeatMapIdx and len(featsToFeatMapIdx)!=nToScore:
raise ValueError,'if provided, len(featsToFeatMapIdx) should equal len(featsToScore)'
raise ValueError('if provided, len(featsToFeatMapIdx) should equal len(featsToScore)')
if mapScoreVect:
for i in range(nFeats): mapScoreVect[i]=0.0
@@ -206,7 +206,7 @@ class FeatMap(object):
mapScoreVect[sIdx] += lScore
featsToFeatMapIdx[oIdx].append(sIdx)
else:
raise ValueError,'bad score mode'
raise ValueError('bad score mode')
totScore = 0.0
if self.scoreMode == FeatMapScoreMode.Closest:

140
rdkit/Chem/FeatMaps/UnitTestFeatMap.py
View File

@@ -39,22 +39,22 @@ class TestCase(unittest.TestCase):
fmap.AddFeature(fs[2],2.0)
fmap.AddFeature(fs[2],2.0)
self.failUnless(fmap.GetNumFeatures()==4)
self.failUnless(len(fmap.GetFeatures())==4)
self.assertTrue(fmap.GetNumFeatures()==4)
self.assertTrue(len(fmap.GetFeatures())==4)
fmap.DropFeature(3)
self.failUnless(fmap.GetNumFeatures()==3)
self.failUnless(len(fmap.GetFeatures())==3)
self.assertTrue(fmap.GetNumFeatures()==3)
self.assertTrue(len(fmap.GetFeatures())==3)
f = fmap.GetFeature(0)
self.failUnless(f.GetFamily()=='Aromatic')
self.failUnless(feq(f.weight,1.0))
self.assertTrue(f.GetFamily()=='Aromatic')
self.assertTrue(feq(f.weight,1.0))
f = fmap.GetFeature(1)
self.failUnless(f.GetFamily()=='Acceptor')
self.failUnless(feq(f.weight,1.0))
self.assertTrue(f.GetFamily()=='Acceptor')
self.assertTrue(feq(f.weight,1.0))
f = fmap.GetFeature(2)
self.failUnless(f.GetFamily()=='Acceptor')
self.failUnless(feq(f.weight,2.0))
self.assertTrue(f.GetFamily()=='Acceptor')
self.assertTrue(feq(f.weight,2.0))
def test2FeatFeatScoreGauss(self):
aFmp = FeatMaps.FeatMapParams()
@@ -64,24 +64,24 @@ class TestCase(unittest.TestCase):
fs = [FreeChemicalFeature('Aromatic','Foo',Point3D(0,0,0))]
fmap.AddFeature(fs[0],1.0)
self.failUnless(len(fmap.GetFeatures())==1)
self.assertTrue(len(fmap.GetFeatures())==1)
sc = fmap.GetFeatFeatScore(fmap.GetFeature(0),FreeChemicalFeature('Aromatic','',Point3D(1,0,0)))
self.failUnless(feq(sc,math.exp(-1)))
self.assertTrue(feq(sc,math.exp(-1)))
sc = fmap.GetFeatFeatScore(fmap.GetFeature(0),FreeChemicalFeature('Aromatic','',Point3D(1.5,0,0)))
self.failUnless(feq(sc,math.exp(-2.25)))
self.assertTrue(feq(sc,math.exp(-2.25)))
sc = fmap.GetFeatFeatScore(fmap.GetFeature(0),FreeChemicalFeature('Aromatic','',Point3D(0,0,0)))
self.failUnless(feq(sc,1.0))
self.assertTrue(feq(sc,1.0))
sc = fmap.GetFeatFeatScore(fmap.GetFeature(0),FreeChemicalFeature('Aromatic','',Point3D(2.1,0,0)))
self.failUnless(feq(sc,0))
self.assertTrue(feq(sc,0))
sc = fmap.GetFeatFeatScore(fmap.GetFeature(0),FreeChemicalFeature('Acceptor','',Point3D(1,0,0)))
self.failUnless(feq(sc,0))
self.assertTrue(feq(sc,0))
sc = fmap.GetFeatFeatScore(fmap.GetFeature(0),FreeChemicalFeature('Acceptor','',Point3D(1,0,0)),
typeMatch=False)
self.failUnless(feq(sc,math.exp(-1)))
self.assertTrue(feq(sc,math.exp(-1)))
self.failUnlessRaises(IndexError,lambda: fmap.GetFeatFeatScore(fmap.GetFeature(1),FreeChemicalFeature('Aromatic','',Point3D(0,0,0))))
self.assertRaises(IndexError,lambda: fmap.GetFeatFeatScore(fmap.GetFeature(1),FreeChemicalFeature('Aromatic','',Point3D(0,0,0))))
def test3FeatFeatScoreTriangle(self):
aFmp = FeatMaps.FeatMapParams()
@@ -93,17 +93,17 @@ class TestCase(unittest.TestCase):
fs = [FreeChemicalFeature('Aromatic','Foo',Point3D(0,0,0))]
fmap.AddFeature(fs[0],1.0)
self.failUnless(len(fmap.GetFeatures())==1)
self.assertTrue(len(fmap.GetFeatures())==1)
sc = fmap.GetFeatFeatScore(fmap.GetFeature(0),FreeChemicalFeature('Aromatic','',Point3D(1,0,0)))
self.failUnless(feq(sc,0.5))
self.assertTrue(feq(sc,0.5))
sc = fmap.GetFeatFeatScore(fmap.GetFeature(0),FreeChemicalFeature('Aromatic','',Point3D(1.5,0,0)))
self.failUnless(feq(sc,0.25))
self.assertTrue(feq(sc,0.25))
sc = fmap.GetFeatFeatScore(fmap.GetFeature(0),FreeChemicalFeature('Aromatic','',Point3D(0,0,0)))
self.failUnless(feq(sc,1.0))
self.assertTrue(feq(sc,1.0))
sc = fmap.GetFeatFeatScore(fmap.GetFeature(0),FreeChemicalFeature('Aromatic','',Point3D(2.1,0,0)))
self.failUnless(feq(sc,0))
self.assertTrue(feq(sc,0))
def test4FeatFeatScoreBox(self):
aFmp = FeatMaps.FeatMapParams()
@@ -114,16 +114,16 @@ class TestCase(unittest.TestCase):
fs = [FreeChemicalFeature('Aromatic','Foo',Point3D(0,0,0))]
fmap.AddFeature(fs[0],1.1)
self.failUnless(len(fmap.GetFeatures())==1)
self.assertTrue(len(fmap.GetFeatures())==1)
sc = fmap.GetFeatFeatScore(fmap.GetFeature(0),FreeChemicalFeature('Aromatic','',Point3D(1,0,0)))
self.failUnless(feq(sc,1.1))
self.assertTrue(feq(sc,1.1))
sc = fmap.GetFeatFeatScore(fmap.GetFeature(0),FreeChemicalFeature('Aromatic','',Point3D(1.5,0,0)))
self.failUnless(feq(sc,1.1))
self.assertTrue(feq(sc,1.1))
sc = fmap.GetFeatFeatScore(fmap.GetFeature(0),FreeChemicalFeature('Aromatic','',Point3D(0,0,0)))
self.failUnless(feq(sc,1.1))
self.assertTrue(feq(sc,1.1))
sc = fmap.GetFeatFeatScore(fmap.GetFeature(0),FreeChemicalFeature('Aromatic','',Point3D(2.1,0,0)))
self.failUnless(feq(sc,0))
self.assertTrue(feq(sc,0))
def test5ScoreFeats(self):
aFmp = FeatMaps.FeatMapParams()
@@ -140,17 +140,17 @@ class TestCase(unittest.TestCase):
l1 = fmap._loopOverMatchingFeats(FreeChemicalFeature('Aromatic','',Point3D(0,0,0)))
l1 = list(l1)
self.failUnless(len(l1)==1)
self.failUnless(l1[0][0]==0)
self.failUnless(l1[0][1].GetFamily()=='Aromatic')
self.assertTrue(len(l1)==1)
self.assertTrue(l1[0][0]==0)
self.assertTrue(l1[0][1].GetFamily()=='Aromatic')
l1 = fmap._loopOverMatchingFeats(FreeChemicalFeature('Acceptor','',Point3D(0,0,0)))
l1 = list(l1)
self.failUnless(len(l1)==2)
self.failUnless(l1[0][0]==1)
self.failUnless(l1[0][1].GetFamily()=='Acceptor')
self.failUnless(l1[1][0]==2)
self.failUnless(l1[1][1].GetFamily()=='Acceptor')
self.assertTrue(len(l1)==2)
self.assertTrue(l1[0][0]==1)
self.assertTrue(l1[0][1].GetFamily()=='Acceptor')
self.assertTrue(l1[1][0]==2)
self.assertTrue(l1[1][1].GetFamily()=='Acceptor')
def test6ScoreFeats(self):
aFmp = FeatMaps.FeatMapParams()
@@ -180,42 +180,42 @@ class TestCase(unittest.TestCase):
]
sc = fmap.ScoreFeats(fs)
self.failUnless(feq(sc,4.3))
self.assertTrue(feq(sc,4.3))
msv = [-1]*3
fsv = [-1]*2
fsfmi = [None]*2
sc = fmap.ScoreFeats(fs,mapScoreVect=msv,featsScoreVect=fsv,
featsToFeatMapIdx=fsfmi)
self.failUnless(feq(sc,4.3))
self.failUnless(feq(sum(msv),sc))
self.failUnless(feq(sum(fsv),sc))
self.failUnless(fsfmi==[[0],[1,2]])
self.assertTrue(feq(sc,4.3))
self.assertTrue(feq(sum(msv),sc))
self.assertTrue(feq(sum(fsv),sc))
self.assertTrue(fsfmi==[[0],[1,2]])
# make sure we reset the vectors internally:
sc = fmap.ScoreFeats(fs,mapScoreVect=msv,featsScoreVect=fsv,
featsToFeatMapIdx=fsfmi)
self.failUnless(feq(sc,4.3))
self.failUnless(feq(sum(msv),sc))
self.failUnless(feq(sum(fsv),sc))
self.failUnless(fsfmi==[[0],[1,2]])
self.assertTrue(feq(sc,4.3))
self.assertTrue(feq(sum(msv),sc))
self.assertTrue(feq(sum(fsv),sc))
self.assertTrue(fsfmi==[[0],[1,2]])
fmap.scoreMode=FeatMaps.FeatMapScoreMode.Closest
sc = fmap.ScoreFeats(fs,mapScoreVect=msv,featsScoreVect=fsv,
featsToFeatMapIdx=fsfmi)
self.failUnless(feq(sc,2.1))
self.failUnless(feq(sum(msv),sc))
self.failUnless(feq(sum(fsv),sc))
self.failUnless(fsfmi==[[0],[1]])
self.assertTrue(feq(sc,2.1))
self.assertTrue(feq(sum(msv),sc))
self.assertTrue(feq(sum(fsv),sc))
self.assertTrue(fsfmi==[[0],[1]])
fmap.scoreMode=FeatMaps.FeatMapScoreMode.Best
sc = fmap.ScoreFeats(fs,mapScoreVect=msv,featsScoreVect=fsv,
featsToFeatMapIdx=fsfmi)
self.failUnless(feq(sc,3.2))
self.failUnless(feq(sum(msv),sc))
self.failUnless(feq(sum(fsv),sc))
self.failUnless(fsfmi==[[0],[2]])
self.assertTrue(feq(sc,3.2))
self.assertTrue(feq(sum(msv),sc))
self.assertTrue(feq(sum(fsv),sc))
self.assertTrue(fsfmi==[[0],[2]])
def test7ScoreFeats(self):
aFmp = FeatMaps.FeatMapParams()
@@ -244,26 +244,26 @@ class TestCase(unittest.TestCase):
fsfmi = [-1]*2
sc = fmap.ScoreFeats(fs,mapScoreVect=msv,featsScoreVect=fsv,
featsToFeatMapIdx=fsfmi)
self.failUnless(feq(sc,1.1))
self.failUnless(feq(sum(msv),sc))
self.failUnless(feq(sum(fsv),sc))
self.failUnless(fsfmi==[[0],[]])
self.assertTrue(feq(sc,1.1))
self.assertTrue(feq(sum(msv),sc))
self.assertTrue(feq(sum(fsv),sc))
self.assertTrue(fsfmi==[[0],[]])
fmap.scoreMode=FeatMaps.FeatMapScoreMode.Closest
sc = fmap.ScoreFeats(fs,mapScoreVect=msv,featsScoreVect=fsv,
featsToFeatMapIdx=fsfmi)
self.failUnless(feq(sc,1.1))
self.failUnless(feq(sum(msv),sc))
self.failUnless(feq(sum(fsv),sc))
self.failUnless(fsfmi==[[0],[]])
self.assertTrue(feq(sc,1.1))
self.assertTrue(feq(sum(msv),sc))
self.assertTrue(feq(sum(fsv),sc))
self.assertTrue(fsfmi==[[0],[]])
fmap.scoreMode=FeatMaps.FeatMapScoreMode.Best
sc = fmap.ScoreFeats(fs,mapScoreVect=msv,featsScoreVect=fsv,
featsToFeatMapIdx=fsfmi)
self.failUnless(feq(sc,1.1))
self.failUnless(feq(sum(msv),sc))
self.failUnless(feq(sum(fsv),sc))
self.failUnless(fsfmi==[[0],[]])
self.assertTrue(feq(sc,1.1))
self.assertTrue(feq(sum(msv),sc))
self.assertTrue(feq(sum(fsv),sc))
self.assertTrue(fsfmi==[[0],[]])
def test8ScoreFeatDirs(self):
aFmp = FeatMaps.FeatMapParams()
@@ -284,24 +284,24 @@ class TestCase(unittest.TestCase):
fs[0].featDirs=[Point3D(0,1,0)]
sc = fmap.ScoreFeats(fs)
self.failUnless(feq(sc,1.1))
self.assertTrue(feq(sc,1.1))
fs[0].featDirs=[Point3D(0,-1,0)]
sc = fmap.ScoreFeats(fs)
self.failUnless(feq(sc,-1.1))
self.assertTrue(feq(sc,-1.1))
fs[0].featDirs=[Point3D(0,0,1)]
sc = fmap.ScoreFeats(fs)
self.failUnless(feq(sc,0.0))
self.assertTrue(feq(sc,0.0))
fmap.dirScoreMode = FeatMaps.FeatDirScoreMode.DotPosRange
fs[0].featDirs=[Point3D(0,-1,0)]
sc = fmap.ScoreFeats(fs)
self.failUnless(feq(sc,0))
self.assertTrue(feq(sc,0))
fs[0].featDirs=[Point3D(0,1,0)]
sc = fmap.ScoreFeats(fs)
self.failUnless(feq(sc,1.1))
self.assertTrue(feq(sc,1.1))

20
rdkit/Chem/FeatMaps/UnitTestFeatMapParser.py
View File

@@ -43,22 +43,22 @@ EndPoints
p = FeatMapParser.FeatMapParser()
p.SetData(txt)
fm = p.Parse()
self.failUnless(fm.scoreMode==FeatMaps.FeatMapScoreMode.Best)
self.failUnless(fm.dirScoreMode==FeatMaps.FeatDirScoreMode.DotFullRange)
self.failUnless(fm.GetNumFeatures()==3)
self.assertTrue(fm.scoreMode==FeatMaps.FeatMapScoreMode.Best)
self.assertTrue(fm.dirScoreMode==FeatMaps.FeatDirScoreMode.DotFullRange)
self.assertTrue(fm.GetNumFeatures()==3)
feats = fm.GetFeatures()
self.failUnless(feq(feats[0].weight,1.25))
self.failUnless(feq(feats[1].weight,2.0))
self.failUnless(feq(feats[2].weight,1.25))
self.assertTrue(feq(feats[0].weight,1.25))
self.assertTrue(feq(feats[1].weight,2.0))
self.assertTrue(feq(feats[2].weight,1.25))
self.failUnless(len(feats[0].featDirs)==1)
self.failUnless(len(feats[1].featDirs)==2)
self.failUnless(len(feats[2].featDirs)==0)
self.assertTrue(len(feats[0].featDirs)==1)
self.assertTrue(len(feats[1].featDirs)==2)
self.assertTrue(len(feats[2].featDirs)==0)
fams = [x.GetFamily() for x in feats]
self.failUnless(fams==['Acceptor','Aromatic','Acceptor'])
self.assertTrue(fams==['Acceptor','Aromatic','Acceptor'])
if __name__ == '__main__':
unittest.main()

136
rdkit/Chem/FeatMaps/UnitTestFeatMapUtils.py
View File

@@ -40,12 +40,12 @@ EndPoints
self.p.SetData(txt)
fm1 = self.p.Parse()
self.failUnless(fm1.GetNumFeatures()==3)
self.failIf(FeatMapUtils.MergeFeatPoints(fm1))
self.failUnless(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Distance))
self.failUnless(fm1.GetNumFeatures()==2)
self.failUnless(pteq(fm1.GetFeature(0).GetPos(),Point3D(1.05,0,0)))
self.failUnless(pteq(fm1.GetFeature(1).GetPos(),Point3D(3.0,0,0)))
self.assertTrue(fm1.GetNumFeatures()==3)
self.assertFalse(FeatMapUtils.MergeFeatPoints(fm1))
self.assertTrue(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Distance))
self.assertTrue(fm1.GetNumFeatures()==2)
self.assertTrue(pteq(fm1.GetFeature(0).GetPos(),Point3D(1.05,0,0)))
self.assertTrue(pteq(fm1.GetFeature(1).GetPos(),Point3D(3.0,0,0)))
txt = self.paramTxt+"""
BeginPoints
@@ -58,11 +58,11 @@ EndPoints
self.p.SetData(txt)
fm1 = self.p.Parse()
self.failUnless(fm1.GetNumFeatures()==4)
self.failUnless(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Distance))
self.failUnless(fm1.GetNumFeatures()==2)
self.failUnless(pteq(fm1.GetFeature(0).GetPos(),Point3D(1.05,0,0)))
self.failUnless(pteq(fm1.GetFeature(1).GetPos(),Point3D(3.5,0,0)))
self.assertTrue(fm1.GetNumFeatures()==4)
self.assertTrue(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Distance))
self.assertTrue(fm1.GetNumFeatures()==2)
self.assertTrue(pteq(fm1.GetFeature(0).GetPos(),Point3D(1.05,0,0)))
self.assertTrue(pteq(fm1.GetFeature(1).GetPos(),Point3D(3.5,0,0)))
txt = self.paramTxt+"""
BeginPoints
@@ -75,12 +75,12 @@ EndPoints
self.p.SetData(txt)
fm1 = self.p.Parse()
self.failUnless(fm1.GetNumFeatures()==4)
self.failUnless(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Distance))
self.failUnless(fm1.GetNumFeatures()==3)
self.failUnless(pteq(fm1.GetFeature(0).GetPos(),Point3D(1.00,0,0)))
self.failUnless(pteq(fm1.GetFeature(1).GetPos(),Point3D(1.25,0,0)))
self.failUnless(pteq(fm1.GetFeature(2).GetPos(),Point3D(4.0,0,0)))
self.assertTrue(fm1.GetNumFeatures()==4)
self.assertTrue(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Distance))
self.assertTrue(fm1.GetNumFeatures()==3)
self.assertTrue(pteq(fm1.GetFeature(0).GetPos(),Point3D(1.00,0,0)))
self.assertTrue(pteq(fm1.GetFeature(1).GetPos(),Point3D(1.25,0,0)))
self.assertTrue(pteq(fm1.GetFeature(2).GetPos(),Point3D(4.0,0,0)))
txt = self.paramTxt+"""
BeginPoints
@@ -93,33 +93,33 @@ EndPoints
self.p.SetData(txt)
fm1 = self.p.Parse()
self.failUnless(fm1.GetNumFeatures()==4)
self.failUnless(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Distance,
self.assertTrue(fm1.GetNumFeatures()==4)
self.assertTrue(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Distance,
mergeMethod=FeatMapUtils.MergeMethod.Average))
self.failUnless(fm1.GetNumFeatures()==3)
self.failUnless(pteq(fm1.GetFeature(0).GetPos(),Point3D(1.00,0,0)))
self.failUnless(pteq(fm1.GetFeature(1).GetPos(),Point3D(1.25,0,0)))
self.failUnless(pteq(fm1.GetFeature(2).GetPos(),Point3D(4.0,0,0)))
self.assertTrue(fm1.GetNumFeatures()==3)
self.assertTrue(pteq(fm1.GetFeature(0).GetPos(),Point3D(1.00,0,0)))
self.assertTrue(pteq(fm1.GetFeature(1).GetPos(),Point3D(1.25,0,0)))
self.assertTrue(pteq(fm1.GetFeature(2).GetPos(),Point3D(4.0,0,0)))
self.p.SetData(txt)
fm1 = self.p.Parse()
self.failUnless(fm1.GetNumFeatures()==4)
self.failUnless(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Distance,
self.assertTrue(fm1.GetNumFeatures()==4)
self.assertTrue(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Distance,
mergeMethod=FeatMapUtils.MergeMethod.WeightedAverage))
self.failUnless(fm1.GetNumFeatures()==3)
self.failUnless(pteq(fm1.GetFeature(0).GetPos(),Point3D(1.00,0,0)))
self.failUnless(pteq(fm1.GetFeature(1).GetPos(),Point3D(1.225,0,0)))
self.failUnless(pteq(fm1.GetFeature(2).GetPos(),Point3D(4.0,0,0)))
self.assertTrue(fm1.GetNumFeatures()==3)
self.assertTrue(pteq(fm1.GetFeature(0).GetPos(),Point3D(1.00,0,0)))
self.assertTrue(pteq(fm1.GetFeature(1).GetPos(),Point3D(1.225,0,0)))
self.assertTrue(pteq(fm1.GetFeature(2).GetPos(),Point3D(4.0,0,0)))
self.p.SetData(txt)
fm1 = self.p.Parse()
self.failUnless(fm1.GetNumFeatures()==4)
self.failUnless(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Distance,
self.assertTrue(fm1.GetNumFeatures()==4)
self.assertTrue(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Distance,
mergeMethod=FeatMapUtils.MergeMethod.UseLarger))
self.failUnless(fm1.GetNumFeatures()==3)
self.failUnless(pteq(fm1.GetFeature(0).GetPos(),Point3D(1.00,0,0)))
self.failUnless(pteq(fm1.GetFeature(1).GetPos(),Point3D(1.2,0,0)))
self.failUnless(pteq(fm1.GetFeature(2).GetPos(),Point3D(4.0,0,0)))
self.assertTrue(fm1.GetNumFeatures()==3)
self.assertTrue(pteq(fm1.GetFeature(0).GetPos(),Point3D(1.00,0,0)))
self.assertTrue(pteq(fm1.GetFeature(1).GetPos(),Point3D(1.2,0,0)))
self.assertTrue(pteq(fm1.GetFeature(2).GetPos(),Point3D(4.0,0,0)))
def _test1BasicsRepeated(self):
txt = self.paramTxt+"""
@@ -134,24 +134,24 @@ EndPoints
self.p.SetData(txt)
fm1 = self.p.Parse()
self.failUnless(fm1.GetNumFeatures()==5)
self.failUnless(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Distance))
self.failUnless(fm1.GetNumFeatures()==4)
self.failUnless(pteq(fm1.GetFeature(0).GetPos(),Point3D(0.7,0,0)))
self.failUnless(pteq(fm1.GetFeature(1).GetPos(),Point3D(1.0,0,0)))
self.failUnless(pteq(fm1.GetFeature(2).GetPos(),Point3D(1.25,0,0)))
self.failUnless(pteq(fm1.GetFeature(3).GetPos(),Point3D(4.0,0,0)))
self.assertTrue(fm1.GetNumFeatures()==5)
self.assertTrue(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Distance))
self.assertTrue(fm1.GetNumFeatures()==4)
self.assertTrue(pteq(fm1.GetFeature(0).GetPos(),Point3D(0.7,0,0)))
self.assertTrue(pteq(fm1.GetFeature(1).GetPos(),Point3D(1.0,0,0)))
self.assertTrue(pteq(fm1.GetFeature(2).GetPos(),Point3D(1.25,0,0)))
self.assertTrue(pteq(fm1.GetFeature(3).GetPos(),Point3D(4.0,0,0)))
self.failUnless(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Distance))
self.failUnless(fm1.GetNumFeatures()==3)
self.failUnless(pteq(fm1.GetFeature(0).GetPos(),Point3D(0.7,0,0)))
self.failUnless(pteq(fm1.GetFeature(1).GetPos(),Point3D(1.125,0,0)))
self.failUnless(pteq(fm1.GetFeature(2).GetPos(),Point3D(4.0,0,0)))
self.assertTrue(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Distance))
self.assertTrue(fm1.GetNumFeatures()==3)
self.assertTrue(pteq(fm1.GetFeature(0).GetPos(),Point3D(0.7,0,0)))
self.assertTrue(pteq(fm1.GetFeature(1).GetPos(),Point3D(1.125,0,0)))
self.assertTrue(pteq(fm1.GetFeature(2).GetPos(),Point3D(4.0,0,0)))
self.failUnless(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Distance))
self.failUnless(fm1.GetNumFeatures()==2)
self.failUnless(pteq(fm1.GetFeature(0).GetPos(),Point3D(0.9125,0,0)))
self.failUnless(pteq(fm1.GetFeature(1).GetPos(),Point3D(4.0,0,0)))
self.assertTrue(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Distance))
self.assertTrue(fm1.GetNumFeatures()==2)
self.assertTrue(pteq(fm1.GetFeature(0).GetPos(),Point3D(0.9125,0,0)))
self.assertTrue(pteq(fm1.GetFeature(1).GetPos(),Point3D(4.0,0,0)))
def test2ScoreBasics(self):
txt = self.paramTxt+"""
@@ -164,12 +164,12 @@ EndPoints
self.p.SetData(txt)
fm1 = self.p.Parse()
self.failUnless(fm1.GetNumFeatures()==3)
self.failUnless(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Overlap,
self.assertTrue(fm1.GetNumFeatures()==3)
self.assertTrue(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Overlap,
mergeMethod=FeatMapUtils.MergeMethod.Average))
self.failUnless(fm1.GetNumFeatures()==2)
self.failUnless(pteq(fm1.GetFeature(0).GetPos(),Point3D(1.1,0,0)))
self.failUnless(pteq(fm1.GetFeature(1).GetPos(),Point3D(4.0,0,0)))
self.assertTrue(fm1.GetNumFeatures()==2)
self.assertTrue(pteq(fm1.GetFeature(0).GetPos(),Point3D(1.1,0,0)))
self.assertTrue(pteq(fm1.GetFeature(1).GetPos(),Point3D(4.0,0,0)))
txt = self.paramTxt+"""
BeginPoints
@@ -182,13 +182,13 @@ EndPoints
self.p.SetData(txt)
fm1 = self.p.Parse()
self.failUnless(fm1.GetNumFeatures()==4)
self.failUnless(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Overlap,
self.assertTrue(fm1.GetNumFeatures()==4)
self.assertTrue(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Overlap,
mergeMethod=FeatMapUtils.MergeMethod.Average))
self.failUnless(fm1.GetNumFeatures()==3)
self.failUnless(pteq(fm1.GetFeature(0).GetPos(),Point3D(1.15,0,0)))
self.failUnless(pteq(fm1.GetFeature(1).GetPos(),Point3D(1.1,0,0)))
self.failUnless(pteq(fm1.GetFeature(2).GetPos(),Point3D(4.0,0,0)))
self.assertTrue(fm1.GetNumFeatures()==3)
self.assertTrue(pteq(fm1.GetFeature(0).GetPos(),Point3D(1.15,0,0)))
self.assertTrue(pteq(fm1.GetFeature(1).GetPos(),Point3D(1.1,0,0)))
self.assertTrue(pteq(fm1.GetFeature(2).GetPos(),Point3D(4.0,0,0)))
txt = self.paramTxt+"""
BeginPoints
@@ -201,13 +201,13 @@ EndPoints
self.p.SetData(txt)
fm1 = self.p.Parse()
self.failUnless(fm1.GetNumFeatures()==4)
self.failUnless(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Overlap,
self.assertTrue(fm1.GetNumFeatures()==4)
self.assertTrue(FeatMapUtils.MergeFeatPoints(fm1,FeatMapUtils.MergeMetric.Overlap,
mergeMethod=FeatMapUtils.MergeMethod.Average))
self.failUnless(fm1.GetNumFeatures()==3)
self.failUnless(pteq(fm1.GetFeature(0).GetPos(),Point3D(1.0,0,0)))
self.failUnless(pteq(fm1.GetFeature(1).GetPos(),Point3D(1.4,0,0)))
self.failUnless(pteq(fm1.GetFeature(2).GetPos(),Point3D(4.0,0,0)))
self.assertTrue(fm1.GetNumFeatures()==3)
self.assertTrue(pteq(fm1.GetFeature(0).GetPos(),Point3D(1.0,0,0)))
self.assertTrue(pteq(fm1.GetFeature(1).GetPos(),Point3D(1.4,0,0)))
self.assertTrue(pteq(fm1.GetFeature(2).GetPos(),Point3D(4.0,0,0)))

7
rdkit/Chem/Fingerprints/DbFpSupplier.py
View File

@@ -15,7 +15,7 @@
from rdkit import RDConfig
from rdkit.VLib.Node import VLibNode
from rdkit import DataStructs
import cPickle
from rdkit.six.moves import cPickle
import sys
def warning(msg,dest=sys.stderr):
dest.write(msg)
@@ -38,7 +38,7 @@ class DbFpSupplier(VLibNode):
self._fpColName = fpColName.upper()
self._colNames = [x.upper() for x in self._data.GetColumnNames()]
if self._fpColName not in self._colNames:
raise ValueError,'fp column name "%s" not found in result set: %s'%(self._fpColName,str(self._colNames))
raise ValueError('fp column name "%s" not found in result set: %s'%(self._fpColName,str(self._colNames)))
self.fpCol = self._colNames.index(self._fpColName)
del self._colNames[self.fpCol]
self._colNames = tuple(self._colNames)
@@ -71,6 +71,9 @@ class DbFpSupplier(VLibNode):
if itm is None:
raise StopIteration
return itm
__next__ = next # py3
class ForwardDbFpSupplier(DbFpSupplier):
""" DbFp supplier supporting only forward iteration

13
rdkit/Chem/Fingerprints/SimilarityScreener.py
View File

@@ -16,6 +16,7 @@ See _SimilarityScreener_ for overview of required API
from rdkit import DataStructs
from rdkit.DataStructs import TopNContainer
from rdkit import RDConfig
from rdkit import six
class SimilarityScreener(object):
""" base class
@@ -95,7 +96,7 @@ class ThresholdScreener(SimilarityScreener):
while not done:
# this is going to crap out when the data source iterator finishes,
# that's how we stop when no match is found
obj = self.dataIter.next()
obj = six.next(self.dataIter)
fp = self.fingerprinter(obj)
sim = DataStructs.FingerprintSimilarity(fp,self.probe,self.metric)
if sim >= self.threshold:
@@ -109,15 +110,20 @@ class ThresholdScreener(SimilarityScreener):
"""
self.dataSource.reset()
self.dataIter = iter(self.dataSource)
def __iter__(self):
""" returns an iterator for this screener
"""
self.Reset()
return self
def next(self):
""" required part of iterator interface """
return self._nextMatch()
__next__ = next
class TopNScreener(SimilarityScreener):
""" A screener that only returns the top N hits found
@@ -139,6 +145,7 @@ class TopNScreener(SimilarityScreener):
self._initTopN()
self.Reset()
return self
def next(self):
if self._pos >= self.numToGet:
raise StopIteration
@@ -146,7 +153,9 @@ class TopNScreener(SimilarityScreener):
res = self.topN[self._pos]
self._pos += 1
return res
__next__ = next
def _initTopN(self):
self.topN = TopNContainer.TopNContainer(self.numToGet)
for obj in self.dataSource:

12
rdkit/Chem/Fraggle/FraggleSim.py
View File

@@ -67,14 +67,14 @@ def delete_bonds(mol,bonds,ftype,hac):
for b in bonds:
#remove the bond
em.RemoveBond(b[0],b[1])
em.RemoveBond(b[0],b[1])
#now add attachement points
newAtomA = em.AddAtom(Chem.Atom(0))
em.AddBond(b[0],newAtomA,Chem.BondType.SINGLE)
#now add attachement points
newAtomA = em.AddAtom(Chem.Atom(0))
em.AddBond(b[0],newAtomA,Chem.BondType.SINGLE)
newAtomB = em.AddAtom(Chem.Atom(0))
em.AddBond(b[1],newAtomB,Chem.BondType.SINGLE)
newAtomB = em.AddAtom(Chem.Atom(0))
em.AddBond(b[1],newAtomB,Chem.BondType.SINGLE)
#should be able to get away without sanitising mol
#as the valencies should be okay

7
rdkit/Chem/Fraggle/UnitTestFraggle.py
View File

@@ -7,7 +7,8 @@
# of the RDKit source tree.
#
from rdkit import RDConfig
import unittest,cPickle,os
import unittest,os
from rdkit.six.moves import cPickle
from rdkit import Chem
from rdkit.Chem.Fraggle import FraggleSim
@@ -18,7 +19,7 @@ class TestCase(unittest.TestCase):
"""
mol = Chem.MolFromSmiles('COc1cc(CN2CCC(CC2)NC(=O)c2cncc(C)c2)c(OC)c2ccccc12')
frags = FraggleSim.generate_fraggle_fragmentation(mol)
self.failUnlessEqual(len(frags),16)
self.assertEqual(len(frags),16)
expected=('[*]C(=O)NC1CCN(Cc2cc(OC)c3ccccc3c2OC)CC1',
'[*]C(=O)c1cncc(C)c1.[*]C1CCN(Cc2cc(OC)c3ccccc3c2OC)CC1',
@@ -37,7 +38,7 @@ class TestCase(unittest.TestCase):
'[*]c1cncc(C)c1.[*]C1CCN(Cc2cc(OC)c3ccccc3c2OC)CC1',
'[*]c1cncc(C)c1.[*]c1cc(OC)c2ccccc2c1OC')
for smi in frags:
self.failUnless(smi in expected)
self.assertTrue(smi in expected)
if __name__ == '__main__':
unittest.main()

5
rdkit/Chem/FragmentCatalog.py
View File

@@ -8,10 +8,11 @@
# which is included in the file license.txt, found at the root
# of the RDKit source tree.
#
from rdkit import Chem
from rdfragcatalog import *
import sys
from rdkit import Chem
from rdkit.Chem.rdfragcatalog import *
def message(msg,dest=sys.stdout):
dest.write(msg)

2
rdkit/Chem/Fragments.py
View File

@@ -47,7 +47,7 @@ def _LoadPatterns(fileName=None):
ok=0
else:
if not patt or patt.GetNumAtoms()==0: ok=0
if not ok: raise ImportError,'Smarts %s could not be parsed'%(repr(sma))
if not ok: raise ImportError('Smarts %s could not be parsed'%(repr(sma)))
fn = lambda mol,countUnique=True,pattern=patt:_CountMatches(mol,pattern,unique=countUnique)
fn.__doc__ = descr
name = name.replace('=','_')

21
rdkit/Chem/FunctionalGroups.py
View File

@@ -31,8 +31,9 @@
#
# Created by Greg Landrum, October 2006
#
import os,weakref,re
from rdkit.six.moves import cStringIO as StringIO
from rdkit import RDConfig
import os,weakref,cStringIO,re
class FGHierarchyNode(object):
children=None
@@ -79,12 +80,12 @@ def BuildFuncGroupHierarchy(fileNm=None,data=None,force=False):
fileNm = os.path.join(RDConfig.RDDataDir,'Functional_Group_Hierarchy.txt')
if fileNm:
inF = file(fileNm,'r')
inF = open(fileNm,'r')
lastFilename = fileNm
elif data:
inF = cStringIO.StringIO(data)
inF = StringIO(data)
else:
raise ValueError,"need data or filename"
raise ValueError("need data or filename")
groupDefns={}
res = []
@@ -97,16 +98,16 @@ def BuildFuncGroupHierarchy(fileNm=None,data=None,force=False):
continue
splitL = splitter.split(line)
if len(splitL)<3:
raise FuncGroupFileParseError,"Input line %d (%s) is not long enough."%(lineNo,repr(line))
raise FuncGroupFileParseError("Input line %d (%s) is not long enough."%(lineNo,repr(line)))
label = splitL[0].strip()
if groupDefns.has_key(label):
raise FuncGroupFileParseError,"Duplicate label on line %d."%lineNo
if label in groupDefns:
raise FuncGroupFileParseError("Duplicate label on line %d."%lineNo)
labelHierarchy = label.split('.')
if len(labelHierarchy)>1:
for i in range(len(labelHierarchy)-1):
tmp = '.'.join(labelHierarchy[:i+1])
if not groupDefns.has_key(tmp):
raise FuncGroupFileParseError,"Hierarchy member %s (line %d) not found."%(tmp,lineNo)
if not tmp in groupDefns:
raise FuncGroupFileParseError("Hierarchy member %s (line %d) not found."%(tmp,lineNo))
parent = groupDefns['.'.join(labelHierarchy[:-1])]
else:
parent = None
@@ -118,7 +119,7 @@ def BuildFuncGroupHierarchy(fileNm=None,data=None,force=False):
traceback.print_exc()
patt = None
if not patt:
raise FuncGroupFileParseError,'Smarts "%s" (line %d) could not be parsed.'%(smarts,lineNo)
raise FuncGroupFileParseError('Smarts "%s" (line %d) could not be parsed.'%(smarts,lineNo))
name = splitL[2].strip()

7
rdkit/Chem/GraphDescriptors.py
View File

@@ -13,6 +13,7 @@
"""
from __future__ import print_function
from rdkit import Chem
from rdkit.Chem import Graphs
from rdkit.Chem import rdchem
@@ -82,7 +83,7 @@ def _pyHallKierAlpha(m):
else:
rA = PeriodicTable.nameTable[symb][5]
alpha = rA/rC - 1
print atom.GetIdx(),atom.GetSymbol(),alpha
print(atom.GetIdx(),atom.GetSymbol(),alpha)
alphaSum += alpha
return alphaSum
#HallKierAlpha.version="1.0.2"
@@ -617,7 +618,7 @@ def BertzCT(mol, cutoff = 100, dMat = None, forceDMat = 1):
bondDict, neighborList, vdList = _CreateBondDictEtc(mol, numAtoms)
symmetryClasses = _AssignSymmetryClasses(mol, vdList, dMat, forceDMat, numAtoms, cutoff)
#print 'Symmm Classes:',symmetryClasses
#print('Symmm Classes:',symmetryClasses)
for atomIdx in range(numAtoms):
hingeAtomNumber = mol.GetAtomWithIdx(atomIdx).GetAtomicNum()
atomTypeDict[hingeAtomNumber] = atomTypeDict.get(hingeAtomNumber,0)+1
@@ -628,7 +629,7 @@ def BertzCT(mol, cutoff = 100, dMat = None, forceDMat = 1):
neighbor_iIdx = neighborList[atomIdx][i]
NiClass = symmetryClasses[neighbor_iIdx]
bond_i_order = _LookUpBondOrder(atomIdx, neighbor_iIdx, bondDict)
#print '\t',atomIdx,i,hingeAtomClass,NiClass,bond_i_order
#print('\t',atomIdx,i,hingeAtomClass,NiClass,bond_i_order)
if (bond_i_order > 1) and (neighbor_iIdx > atomIdx):
numConnections = bond_i_order*(bond_i_order - 1)/2
connectionKey = (min(hingeAtomClass, NiClass), max(hingeAtomClass, NiClass))

1
rdkit/Chem/Graphs.py
View File

@@ -17,6 +17,7 @@ C/C++ codebase.
import numpy
from rdkit import Chem
from rdkit import DataStructs
from rdkit.six.moves import xrange
import types
def CharacteristicPolynomial(mol,mat=None):

3
rdkit/Chem/MACCSkeys.py
View File

@@ -30,6 +30,7 @@ Rev history:
May 2011 (gl): Update some definitions based on feedback from Andrew Dalke
"""
from __future__ import print_function
from rdkit import Chem
from rdkit.Chem import rdMolDescriptors
from rdkit import DataStructs
@@ -221,7 +222,7 @@ def _InitKeys(keyList,keyDict):
except:
sma = None
if not sma:
print 'SMARTS parser error for key #%d: %s'%(key,patt)
print('SMARTS parser error for key #%d: %s'%(key,patt))
else:
keyList[key-1] = sma,count

2
rdkit/Chem/MolCatalog.py
View File

@@ -2,7 +2,7 @@
#
# Copyright (C) 2006 Greg Landrum
#
from rdMolCatalog import *
from rdkit.Chem.rdMolCatalog import *

10
rdkit/Chem/MolDb/FingerprintUtils.py
View File

@@ -3,7 +3,9 @@
# Copyright (C) 2009 Greg Landrum
# All Rights Reserved
#
import cPickle
from __future__ import print_function
from rdkit.six.moves import cPickle
from rdkit.six import iterkeys
from rdkit import DataStructs,Chem
from rdkit import Chem
@@ -14,7 +16,7 @@ similarityMethods={'RDK':DataStructs.ExplicitBitVect,
'Gobbi2D':DataStructs.SparseBitVect,
'Morgan':DataStructs.UIntSparseIntVect
}
supportedSimilarityMethods=similarityMethods.keys()
supportedSimilarityMethods=list(iterkeys(similarityMethods))
class LayeredOptions:
@@ -59,7 +61,7 @@ def BuildSigFactory(options=None,fdefFile=None,
if options:
fdefFile = options.fdefFile
if not fdefFile:
raise ValueError,'bad fdef file'
raise ValueError('bad fdef file')
from rdkit.Chem import ChemicalFeatures
from rdkit.Chem.Pharm2D import SigFactory
featFactory = ChemicalFeatures.BuildFeatureFactory(fdefFile)
@@ -88,7 +90,7 @@ def BuildPharm2DFP(mol):
try:
fp=Generate.Gen2DFingerprint(mol,sigFactory)
except IndexError:
print 'FAIL:',Chem.MolToSmiles(mol,True)
print('FAIL:',Chem.MolToSmiles(mol,True))
raise
return fp
def BuildMorganFP(mol):

4
rdkit/Chem/MolDb/Loader.py
View File

@@ -10,6 +10,6 @@
try:
import sqlalchemy
except ImportError:
from Loader_orig import *
from rdkit.Chem.MolDb.Loader_orig import *
else:
from Loader_sa import *
from rdkit.Chem.MolDb.Loader_sa import *

2
rdkit/Chem/MolDb/Loader_orig.py
View File

@@ -25,7 +25,7 @@ def ProcessMol(mol,typeConversions,globalProps,nDone,nameProp='_Name',nameCol='c
skipSmiles=False,
uniqNames=None,namesSeen=None):
if not mol:
raise ValueError,'no molecule'
raise ValueError('no molecule')
if keepHs:
Chem.SanitizeMol(mol)
try:

23
rdkit/Chem/MolSurf.py
View File

@@ -14,6 +14,7 @@ descriptors.
The MOE-like VSA descriptors are also calculated here
"""
from __future__ import print_function
from rdkit import Chem
from rdkit.Chem.PeriodicTable import numTable
from rdkit.Chem import Crippen
@@ -185,8 +186,8 @@ def pyPEOE_VSA_(mol,bins=None,force=1):
return res
if bins is None: bins = chgBins
Crippen._Init()
#print '\ts:',repr(mol.GetMol())
#print '\t\t:',len(mol.GetAtoms())
#print('\ts:',repr(mol.GetMol()))
#print('\t\t:',len(mol.GetAtoms()))
rdPartialCharges.ComputeGasteigerCharges(mol)
#propContribs = [float(x.GetProp('_GasteigerCharge')) for x in mol.GetAtoms()]
@@ -378,7 +379,7 @@ def _pyTPSAContribs(mol,verbose=False):
tmp = 30.5 - numNeighbors * 8.2 + nHs * 1.5
if tmp < 0.0: tmp = 0.0
elif atNum==8:
#print nHs,nSing,chg
#print(nHs,nSing,chg)
if numNeighbors == 1:
if nHs==0 and nDoub==1 and chg==0: tmp = 17.07
elif nHs==1 and nSing==1 and chg==0: tmp = 20.23
@@ -393,7 +394,7 @@ def _pyTPSAContribs(mol,verbose=False):
tmp = 28.5 - numNeighbors * 8.6 + nHs * 1.5
if tmp < 0.0: tmp = 0.0
if verbose:
print '\t',atom.GetIdx(),atom.GetSymbol(),atNum,nHs,nSing,nDoub,nTrip,nArom,chg,tmp
print('\t',atom.GetIdx(),atom.GetSymbol(),atNum,nHs,nSing,nDoub,nTrip,nArom,chg,tmp)
res[atom.GetIdx()] = tmp
return res
@@ -426,11 +427,11 @@ if __name__ == '__main__':
smis = ['C(=O)O','c1ccccc1']
for smi in smis:
m = Chem.MolFromSmiles(smi)
#print smi, LabuteASA(m);
print '-----------\n',smi
#print 'M:',['% 4.2f'%x for x in SMR_VSA_(m)]
#print 'L:',['% 4.2f'%x for x in SlogP_VSA_(m)]
print 'P:',['% 4.2f'%x for x in PEOE_VSA_(m)]
print 'P:',['% 4.2f'%x for x in PEOE_VSA_(m)]
print
#print(smi, LabuteASA(m))
print('-----------\n',smi)
#print('M:',['% 4.2f'%x for x in SMR_VSA_(m)])
#print('L:',['% 4.2f'%x for x in SlogP_VSA_(m)])
print('P:',['% 4.2f'%x for x in PEOE_VSA_(m)])
print('P:',['% 4.2f'%x for x in PEOE_VSA_(m)])
print()

13
rdkit/Chem/PandasTools.py
View File

@@ -76,13 +76,15 @@ This can be reverted using the ChangeMoleculeRendering method
>>> print molX # doctest: +SKIP
<img src="data:image/png;base64,..." alt="Mol"/>
'''
from __future__ import print_function
from base64 import b64encode
import types
from rdkit.six.moves import cStringIO as StringIO
from rdkit import Chem
from rdkit.Chem import Draw
from base64 import b64encode
from StringIO import StringIO
import types
try:
import pandas as pd
v = pd.version.version.split('.')
@@ -300,11 +302,12 @@ def AlignToScaffold(frame, molCol='ROMol', scaffoldCol='Murcko_SMILES'):
if __name__ == "__main__":
import sys
if pd is None:
print >>sys.stderr,"pandas installation not found, skipping tests"
print("pandas installation not found, skipping tests", file=sys.stderr)
else:
v = pd.version.version.split('.')
if v[0]=='0' and int(v[1])<10:
print >>sys.stderr,"pandas installation >=0.10 not found, skipping tests"
print("pandas installation >=0.10 not found, skipping tests",
file=sys.stderr)
else:
import doctest
failed,tried=doctest.testmod(optionflags=doctest.ELLIPSIS+doctest.NORMALIZE_WHITESPACE)

17
rdkit/Chem/Pharm2D/Generate.py
View File

@@ -33,6 +33,7 @@
numbering
"""
from __future__ import print_function
from rdkit.Chem.Pharm2D import Utils,SigFactory
from rdkit.RDLogger import logger
logger = logger()
@@ -44,7 +45,7 @@ def _ShortestPathsMatch(match,featureSet,sig,dMat,sigFactory):
"""
if _verbose:
print 'match:',match
print('match:',match)
nPts = len(match)
distsToCheck = Utils.nPointDistDict[nPts]
nDists = len(distsToCheck)
@@ -68,7 +69,7 @@ def _ShortestPathsMatch(match,featureSet,sig,dMat,sigFactory):
idx = sigFactory.GetBitIdx(featureSet,dist,sortIndices=False)
if _verbose:
print '\t',dist,minD,maxD,idx
print('\t',dist,minD,maxD,idx)
if sigFactory.useCounts:
sig[idx] = sig[idx]+1
@@ -95,10 +96,10 @@ def Gen2DFingerprint(mol,sigFactory,perms=None,dMat=None):
"""
if not isinstance(sigFactory,SigFactory.SigFactory):
raise ValueError,'bad factory'
raise ValueError('bad factory')
featFamilies=sigFactory.GetFeatFamilies()
if _verbose:
print '* feat famillies:',featFamilies
print('* feat famillies:',featFamilies)
nFeats = len(featFamilies)
minCount = sigFactory.minPointCount
maxCount = sigFactory.maxPointCount
@@ -121,7 +122,7 @@ def Gen2DFingerprint(mol,sigFactory,perms=None,dMat=None):
# generate the matches:
featMatches = sigFactory.GetMolFeats(mol)
if _verbose:
print ' featMatches:',featMatches
print(' featMatches:',featMatches)
sig = sigFactory.GetSignature()
for perm in perms:
@@ -138,8 +139,8 @@ def Gen2DFingerprint(mol,sigFactory,perms=None,dMat=None):
# the proto-pharmacophore.
matchPerms = [featMatches[x] for x in perm]
if _verbose:
print '\n->Perm: %s'%(str(perm))
print ' matchPerms: %s'%(str(matchPerms))
print('\n->Perm: %s'%(str(perm)))
print(' matchPerms: %s'%(str(matchPerms)))
# Get all unique combinations of those possible matches:
matchesToMap=Utils.GetUniqueCombinations(matchPerms,featClasses)
@@ -147,7 +148,7 @@ def Gen2DFingerprint(mol,sigFactory,perms=None,dMat=None):
entry = [x[1] for x in entry]
matchesToMap[i]=entry
if _verbose:
print ' mtM:',matchesToMap
print(' mtM:',matchesToMap)
for match in matchesToMap:
if sigFactory.shortestPathsOnly:

Some files were not shown because too many files have changed in this diff Show More