Python 2/3 compatibility in single code base, plus python 3 testing on travis.

wrappers/python/tests/TestNumpyCompatibility.py

 import unittest
-import numpy as np
-
 from simtk.openmm import app
 import simtk.openmm as mm
 from simtk import unit
+try:
+    import numpy as np
+    NUMPY_IMPORT_FAILED = False
+except ImportError:
+    NUMPY_IMPORT_FAILED = True
+
 
+@unittest.skipIf(NUMPY_IMPORT_FAILED, 'Numpy is not installed')
 class TestNumpyCompatibility(unittest.TestCase):
-    
+
     def setUp(self):
         prmtop = app.AmberPrmtopFile('systems/water-box-216.prmtop')
-    
-        system = prmtop.createSystem(nonbondedMethod=app.PME, 
+
+        system = prmtop.createSystem(nonbondedMethod=app.PME,
                                          nonbondedCutoff=0.9*unit.nanometers,
-                                         constraints=app.HBonds, rigidWater=True, 
+                                         constraints=app.HBonds, rigidWater=True,
                                          ewaldErrorTolerance=0.0005)
-        integrator = mm.LangevinIntegrator(300*unit.kelvin, 1.0/unit.picoseconds, 
+        integrator = mm.LangevinIntegrator(300*unit.kelvin, 1.0/unit.picoseconds,
                                            2.0*unit.femtoseconds)
         self.simulation = app.Simulation(prmtop.topology, system, integrator,
                                     mm.Platform.getPlatformByName('Reference'))
-    
-    
+
+
     def test_setPositions(self):
         n_particles = self.simulation.context.getSystem().getNumParticles()
         input = np.random.randn(n_particles, 3)
         self.simulation.context.setPositions(input)
         output = self.simulation.context.getState(getPositions=True).getPositions(asNumpy=True)
-    
+
         np.testing.assert_array_almost_equal(input, output)
-    
+
     def test_setPositions_units(self):
         n_particles = self.simulation.context.getSystem().getNumParticles()
         input = unit.Quantity(np.random.randn(n_particles, 3), unit.angstroms)
         self.simulation.context.setPositions(input)
         output = self.simulation.context.getState(getPositions=True).getPositions(asNumpy=True)
-    
+
         np.testing.assert_array_almost_equal(input.value_in_unit(unit.nanometers), output.value_in_unit(unit.nanometers))
-    
-    
+
+
     def test_setVelocities(self):
         n_particles = self.simulation.context.getSystem().getNumParticles()
         input = np.random.randn(n_particles, 3)
         self.simulation.context.setVelocities(input)
         output = self.simulation.context.getState(getVelocities=True).getVelocities(asNumpy=True)
-    
+
         np.testing.assert_array_almost_equal(input, output)
-    
+
     def test_setVelocities_units(self):
         n_particles = self.simulation.context.getSystem().getNumParticles()
         input = unit.Quantity(np.random.randn(n_particles, 3), unit.angstroms / unit.femtoseconds)
         self.simulation.context.setVelocities(input)
         output = self.simulation.context.getState(getVelocities=True).getVelocities(asNumpy=True)
-    
+
         np.testing.assert_array_almost_equal(input.value_in_unit(unit.angstroms / unit.femtoseconds),
                                              output.value_in_unit(unit.angstroms / unit.femtoseconds))
-    
-    
+
+
     def test_tabulatedFunction(self):
         f = mm.CustomNonbondedForce('g(r)')
-    
+
         r = np.linspace(0,10)
         g_of_r = np.sin(r)
-    
-        indx = f.addFunction('g', g_of_r, np.min(r), np.max(r)) 
-    
+
+        indx = f.addFunction('g', g_of_r, np.min(r), np.max(r))
+
         name, g_of_r_out, min_r_out, max_r_out = f.getFunctionParameters(indx)
-    
+
         np.testing.assert_array_almost_equal(g_of_r, np.asarray(g_of_r_out))
         assert min_r_out == np.min(r)
         assert max_r_out == np.max(r)
-    
+
     def test_CMAP(self):
         f = mm.CMAPTorsionForce()
         energy = np.random.randn(10*10)
@@ -76,10 +81,12 @@ class TestNumpyCompatibility(unittest.TestCase):
         size, energy_out = f.getMapParameters(0)
         energy_out = energy_out.value_in_unit_system(unit.md_unit_system)
 
-    
+
         self.assertEqual(size, 10)
         np.testing.assert_array_almost_equal(energy, np.asarray(energy_out))
 
+
+@unittest.skipIf(NUMPY_IMPORT_FAILED, 'Numpy is not installed')
 class TestNumpyUnits(unittest.TestCase):
 
     def setUp(self):

wrappers/python/tests/TestPdbFile.py

+import sys
 import unittest
 from simtk.openmm.app import *
 from simtk.openmm import *
 from simtk.unit import *
 import simtk.openmm.app.element as elem
-import cStringIO
+if sys.version_info >= (3, 0):
+    from io import StringIO
+else:
+    from cStringIO import StringIO
+
 
 class TestPdbFile(unittest.TestCase):
     """Test the PDB file parser"""
- 
+
     def test_Triclinic(self):
         """Test parsing a file that describes a triclinic box."""
         pdb = PDBFile('systems/triclinic.pdb')
@@ -43,9 +48,9 @@ class TestPdbFile(unittest.TestCase):
     def test_WriteFile(self):
         """Write a file, read it back, and make sure it matches the original."""
         pdb1 = PDBFile('systems/triclinic.pdb')
-        output = cStringIO.StringIO()
+        output = StringIO()
         PDBFile.writeFile(pdb1.topology, pdb1.positions, output)
-        input = cStringIO.StringIO(output.getvalue())
+        input = StringIO(output.getvalue())
         pdb2 = PDBFile(input)
         output.close();
         input.close();

wrappers/python/tests/TestPdbxFile.py

@@ -70,6 +70,7 @@ class TestPdbxFile(unittest.TestCase):
         # There should only be 10 frames (0 through 9)
         self.assertRaises(IndexError, lambda: pdb.getPositions(frame=10))
         self.assertIs(pdb.topology.getPeriodicBoxVectors(), None)
+        del sim
         os.unlink('test.cif')
 
     def assertAlmostEqualVec(self, vec1, vec2, *args, **kwargs):
@@ -111,6 +112,7 @@ class TestPdbxFile(unittest.TestCase):
         self.assertAlmostEqualVec(parm.topology.getPeriodicBoxVectors()[2],
                                   pdb.topology.getPeriodicBoxVectors()[2],
                                   places=5)
+        del sim
         os.unlink('test.cif')
 
 if __name__ == '__main__':