myokit 1.34.0__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
@@ -631,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
@@ -653,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
@@ -670,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
@@ -691,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
@@ -742,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()
 
@@ -855,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:
@@ -869,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(
@@ -1013,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)
@@ -1054,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:
@@ -1125,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)
@@ -1153,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:
@@ -1174,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.',
@@ -1274,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():
@@ -1295,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)):
@@ -1306,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
@@ -1406,10 +1386,10 @@ 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 value must be a variable'
@@ -1468,7 +1448,7 @@ 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()):
@@ -1487,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):
@@ -1586,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
 
@@ -2089,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(
@@ -2660,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
@@ -2766,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)
@@ -2854,7 +2834,7 @@ class Piecewise(Function):
         return iter(self._e)
 
 
-class Condition(object):
+class Condition:
     """
     *Abstract class*
 

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
 
 
@@ -145,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
@@ -154,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
@@ -184,7 +171,7 @@ def save(filename=None, model=None, protocol=None, script=None):
         filename = os.path.expanduser(filename)
         f = open(filename, 'w')
     else:
-        f = StringIO()
+        f = io.StringIO()
     out = None
     try:
         if model is not None:
@@ -297,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)
@@ -311,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)
 

myokit/_model_api.py

@@ -4,25 +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
-
-from collections import OrderedDict
+import io
 import math
 import re
-import myokit
 
-# StringIO in Python 2 and 3
-try:
-    from cStringIO import StringIO
-except ImportError:
-    from io import StringIO
+from collections import OrderedDict
+
+import myokit
 
-# Strings in Python 2 and 3
-try:
-    basestring
-except NameError:   # pragma: no cover
-    basestring = str
 
 TAB = ' ' * 4
 NAME = re.compile(r'^[a-zA-Z]\w*$')
@@ -34,8 +23,6 @@ def check_name(name):
     Tests if the given name is a valid myokit name and raises a
     :class:`myokit.InvalidNameError` if it isn't.
     """
-    # Note: Names are stored as str (so unicode in Python3)
-    # But the regex restriction means their format is compatible with ascii.
     # Check str compatibility
     name = str(name)
 
@@ -65,7 +52,7 @@ class MetaDataContainer(dict):
             raise myokit.InvalidMetaDataNameError(
                 'The key <' + str(key) + '>'
                 ' is not a valid meta-data property identifier.')
-        return super(MetaDataContainer, self).__getitem__(key)
+        return super().__getitem__(key)
 
     def __setitem__(self, key, item):
         # Check item
@@ -75,10 +62,10 @@ class MetaDataContainer(dict):
             raise myokit.InvalidMetaDataNameError(
                 'The key <' + str(key) + '>'
                 ' is not a valid meta-data property identifier.')
-        super(MetaDataContainer, self).__setitem__(key, item)
+        super().__setitem__(key, item)
 
 
-class ObjectWithMeta(object):
+class ObjectWithMeta:
     """
     Base class for objects with meta data.
 
@@ -87,7 +74,7 @@ class ObjectWithMeta(object):
     """
 
     def __init__(self):
-        super(ObjectWithMeta, self).__init__()
+        super().__init__()
         self.meta = MetaDataContainer()
 
     def _clone_metadata(self, clone):
@@ -135,7 +122,7 @@ class ModelPart(ObjectWithMeta):
         The given parent should be a ModelPart or None. The name should be
         unique within the set of children for the given parent.
         """
-        super(ModelPart, self).__init__()
+        super().__init__()
         self._parent = parent   # This object's parent
         self._model = None      # The model this object belongs to
         self._name = str(name)  # Local name
@@ -153,7 +140,7 @@ class ModelPart(ObjectWithMeta):
         """
         Returns this object in ``mmt`` syntax.
         """
-        b = StringIO()
+        b = io.StringIO()
         self._code(b, 0)
         return b.getvalue()
 
@@ -162,7 +149,7 @@ class ModelPart(ObjectWithMeta):
         Internal version of _code(), to be implemented by all subclasses.
 
         The argument ``t`` specifies the number of tabs to indent the code
-        with. The argument ``b`` is a cStringIO buffer.
+        with. The argument ``b`` is a StringIO buffer.
         """
         raise NotImplementedError
 
@@ -249,7 +236,7 @@ class ModelPart(ObjectWithMeta):
         return self._uname
 
 
-class VarProvider(object):
+class VarProvider:
     """
     *Abstract class*
 
@@ -463,7 +450,7 @@ class VarOwner(ModelPart, VarProvider):
     """
 
     def __init__(self, parent, name):
-        super(VarOwner, self).__init__(parent, name)
+        super().__init__(parent, name)
         self._variables = {}
         # Set component
         self._component = self
@@ -789,7 +776,7 @@ class Model(ObjectWithMeta, VarProvider):
     """
 
     def __init__(self, name=None):
-        super(Model, self).__init__()
+        super().__init__()
 
         # A dictionary of components
         self._components = {}
@@ -1124,7 +1111,7 @@ class Model(ObjectWithMeta, VarProvider):
 
         Line numbers can be added by setting ``line_numbers=True``.
         """
-        b = StringIO()
+        b = io.StringIO()
         b.write('[[model]]\n')
         self._code(b, 0)
         if line_numbers:
@@ -1749,7 +1736,7 @@ class Model(ObjectWithMeta, VarProvider):
             'as external_component, or a string if only one '
             'component is provided'
         )
-        if isinstance(new_name, basestring):
+        if isinstance(new_name, str):
             if len(external_component) != 1:
                 raise TypeError(new_name_error_str)
             new_name = [new_name]
@@ -1757,7 +1744,7 @@ class Model(ObjectWithMeta, VarProvider):
             try:
                 ok = (
                     len(new_name) == len(external_component) and
-                    all(isinstance(name, basestring) for name in new_name)
+                    all(isinstance(name, str) for name in new_name)
                 )
                 if not ok:
                     raise TypeError(new_name_error_str)
@@ -1836,7 +1823,7 @@ class Model(ObjectWithMeta, VarProvider):
                             'The variable <' + self_var.qname() + '> in the'
                             ' given var_map\'s values is not part of this'
                             ' model.')
-                elif isinstance(self_var, basestring):
+                elif isinstance(self_var, str):
                     try:
                         self_var = self.var(self_var)
                     except KeyError:
@@ -1858,7 +1845,7 @@ class Model(ObjectWithMeta, VarProvider):
                             'The variable <' + ext_var.qname() + '> in the'
                             ' given var_map\'s keys but is not part of the'
                             ' source model.')
-                elif isinstance(ext_var, basestring):
+                elif isinstance(ext_var, str):
                     try:
                         ext_var = ext_model.var(ext_var)
                     except KeyError:
@@ -2597,7 +2584,7 @@ class Model(ObjectWithMeta, VarProvider):
 
         """
         n = self.count_states()
-        if isinstance(state, basestring):
+        if isinstance(state, str):
             # String given. Parse into name:float map or list
             state = myokit.parse_state(state)
         if isinstance(state, dict):
@@ -2912,7 +2899,7 @@ class Model(ObjectWithMeta, VarProvider):
         accepted by :meth:`map_to_state`.
         """
         # Use map to state?
-        if isinstance(values, basestring) or isinstance(values, dict):
+        if isinstance(values, str) or isinstance(values, dict):
             self._state_init = [
                 myokit.Number(x) for x in self.map_to_state(values)]
         elif len(values) != len(self._state_vars):
@@ -3655,7 +3642,7 @@ class Component(VarOwner):
     """
 
     def __init__(self, model, name):
-        super(Component, self).__init__(model, name)
+        super().__init__(model, name)
         self._alias_map = {}    # Maps variable names to other variables names
 
     def _clone1(self, model, new_name=None):
@@ -3741,7 +3728,7 @@ class Component(VarOwner):
             var._delete(recursive=True, ignore_siblings=True)
 
         # Delete links to parent
-        super(Component, self)._delete()
+        super()._delete()
 
     def alias(self, name):
         """
@@ -3873,7 +3860,7 @@ class Variable(VarOwner):
     """
 
     def __init__(self, parent, name):
-        super(Variable, self).__init__(parent, name)
+        super().__init__(parent, name)
 
         # Index, only set if this is a state variable
         self._index = None
@@ -4280,7 +4267,7 @@ class Variable(VarOwner):
                 self._remove_variable_internal(kid)
 
         # Remove parent links
-        super(Variable, self)._delete()
+        super()._delete()
 
     def demote(self):
         """
@@ -4498,7 +4485,7 @@ class Variable(VarOwner):
         # Handle string and number rhs's
         model = self.model()
         if not isinstance(initial_value, myokit.Expression):
-            if isinstance(initial_value, basestring):
+            if isinstance(initial_value, str):
                 # Expressions are evaluated in model context
                 initial_value = myokit.parse_expression(
                     initial_value, context=model)
@@ -4588,9 +4575,9 @@ class Variable(VarOwner):
         # Create function
         local = {}
         if use_numpy:
-            myokit._exec(func, {'numpy': numpy}, local)
+            exec(func, {'numpy': numpy}, local)
         else:
-            myokit._exec(func, {'math': math}, local)
+            exec(func, {'math': math}, local)
         handle = local['var_pyfunc_generated']
 
         # Return
@@ -4766,7 +4753,7 @@ class Variable(VarOwner):
         # Handle strings and floats
         model = self.model()
         if not isinstance(value, myokit.Expression):
-            if isinstance(value, basestring):
+            if isinstance(value, str):
                 value = myokit.parse_expression(value, context=model)
             else:
                 value = myokit.Number(value)
@@ -4834,7 +4821,7 @@ class Variable(VarOwner):
         """
         # Handle string and number rhs's
         if not isinstance(rhs, myokit.Expression):
-            if isinstance(rhs, basestring):
+            if isinstance(rhs, str):
                 rhs = myokit.parse_expression(rhs, context=self)
             elif rhs is not None:
                 rhs = myokit.Number(rhs)
@@ -4885,7 +4872,7 @@ class Variable(VarOwner):
         """
         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 TypeError('Method set_unit() expects a myokit.Unit or None.')
@@ -5068,7 +5055,7 @@ class Variable(VarOwner):
         return self._rhs.eval()
 
 
-class Equation(object):
+class Equation:
     """
     Defines an equation: a statement that a left-hand side (LHS) is equal to a
     right-hand side (RHS) expression.
@@ -5103,7 +5090,7 @@ class Equation(object):
 
     def code(self):
         """ Returns an ``.mmt`` representation of this equation. """
-        b = StringIO()
+        b = io.StringIO()
         self._lhs._code(b, None)
         b.write(' = ')
         self._rhs._code(b, None)
@@ -5149,7 +5136,7 @@ class EquationList(list, VarProvider):
         return stream(self)
 
 
-class UserFunction(object):
+class UserFunction:
     """
     Represents a user function.
 

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, 34, 0
+__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