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

myokit/tests/test_model_building.py

@@ -2,27 +2,15 @@
 #
 # Tests the model building API.
 #
+# NOTE: THESE TESTS SHOULD SLOWLY BE MERGED INTO test_model, test_variable, etc
+#
+#
 # 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
 
-# Strings in Python 2 and 3
-try:
-    basestring
-except NameError:
-    basestring = str
-
-# Unit testing in Python 2 and 3
-try:
-    unittest.TestCase.assertRaisesRegex
-except AttributeError:
-    unittest.TestCase.assertRaisesRegex = unittest.TestCase.assertRaisesRegexp
-
 # Further model API tests are found in:
 #  - test_dependency_checking.py
 
@@ -33,13 +21,23 @@ class ModelBuildTest(unittest.TestCase):
         # Create a model
         m = myokit.Model('LotkaVolterra')
 
-        # Add the first component
+        # Add engine component
+        E = m.add_component('engine')
+        self.assertEqual(len(m), 1)
+        time = E.add_variable('time')
+        time.set_rhs(0)
+        self.assertIsNone(time.binding())
+        time.set_binding('time')
+        self.assertIsNotNone(time.binding())
+
+        # Add the first test component
         X = m.add_component('X')
+        self.assertNotEqual(E, X)
         self.assertEqual(X.qname(), 'X')
         self.assertEqual(X.parent(), m)
         self.assertIsInstance(X, myokit.Component)
         self.assertIn(X.qname(), m)
-        self.assertEqual(len(m), 1)
+        self.assertEqual(len(m), 2)
 
         # Add variable a
         self.assertFalse(X.has_variable('a'))
@@ -111,7 +109,7 @@ class ModelBuildTest(unittest.TestCase):
         self.assertFalse(x.is_intermediary())
         self.assertFalse(x.is_constant())
         self.assertEqual(x.lhs(), myokit.Derivative(myokit.Name(x)))
-        self.assertEqual(x.indice(), 0)
+        self.assertEqual(x.index(), 0)
 
         # Test demoting, promoting
         x.demote()
@@ -133,10 +131,32 @@ class ModelBuildTest(unittest.TestCase):
         self.assertFalse(x.is_constant())
         self.assertEqual(x.lhs(), myokit.Derivative(myokit.Name(x)))
 
+        # Set number initial value
+        x.demote()
+        x.promote(1)
+        self.assertEqual(x.initial_value(as_float=True), 1)
+
+        # Set constant expression initial value
+        x.set_initial_value(myokit.Name(b))
+        self.assertEqual(x.initial_value(as_float=True), 2)
+        self.assertEqual(x.initial_value(), myokit.Name(b))
+
+        # Non-constant expression initial value can be set, but isn't valid
+        m.validate()
+        b.promote()
+        self.assertRaisesRegex(
+            myokit.IntegrityError, 'not constant', m.validate)
+        b.demote()
+
+        # Set literal valued expression initial value
+        x.demote()
+        x.promote('1 + 2')
+        self.assertEqual(x.initial_value(as_float=True), 3)
+
         # Add second component, variables
         Y = m.add_component('Y')
         self.assertNotEqual(X, Y)
-        self.assertEqual(len(m), 2)
+        self.assertEqual(len(m), 3)
         c = Y.add_variable('c')
         c.set_rhs(myokit.Minus(myokit.Name(a), myokit.Number(1)))
         d = Y.add_variable('d')
@@ -152,7 +172,7 @@ class ModelBuildTest(unittest.TestCase):
                 myokit.Name(y)
             )
         ))
-        x.set_state_value(10)
+        x.set_initial_value(10)
         self.assertEqual(x.rhs().code(), 'X.a * X.x - X.b * X.x * Y.y')
         y.set_rhs(myokit.Plus(
             myokit.Multiply(
@@ -163,14 +183,14 @@ class ModelBuildTest(unittest.TestCase):
                 myokit.Name(y)
             )
         ))
-        y.set_state_value(5)
+        y.set_initial_value(5)
         self.assertEqual(y.rhs().code(), '-Y.c * Y.y + Y.d * X.x * Y.y')
 
         # Add ano component, variables
         Z = m.add_component('Z')
         self.assertNotEqual(X, Z)
         self.assertNotEqual(Y, Z)
-        self.assertEqual(len(m), 3)
+        self.assertEqual(len(m), 4)
         t = Z.add_variable('total')
         self.assertEqual(t.name(), 'total')
         self.assertEqual(t.qname(), 'Z.total')
@@ -185,18 +205,6 @@ class ModelBuildTest(unittest.TestCase):
         self.assertEqual(t.rhs().code(Y), 'X.x + y')
         self.assertEqual(t.rhs().code(Z), 'X.x + Y.y')
 
-        # Add engine component
-        E = m.add_component('engine')
-        self.assertNotEqual(X, E)
-        self.assertNotEqual(Y, E)
-        self.assertNotEqual(Z, E)
-        self.assertEqual(len(m), 4)
-        time = E.add_variable('time')
-        time.set_rhs(0)
-        self.assertIsNone(time.binding())
-        time.set_binding('time')
-        self.assertIsNotNone(time.binding())
-
         # Check state
         state = [i for i in m.states()]
         self.assertEqual(len(state), 2)
@@ -277,10 +285,10 @@ class ModelBuildTest(unittest.TestCase):
 
         # Test dependency mapping
         def has(var, *dps):
-            lst = vrs[m.get(var).lhs() if isinstance(var, basestring) else var]
+            lst = vrs[m.get(var).lhs() if isinstance(var, str) else var]
             self.assertEqual(len(lst), len(dps))
             for d in dps:
-                d = m.get(d).lhs() if isinstance(d, basestring) else d
+                d = m.get(d).lhs() if isinstance(d, str) else d
                 self.assertIn(d, lst)
 
         vrs = m.map_shallow_dependencies(omit_states=False)
@@ -355,16 +363,6 @@ class ModelBuildTest(unittest.TestCase):
         code2 = m.clone().code()
         self.assertEqual(code1, code2)
 
-    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_scope(self):
         # Test if illegal references are detected.
 
@@ -436,56 +434,6 @@ class ModelBuildTest(unittest.TestCase):
         self.assertRaises(myokit.InvalidNameError, v1.add_variable, 'not')
         self.assertRaises(myokit.InvalidNameError, v1.add_variable, 'in')
 
-    def test_unused_and_cycles(self):
-        # Test unused variable and cycle detection.
-
-        m = myokit.Model('LotkaVolterra')
-        c0 = m.add_component('c0')
-        t = c0.add_variable('time')
-        t.set_rhs(myokit.Number(0))
-        t.set_binding('time')
-        c1 = m.add_component('c1')
-        m.add_component('c2')
-        c1_a = c1.add_variable('a')
-        c1_b = c1.add_variable('b')
-        c1_a.promote(1.0)
-        c1_a.set_rhs(myokit.Multiply(myokit.Name(c1_a), myokit.Number(0.5)))
-        c1_b.set_rhs(myokit.Multiply(myokit.Name(c1_a), myokit.Number(1.0)))
-        # b is unused, test if found
-        m.validate()
-        w = m.warnings()
-        self.assertEqual(len(w), 1)
-        self.assertEqual(type(w[0]), myokit.UnusedVariableError)
-        # b is used by c, c is unused, test if found
-        c1_c = c1.add_variable('c')
-        c1_c.set_rhs(myokit.Name(c1_b))
-        m.validate()
-        w = m.warnings()
-        self.assertEqual(len(w), 2)
-        self.assertEqual(type(w[0]), myokit.UnusedVariableError)
-        self.assertEqual(type(w[1]), myokit.UnusedVariableError)
-        # Test 1:1 cycle
-        c1_b.set_rhs(myokit.Name(c1_b))
-        self.assertRaises(myokit.CyclicalDependencyError, m.validate)
-        # Test longer cycles
-        c1_b.set_rhs(myokit.Multiply(myokit.Number(10), myokit.Name(c1_c)))
-        self.assertRaises(myokit.CyclicalDependencyError, m.validate)
-        # Reset
-        c1_b.set_rhs(myokit.Multiply(myokit.Name(c1_a), myokit.Number(1.0)))
-        m.validate()
-        # Test cycle involving state variable
-        c1_a.set_rhs(myokit.Name(c1_b))
-        m.validate()
-        c1_b.set_rhs(myokit.Multiply(myokit.Name(c1_a), myokit.Name(c1_b)))
-        self.assertRaises(myokit.CyclicalDependencyError, m.validate)
-        c1_b.set_rhs(myokit.Multiply(myokit.Name(c1_a), myokit.Name(c1_c)))
-        c1_c.set_rhs(myokit.Multiply(myokit.Name(c1_a), myokit.Number(3)))
-        m.validate()
-        w = m.warnings()
-        self.assertEqual(len(w), 0)
-        c1_c.set_rhs(myokit.Multiply(myokit.Name(c1_a), myokit.Name(c1_b)))
-        self.assertRaises(myokit.CyclicalDependencyError, m.validate)
-
 
 if __name__ == '__main__':
     unittest.main()

myokit/tests/test_opencl_info.py

@@ -5,21 +5,12 @@
 # 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 unittest
 
 import myokit
 
 from myokit.tests import TemporaryDirectory, OpenCL_FOUND
 
-# Strings in Python2 and Python3
-try:
-    basestring
-except NameError:
-    basestring = str
-
 
 @unittest.skipIf(not OpenCL_FOUND, 'OpenCL not found on this system.')
 class OpenCLTest(unittest.TestCase):
@@ -35,12 +26,12 @@ class OpenCLTest(unittest.TestCase):
         # Tests the method to query the current device
         self.assertIsInstance(
             myokit.OpenCL.current_info(), myokit.OpenCLPlatformInfo)
-        self.assertIsInstance(myokit.OpenCL.current_info(True), basestring)
+        self.assertIsInstance(myokit.OpenCL.current_info(True), str)
 
     def test_info(self):
         # Tests the method to query the current device
         self.assertIsInstance(myokit.OpenCL.info(), myokit.OpenCLInfo)
-        self.assertIsInstance(myokit.OpenCL.info(True), basestring)
+        self.assertIsInstance(myokit.OpenCL.info(True), str)
 
     def test_load_save_selection(self):
         # Tests the load_selection method
@@ -83,9 +74,9 @@ class OpenCLTest(unittest.TestCase):
         item = info[0]
         self.assertEqual(len(item), 3)
         platform, device, specs = item
-        self.assertIsInstance(platform, basestring)
-        self.assertIsInstance(device, basestring)
-        self.assertIsInstance(specs, basestring)
+        self.assertIsInstance(platform, str)
+        self.assertIsInstance(device, str)
+        self.assertIsInstance(specs, str)
 
     def test_supported(self):
         # Tested as condition to get in, so must be true

myokit/tests/test_pacing_factory.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 unittest
 
 import myokit

myokit/tests/test_pacing_system_c.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 unittest
 import numpy as np
 
@@ -16,12 +13,6 @@ import myokit
 from myokit.tests.ansic_event_based_pacing import AnsicEventBasedPacing
 from myokit.tests.ansic_fixed_form_pacing import AnsicFixedFormPacing
 
-# Unit testing in Python 2 and 3
-try:
-    unittest.TestCase.assertRaisesRegex
-except AttributeError:
-    unittest.TestCase.assertRaisesRegex = unittest.TestCase.assertRaisesRegexp
-
 
 class EventBasedPacingAnsicTest(unittest.TestCase):
     """
@@ -144,24 +135,11 @@ class FixedFormPacingAnsicTest(unittest.TestCase):
             import sys
             sys.exit(1)
 
-        # Test input checking
-        times = 1
-        values = [1, 2]
-        self.assertRaises(Exception, AnsicFixedFormPacing)
-        self.assertRaises(Exception, AnsicFixedFormPacing, 1)
-        self.assertRaises(Exception, AnsicFixedFormPacing, 1, 2)
-        self.assertRaises(Exception, AnsicFixedFormPacing, [1], [2])
-        self.assertRaises(
-            Exception, AnsicFixedFormPacing, [1, 2], [2])
-        self.assertRaises(
-            Exception, AnsicFixedFormPacing, [2, 1], [2, 2])
-        AnsicFixedFormPacing([1, 2], [1, 2])
-
         # Test with small lists
         values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
         times = [0, 0, 1, 1, 1, 2, 2, 2, 3, 4, 5, 7]
         values = list(range(len(times)))
-        pacing = AnsicFixedFormPacing(times, values)
+        pacing = AnsicFixedFormPacing(myokit.TimeSeriesProtocol(times, values))
 
         def test(value, index):
             self.assertEqual(pacing.pace(value), index)

myokit/tests/test_pacing_system_py.py

@@ -5,19 +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 unittest
 
 import myokit
 
-# Unit testing in Python 2 and 3
-try:
-    unittest.TestCase.assertRaisesRegex
-except AttributeError:
-    unittest.TestCase.assertRaisesRegex = unittest.TestCase.assertRaisesRegexp
-
 
 class EventBasedPacingPythonTest(unittest.TestCase):
     """

myokit/tests/test_parsing.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
 
@@ -17,18 +14,6 @@ import myokit.units
 
 from myokit.tests import DIR_DATA, TemporaryDirectory
 
-# 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 python 2 cover
-    basestring = str
-
 
 class TokenizerTest(unittest.TestCase):
     """
@@ -223,6 +208,7 @@ class PhasedParseTest(unittest.TestCase):
     """
     Tests several phases of parsing.
     """
+
     def test_segment_parsing(self):
         # Test :meth:`parse_model()`.
         from myokit._parsing import parse
@@ -907,29 +893,29 @@ class PhasedParseTest(unittest.TestCase):
             '[[script]]',
         )
         script = parse_script(code)
-        self.assertIsInstance(script, basestring)
+        self.assertIsInstance(script, str)
         script = parse_script(''.join(code))
-        self.assertIsInstance(script, basestring)
+        self.assertIsInstance(script, str)
 
         code = (
             '[[script]]\n',
         )
         script = parse_script(code)
-        self.assertIsInstance(script, basestring)
+        self.assertIsInstance(script, str)
 
         code = (
             '[[script]]\n',
             'print("hi")',
         )
         script = parse_script(code)
-        self.assertIsInstance(script, basestring)
+        self.assertIsInstance(script, str)
 
         code = (
             '[[script]]\n',
             'print("hi")\n',
         )
         script = parse_script(code)
-        self.assertIsInstance(script, basestring)
+        self.assertIsInstance(script, str)
 
         # Not a script
         code = (
@@ -1229,7 +1215,12 @@ class PhasedParseTest(unittest.TestCase):
 
 
 class ModelParseTest(unittest.TestCase):
+    """
+    Test parsing models.
+    """
+
     def test_model_creation(self):
+        # Basic model creation via the parser
         m = myokit.load_model(os.path.join(DIR_DATA, 'lr-1991.mmt'))
 
         # Test components
@@ -1263,36 +1254,14 @@ class ModelParseTest(unittest.TestCase):
             1,
             0.0057,
             0.0002]
+        self.assertEqual(len(values), m.count_states())
+
+        # Test initial value parsing
         out = ', '.join([str(x) for x in m.states()])
         ref = ', '.join(states)
         self.assertEqual(ref, out)
-        for k, eq in enumerate(m.inits()):
-            self.assertEqual(eq.rhs.eval(), values[k])
-
-        # Test state parsing / setting
-        m.set_state(values)
-        for k, eq in enumerate(m.inits()):
-            self.assertEqual(eq.rhs.eval(), values[k])
-        s = dict(zip(states, values))
-        m.set_state(s)
-        for k, eq in enumerate(m.inits()):
-            self.assertEqual(eq.rhs.eval(), values[k])
-        s = '\n'.join([str(a) + '=' + str(b) for a, b in s.items()])
-        m.set_state(s)
-        for k, eq in enumerate(m.inits()):
-            self.assertEqual(eq.rhs.eval(), values[k])
-
-        # Test cloning
-        try:
-            m2 = m.clone()
-        except Exception as e:
-            s = m.code(line_numbers=True)
-            print('\n')
-            print(s)
-            print('-' * 80)
-            print(myokit.format_parse_error(e, s.splitlines()))
-            raise e
-        self.assertEqual(m.code(), m2.code())
+        for val, ref in zip(m.initial_values(as_floats=True), values):
+            self.assertEqual(val, ref)
 
     def test_unresolved_reference_error(self):
         # Test unresolved reference errors.
@@ -1354,19 +1323,21 @@ class ModelParseTest(unittest.TestCase):
         # Test evaluation
         x = m.get('test.x')
         y = m.get('test.y')
-        s = m.state()
-        i = m.get('membrane.V').indice()
+        s = m.initial_values(as_floats=True)
+        i = m.get('membrane.V').index()
         # Test x, xo, y, yo
+
+        v = myokit.Name(m.get('membrane.V'))
         s[i] = -80
-        m.set_state(s)
+        m.set_initial_values(s)
         self.assertEqual(x.rhs().eval(), 3)
         self.assertEqual(y.rhs().eval(), 2)
         s[i] = -10
-        m.set_state(s)
+        m.set_initial_values(s)
         self.assertEqual(x.rhs().eval(), 2)
         self.assertEqual(y.rhs().eval(), 2)
         s[i] = 30
-        m.set_state(s)
+        m.set_initial_values(s)
         self.assertEqual(x.rhs().eval(), 1)
         self.assertEqual(y.rhs().eval(), 1)
         # Test code() output by cloning
@@ -1387,13 +1358,50 @@ class ModelParseTest(unittest.TestCase):
             dot(p) = 1
             dot(q) = 2
             """
-        myokit.parse(code)
+        m = myokit.parse_model(code)
+        self.assertEqual(m.get('c.p').initial_value(), myokit.Number(1))
+        self.assertEqual(m.get('c.q').initial_value().code(), '10 * 2')
+
+        # initial expression
+        code = """
+            [[model]]
+            c.q = 10 * 2 + c.p
+            c.r = c.p + c.a
+
+            [engine]
+            time = 0 bind time
+
+            [c]
+            p = 0.5
+            dot(q) = 2
+            dot(r) = 1
+            a = p + 1
+            """
+        m = myokit.parse_model(code)
+        self.assertEqual(
+            m.get('c.q').initial_value().code(), '10 * 2 + c.p')
 
-        # Non-literal value
+        # initial expression with just literals
+        code = """
+            [[model]]
+            c.q = 10 * exp(2)
+
+            [engine]
+            time = 0 bind time
+
+            [c]
+            p = 0.5
+            dot(q) = 2
+            """
+        m = myokit.parse_model(code)
+        self.assertEqual(
+            m.get('c.q').initial_value().code(), '10 * exp(2)')
+
+        # non-existent variable in initial value
         code = """
             [[model]]
             c.p = 1.0
-            c.q = 10 * 2 + b
+            c.q = 10 * 2 + c.b
 
             [engine]
             time = 0 bind time
@@ -1402,7 +1410,82 @@ class ModelParseTest(unittest.TestCase):
             dot(p) = 1
             dot(q) = 2
             """
-        self.assertRaises(myokit.ParseError, myokit.parse, code)
+        self.assertRaisesRegex(
+            myokit.ParseError, 'Unresolved reference', myokit.parse, code)
+
+        # initial expression using child variables should fail
+        code = """
+            [[model]]
+            c.q = a
+
+            [engine]
+            time = 0 bind time
+
+            [c]
+            p = 0.5
+            dot(q) = 2
+                a = 10 * 2 + p
+            """
+        self.assertRaisesRegex(
+            myokit.ParseError, 'Unresolved reference', myokit.parse, code)
+
+        # non-constant initial value
+        code = """
+            [[model]]
+            c.p = engine.time
+
+            [engine]
+            time = 0 bind time
+
+            [c]
+            dot(p) = 1
+            """
+        self.assertRaisesRegex(
+            myokit.ParseError, 'is not constant', myokit.parse, code)
+
+        # indirect non-constant initial value
+        code = """
+            [[model]]
+            c.p = c.r
+            c.q = 1
+
+            [engine]
+            time = 0 bind time
+
+            [c]
+            dot(p) = 1
+            dot(q) = 2
+            r = 2 * q
+            """
+        self.assertRaisesRegex(
+            myokit.ParseError, 'is not constant', myokit.parse, code)
+
+        # looks like it shouldn't be constant, but it is!
+        code = """
+            [[model]]
+            c.p = dot(c.p)
+
+            [engine]
+            time = 0 bind time
+
+            [c]
+            dot(p) = 0
+            """
+        # Treat all state variables as non-constant
+        self.assertRaisesRegex(
+            myokit.ParseError, 'is not constant', myokit.parse, code)
+
+        # Initial value cycles are caught in validation
+        code = """
+            [[model]]
+            x.x = x.x
+
+            [x]
+            dot(x) = x
+            t = 0 bind time
+            """
+        self.assertRaisesRegex(
+            myokit.ParseError, 'is not constant', myokit.parse, code)
 
     def test_aliases(self):
         code = """

myokit/tests/test_progress_reporters.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 unittest
 import re
 import time

myokit/tests/test_protocol.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 pickle
 import unittest
 
@@ -15,12 +12,6 @@ import myokit
 
 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 ProtocolTest(unittest.TestCase):
     """