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

myokit/_expressions.py

@@ -5,26 +5,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 io
 import math
 import numpy
 
 import myokit
-from myokit import IntegrityError
 
-# StringIO in Python 2 and 3
-try:
-    from cStringIO import StringIO
-except ImportError:
-    from io import StringIO
+from myokit import IntegrityError
 
-# Strings in Python 2 and 3
-try:
-    basestring
-except NameError:   # pragma: no python 2 cover
-    basestring = str
 
 # Expression precedence levels
 FUNCTION_CALL = 70
@@ -37,7 +25,7 @@ CONDITION_AND = 10
 LITERAL = 0
 
 
-class Expression(object):
+class Expression:
     """
     Myokit's most generic interface for expressions. All expressions extend
     this class.
@@ -85,8 +73,8 @@ class Expression(object):
         self._cached_unit_tolerant = None
         self._cached_unit_strict = None
 
-    def __bool__(self):     # pragma: no python 2 cover
-        """ Python 3 method to determine the outcome of "if expression". """
+    def __bool__(self):
+        # Determines the outcome of "if expression".
         return True
 
     def bracket(self, op=None):
@@ -142,7 +130,7 @@ class Expression(object):
         """
         # Note: Because variable and component names can change, the output of
         # code can not be cached (for non-literal expressions).
-        b = StringIO()
+        b = io.StringIO()
         self._code(b, component)
         return b.getvalue()
 
@@ -540,8 +528,6 @@ class Expression(object):
         raise NotImplementedError
 
     def __float__(self):
-        # Cast to float is required in Python 3: numpy float etc. are ok, but
-        # this is deprecated.
         return float(self.eval())
 
     def __getitem__(self, key):
@@ -551,9 +537,7 @@ class Expression(object):
         if self._cached_hash is None:
             self._cached_hash = hash(self._polish())
         return self._cached_hash
-        # Note for Python3:
-        #   In Python3, anything that has an __eq__ stops inheriting this hash
-        #   method!
+        # Note: anything that has an __eq__ stops inheriting this hash method!
         # From: https://docs.python.org/3.1/reference/datamodel.html
         # > If a class that overrides __eq__() needs to retain the
         #   implementation of __hash__() from a parent class, the interpreter
@@ -595,7 +579,7 @@ class Expression(object):
 
     def is_literal(self):
         """
-        Returns ``True`` if this expression doesn't contain any references.
+        Returns ``True`` if this expression does not contain any references.
         """
         return len(self._references) == 0
 
@@ -608,8 +592,10 @@ class Expression(object):
 
     def is_number(self, value=None):
         """
-        Returns ``True`` only if this expression is a :class:`myokit.Number`
-        (and has the value ``value``, if given).
+        Returns ``True`` only if this expression is a :class:`myokit.Number`.
+
+        If the optional argument ``value`` is set, it will also return
+        ``False`` if the number does not have the given value.
         """
         return False
 
@@ -629,10 +615,6 @@ class Expression(object):
     def __ne__(self, other):
         return not self.__eq__(other)
 
-    def __nonzero__(self):  # pragma: no python 3 cover
-        """ Python 2 method to determine the outcome of "if expression". """
-        return True
-
     def operator_rep(self):
         """
         Returns a representation of this expression's type. (For example '+' or
@@ -651,7 +633,7 @@ class Expression(object):
         variable id is immutable in the expression's lifetime.
         """
         if self._cached_polish is None:
-            b = StringIO()
+            b = io.StringIO()
             self._polishb(b)
             self._cached_polish = b.getvalue()
         return self._cached_polish
@@ -668,7 +650,7 @@ class Expression(object):
 
     def pyfunc(self, use_numpy=True):
         """
-        Converts this expression to python and returns the new function's
+        Converts this expression to Python and returns the new function's
         handle.
 
         By default, when converting mathematical functions such as ``log``, the
@@ -689,19 +671,19 @@ class Expression(object):
         # Create function
         local = {}
         if use_numpy:
-            myokit._exec(c, {'numpy': numpy}, local)
+            exec(c, {'numpy': numpy}, local)
         else:
-            myokit._exec(c, {'math': math}, local)
+            exec(c, {'math': math}, local)
 
         # Return
         return local['ex_pyfunc_generated']
 
     def pystr(self, use_numpy=False):
         """
-        Returns a string representing this expression in python syntax.
+        Returns a string representing this expression in Python syntax.
 
         By default, built-in functions such as 'exp' are converted to the
-        python version 'math.exp'. To use the numpy versions, set
+        Python version 'math.exp'. To use the numpy versions, set
         ``numpy=True``.
         """
         # Get expression writer
@@ -740,7 +722,7 @@ class Expression(object):
         Returns a string representing the parse tree corresponding to this
         expression.
         """
-        b = StringIO()
+        b = io.StringIO()
         self._tree_str(b, 0)
         return b.getvalue()
 
@@ -853,7 +835,7 @@ class Number(Expression):
     _rbp = LITERAL
 
     def __init__(self, value, unit=None):
-        super(Number, self).__init__()
+        super().__init__()
         if isinstance(value, myokit.Quantity):
             # Conversion from Quantity class
             if unit is not None:
@@ -867,7 +849,7 @@ class Number(Expression):
             self._value = float(value) if value else 0.0
             if unit is None or isinstance(unit, myokit.Unit):
                 self._unit = unit
-            elif isinstance(unit, basestring):
+            elif isinstance(unit, str):
                 self._unit = myokit.parse_unit(unit)
             else:
                 raise ValueError(
@@ -983,7 +965,7 @@ class LhsExpression(Expression):
         return self.var().is_constant()
 
     def is_literal(self):
-        """See :meth:`Expression.is_constant()`."""
+        """See :meth:`Expression.is_literal()`."""
         return False
 
     def rhs(self):
@@ -1011,10 +993,10 @@ class Name(LhsExpression):
     *Extends:* :class:`LhsExpression`
     """
     _rbp = LITERAL
-    __hash__ = LhsExpression.__hash__   # For Python3, when __eq__ is present
+    __hash__ = LhsExpression.__hash__
 
     def __init__(self, value):
-        super(Name, self).__init__()
+        super().__init__()
         self._value = value
         self._references = set([self])
         self._proper = isinstance(self._value, myokit.Variable)
@@ -1052,7 +1034,7 @@ class Name(LhsExpression):
                     except KeyError:
                         pass
                 b.write(self._value.qname(c))
-        elif isinstance(self._value, basestring):
+        elif isinstance(self._value, str):
             # Allow strings for debugging
             b.write('str:' + str(self._value))
         else:
@@ -1123,7 +1105,7 @@ class Name(LhsExpression):
         return self._proper and self._value.is_state()
 
     def _polishb(self, b):
-        if isinstance(self._value, basestring):
+        if isinstance(self._value, str):
             # Allow an exception for strings
             b.write('str:')
             b.write(self._value)
@@ -1142,7 +1124,7 @@ class Name(LhsExpression):
         """See :meth:`LhsExpression.rhs()`."""
         if self._proper:
             if self._value.is_state():
-                return Number(self._value.state_value())
+                return self._value.initial_value()
             elif self._value.lhs() == self:
                 return self._value.rhs()
         return None
@@ -1151,7 +1133,7 @@ class Name(LhsExpression):
         b.write(' ' * n + str(self._value) + '\n')
 
     def _validate(self, trail):
-        super(Name, self)._validate(trail)
+        super()._validate(trail)
         # Check value: String is allowed at construction for debugging, but
         # not here!
         if not self._proper:
@@ -1172,10 +1154,10 @@ class Derivative(LhsExpression):
     """
     _rbp = FUNCTION_CALL
     _nargs = [1]    # Allows parsing as a function
-    __hash__ = LhsExpression.__hash__   # For Python3, when __eq__ is present
+    __hash__ = LhsExpression.__hash__
 
     def __init__(self, op):
-        super(Derivative, self).__init__((op,))
+        super().__init__((op,))
         if not isinstance(op, Name):
             raise IntegrityError(
                 'The dot() operator can only be used on variables.',
@@ -1272,7 +1254,7 @@ class Derivative(LhsExpression):
         return self._op._value
 
     def _validate(self, trail):
-        super(Derivative, self)._validate(trail)
+        super()._validate(trail)
         # Check that value is a variable has already been performed by name
         # Check if value is the name of a state variable
         if not self._op._value.is_state():
@@ -1293,7 +1275,7 @@ class PartialDerivative(LhsExpression):
     """
     _rbp = FUNCTION_CALL
     _nargs = [2]    # Allows parsing as a function
-    __hash__ = LhsExpression.__hash__   # For Python3, when __eq__ is present
+    __hash__ = LhsExpression.__hash__
 
     def __init__(self, var1, var2):
         if not isinstance(var1, (Name, Derivative)):
@@ -1304,7 +1286,7 @@ class PartialDerivative(LhsExpression):
             raise IntegrityError(
                 'The second argument to a partial derivative must be a'
                 ' variable name or an initial value.')
-        super(PartialDerivative, self).__init__((var1, var2))
+        super().__init__((var1, var2))
 
         self._var1 = var1
         self._var2 = var2
@@ -1390,7 +1372,7 @@ class PartialDerivative(LhsExpression):
         As with time-derivatives, this returns the variable of which a
         derivative is taken (i.e. the dependent variable "y" in "dy/dx").
         """
-        return self._var1._value
+        return self._var1.var()
 
 
 class InitialValue(LhsExpression):
@@ -1404,13 +1386,13 @@ class InitialValue(LhsExpression):
     """
     _rbp = FUNCTION_CALL
     _nargs = [1]    # Allows parsing as a function
-    __hash__ = LhsExpression.__hash__   # For Python3, when __eq__ is present
+    __hash__ = LhsExpression.__hash__
 
     def __init__(self, var):
-        super(InitialValue, self).__init__((var, ))
+        super().__init__((var, ))
         if not isinstance(var, Name):
             raise IntegrityError(
-                'The first argument to an initial condition must be a variable'
+                'The first argument to an initial value must be a variable'
                 ' name.', self._token)
 
         self._var = var
@@ -1436,7 +1418,7 @@ class InitialValue(LhsExpression):
 
     def _diff(self, lhs, idstates):
         raise NotImplementedError(
-            'Partial derivatives of initial conditions are not supported.')
+            'Partial derivatives of initial values are not supported.')
 
     def _eval_unit(self, mode):
         return self._var._eval_unit(mode)
@@ -1453,7 +1435,7 @@ class InitialValue(LhsExpression):
         See :meth:`LhsExpression.rhs()`.
 
         The RHS returned in this case will be ``None``, as there is no RHS
-        associated with initial conditions in the model.
+        associated with initial values in the model.
         """
         # Note: This _could_ return a Number(init, var unit) instead...
         return None
@@ -1466,12 +1448,12 @@ class InitialValue(LhsExpression):
         return self._var._value
 
     def _validate(self, trail):
-        super(InitialValue, self)._validate(trail)
+        super()._validate(trail)
         # Check if value is the name of a state variable
         var = self._var._value
         if not (isinstance(var, myokit.Variable) and var.is_state()):
             raise IntegrityError(
-                'Initial conditions can only be defined for state variables.',
+                'Initial values can only be defined for state variables.',
                 self._token)
 
 
@@ -1485,7 +1467,7 @@ class PrefixExpression(Expression):
     _rep = None
 
     def __init__(self, op):
-        super(PrefixExpression, self).__init__((op,))
+        super().__init__((op,))
         self._op = op
 
     def bracket(self, op):
@@ -1584,7 +1566,7 @@ class InfixExpression(Expression):
     _spaces_round_operator = True
 
     def __init__(self, left, right):
-        super(InfixExpression, self).__init__((left, right))
+        super().__init__((left, right))
         self._op1 = left
         self._op2 = right
 
@@ -1878,7 +1860,7 @@ class Quotient(InfixExpression):
         #
         # Alternatively, a // b = floor(a / b).
         #
-        # Here we ignore the discontinuities in favour of a left or right
+        # Here we ignore the discontinuities in favor of a left or right
         # derivative, and simply return zero for all points.
         return None
 
@@ -2087,7 +2069,7 @@ class Function(Expression):
     _rbp = FUNCTION_CALL
 
     def __init__(self, *ops):
-        super(Function, self).__init__(ops)
+        super().__init__(ops)
         if self._nargs is not None:
             if not len(ops) in self._nargs:
                 raise IntegrityError(
@@ -2658,7 +2640,7 @@ class If(Function):
     _fname = 'if'
 
     def __init__(self, i, t, e):
-        super(If, self).__init__(i, t, e)
+        super().__init__(i, t, e)
         self._i = i     # if
         self._t = t     # then
         self._e = e     # else
@@ -2764,7 +2746,7 @@ class Piecewise(Function):
     _fname = 'piecewise'
 
     def __init__(self, *ops):
-        super(Piecewise, self).__init__(*ops)
+        super().__init__(*ops)
 
         # Check number of arguments
         n = len(self._operands)
@@ -2852,7 +2834,7 @@ class Piecewise(Function):
         return iter(self._e)
 
 
-class Condition(object):
+class Condition:
     """
     *Abstract class*
 
@@ -2866,7 +2848,7 @@ class Condition(object):
             'Conditions do not have partial derivatives.')
 
 
-class PrefixCondition(Condition, PrefixExpression):
+class PrefixCondition(PrefixExpression, Condition):
     """
     Interface for prefix conditions.
 
@@ -2920,7 +2902,7 @@ class Not(PrefixCondition):
         self._op._polishb(b)
 
 
-class InfixCondition(Condition, InfixExpression):
+class InfixCondition(InfixExpression, Condition):
     """
     Base class for infix expressions.
 

myokit/_io.py

@@ -6,19 +6,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 array
+import io
 import os
 import sys
 
-# StringIO in Python 2 and 3
-try:
-    from cStringIO import StringIO
-except ImportError:  # pragma: no python 2 cover
-    from io import StringIO
-
 import myokit
 
 
@@ -93,7 +85,7 @@ def load_script(filename):
 
 def load_state(filename, model=None):
     """
-    Loads an initial state from a file in one of the formats specified by
+    Loads a model state from a file in one of the formats specified by
     :func:`myokit.parse_state()`.
 
     If a :class:`Model` is provided the state will be run through
@@ -110,7 +102,8 @@ def load_state(filename, model=None):
 
 def load_state_bin(filename):
     """
-    Loads an initial state from a file in the binary format used by myokit.
+    Loads a model state from a file in the binary format used by Myokit.
+
     See :meth:`save_state_bin` for details.
     """
     filename = os.path.expanduser(filename)
@@ -144,8 +137,6 @@ def load_state_bin(filename):
         code = parts[1]
         if code not in ['d', 'f']:  # pragma: no cover
             raise Exception('Invalid state file format [40].')
-        # Convert code to str for Python 2.7.10 (see #225)
-        code = str(code)
 
         size = int(parts[2])
         if size < 0:    # pragma: no cover
@@ -153,10 +144,7 @@ def load_state_bin(filename):
 
         # Create array, read bytes into array
         ar = array.array(code)
-        try:
-            ar.frombytes(f.read(info))
-        except AttributeError:  # pragma: no python 3 cover
-            ar.fromstring(f.read(info))
+        ar.frombytes(f.read(info))
 
         # Always store as little endian
         if sys.byteorder == 'big':  # pragma: no cover
@@ -175,11 +163,15 @@ def save(filename=None, model=None, protocol=None, script=None):
 
     If no filename is given the ``mmt`` code is returned as a string.
     """
+    if model is None and protocol is None and script is None:
+        raise ValueError(
+            'At least one of [model, protocol, script] must not be None.')
+
     if filename:
         filename = os.path.expanduser(filename)
         f = open(filename, 'w')
     else:
-        f = StringIO()
+        f = io.StringIO()
     out = None
     try:
         if model is not None:
@@ -244,7 +236,7 @@ def save_script(filename, script):
 
 def save_state(filename, state, model=None):
     """
-    Stores the given state in the file at ``filename``.
+    Stores a model state to the path ``filename``.
 
     If no ``model`` is specified ``state`` should be given as a list of
     floating point numbers and will be stored by simply placing each number on
@@ -272,8 +264,8 @@ def save_state(filename, state, model=None):
 
 def save_state_bin(filename, state, precision=myokit.DOUBLE_PRECISION):
     """
-    Stores the given state (or any list of floating point numbers) in the file
-    at ``filename``, using a binary format.
+    Stores a model state (or any given list of floating point numbers) to the
+    path ``filename``, using a binary format.
 
     The used format is a zip file, containing a single entry: ``state_x_y``,
     where ``x`` is the used data type (``d`` or ``f``) and ``y`` is the number
@@ -292,8 +284,7 @@ def save_state_bin(filename, state, precision=myokit.DOUBLE_PRECISION):
             'This method requires the `zlib` module to be installed.')
 
     # Data type
-    # Convert code to str for Python 2.7.10 (see #225)
-    code = str('d' if precision == myokit.DOUBLE_PRECISION else 'f')
+    code = 'd' if precision == myokit.DOUBLE_PRECISION else 'f'
 
     # Create array, ensure it's little-endian
     ar = array.array(code, state)
@@ -306,10 +297,7 @@ def save_state_bin(filename, state, precision=myokit.DOUBLE_PRECISION):
     info.compress_type = zipfile.ZIP_DEFLATED
 
     # Write to compressed file
-    try:
-        ar = ar.tobytes()
-    except AttributeError:  # pragma: no python 3 cover
-        ar = ar.tostring()
+    ar = ar.tobytes()
     with zipfile.ZipFile(filename, 'w') as f:
         f.writestr(info, ar)