myokit 1.33.9__py3-none-any.whl → 1.35.0__py3-none-any.whl

myokit/tests/test_component.py

@@ -5,20 +5,10 @@
 # This file is part of Myokit.
 # See http://myokit.org for copyright, sharing, and licensing details.
 #
-from __future__ import absolute_import, division
-from __future__ import print_function, unicode_literals
-
 import myokit
 import unittest
 
 
-# Unit testing in Python 2 and 3
-try:
-    unittest.TestCase.assertRaisesRegex
-except AttributeError:
-    unittest.TestCase.assertRaisesRegex = unittest.TestCase.assertRaisesRegexp
-
-
 class VarOwnerTest(unittest.TestCase):
     """
     Tests parts of :class:`myokit.VarOwner`.
@@ -58,7 +48,7 @@ class VarOwnerTest(unittest.TestCase):
                 myokit.Name(y)
             )
         ))
-        x.set_state_value(10)
+        x.set_initial_value(10)
         y.set_rhs(myokit.Plus(
             myokit.Multiply(
                 myokit.PrefixMinus(myokit.Name(c)), myokit.Name(y)
@@ -67,7 +57,7 @@ class VarOwnerTest(unittest.TestCase):
                 myokit.Multiply(myokit.Name(d), myokit.Name(x)), myokit.Name(y)
             )
         ))
-        y.set_state_value(5)
+        y.set_initial_value(5)
         Z = m.add_component('Z')
         t = Z.add_variable('total')
         t.set_rhs(myokit.Plus(myokit.Name(x), myokit.Name(y)))
@@ -117,92 +107,92 @@ class VarOwnerTest(unittest.TestCase):
         m = myokit.Model('LotkaVolterra')
 
         # Add a variable 'a'
-        X = m.add_component('X')
+        z = m.add_component('z')
 
         # Simplest case
-        a = X.add_variable('a')
-        self.assertEqual(X.count_variables(), 1)
-        X.remove_variable(a)
-        self.assertEqual(X.count_variables(), 0)
-        self.assertRaises(Exception, X.remove_variable, a)
+        a = z.add_variable('a')
+        self.assertEqual(z.count_variables(), 1)
+        z.remove_variable(a)
+        self.assertEqual(z.count_variables(), 0)
+        self.assertRaises(Exception, z.remove_variable, a)
 
         # Test re-adding
-        a = X.add_variable('a')
+        a = z.add_variable('a')
         a.set_rhs(myokit.Number(5))
-        self.assertEqual(X.count_variables(), 1)
+        self.assertEqual(z.count_variables(), 1)
 
         # Test deleting dependent variables
-        b = X.add_variable('b')
-        self.assertEqual(X.count_variables(), 2)
+        b = z.add_variable('b')
+        self.assertEqual(z.count_variables(), 2)
         b.set_rhs(myokit.Plus(myokit.Number(3), myokit.Name(a)))
 
         # Test blocking of removal
-        self.assertRaises(myokit.IntegrityError, X.remove_variable, a)
-        self.assertEqual(X.count_variables(), 2)
+        self.assertRaises(myokit.IntegrityError, z.remove_variable, a)
+        self.assertEqual(z.count_variables(), 2)
 
         # Test removal in the right order
-        X.remove_variable(b)
-        self.assertEqual(X.count_variables(), 1)
-        X.remove_variable(a)
-        self.assertEqual(X.count_variables(), 0)
+        z.remove_variable(b)
+        self.assertEqual(z.count_variables(), 1)
+        z.remove_variable(a)
+        self.assertEqual(z.count_variables(), 0)
 
         # Test reference to current state variable values
-        a = X.add_variable('a')
+        a = z.add_variable('a')
         a.set_rhs(myokit.Number(5))
         a.promote()
-        b = X.add_variable('b')
+        b = z.add_variable('b')
         b.set_rhs(myokit.Plus(myokit.Number(3), myokit.Name(a)))
-        self.assertRaises(myokit.IntegrityError, X.remove_variable, a)
-        X.remove_variable(b)
-        X.remove_variable(a)
-        self.assertEqual(X.count_variables(), 0)
+        self.assertRaises(myokit.IntegrityError, z.remove_variable, a)
+        z.remove_variable(b)
+        z.remove_variable(a)
+        self.assertEqual(z.count_variables(), 0)
 
         # Test reference to current state variable values with "self"-ref
-        a = X.add_variable('a')
+        a = z.add_variable('a')
         a.promote()
         a.set_rhs(myokit.Name(a))
-        X.remove_variable(a)
+        z.remove_variable(a)
 
         # Test it doesn't interfere with normal workings
-        a = X.add_variable('a')
+        a = z.add_variable('a')
         a.promote()
         a.set_rhs(myokit.Name(a))
-        b = X.add_variable('b')
+        b = z.add_variable('b')
         b.set_rhs(myokit.Name(a))
-        self.assertRaises(myokit.IntegrityError, X.remove_variable, a)
-        X.remove_variable(b)
-        X.remove_variable(a)
+        self.assertRaises(myokit.IntegrityError, z.remove_variable, a)
+        z.remove_variable(b)
+        z.remove_variable(a)
 
         # Test reference to dot
-        a = X.add_variable('a')
+        a = z.add_variable('a')
         a.set_rhs(myokit.Number(5))
         a.promote()
-        b = X.add_variable('b')
+        b = z.add_variable('b')
         b.set_rhs(myokit.Derivative(myokit.Name(a)))
-        self.assertRaises(myokit.IntegrityError, X.remove_variable, a)
-        X.remove_variable(b)
-        X.remove_variable(a)
+        self.assertRaises(myokit.IntegrityError, z.remove_variable, a)
+        z.remove_variable(b)
+        z.remove_variable(a)
 
         # Test if orphaned
         self.assertIsNone(b.parent())
 
         # Test deleting variable with nested variables
-        a = X.add_variable('a')
+        a = z.add_variable('a')
         b = a.add_variable('b')
         b.set_rhs(myokit.Plus(myokit.Number(2), myokit.Number(2)))
         a.set_rhs(myokit.Multiply(myokit.Number(3), myokit.Name(b)))
-        self.assertRaises(myokit.IntegrityError, X.remove_variable, a)
+        self.assertRaises(myokit.IntegrityError, z.remove_variable, a)
         self.assertEqual(a.count_variables(), 1)
-        self.assertEqual(X.count_variables(), 1)
+        self.assertEqual(z.count_variables(), 1)
 
         # Test recursive deleting
-        X.remove_variable(a, recursive=True)
+        z.remove_variable(a, recursive=True)
         self.assertEqual(a.count_variables(), 0)
-        self.assertEqual(X.count_variables(), 0)
+        self.assertEqual(z.count_variables(), 0)
 
         # Test deleting variable with nested variables that depend on each
         # other
-        a = X.add_variable('a')
+        a = z.add_variable('a')
         b = a.add_variable('b')
         c = a.add_variable('c')
         d = a.add_variable('d')
@@ -211,12 +201,12 @@ class VarOwnerTest(unittest.TestCase):
         b.set_rhs('2 * a - d')
         c.set_rhs('a + b + d')
         d.set_rhs('3 * a')
-        self.assertRaises(myokit.IntegrityError, X.remove_variable, a)
+        self.assertRaises(myokit.IntegrityError, z.remove_variable, a)
         self.assertEqual(a.count_variables(), 3)
-        self.assertEqual(X.count_variables(), 1)
-        X.remove_variable(a, recursive=True)
+        self.assertEqual(z.count_variables(), 1)
+        z.remove_variable(a, recursive=True)
         self.assertEqual(a.count_variables(), 0)
-        self.assertEqual(X.count_variables(), 0)
+        self.assertEqual(z.count_variables(), 0)
 
         # Test if removed from model's label and binding lists
         m = myokit.Model()
@@ -236,6 +226,68 @@ class VarOwnerTest(unittest.TestCase):
         self.assertIs(m.binding('time'), None)
         self.assertIs(m.label('membrane_potential'), None)
 
+        # Test variable can't be removed if used in initial expression
+        m = myokit.Model()
+        c = m.add_component('c')
+        p = c.add_variable('p')
+        p.set_rhs(2)
+        x = c.add_variable('x')
+        x.set_rhs(1)
+        x.promote('1 + c.p')
+        self.assertRaises(myokit.IntegrityError, c.remove_variable, p)
+        q = c.add_variable('q')
+        q.set_rhs(10)
+        x.set_initial_value('1 / c.q')
+        c.remove_variable(p)
+        self.assertRaises(myokit.IntegrityError, c.remove_variable, q)
+        x.set_initial_value('sqrt(2)')
+        c.remove_variable(q)
+
+        # But it's OK if we're deleting a whole component
+        m = myokit.Model()
+        c = m.add_component('c')
+        p = c.add_variable('p')
+        p.set_rhs(2)
+        x = c.add_variable('x')
+        x.set_rhs(1)
+        x.promote('1 + c.p')
+        m.remove_component('c')
+
+    def test_remove_variable_with_alias(self):
+        # Test cloning of a variable with an alias after an add / remove event.
+
+        m = myokit.Model('AddRemoveClone')
+        c = m.add_component('c')
+        p = c.add_variable('p')
+        p.set_binding('time')
+        p.set_rhs(0)
+        q = c.add_variable('q')
+        q.set_rhs(12)
+        m.validate()    # Raises error if not ok
+        m.clone()       # Raises error if not ok
+        d = m.add_component('d')
+        d.add_alias('bert', p)
+        e = d.add_variable('e')
+        e.set_rhs('10 * bert')
+        m.validate()
+        m.clone()
+        d.add_alias('ernie', q)
+        m.validate()
+        m.clone()
+        c.remove_variable(q)
+        m.validate()
+        m.clone()   # Will raise error if alias isn't deleted
+
+    def test_resolve(self):
+        # Test if an error is raised when a variable can't be resolved.
+
+        m = myokit.Model('Resolve')
+        c = m.add_component('c')
+        p = c.add_variable('p')
+        q = c.add_variable('q')
+        p.set_rhs('10 * q')
+        self.assertRaises(myokit.ParseError, q.set_rhs, '10 * r')
+
     def test_sequence_interface(self):
         # Test the sequence interface implementation
 

myokit/tests/test_config.py

@@ -5,9 +5,6 @@
 # This file is part of Myokit.
 # See http://myokit.org for copyright, sharing, and licensing details.
 #
-from __future__ import absolute_import, division
-from __future__ import print_function, unicode_literals
-
 import os
 import sys
 import unittest
@@ -16,8 +13,7 @@ import myokit
 
 from myokit.tests import TemporaryDirectory, WarningCollector
 
-
-debug = True
+debug = False
 
 
 # Simple test
@@ -44,7 +40,7 @@ str=String value
 """
 
 # Config with empty paths and spaces
-config_paths_1 = """
+config_paths = """
 [sundials]
 lib = five
 inc = three;four;
@@ -53,16 +49,6 @@ lib = one;;   two point five;three;
 inc =
 """
 
-# Config with empty paths and " ;", which in Python 2 is ignored
-config_paths_2 = """
-[sundials]
-lib = five ; six
-inc = three;four;
-[opencl]
-lib = one ;;   two point five ;three;
-inc =
-"""
-
 
 class TestConfig(unittest.TestCase):
 
@@ -82,10 +68,10 @@ class TestConfig(unittest.TestCase):
         cls._compat_no_fd_capture = myokit.COMPAT_NO_FD_CAPTURE
         cls._date_format = myokit.DATE_FORMAT
         cls._time_format = myokit.TIME_FORMAT
-        cls._force_pyside = myokit.FORCE_PYSIDE
-        cls._force_pyside2 = myokit.FORCE_PYSIDE2
-        cls._force_pyqt4 = myokit.FORCE_PYQT4
+        cls._force_pyqt6 = myokit.FORCE_PYQT6
         cls._force_pyqt5 = myokit.FORCE_PYQT5
+        cls._force_pyside6 = myokit.FORCE_PYSIDE6
+        cls._force_pyside2 = myokit.FORCE_PYSIDE2
         cls._sundials_lib = myokit.SUNDIALS_LIB
         cls._sundials_inc = myokit.SUNDIALS_INC
         cls._opencl_lib = myokit.OPENCL_LIB
@@ -114,10 +100,10 @@ class TestConfig(unittest.TestCase):
         myokit.COMPAT_NO_FD_CAPTURE = cls._compat_no_fd_capture
         myokit.DATE_FORMAT = cls._date_format
         myokit.TIME_FORMAT = cls._time_format
-        myokit.FORCE_PYSIDE = cls._force_pyside
-        myokit.FORCE_PYSIDE2 = cls._force_pyside2
-        myokit.FORCE_PYQT4 = cls._force_pyqt4
+        myokit.FORCE_PYQT6 = cls._force_pyqt6
         myokit.FORCE_PYQT5 = cls._force_pyqt5
+        myokit.FORCE_PYSIDE6 = cls._force_pyside6
+        myokit.FORCE_PYSIDE2 = cls._force_pyside2
         myokit.SUNDIALS_LIB = cls._sundials_lib
         myokit.SUNDIALS_INC = cls._sundials_inc
         myokit.OPENCL_LIB = cls._opencl_lib
@@ -131,10 +117,10 @@ class TestConfig(unittest.TestCase):
         assert myokit.COMPAT_NO_FD_CAPTURE == cls._compat_no_fd_capture
         assert myokit.DATE_FORMAT != 'TEST_DATE_FORMAT'
         assert myokit.TIME_FORMAT != 'TEST_TIME_FORMAT'
-        assert myokit.FORCE_PYSIDE == cls._force_pyside
-        assert myokit.FORCE_PYSIDE2 == cls._force_pyside2
-        assert myokit.FORCE_PYQT4 == cls._force_pyqt4
+        assert myokit.FORCE_PYQT6 == cls._force_pyqt6
         assert myokit.FORCE_PYQT5 == cls._force_pyqt5
+        assert myokit.FORCE_PYSIDE6 == cls._force_pyside6
+        assert myokit.FORCE_PYSIDE2 == cls._force_pyside2
         assert myokit.SUNDIALS_LIB != ['one', 'two']
         assert myokit.SUNDIALS_INC != ['three', 'four']
         assert myokit.OPENCL_LIB != ['five', 'six']
@@ -168,17 +154,17 @@ class TestConfig(unittest.TestCase):
         myokit.SUNDIALS_INC = []
         myokit.OPENCL_LIB = []
         myokit.OPENCL_INC = []
-        myokit.FORCE_PYSIDE = myokit.FORCE_PYSIDE2 = False
-        myokit.FORCE_PYQT4 = myokit.FORCE_PYQT5 = False
+        myokit.FORCE_PYSIDE6 = myokit.FORCE_PYSIDE2 = False
+        myokit.FORCE_PYQT6 = myokit.FORCE_PYQT5 = False
         with open(self._temp_dir.path('myokit.ini'), 'w') as f:
             f.write(config_basic)
         self._config_module._load()
         self.assertEqual(myokit.DATE_FORMAT, 'TEST_DATE_FORMAT')
         self.assertEqual(myokit.TIME_FORMAT, 'TEST_TIME_FORMAT')
-        self.assertFalse(myokit.FORCE_PYSIDE)
-        self.assertFalse(myokit.FORCE_PYSIDE2)
-        self.assertFalse(myokit.FORCE_PYQT4)
+        self.assertFalse(myokit.FORCE_PYQT6)
         self.assertFalse(myokit.FORCE_PYQT5)
+        self.assertFalse(myokit.FORCE_PYSIDE6)
+        self.assertFalse(myokit.FORCE_PYSIDE2)
         self.assertEqual(myokit.SUNDIALS_LIB, ['one', 'two'])
         self.assertEqual(myokit.SUNDIALS_INC, ['three', 'four'])
         self.assertEqual(myokit.OPENCL_LIB, ['five', 'six'])
@@ -205,7 +191,7 @@ class TestConfig(unittest.TestCase):
         myokit.OPENCL_LIB = []
         myokit.OPENCL_INC = []
         with open(self._temp_dir.path('myokit.ini'), 'w') as f:
-            f.write(config_paths_1)
+            f.write(config_paths)
         self._config_module._load()
         self.assertEqual(myokit.SUNDIALS_LIB, ['five'])
         self.assertEqual(myokit.SUNDIALS_INC, ['three', 'four'])
@@ -214,60 +200,41 @@ class TestConfig(unittest.TestCase):
             ['one', 'two point five', 'three'])
         self.assertEqual(myokit.OPENCL_INC, [])
 
-        # Even if the list contains " ;", which Python 2's config parser treats
-        # as a comment
-        myokit.SUNDIALS_LIB = []
-        myokit.SUNDIALS_INC = []
-        myokit.OPENCL_LIB = []
-        myokit.OPENCL_INC = []
-        with open(self._temp_dir.path('myokit.ini'), 'w') as f:
-            f.write(config_paths_2)
-        if sys.hexversion < 0x03020000:
-            self.assertRaises(ImportError, self._config_module._load)
-        else:
-            self._config_module._load()
-            self.assertEqual(myokit.SUNDIALS_LIB, ['five', 'six'])
-            self.assertEqual(myokit.SUNDIALS_INC, ['three', 'four'])
-            self.assertEqual(
-                myokit.OPENCL_LIB,
-                ['one', 'two point five', 'three'])
-            self.assertEqual(myokit.OPENCL_INC, [])
-
     def test_load_gui_backend(self):
         # Tests setting the GUI back end
 
         # Qt gui options
         with open(self._temp_dir.path('myokit.ini'), 'w') as f:
-            f.write('[gui]\nbackend=pyqt4\n')
+            f.write('[gui]\nbackend=pyqt6\n')
         self._config_module._load()
-        self.assertFalse(myokit.FORCE_PYSIDE)
-        self.assertFalse(myokit.FORCE_PYSIDE2)
-        self.assertTrue(myokit.FORCE_PYQT4)
+        self.assertTrue(myokit.FORCE_PYQT6)
         self.assertFalse(myokit.FORCE_PYQT5)
+        self.assertFalse(myokit.FORCE_PYSIDE6)
+        self.assertFalse(myokit.FORCE_PYSIDE2)
 
         with open(self._temp_dir.path('myokit.ini'), 'w') as f:
             f.write('[gui]\nbackend=pyqt5\n')
         self._config_module._load()
-        self.assertFalse(myokit.FORCE_PYSIDE)
-        self.assertFalse(myokit.FORCE_PYSIDE2)
-        self.assertFalse(myokit.FORCE_PYQT4)
+        self.assertFalse(myokit.FORCE_PYQT6)
         self.assertTrue(myokit.FORCE_PYQT5)
+        self.assertFalse(myokit.FORCE_PYSIDE6)
+        self.assertFalse(myokit.FORCE_PYSIDE2)
 
         with open(self._temp_dir.path('myokit.ini'), 'w') as f:
-            f.write('[gui]\nbackend=pyside\n')
+            f.write('[gui]\nbackend=pyside6\n')
         self._config_module._load()
-        self.assertTrue(myokit.FORCE_PYSIDE)
-        self.assertFalse(myokit.FORCE_PYSIDE2)
-        self.assertFalse(myokit.FORCE_PYQT4)
+        self.assertFalse(myokit.FORCE_PYQT6)
         self.assertFalse(myokit.FORCE_PYQT5)
+        self.assertTrue(myokit.FORCE_PYSIDE6)
+        self.assertFalse(myokit.FORCE_PYSIDE2)
 
         with open(self._temp_dir.path('myokit.ini'), 'w') as f:
             f.write('[gui]\nbackend=pyside2\n')
         self._config_module._load()
-        self.assertFalse(myokit.FORCE_PYSIDE)
-        self.assertTrue(myokit.FORCE_PYSIDE2)
-        self.assertFalse(myokit.FORCE_PYQT4)
+        self.assertFalse(myokit.FORCE_PYQT6)
         self.assertFalse(myokit.FORCE_PYQT5)
+        self.assertFalse(myokit.FORCE_PYSIDE6)
+        self.assertTrue(myokit.FORCE_PYSIDE2)
 
         # Empty has no effect
         with open(self._temp_dir.path('myokit.ini'), 'w') as f:
@@ -275,10 +242,10 @@ class TestConfig(unittest.TestCase):
         with WarningCollector() as c:
             self._config_module._load()
         self.assertEqual(c.text(), '')
-        self.assertFalse(myokit.FORCE_PYSIDE)
-        self.assertTrue(myokit.FORCE_PYSIDE2)
-        self.assertFalse(myokit.FORCE_PYQT4)
+        self.assertFalse(myokit.FORCE_PYQT6)
         self.assertFalse(myokit.FORCE_PYQT5)
+        self.assertFalse(myokit.FORCE_PYSIDE6)
+        self.assertTrue(myokit.FORCE_PYSIDE2)
 
         # Invalid raises warning
         with open(self._temp_dir.path('myokit.ini'), 'w') as f:

myokit/tests/test_datablock.py

@@ -5,11 +5,9 @@
 # This file is part of Myokit.
 # See http://myokit.org for copyright, sharing, and licensing details.
 #
-from __future__ import absolute_import, division
-from __future__ import print_function, unicode_literals
-
 import os
 import unittest
+
 import numpy as np
 
 import myokit
@@ -23,12 +21,6 @@ from myokit.tests import (
     WarningCollector,
 )
 
-# Unit testing in Python 2 and 3
-try:
-    unittest.TestCase.assertRaisesRegex
-except AttributeError:
-    unittest.TestCase.assertRaisesRegex = unittest.TestCase.assertRaisesRegexp
-
 
 class DataBlock1dTest(unittest.TestCase):
     """

myokit/tests/test_datalog.py

@@ -5,11 +5,9 @@
 # This file is part of Myokit.
 # See http://myokit.org for copyright, sharing, and licensing details.
 #
-from __future__ import absolute_import, division
-from __future__ import print_function, unicode_literals
-
 import os
 import unittest
+
 import numpy as np
 
 import myokit
@@ -23,21 +21,6 @@ from myokit.tests import (
     WarningCollector,
 )
 
-# Unit testing in Python 2 and 3
-try:
-    unittest.TestCase.assertRaisesRegex
-except AttributeError:
-    unittest.TestCase.assertRaisesRegex = unittest.TestCase.assertRaisesRegexp
-
-
-# Universal newline mode in Python 2 and 3
-def uopen(filename):
-    try:
-        return open(filename, 'r', newline=None)
-    except TypeError:
-        return open(filename, 'U')
-
-
 # Extra output
 debug = False
 
@@ -126,8 +109,10 @@ class DataLogTest(unittest.TestCase):
             'engine.time': [0, 5, 10, 15, 20],
             'membrane.V': [0, 50, 100, 150, 200]})
         d.set_time_key('engine.time')
-        with WarningCollector():
+        with WarningCollector() as w:
             self.assertEqual(d.find(-5), d.find_after(-5))
+        self.assertIn('eprecated', w.text())
+        with WarningCollector():
             self.assertEqual(d.find(0), d.find_after(0))
             self.assertEqual(d.find(2), d.find_after(2))
             self.assertEqual(d.find(5), d.find_after(5))
@@ -1393,12 +1378,12 @@ class DataLogTest(unittest.TestCase):
         with TemporaryDirectory() as td:
             fname = td.path('test.csv')
             d.save_csv(fname, order=['a.b', 'c.d', 'e.f'])
-            with uopen(fname) as f:
+            with open(fname, 'r', newline=None) as f:
                 header = f.readline()
             self.assertEqual(header, '"a.b","c.d","e.f"\n')
 
             d.save_csv(fname, order=['e.f', 'a.b', 'c.d'])
-            with uopen(fname) as f:
+            with open(fname, 'r', newline=None) as f:
                 header = f.readline()
             self.assertEqual(header, '"e.f","a.b","c.d"\n')
 
@@ -1420,7 +1405,7 @@ class DataLogTest(unittest.TestCase):
         with TemporaryDirectory() as td:
             fname = td.path('test.csv')
             d.save_csv(fname)
-            with uopen(fname) as f:
+            with open(fname, 'r', newline=None) as f:
                 order = [x[1:-1] for x in f.readline().strip().split(',')]
             self.assertEqual(len(order), 9)
             self.assertEqual(order[0], 'e.t')
@@ -2181,12 +2166,22 @@ class DataLogTest(unittest.TestCase):
         self.assertEqual(d.length(), 100)
 
     def test_regularize(self):
-        # Test the regularize() method.
+        # Test the deprecated regularize() method.
 
         d = myokit.DataLog(time='time')
         d['time'] = np.log(np.linspace(1, 25, 100))
         d['values'] = np.linspace(1, 25, 100)
-        e = d.regularize(dt=0.5)
+
+        has_scipy = True
+        with WarningCollector() as w:
+            try:
+                e = d.regularize(dt=0.5)
+            except ImportError:
+                has_scipy = False
+        self.assertIn('eprecated', w.text())
+        if not has_scipy:
+            return
+
         self.assertEqual(len(e['time']), 7)
         x = np.array([0, 0.5, 1, 1.5, 2, 2.5, 3])
         self.assertTrue(np.all(e['time'] == x))

myokit/tests/test_dependency_checking.py

@@ -6,9 +6,6 @@
 # This file is part of Myokit.
 # See http://myokit.org for copyright, sharing, and licensing details.
 #
-from __future__ import absolute_import, division
-from __future__ import print_function, unicode_literals
-
 import os
 import unittest
 
@@ -16,18 +13,6 @@ import myokit
 
 from myokit.tests import DIR_DATA
 
-# Unit testing in Python 2 and 3
-try:
-    unittest.TestCase.assertRaisesRegex
-except AttributeError:
-    unittest.TestCase.assertRaisesRegex = unittest.TestCase.assertRaisesRegexp
-
-# Strings in Python 2 and 3
-try:
-    basestring
-except NameError:   # pragma: no cover
-    basestring = str
-
 
 # Extra output
 debug = False
@@ -55,7 +40,7 @@ class DepTest(unittest.TestCase):
         """
         # If a string lhs is given, interpret it as a variable name and get
         # the lhs of its defining equation
-        if isinstance(key, basestring):
+        if isinstance(key, str):
             key = self.m.get(key)
             if isinstance(key, myokit.Variable):
                 key = key.lhs()
@@ -64,7 +49,7 @@ class DepTest(unittest.TestCase):
         # convert it to a Name. Ensure no duplicates are given.
         deps = list(set(deps))
         for k, dep in enumerate(deps):
-            if isinstance(dep, basestring):
+            if isinstance(dep, str):
                 deps[k] = self.n(dep)
 
         # Get dep map
@@ -449,7 +434,7 @@ class DeepDepTest(DepTest):
             return self.has_lhs(depmap, lhs, *deps)
 
         def nhas(lhs):
-            if isinstance(lhs, basestring):
+            if isinstance(lhs, str):
                 lhs = self.m.get(lhs).lhs()
             self.assertNotIn(lhs, depmap)
 
@@ -594,7 +579,7 @@ class DeepDepTest(DepTest):
             return self.has_lhs(depmap, lhs, *deps)
 
         def nhas(lhs):
-            if isinstance(lhs, basestring):
+            if isinstance(lhs, str):
                 lhs = self.m.get(lhs).lhs()
             self.assertNotIn(lhs, depmap)
 
@@ -1360,10 +1345,10 @@ class SolvableOrderTest(DepTest):
 
         def before(lhs1, *lhs2s):
             """ Asserts lhs1 comes before lhs2 in the current component """
-            if isinstance(lhs1, basestring):
+            if isinstance(lhs1, str):
                 lhs1 = self.m.get(self.ccomp + '.' + lhs1).lhs()
             for lhs2 in lhs2s:
-                if isinstance(lhs2, basestring):
+                if isinstance(lhs2, str):
                     lhs2 = self.m.get(self.ccomp + '.' + lhs2).lhs()
                 i1 = i2 = None
                 for i, eq in enumerate(self.order[self.ccomp]):
@@ -1508,14 +1493,14 @@ class SolvableOrderTest(DepTest):
 
         def before(lhs1, *lhs2s):
             """ Asserts lhs2 comes before lhs1 """
-            if isinstance(lhs1, basestring):
+            if isinstance(lhs1, str):
                 if lhs1.startswith('dot('):
                     lhs1 = myokit.Derivative(myokit.Name(
                         self.m.get(lhs1[4:-1])))
                 else:
                     lhs1 = myokit.Name(self.m.get(lhs1))
             for lhs2 in lhs2s:
-                if isinstance(lhs2, basestring):
+                if isinstance(lhs2, str):
                     if lhs2.startswith('dot('):
                         lhs2 = myokit.Derivative(myokit.Name(
                             self.m.get(lhs2[4:-1])))