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

myokit/_datalog.py

@@ -4,22 +4,16 @@
 # 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 sys
 import array
+
 import numpy as np
+
 from collections import OrderedDict
-import myokit
 
-# Strings in Python 2 and 3
-try:
-    basestring
-except NameError:   # pragma: no python 2 cover
-    basestring = str
+import myokit
 
 
 # Function to split keys into dimension-key,qname-key pairs
@@ -95,18 +89,17 @@ class DataLog(OrderedDict):
     ``time``
         The log key to use for the time variable. When cloning a log, adding
         the ``time`` argument will overwrite the cloned value.
+
     """
+
     def __init__(self, other=None, time=None):
-        """
-        Creates a new DataLog.
-        """
         if other is None:
             # Create new
-            super(DataLog, self).__init__()
+            super().__init__()
             self._time = None
         else:
             # Clone
-            super(DataLog, self).__init__(other)
+            super().__init__(other)
             try:
                 self._time = str(other._time)
             except Exception:
@@ -119,7 +112,7 @@ class DataLog(OrderedDict):
         Calculates one or more Action Potential Durations (APDs) in a single
         cell's membrane potential.
 
-        *Note 1: More accuracte apd measurements can be created using the*
+        *Note 1: More accuracte APD measurements can be obtained using the*
         :class:`Simulation` *object's APD tracking functionality. See*
         :meth:`Simulation.run()` *for details.*
 
@@ -130,10 +123,6 @@ class DataLog(OrderedDict):
         The membrane potential data should be listed in the log under the key
         given by ``v``.
 
-        The APD is measured as the time that the membrane potential exceeds a
-        certain, fixed, threshold. It does *not* calculate dynamic thresholds
-        like "90% of max(V) - min(V)".
-
         The returned value is a list of tuples (AP_start, APD).
         """
         def crossings(x, y, t):
@@ -221,10 +210,10 @@ class DataLog(OrderedDict):
         return log
 
     def __contains__(self, key):
-        return super(DataLog, self).__contains__(self._parse_key(key))
+        return super().__contains__(self._parse_key(key))
 
     def __delitem__(self, key):
-        return super(DataLog, self).__delitem__(self._parse_key(key))
+        return super().__delitem__(self._parse_key(key))
 
     def extend(self, other):
         """
@@ -240,9 +229,11 @@ class DataLog(OrderedDict):
                 'Cannot extend DataLog with data from an earlier time.')
         if set(self.keys()) != set(other.keys()):
             raise ValueError('Both logs must have the same keys.')
+
         # Create new log
         log = DataLog()
         log._time = self._time
+
         # Add data
         for k, v1 in self.items():
             v2 = other[k]
@@ -252,6 +243,7 @@ class DataLog(OrderedDict):
             else:
                 log[k] = list(v1)   # Copies v1 data
                 log[k].extend(v2)   # Copies v2 data
+
         # Return
         return log
 
@@ -269,7 +261,7 @@ class DataLog(OrderedDict):
 
     def find_after(self, time):
         """
-        Returns the lowest indice ``i`` such that
+        Returns the lowest index ``i`` such that
 
             times[i] >= time
 
@@ -288,7 +280,7 @@ class DataLog(OrderedDict):
 
         # Find t
         def find(lo, hi):
-            # lo = first indice, hi = last indice + 1
+            # lo = first index, hi = last index + 1
             if (lo + 1 == hi):
                 return lo + 1
             m = int((lo + hi) / 2)
@@ -330,7 +322,7 @@ class DataLog(OrderedDict):
         return out
 
     def __getitem__(self, key):
-        return super(DataLog, self).__getitem__(self._parse_key(key))
+        return super().__getitem__(self._parse_key(key))
 
     def has_nan(self):
         """
@@ -442,7 +434,7 @@ class DataLog(OrderedDict):
 
     def itrim_left(self, i):
         """
-        Returns a copy of this log, with all entries before indice ``i``
+        Returns a copy of this log, with all entries before index ``i``
         removed (similar to performing ``x = x[i:]`` on a list).
         """
         log = DataLog()
@@ -456,7 +448,7 @@ class DataLog(OrderedDict):
 
     def itrim_right(self, i):
         """
-        Returns a copy of this log, with all entries starting from indice ``i``
+        Returns a copy of this log, with all entries starting from index ``i``
         removed (similar to performing ``x = x[:i]`` on a list).
         """
         log = DataLog()
@@ -519,17 +511,10 @@ class DataLog(OrderedDict):
                 'This method requires the ``zlib`` module to be installed.')
 
         # Get size of single and double types on this machine
-        try:
-            dsize = {
-                'd': len(array.array('d', [1]).tobytes()),
-                'f': len(array.array('f', [1]).tobytes()),
-            }
-        except (AttributeError, TypeError):  # pragma: no python 3 cover
-            # List dtype as str for Python 2.7.10 (see #225)
-            dsize = {
-                b'd': len(array.array(b'd', [1]).tostring()),
-                b'f': len(array.array(b'f', [1]).tostring()),
-            }
+        dsize = {
+            'd': len(array.array('d', [1]).tobytes()),
+            'f': len(array.array('f', [1]).tobytes()),
+        }
 
         # Read data
         try:
@@ -565,7 +550,7 @@ class DataLog(OrderedDict):
         head = iter(head.splitlines())
         n = int(next(head))
         data_size = int(next(head))
-        data_type = str(next(head))  # Cast to str for Python 2.7.10 (see #225)
+        data_type = next(head)
         time = next(head)
         if time:
             # Note, this field doesn't have to be present in the log!
@@ -606,10 +591,7 @@ class DataLog(OrderedDict):
 
                 # Read data
                 ar = array.array(data_type)
-                try:
-                    ar.frombytes(body[start:end])
-                except AttributeError:  # pragma: no python 3 cover
-                    ar.fromstring(body[start:end])
+                ar.frombytes(body[start:end])
                 if sys.byteorder == 'big':  # pragma: no cover
                     ar.byteswap()
                 log[field] = ar
@@ -640,8 +622,7 @@ class DataLog(OrderedDict):
         filename = os.path.expanduser(filename)
 
         # Typecode dependent on precision
-        # Typecode must be str for Python 2.7.10 (see #225)
-        typecode = str('d' if precision == myokit.DOUBLE_PRECISION else 'f')
+        typecode = 'd' if precision == myokit.DOUBLE_PRECISION else 'f'
 
         # Error raising function
         def e(line, char, msg):
@@ -649,16 +630,9 @@ class DataLog(OrderedDict):
                 'Syntax error on line ' + str(line) + ', character '
                 + str(1 + char) + ': ' + msg)
 
-        def uopen(filename):
-            # Open a filename in 'universal newline' mode, python 2 and 3
-            try:
-                return open(filename, 'r', newline=None)
-            except TypeError:   # pragma: no python 3 cover
-                return open(filename, 'U')
-
         quote = '"'
         delim = ','
-        with uopen(filename) as f:
+        with open(filename, 'r', newline=None) as f:
             # Read header
             keys = []   # The log keys, in order of appearance
 
@@ -828,11 +802,16 @@ class DataLog(OrderedDict):
             key = '.'.join(parts)
         return str(key)
 
-    def regularize(self, dt, tmin=None, tmax=None):
+    def regularize(self, dt, tmin=None, tmax=None):  # pragma: no cover
         """
         Returns a copy of this DataLog with data points at regularly spaced
         times.
 
+        This method is deprecated and will be removed in future versions of
+        Myokit.
+
+        This method requires ``SciPy`` to be installed.
+
         *Note: While regularize() can be used post-simulation to create fixed
         time-step data from variable time-step data, it is usually better to
         re-run a simulation with fixed time step logging. See*
@@ -856,17 +835,21 @@ class DataLog(OrderedDict):
 
         As a result of the cubic spline interpolation, the function may perform
         poorly on large data sets.
-
-        This method requires ``SciPy`` to be installed.
         """
-        self.validate()
+        # Deprecated since 2023-06-06
+        import warnings
+        warnings.warn(
+            'The method `regularize` is deprecated and will be removed in'
+            ' future versions of Myokit.')
+
         from scipy.interpolate import UnivariateSpline as Spline
+        self.validate()
 
         # Check time variable
         time = self.time()
         n = len(time)
 
-        # Get left indice for splines
+        # Get left index for splines
         imin = 0
         if tmin is None:
             tmin = time[0]
@@ -875,7 +858,7 @@ class DataLog(OrderedDict):
             # left so that the spline has 4 points
             imin = max(0, np.searchsorted(time, tmin) - 2)
 
-        # Get right indice for splines
+        # Get right index for splines
         imax = n
         if tmax is None:
             tmax = time[-1]
@@ -929,8 +912,7 @@ class DataLog(OrderedDict):
                 'This method requires the `zlib` module to be installed.')
 
         # Data type
-        # dtype must be str for Python 2.7.10 (see #225)
-        dtype = str('d' if precision == myokit.DOUBLE_PRECISION else 'f')
+        dtype = 'd' if precision == myokit.DOUBLE_PRECISION else 'f'
 
         # Create data strings
         head_str = []
@@ -952,10 +934,7 @@ class DataLog(OrderedDict):
             ar = array.array(dtype, v)
             if sys.byteorder == 'big':  # pragma: no cover
                 ar.byteswap()
-            try:
-                body_str.append(ar.tobytes())
-            except AttributeError:   # pragma: no python 3 cover
-                body_str.append(ar.tostring())
+            body_str.append(ar.tobytes())
         head_str = '\n'.join(head_str)
         body_str = b''.join(body_str)
 
@@ -999,7 +978,7 @@ class DataLog(OrderedDict):
             If a precision argument (for example ``myokit.DOUBLE_PRECISION``)
             is given, the output will be stored in such a way that this amount
             of precision is guaranteed to be present in the string. If the
-            precision argument is set to ``None`` python's default formatting
+            precision argument is set to ``None`` Python's default formatting
             is used, which may lead to smaller files.
         ``order``
             To specify the ordering of the log's arguments, pass in a sequence
@@ -1100,7 +1079,7 @@ class DataLog(OrderedDict):
         self._time = None if key is None else str(key)
 
     def __setitem__(self, key, value):
-        return super(DataLog, self).__setitem__(
+        return super().__setitem__(
             self._parse_key(key), value)
 
     def split(self, value):
@@ -1129,7 +1108,7 @@ class DataLog(OrderedDict):
 
         By default, the returned intervals are *closed*, so both the left and
         right endpoint are included (if present in the data). This may involve
-        the duplication of some data points. To disable this behaviour and
+        the duplication of some data points. To disable this behavior and
         return half-closed endpoints (containing only the left point), set
         ``closed_intervals`` to ``False``.
         """
@@ -1415,7 +1394,7 @@ class DataLog(OrderedDict):
         return infos
 
 
-class LoggedVariableInfo(object):
+class LoggedVariableInfo:
     """
     Contains information about the log entries for each variable. These objects
     should only be created by :meth:`DataLog.variable_info()`.
@@ -1622,9 +1601,7 @@ def prepare_log(
     be specified using the ``precision`` argument.
     """
     # Typecode dependent on precision
-    # Note: Cast to str() here makes it work with older versions of 2.7.x,
-    # where unicode isn't accepted (Python 3 of course doesn't accept bytes)
-    typecode = str('d' if precision == myokit.DOUBLE_PRECISION else 'f')
+    typecode = 'd' if precision == myokit.DOUBLE_PRECISION else 'f'
 
     # Get all options for dimensionality
     if dims is None:
@@ -1867,7 +1844,7 @@ def prepare_log(
             'Argument `log` has unexpected type. Expecting None, integer flag,'
             ' sequence of names, dict or DataLog.')
 
-    if isinstance(log, basestring):
+    if isinstance(log, str):
         raise ValueError(
             'String passed in as `log` argument, should be list'
             ' or other sequence containing strings.')

myokit/_err.py

@@ -4,8 +4,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
 
 
 # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
@@ -24,7 +22,7 @@ class MyokitError(Exception):
     *Extends:* ``Exception``
     """
     def __init__(self, message):
-        super(MyokitError, self).__init__(message)
+        super().__init__(message)
 
 
 class IntegrityError(MyokitError):
@@ -37,7 +35,7 @@ class IntegrityError(MyokitError):
     *Extends:* :class:`myokit.MyokitError`
     """
     def __init__(self, message, token=None):
-        super(IntegrityError, self).__init__(message)
+        super().__init__(message)
         self._token = token
 
     def token(self):
@@ -77,7 +75,7 @@ class CyclicalDependencyError(IntegrityError):
         # Set token: First item in cycle is model's defining lhs
         tok = cycle[0].var()._token
         # Raise
-        super(CyclicalDependencyError, self).__init__(msg, tok)
+        super().__init__(msg, tok)
 
 
 class DataBlockReadError(MyokitError):
@@ -167,10 +165,21 @@ class IllegalReferenceError(IntegrityError):
     *Extends:* :class:`myokit.IntegrityError`
     """
     def __init__(self, reference, owner):
-        super(IllegalReferenceError, self).__init__(
+        super().__init__(
             'Illegal reference: The referenced variable <' + reference.qname()
-            + '> is outside the scope of <' + owner.qname() + '>.'
-        )
+            + '> is outside the scope of <' + owner.qname() + '>.')
+
+
+class IllegalReferenceInInitialValueError(IllegalReferenceError):
+    """
+    Raised when an illegal reference is made in an initial value.
+
+    The only way this can occur is if the reference is to a nested variable.
+    """
+    def __init__(self, reference, owner):
+        super(IntegrityError, self).__init__(
+            'Illegal reference made in initial value: The referenced variable'
+            ' <' + reference.qname() + '> is nested.')
 
 
 class ImportError(MyokitError):
@@ -192,7 +201,7 @@ class IncompatibleModelError(MyokitError):
         if model_name:
             msg += ' <' + str(model_name) + '>'
         msg += ': ' + str(message)
-        super(IncompatibleModelError, self).__init__(msg)
+        super().__init__(msg)
 
 
 class IncompatibleUnitError(MyokitError):
@@ -202,7 +211,7 @@ class IncompatibleUnitError(MyokitError):
     *Extends:* :class:`myokit.MyokitError`.
     """
     def __init__(self, message, token=None):
-        super(MyokitError, self).__init__(message)
+        super().__init__(message)
         self._token = token
 
     def token(self):
@@ -277,7 +286,7 @@ class MissingRhsError(IntegrityError):
     def __init__(self, var):
         msg = 'No rhs set for <' + var.qname() + '>.'
         tok = var._token
-        super(MissingRhsError, self).__init__(msg, tok)
+        super().__init__(msg, tok)
 
 
 class MissingTimeVariableError(IntegrityError):
@@ -289,15 +298,7 @@ class MissingTimeVariableError(IntegrityError):
     def __init__(self):
         msg = 'No variable bound to time. At least one of the model\'s' \
               ' variables must be bound to "time".'
-        super(MissingTimeVariableError, self).__init__(msg)
-
-
-class NonLiteralValueError(IntegrityError):
-    """
-    Raised when a literal value is required but not given.
-
-    *Extends:* :class:`myokit.IntegrityError`
-    """
+        super().__init__(msg)
 
 
 class NumericalError(MyokitError):
@@ -336,7 +337,7 @@ class ParseError(MyokitError):
         self.desc = str(desc)
         self.value += ': ' + self.desc
         self.cause = cause
-        super(ParseError, self).__init__(self.value)
+        super().__init__(self.value)
 
 
 class ProtocolEventError(MyokitError):
@@ -380,7 +381,7 @@ class SimulationCancelledError(MyokitError):
     *Extends:* :class:`myokit.MyokitError`
     """
     def __init__(self, message='Operation cancelled by user.'):
-        super(SimulationCancelledError, self).__init__(message)
+        super().__init__(message)
 
 
 class SimultaneousProtocolEventError(MyokitError):
@@ -399,7 +400,7 @@ class UnresolvedReferenceError(IntegrityError):
     *Extends:* :class:`myokit.IntegrityError`
     """
     def __init__(self, reference, extra_message=None):
-        super(UnresolvedReferenceError, self).__init__(
+        super().__init__(
             'Unknown variable: <' + reference + '>.'
             + ((' ' + extra_message) if extra_message else '')
         )
@@ -416,7 +417,7 @@ class UnusedVariableError(IntegrityError):
     def __init__(self, var):
         msg = 'Unused variable: <' + var.qname() + '>.'
         tok = var.lhs()._token
-        super(UnusedVariableError, self).__init__(msg, tok)
+        super().__init__(msg, tok)
 
 
 class VariableMappingError(MyokitError):