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

myokit/_myokit_version.py

@@ -4,7 +4,6 @@
 # This file is part of Myokit.
 # See http://myokit.org for copyright, sharing, and licensing details.
 #
-import sys
 
 # True if this is a release, False for a development version
 __release__ = True
@@ -15,7 +14,7 @@ __release__ = True
 #    incompatibility
 #  - Changes to revision indicate bugfixes, tiny new features
 #  - There is no significance to odd/even numbers
-__version_tuple__ = 1, 33, 9
+__version_tuple__ = 1, 35, 0
 
 # String version of the version number
 __version__ = '.'.join([str(x) for x in __version_tuple__])
@@ -23,6 +22,3 @@ if not __release__:  # pragma: no cover
     __version_tuple__ += ('dev', )
     __version__ += '.dev'
 
-# Don't expose x on Python2
-if sys.hexversion < 0x03000000:  # pragma: no python 3 cover
-    del x

myokit/_parsing.py

@@ -4,22 +4,14 @@
 # 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 re
-#import unicodedata
+
 from collections import OrderedDict
 
 import myokit
-from myokit import ParseError, ProtocolParseError
 
-# Strings in Python2 and Python3
-try:
-    basestring
-except NameError:   # pragma: no cover
-    basestring = str
+from myokit import ParseError, ProtocolParseError
 
 
 def parse(source):
@@ -34,7 +26,7 @@ def parse(source):
     """
     # Get raw stream
     raw = source
-    if isinstance(raw, basestring):
+    if isinstance(raw, str):
         raw = raw.splitlines()
     raw = iter(raw)
 
@@ -78,7 +70,7 @@ def parse_model(source):
     """
     # Get raw stream
     raw = source
-    if isinstance(raw, basestring):
+    if isinstance(raw, str):
         raw = raw.splitlines()
     raw = iter(raw)
 
@@ -100,7 +92,7 @@ def parse_protocol(source):
     """
     # Get raw stream
     raw = source
-    if isinstance(raw, basestring):
+    if isinstance(raw, str):
         raw = raw.splitlines()
     raw = iter(raw)
 
@@ -122,7 +114,7 @@ def parse_script(source):
     """
     # Get raw stream
     raw = source
-    if isinstance(raw, basestring):
+    if isinstance(raw, str):
         raw = raw.splitlines()
     raw = iter(raw)
 
@@ -162,7 +154,7 @@ def parse_state(state):
     """
     # Get raw stream
     raw = state
-    if isinstance(raw, basestring):
+    if isinstance(raw, str):
         raw = raw.splitlines()
     raw = iter(raw)
 
@@ -205,7 +197,7 @@ def split(source):
     """
     # Get raw stream
     raw = source
-    if isinstance(raw, basestring):
+    if isinstance(raw, str):
         raw = raw.splitlines()
     raw = iter(raw)
     segments = ['', '', '']
@@ -317,7 +309,7 @@ def unexpected_token(token, expected):
     # Parse expected token(s) or string
     if type(expected) == int:
         expected = [expected]
-    if not isinstance(expected, basestring):
+    if not isinstance(expected, str):
         if len(expected) > 2:
             expected = 'one of [' \
                 + ', '.join([token_str[i] for i in expected]) + ']'
@@ -348,10 +340,11 @@ def reg_token(info, token, obj):
         d[token[3]] = (token, obj)
 
 
-class ParseInfo(object):
+class ParseInfo:
     def __init__(self):
         self.model = None
         self.initial_values = OrderedDict()
+        self.initial_value_tokens = {}
         self.alias_map = {}
         self.user_functions = {}
 
@@ -420,10 +413,10 @@ def parse_model_from_stream(stream, syntax_only=False):
                     'Duplicate initial value', t0[2], t0[3],
                     'A value for <' + name + '> was already specified.')
             expect(next(stream), EQUAL)
-            expr = parse_expression_stream(stream)
+            expr = parse_proto_expression(stream)
             expect(next(stream), EOL)
             info.initial_values[name] = expr
-            reg_token(info, t0, expr)
+            info.initial_value_tokens[name] = t0
 
         token = stream.peek()
 
@@ -439,15 +432,6 @@ def parse_model_from_stream(stream, syntax_only=False):
     if syntax_only:
         return True
 
-    # All initial variables must have been used
-    for qname, e in info.initial_values.items():
-        raise ParseError(
-            'Unused initial value', 0, 0,
-            'An unused initial value was found for "' + str(qname) + '".')
-
-    # Re-order the model state
-    model.reorder_state(state_order)
-
     # Order encountered tokens
     m = model._tokens
     model._tokens = {}
@@ -468,6 +452,23 @@ def parse_model_from_stream(stream, syntax_only=False):
             var.set_rhs(convert_proto_expression(var._proto_rhs, var, info))
         del var._proto_rhs
 
+    # Resolve variable references in initial values
+    for i, var in enumerate(model.states()):
+        e = info.initial_values[var.qname()]
+        expr = convert_proto_expression(e, model, info)
+        var.set_initial_value(expr)
+        del info.initial_values[var.qname()]
+
+    # All initial variables must have been used
+    for qname, e in info.initial_values.items():
+        t = info.initial_value_tokens[qname]
+        raise ParseError(
+            'Unused initial value', t[2], t[3],
+            'An unused initial value was found for "' + qname + '".')
+
+    # Re-order the model state
+    model.reorder_state(state_order)
+
     # Check the semantics of the model
     try:
         model.validate()
@@ -675,14 +676,7 @@ def parse_variable(stream, info, parent):
             raise ParseError(
                 'Missing initial value', line, char,
                 'No initial value was found for "' + var.qname() + '"')
-        state_value = info.initial_values[var.qname()]
-        try:
-            var.promote(state_value)
-        except myokit.NonLiteralValueError as e:
-            t = state_value._token
-            raise ParseError(
-                'Illegal state value', t[2], t[3], str(e), cause=e)
-        del info.initial_values[var.qname()]
+        var.promote()
 
     # Parse definition, quick unit, bind, label and description syntax
     # These token must occur in a fixed order!
@@ -1069,7 +1063,7 @@ def strip_expression_units(model_text, skip_literals=True):
     This method will raise a :class:`myokit.ParseError` if the given code
     cannot be parsed to a valid model.
     """
-    if isinstance(model_text, basestring):
+    if isinstance(model_text, str):
         lines = model_text.splitlines()
     else:
         lines = model_text
@@ -1265,7 +1259,7 @@ _COMPEQ = '=!><'
 _COMPEQ_MAP = [EQEQUAL, NOTEQUAL, MOREEQUAL, LESSEQUAL]
 
 
-class Tokenizer(object):
+class Tokenizer:
     """
     Takes a stream of lines as input and provides a stream interface returning
     tokens.
@@ -1310,7 +1304,7 @@ class Tokenizer(object):
         self._catcheri = 0
 
         # String given instead of stream of lines? Convert
-        if isinstance(stream_of_lines, basestring):
+        if isinstance(stream_of_lines, str):
             stream_of_lines = iter(stream_of_lines.splitlines())
 
         # Create tokenizer
@@ -1963,7 +1957,7 @@ def format_parse_error(ex, source=None):
     line = None
 
     if ex.line > 0 and source is not None:
-        if isinstance(source, basestring) and os.path.isfile(source):
+        if isinstance(source, str) and os.path.isfile(source):
             # Re-open file, find line
             with open(source, 'r') as f:
                 for i in range(0, ex.line):
@@ -2013,7 +2007,7 @@ def format_parse_error(ex, source=None):
     return '\n'.join(out)
 
 
-class NudParser(object):
+class NudParser:
     """
     Expression parser for nud operators.
 
@@ -2082,7 +2076,7 @@ class FunctionParser(NudParser):
     Parser for function calls.
     """
     def __init__(self):
-        super(FunctionParser, self).__init__()
+        super().__init__()
         self._rbp = myokit.Function._rbp
 
     def parse(self, stream, info):
@@ -2123,7 +2117,7 @@ class FunctionParser(NudParser):
         return (func, ops, (name,))
 
 
-class LedParser(object):
+class LedParser:
     """
     Expression parser for led operators.
 

myokit/_progress.py

@@ -4,15 +4,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 timeit
 
 import myokit
 
 
-class ProgressReporter(object):
+class ProgressReporter:
     """
     Interface for progress updates in Simulations. Also allows some job types
     to be cancelled by the user.
@@ -21,7 +18,7 @@ class ProgressReporter(object):
     pass in an object implementing this interface. The simulation will use this
     object to report on its progress.
 
-    Note that progress reporters should be re-usable, but the behaviour when
+    Note that progress reporters should be re-usable, but the behavior when
     making calls to a reporter from two different processes (either through
     multi-threading/multi-processing or jobs nested within jobs) is undefined.
 
@@ -62,7 +59,7 @@ class ProgressReporter(object):
         """
         pass
 
-    class _Job(object):
+    class _Job:
         def __init__(self, parent, msg):
             self._parent = parent
             self._msg = msg
@@ -97,7 +94,7 @@ class ProgressPrinter(ProgressReporter):
     status every ten percent.
     """
     def __init__(self, digits=1):
-        super(ProgressPrinter, self).__init__()
+        super().__init__()
         self._b = myokit.tools.Benchmarker()
         self._f = None
         self._d = int(digits)
@@ -138,7 +135,7 @@ class Timeout(ProgressReporter):
     Progress reporter that cancels a simulation after ``timeout`` seconds.
     """
     def __init__(self, timeout):
-        super(Timeout, self).__init__()
+        super().__init__()
         self._timeout = float(timeout)
 
     def enter(self, msg=None):

myokit/_protocol.py

@@ -1,18 +1,17 @@
 #
-# Defines the python classes that represent a pacing protocol.
+# Defines the python classes that represent pacing protocols.
 #
 # 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 numpy as np
 
+from bisect import bisect_right
+
 
-class Protocol(object):
+class Protocol:
     """
     Represents a pacing protocol as a sequence of :class:`events
     <ProtocolEvent>`.
@@ -43,11 +42,11 @@ class Protocol(object):
     is not.
 
     Protocols can be compared with ``==``, which will check if the :meth:`code`
-    for both protocols is the same. Protocols can be serialised with
+    for both protocols is the same. Protocols can be serialized with
     ``pickle``.
     """
     def __init__(self):
-        super(Protocol, self).__init__()
+        super().__init__()
         self._head = None
 
     def add(self, e):
@@ -534,7 +533,7 @@ class Protocol(object):
         return [p.advance(t) for t in times]
 
 
-class ProtocolEvent(object):
+class ProtocolEvent:
     """
     Describes an event occurring as part of a protocol.
     """
@@ -717,7 +716,7 @@ class ProtocolEvent(object):
         return self.in_words()
 
 
-class PacingSystem(object):
+class PacingSystem:
     """
     This class uses a :class:`myokit.Protocol` to update the value of a
     pacing variable over time.
@@ -850,3 +849,94 @@ class NotAnUnbrokenSequenceError(myokit.MyokitError):
     """ Error raised exclusively by is_unbroken_sequence_exception(). """
     pass
 
+
+class TimeSeriesProtocol:
+    """
+    Represents a pacing protocol as a sequence of time value pairs and an
+    interpolation method (currently only linear interpolation is supported).
+
+    A 1D time-series should be given as input. During the simulation, the value
+    of the pacing variable will be determined by interpolating between the two
+    nearest points in the series. If the simulation time is outside the bounds
+    of the time-series, the first or last value in the series will be used.
+
+    Protocols can be compared with ``==``, which will check if the sequence of
+    time value pairs is the same, and the interpolation method is the same.
+    Protocols can be serialized with ``pickle``.
+
+    """
+
+    def __init__(self, times, values, method=None):
+        super().__init__()
+
+        if len(times) != len(values):
+            raise ValueError('Times and values array must have same size.')
+        times_tpl, values_tpl = zip(*[
+            (float(t), float(v)) for t, v in sorted(zip(times, values))
+        ])
+        self._times = list(times_tpl)
+        self._values = list(values_tpl)
+
+        if method is None:
+            self._method = 'linear'
+        else:
+            self._method = str(method).lower()
+            if self._method not in ('linear', ):
+                raise ValueError(
+                    'Unknown interpolation method: ' + self._method)
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        if not isinstance(other, TimeSeriesProtocol):
+            return False
+        return (
+            self._method == other._method
+            and self._values == other._values
+            and self._times == other._times
+        )
+
+    def __getstate__(self):
+        return {
+            'times': self._times,
+            'values': self._values,
+            'method': self._method,
+        }
+
+    def __setstate__(self, values):
+        self._times = values['times']
+        self._values = values['values']
+        self._method = values['method']
+
+    def clone(self):
+        """
+        Returns a clone of this protocol.
+        """
+        return TimeSeriesProtocol(self._times, self._values, self._method)
+
+    def pace(self, t):
+        """
+        Returns the value of the pacing variable at time ``t``.
+        """
+        if t < self._times[0]:
+            return self._values[0]
+        if t > self._times[-1]:
+            return self._values[-1]
+        i = bisect_right(self._times, t) - 1
+        if i == len(self._times) - 1:
+            return self._values[i]
+        return self._values[i] + (t - self._times[i]) * (
+            self._values[i + 1] - self._values[i]
+        ) / (self._times[i + 1] - self._times[i])
+
+    def times(self):
+        """
+        Returns a list of the times in this protocol.
+        """
+        return self._times
+
+    def values(self):
+        """
+        Returns a list of the values in this protocol.
+        """
+        return self._values

myokit/_sim/__init__.py

@@ -5,10 +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
-
-# Library imports
 import os
 import platform
 import sys
@@ -36,36 +32,23 @@ if platform.system() == 'Windows':  # pragma: no linux cover
             ).stdin
     os.popen = _ospop
 
-
-# Setuptools imports
 from setuptools import setup, Extension  # noqa
 
-
-# Myokit imports
 import myokit       # noqa
 import myokit.pype  # noqa
 
 
-# Dynamic module finding and loading in Python 3.5+ and younger
-if sys.hexversion >= 0x03050000:
-    import importlib.machinery
+def load_module(name, path):
+    """ Dynamically find and load a module (Python 3.5+). """
     import importlib
+    import importlib.machinery
 
-    def load_module(name, path):
-        spec = importlib.machinery.PathFinder.find_spec(name, [path])
-        module = importlib.util.module_from_spec(spec)
-        return module
-
-else:  # pragma: no python 3 cover
-    import imp
-
-    def load_module(name, path):
-        (f, pathname, description) = imp.find_module(name, [path])
-        f.close()
-        return imp.load_dynamic(name, pathname)
+    spec = importlib.machinery.PathFinder.find_spec(name, [path])
+    module = importlib.util.module_from_spec(spec)
+    return module
 
 
-class CModule(object):
+class CModule:
     """
     Abstract base class for classes that dynamically create and compile a
     back-end C-module.

myokit/_sim/cable.c

@@ -26,11 +26,11 @@ model.create_unique_names()
 w = ansic.AnsiCExpressionWriter()
 
 # Process bindings, remove unsupported bindings.
-bound_variables = model.prepare_bindings({
+bound_variables = myokit._prepare_bindings(model, {
     'time'         : 'engine_time',
     'pace'         : 'engine_pace',
     'diffusion_current' : 'diffusion_current',
-    })
+})
 
 # Define var/lhs function
 def v(var, pre='cell->'):
@@ -279,7 +279,7 @@ py_sim_clean()
 }
 
 /*
- * Initialise a run
+ * Initialize a run
  */
 static PyObject*
 sim_init(PyObject *self, PyObject *args)
@@ -367,9 +367,7 @@ sim_init(PyObject *self, PyObject *args)
     for(i_state=0; i_state<ncells * N_STATE; i_state++) {
         flt = PyList_GetItem(state_in, i_state);    /* Borrowed reference */
         if (!PyFloat_Check(flt)) {
-            char errstr[200];
-            sprintf(errstr, "Item %d in state vector is not a float.", i_state);
-            PyErr_SetString(PyExc_Exception, errstr);
+            PyErr_Format(PyExc_Exception, "Item %d in state vector is not a float.", i_state);
             return sim_clean();
         }
     }
@@ -441,7 +439,7 @@ for label, eqs in equations.items():
         /* Initial values */
 <?
 for var in model.states():
-    print(tab*2 + v(var) + ' = PyFloat_AsDouble(PyList_GetItem(state_in, icell * N_STATE + ' + str(var.indice()) + '));')
+    print(tab*2 + v(var) + ' = PyFloat_AsDouble(PyList_GetItem(state_in, icell * N_STATE + ' + str(var.index()) + '));')
 ?>
         /* Zeros for pacing and diffusion current */
 <?
@@ -581,7 +579,7 @@ for var in model.states():
     for(icell=0; icell<ncells; icell++) {
 <?
 for var in model.states():
-    print(tab*2 + 'PyList_SetItem(state_out, icell * N_STATE + ' + str(var.indice()) + ', PyFloat_FromDouble(' + v(var) + '));')
+    print(tab*2 + 'PyList_SetItem(state_out, icell * N_STATE + ' + str(var.index()) + ', PyFloat_FromDouble(' + v(var) + '));')
 ?>
         cell++;
     }

myokit/_sim/cable.py

@@ -4,13 +4,11 @@
 # 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 myokit
 import platform
 
+import myokit
+
 # Location of source file
 SOURCE_FILE = 'cable.c'
 
@@ -39,7 +37,7 @@ class Simulation1d(myokit.CModule):
     ``pace``
         The pacing level, this is set if a protocol was passed in.
     ``diffusion_current``
-        The current flowing from the cell to its neighbours. This will be
+        The current flowing from the cell to its neighbors. This will be
         positive when the cell is acting as a source, negative when it is
         acting as a sink.
 
@@ -77,7 +75,7 @@ class Simulation1d(myokit.CModule):
 
         i = sum[g * (V - V_j)]
 
-    Where the sum is taken over all neighbouring cells j (see [1]).
+    Where the sum is taken over all neighboring cells j (see [1]).
 
     The resulting ODE system is solved using a forward Euler (FE) method with
     fixed step sizes. Smaller step sizes lead to more accurate results, and it
@@ -101,7 +99,7 @@ class Simulation1d(myokit.CModule):
     _index = 0      # Unique id for generated module
 
     def __init__(self, model, protocol=None, ncells=50, rl=False):
-        super(Simulation1d, self).__init__()
+        super().__init__()
 
         # Require a valid model
         model.validate()
@@ -176,7 +174,7 @@ class Simulation1d(myokit.CModule):
                 ' next')
 
         # Set state and default state
-        self._state = self._model.state() * ncells
+        self._state = self._model.initial_values(True) * ncells
         self._default_state = list(self._state)
 
         # Unique simulation id