myokit 1.38.0__tar.gz → 1.39.1__tar.gz

{myokit-1.38.0/myokit.egg-info → myokit-1.39.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: myokit
-Version: 1.38.0
+Version: 1.39.1
 Summary: A modeling and simulation tool for cardiac cellular electrophysiology
 Home-page: http://myokit.org
 Author: Michael Clerx
@@ -44,6 +44,19 @@ Requires-Dist: pyqt6; extra == "pyqt"
 Requires-Dist: sip; extra == "pyqt"
 Provides-Extra: pyside
 Requires-Dist: pyside6; extra == "pyside"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 [![Ubuntu unit tests](https://github.com/myokit/myokit/actions/workflows/unit-tests-ubuntu.yml/badge.svg)](https://github.com/myokit/myokit/actions/workflows/unit-tests-ubuntu.yml)
 [![MacOS unit tests](https://github.com/myokit/myokit/actions/workflows/unit-tests-macos.yml/badge.svg)](https://github.com/myokit/myokit/actions/workflows/unit-tests-macos.yml)
@@ -51,6 +64,8 @@ Requires-Dist: pyside6; extra == "pyside"
 [![Windows Miniconda test](https://github.com/myokit/myokit/actions/workflows/unit-tests-windows-miniconda.yml/badge.svg)](https://github.com/myokit/myokit/actions/workflows/unit-tests-windows-miniconda.yml)
 [![codecov](https://codecov.io/gh/myokit/myokit/branch/main/graph/badge.svg)](https://codecov.io/gh/myokit/myokit)
 [![Documentation Status](https://readthedocs.org/projects/myokit/badge/?version=latest)](https://myokit.readthedocs.io/?badge=latest)
+[![pypi](https://img.shields.io/pypi/v/myokit)](https://pypi.org/project/myokit/)
+[![anaconda](https://anaconda.org/conda-forge/myokit/badges/version.svg)](https://anaconda.org/conda-forge/myokit)
 
 ![Myokit](https://myokit.org/static/img/logo.png)
 

{myokit-1.38.0 → myokit-1.39.1}/README.md

@@ -4,6 +4,8 @@
 [![Windows Miniconda test](https://github.com/myokit/myokit/actions/workflows/unit-tests-windows-miniconda.yml/badge.svg)](https://github.com/myokit/myokit/actions/workflows/unit-tests-windows-miniconda.yml)
 [![codecov](https://codecov.io/gh/myokit/myokit/branch/main/graph/badge.svg)](https://codecov.io/gh/myokit/myokit)
 [![Documentation Status](https://readthedocs.org/projects/myokit/badge/?version=latest)](https://myokit.readthedocs.io/?badge=latest)
+[![pypi](https://img.shields.io/pypi/v/myokit)](https://pypi.org/project/myokit/)
+[![anaconda](https://anaconda.org/conda-forge/myokit/badges/version.svg)](https://anaconda.org/conda-forge/myokit)
 
 ![Myokit](https://myokit.org/static/img/logo.png)
 

{myokit-1.38.0 → myokit-1.39.1}/myokit/__init__.py

@@ -261,6 +261,11 @@ UNIT_STRICT = 2
 SFDOUBLE = '{:< 1.17e}'  # Exponent can have 3 digits for very small numbers
 SFSINGLE = '{:< 1.9e}'
 
+#
+# Shared real regex. Unsigned, and without "anchors" for string start and end
+#
+_RE_UNSIGNED_REAL = r'(([0-9]*\.[0-9]+)|([0-9]+\.?[0-9]*))([eE][+-]?[0-9]+)?'
+
 #
 # Date and time formats to use throughout Myokit
 #

{myokit-1.38.0 → myokit-1.39.1}/myokit/_config.py

@@ -45,9 +45,9 @@ def _create(path):
         'compatibility',
         '# Optional settings to make Myokit work on tricky systems.')
     config.set('compatibility', '# Don\'t capture compiler output.')
-    config.set('compatibility', '#no_capture = True')
+    config.set('compatibility', '#no_capture', 'True')
     config.set('compatibility', '# Don\'t use the file-descriptor method.')
-    config.set('compatibility', '#no_fd_capture = True')
+    config.set('compatibility', '#no_fd_capture', 'True')
 
     # Date format
     config.add_section('time')
@@ -63,16 +63,16 @@ def _create(path):
     config.set('gui', '# Backend to use for graphical user interface.')
     config.set('gui', '# Valid options are pyqt6, pyqt5, pyside6 and pyside2.')
     config.set('gui', '# Leave unset for automatic selection.')
-    config.set('gui', '#backend = pyqt6')
-    config.set('gui', '#backend = pyqt5')
-    config.set('gui', '#backend = pyside6')
-    config.set('gui', '#backend = pyside2')
+    config.set('gui', '#backend', 'pyqt6')
+    config.set('gui', '#backend', 'pyqt5')
+    config.set('gui', '#backend', 'pyside6')
+    config.set('gui', '#backend', 'pyside2')
 
     # Locations of sundials library
     config.add_section('sundials')
     config.set(
-        'sundials', '# Location of sundials shared libary files'
-        ' (.so, .dll, or .dylib).')
+        'sundials',
+        '# Location of sundials shared libary files (.so, .dll, or .dylib).')
     config.set('sundials', '# Multiple paths can be set using ; as separator.')
 
     if system == 'Windows':     # pragma: no linux cover
@@ -159,9 +159,9 @@ def _create(path):
         # All windowses
         c64 = 'C:\\Program Files\\'
         config.set('opencl', 'inc', ';'.join([
-            c64 + 'Intel\\OpenCL SDK\\6.3\\include',
-            c64 + 'AMD APP SDK\\2.9\\include',
-            c64 + 'NVIDIA GPU Computing Toolkit\\CUDA\\v11.8\\include',
+            f'{c64}Intel\\OpenCL SDK\\6.3\\include',
+            f'{c64}AMD APP SDK\\2.9\\include',
+            f'{c64}NVIDIA GPU Computing Toolkit\\CUDA\\v11.8\\include',
         ]))
     else:
         # Linux and mac
@@ -205,10 +205,9 @@ def _load():
             if m is not None:
                 x = m.start(1) - 1
                 raise ImportError(
-                    'Unsupported syntax found in ' + str(path) + ' on line '
-                    + str(1 + i) + ', character ' + str(x) + ', semicolons (;)'
-                    + ' must not be preceded by whitespace: ```'
-                    + line.strip() + '```.')
+                    f'Unsupported syntax found in {path} on line {i + 1},'
+                    f' character {x}, semicolons (;) must not be preceded by'
+                    f' whitespace: ```{line.strip()}```.')
         del lines, inline_comment
 
     # Create the config parser (no value allows comments)
@@ -230,7 +229,7 @@ def _load():
         elif x != '':
             warnings.warn(
                 'Invalid setting in myokit.ini. Expected values for no_capture'
-                ' are true, false, or not set (empty), but got: ' + x)
+                f' are true, false, or not set (empty), but got: {x}.')
 
     if config.has_option('compatibility', 'no_fd_capture'):
         x = config.get('compatibility', 'no_fd_capture').strip().lower()
@@ -241,8 +240,8 @@ def _load():
         elif x != '':
             warnings.warn(
                 'Invalid setting in myokit.ini. Expected values for'
-                ' no_fd_capture are true, false, or not set (empty), but got: '
-                + x)
+                ' no_fd_capture are true, false, or not set (empty), but'
+                f' got: {x}.')
 
     # Date format
     if config.has_option('time', 'date_format'):
@@ -282,7 +281,7 @@ def _load():
         elif x != '':
             warnings.warn(
                 'Invalid setting in myokit.ini. Expected values for backend'
-                ' are pyqt6, pyqt5, pyside6, or pyside2. Got: ' + x)
+                f' are pyqt6, pyqt5, pyside6, or pyside2, but got: {x}.')
 
     # Sundials libraries, header files, and version
     if config.has_option('sundials', 'lib'):

{myokit-1.38.0 → myokit-1.39.1}/myokit/_datablock.py

@@ -331,17 +331,18 @@ class DataBlock1d:
 
     def get0d(self, name):
         """
-        Returns the 0d time-series identified by ``name``. The data is returned
-        directly, no copy is made.
+        Returns the 0d time-series identified by ``name``.
+
+        The data is returned directly, no copy is made.
         """
         return self._0d[name]
 
     def get1d(self, name):
         """
-        Returns the 1d time-series identified by ``name``. The data is returned
-        directly, no copy is made.
+        Returns the 1d time-series identified by ``name``.
 
-        The returned data is a 2d array of the shape given by :meth:`shape`.
+        The returned data is a 2d array of the shape given by :meth:`shape`. It
+        is returned directly, no copy is made.
         """
         return self._1d[name]
 

{myokit-1.38.0 → myokit-1.39.1}/myokit/_expressions.py

@@ -848,7 +848,7 @@ class Number(Expression):
             self._unit = value.unit()
         else:
             # Basic creation with number and unit
-            self._value = float(value) if value else 0.0
+            self._value = float(value)
             if unit is None or isinstance(unit, myokit.Unit):
                 self._unit = unit
             elif isinstance(unit, str):
@@ -875,6 +875,11 @@ class Number(Expression):
             else:
                 # Turn e+15 into e15
                 self._str = self._str[:-3] + self._str[-2:]
+        elif self._str == 'inf':
+            self._str = 'infinity'
+        elif self._str == '-inf':
+            self._str = '-infinity'
+        # nan is fine
         if self._unit and self._unit != myokit.units.dimensionless:
             self._str += ' ' + str(self._unit)
 

{myokit-1.38.0 → myokit-1.39.1}/myokit/_model_api.py

@@ -2939,8 +2939,8 @@ class Model(ObjectWithMetaData, VarProvider):
             self._state_init = [
                 myokit.Number(x) for x in self.map_to_state(values)]
         elif len(values) != len(self._state_vars):
-            raise ValueError('Wrong number of initial values, expecting '
-                             + str(len(self._state_vars)) + '.')
+            raise ValueError('Wrong number of initial values, expecting'
+                             f' {len(self._state_vars)}.')
         else:
             # Parsing of arguments without making changes, in case it fails.
             expr = []
@@ -3926,10 +3926,10 @@ class Variable(VarOwner):
         # the expression returned by rhs()). References to values of state
         # variables are stored separately. Bound variables are treated as if
         # they were unbound.
-        self._refs_by = set()   # Vars that refer to this var
-        self._refs_to = set()   # Vars that this var refers to
-        self._srefs_by = set()  # Vars that refer to this state var's value
-        self._srefs_to = set()  # State var values that this var refers to
+        self._refs_by = set()   # Vars that refer to my LHS
+        self._srefs_by = set()  # Vars that refer to my current state value
+        self._refs_to = set()   # Vars whos LHS I refer to
+        self._srefs_to = set()  # Vars who current state value I refer to
 
         # Left-hand side representation (name or dot)
         self._lhs = myokit.Name(self)
@@ -4621,22 +4621,44 @@ class Variable(VarOwner):
 
     def refs_by(self, state_refs=False):
         """
-        Returns an iterator over the set of :class:`Variables <Variable>`  that
-        refer to this variable in their defining equation.
+        Returns an iterator over the set of :class:`Variables <Variable>` that
+        refer to this variable.
+
+        By default (``state_refs=False``), the returned variables all refer to
+        this variable's defining :class:`LhsExpression`, i.e. the one returned
+        by :meth:`lhs()`.
+
+        For example::
+
+            a = 2
+            b = 1 + a
+
+            a.refs_by() will include b
+
+        But references to *state values* are not counted::
 
-        Note that only references to this variable's defining
-        :class:`LhsExpression` (i.e. the one returned by :meth:`lhs()`) are
-        returned. For a state variable ``x``, this means the returned result
-        contains all variables referring to ``dot(x)``. To get an iterator over
-        the variables referring to ``x`` instead, add the optional attribute
-        ``state_refs=True``. For non-state variables this setting will trigger
-        an :class:`Exception`.
+            dot(a) = 2
+            b = 1 + a
+            c = 1 + dot(a)
+
+            a.refs_by() will include c, but not b
+
+        To see who refers to this variable's state value, use
+        ``state_refs=True``::
+
+            dot(a) = 2
+            b = 1 + a
+            c = 1 + dot(a)
+
+            a.refs_by(True) will include b, but not c
+
+        Calling ``refs_by(True)`` on a non-state variable will raise an
+        :class:`Exception`.
         """
         if state_refs:
             if not self._is_state:
-                raise Exception(
-                    'The argument "state_refs=True" can only be used on state'
-                    ' variables.')
+                raise Exception('The argument "state_refs=True" can only be'
+                                ' used on state variables.')
             return iter(self._srefs_by)
         return iter(self._refs_by)
 
@@ -4648,6 +4670,8 @@ class Variable(VarOwner):
         By default, this will _not_ include references to a state variable's
         value. To obtain a list of state variables whose value is referenced,
         use ``state_refs=True``.
+
+        See also: :meth:`refs_by`.
         """
         if state_refs:
             return iter(self._srefs_to)
@@ -4788,6 +4812,8 @@ class Variable(VarOwner):
         if not isinstance(value, myokit.Expression):
             if isinstance(value, str):
                 value = myokit.parse_expression(value, context=model)
+            elif isinstance(value, myokit.Variable):
+                value = myokit.Name(value)
             else:
                 value = myokit.Number(value)
 

{myokit-1.38.0 → myokit-1.39.1}/myokit/_myokit_version.py

@@ -14,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, 38, 0
+__version_tuple__ = 1, 39, 1
 
 # String version of the version number
 __version__ = '.'.join([str(x) for x in __version_tuple__])

{myokit-1.38.0 → myokit-1.39.1}/myokit/_parsing.py

@@ -1184,6 +1184,8 @@ add_token('AS', 'as')           # Alias
 add_token('BIND', 'bind')       # External value
 add_token('LABEL', 'label')     # Special value
 add_token('UNIT', 'unit')       # Used to given Units a useful token.
+add_token('INF', 'infinity')
+add_token('NAN', 'nan')
 
 # Reserved keywords
 KEYWORD_MAP = {
@@ -1195,6 +1197,8 @@ KEYWORD_MAP = {
     'as': AS,
     'bind': BIND,
     'label': LABEL,
+    'infinity': INF,
+    'nan': NAN,
 }
 KEYWORDS = KEYWORD_MAP.keys()
 
@@ -1213,8 +1217,8 @@ _rTOKEN = re.compile('|'.join([
     r'([a-zA-Z]\w*:)+',
     # Names
     r'[a-zA-Z]\w*',
-    # Floating point numbers
-    r'(([0-9]*\.[0-9]+)|([0-9]+\.?[0-9]*))([eE][+-]?[0-9]+)?',
+    # Unsigned real numbers, allowing exponential notation
+    myokit._RE_UNSIGNED_REAL,
     # Integers
     r'[0-9]+',
     # Comparison 1
@@ -2166,6 +2170,8 @@ nud_parsers[MINUS] = PrefixParser(myokit.PrefixMinus)
 nud_parsers[NOT] = PrefixParser(myokit.Not)
 nud_parsers[PAREN_OPEN] = GroupingParser()
 nud_parsers[FUNC_NAME] = FunctionParser()
+nud_parsers[INF] = NumberParser()
+nud_parsers[NAN] = NumberParser()
 # Left denomination parsers
 led_parsers = {}
 led_parsers[PLUS] = InfixParser(myokit.Plus)

{myokit-1.38.0 → myokit-1.39.1}/myokit/_sim/cvodessim.py

@@ -239,6 +239,7 @@ class Simulation(myokit.CModule):
         # Last state reached before error
         self._error_state = None
         self._error_inputs = None
+        self._error_log = None
 
         # Starting time
         self._time = 0
@@ -396,9 +397,26 @@ class Simulation(myokit.CModule):
 
         Will return ``None`` if no simulation was run or the simulation did not
         result in an error.
+
+        A typical use case is to inspect the calculation of derivatives after a
+        crash, with::
+
+            sim.evaluate_derivatives(sim.crash_state(), sim.crash_inputs())
+
         """
         return dict(self._error_inputs) if self._error_inputs else None
 
+    def crash_log(self):
+        """
+        If the last call to :meth:`Simulation.pre()` or
+        :meth:`Simulation.run()` resulted in an error, this will return the
+        :class:`myokit.DataLog` containing the data logged up until the crash.
+
+        Will return ``None`` if no simulation was run or the simulation did not
+        result in an error.
+        """
+        return None if self._error_log is None else self._error_log.clone()
+
     def crash_state(self):
         """
         If the last call to :meth:`Simulation.pre()` or
@@ -407,6 +425,12 @@ class Simulation(myokit.CModule):
 
         Will return ``None`` if no simulation was run or the simulation did not
         result in an error.
+
+        A typical use case is to inspect the calculation of derivatives after a
+        crash, with::
+
+            sim.evaluate_derivatives(sim.crash_state(), sim.crash_inputs())
+
         """
         return list(self._error_state) if self._error_state else None
 
@@ -752,6 +776,7 @@ class Simulation(myokit.CModule):
         # Reset error state
         self._error_state = None
         self._error_inputs = None
+        self._error_log = None
 
         # Simulation times
         if duration < 0:
@@ -915,6 +940,7 @@ class Simulation(myokit.CModule):
                         self._error_inputs[label] = bound[1 + i]
                 for i, label in enumerate(self._pacing_labels):
                     self._error_inputs[label] = bound[3 + i]
+                self._error_log = log
 
                 # Create long error message
                 txt = ['A numerical error occurred during simulation at'

{myokit-1.38.0 → myokit-1.39.1}/myokit/formats/__init__.py

@@ -5,6 +5,7 @@
 # See http://myokit.org for copyright, sharing, and licensing details.
 #
 import os
+import re
 import sys
 import traceback
 import warnings
@@ -19,6 +20,13 @@ _IMPORTERS = None
 _EXPORTERS = None
 _EWRITERS = None
 
+# String matching
+# Note: $ allows a newline before the end of string, \Z does not
+_re_int = re.compile(r'^[+-]?[0-9]+\Z')
+_re_int_s = re.compile(r'^\s*[+-]?[0-9]+\s*\Z')
+_re_real = re.compile(rf'^[+-]?{myokit._RE_UNSIGNED_REAL}\Z')
+_re_real_s = re.compile(rf'^\s*[+-]?{myokit._RE_UNSIGNED_REAL}\s*\Z')
+
 
 # Classes & methods
 class Exporter:
@@ -888,3 +896,32 @@ class SweepSource:
         """ Returns the time unit used in this source. """
         raise NotImplementedError
 
+
+def is_integer_string(text, strip_whitespace=False):
+    """
+    Checks whether ``text`` can be interpreted as a signed integer string.
+
+    By default, this only returns ``True`` if the whole string matches, without
+    whitespace before or after. To allow surrounding whitespace, set
+    ``strip_whitespace=True``.
+    """
+    if strip_whitespace:
+        return _re_int_s.match(text) is not None
+    return _re_int.match(text) is not None
+
+
+def is_real_number_string(text, strip_whitespace=False):
+    """
+    Checks whether ``text`` can be interpreted as a signed real number string.
+
+    By default, this only returns ``True`` if the whole string matches, without
+    whitespace before or after. To allow surrounding whitespace, set
+    ``strip_whitespace=True``.
+
+    Unlike Python's ``float``, values such as ``nan`` or ``-inf`` are not
+    accepted.
+    """
+    if strip_whitespace:
+        return _re_real_s.match(text) is not None
+    return _re_real.match(text) is not None
+

{myokit-1.38.0 → myokit-1.39.1}/myokit/formats/ansic/_ewriter.py

@@ -133,7 +133,7 @@ class AnsiCExpressionWriter(CBasedExpressionWriter):
     def set_condition_function(self, func=None):
         """
         Sets a function name to use for :class:`myokit.If`; if not set the
-        ternary operatur will be used.
+        ternary operator will be used.
 
         If given, the function arguments should be ``(condition, value_if_true,
         value_if_false)``. To revert to using the ternary operator, call with

{myokit-1.38.0 → myokit-1.39.1}/myokit/formats/axon/_abf.py

@@ -223,9 +223,13 @@ class AbfFile(myokit.formats.SweepSource):
         D/A "protocol" information will be read. If left at its default value
         of ``None`` files with the extension ``.pro`` will be recognized as
         protocol files.
+    ``convert_ramps``
+        If set to ``True``, a protocol with ramps will be read, with ramps
+        replaced by steps. If left at the default ``False``, the protocol will
+        not be read.
 
     """
-    def __init__(self, filepath, is_protocol_file=None):
+    def __init__(self, filepath, is_protocol_file=None, convert_ramps=False):
         # The path to the file and its basename
         filepath = str(filepath)
         self._filepath = os.path.abspath(filepath)
@@ -281,6 +285,7 @@ class AbfFile(myokit.formats.SweepSource):
         # will have A/D but no (or no supported) D/A. Conversely protocol files
         # will have D/A only. So all in one sweep is easiest.
         self._sweeps = None
+        self._convert_ramps = bool(convert_ramps)
         self._read_3_protocol_information()
 
         # Read and calculate conversion factors for integer data in ADC
@@ -560,7 +565,6 @@ class AbfFile(myokit.formats.SweepSource):
             self._mode = h['nOperationMode']
         else:
             # In version 2, there are up to 8 "waveform" D/A channels
-
             self._n_adc = int(h['sections']['ADC']['length'])
             self._n_dac = int(h['sections']['DAC']['length'])
             self._rate = 1e6 / h['protocol']['fADCSequenceInterval']
@@ -696,7 +700,6 @@ class AbfFile(myokit.formats.SweepSource):
             return
 
         # Get indices of enabled and supported DAC reconstructions
-        supported = {EPOCH_DISABLED, EPOCH_STEPPED}
         for i_dac in range(self._n_dac):
             if einfo_exists(i_dac):
                 i = einfo(i_dac)
@@ -715,6 +718,12 @@ class AbfFile(myokit.formats.SweepSource):
                         t = e['type']
                         if t == EPOCH_STEPPED:
                             use = True
+                        elif t == EPOCH_RAMPED and self._convert_ramps:  # pragma: no cover  # noqa
+                            # Read ramp as step
+                            use = True
+                            warnings.warn(
+                                f'Unsupported epoch type: {epoch_types[t]}:'
+                                ' converting to step')
                         elif t != EPOCH_DISABLED:  # pragma: no cover
                             use = False
                             warnings.warn(
@@ -980,8 +989,7 @@ class AbfFile(myokit.formats.SweepSource):
         user lists.
 
         The resulting analog signal has the same size as the recorded
-        signals, so not always the full length of the protocol!
-
+        signals, so not always the full length of the protocol.
         """
         dinfo, einfo_exists, einfo = self._epoch_functions
 
@@ -1104,8 +1112,9 @@ class AbfFile(myokit.formats.SweepSource):
         else:
             int_id = int(output_id)  # Propagate TypeError
             if int_id < 0 or int_id >= self._n_dac:
-                raise IndexError(f'output_id out of range: {output_id}')
-
+                raise IndexError(
+                    f'output_id out of range: {output_id} ({self._n_dac}'
+                    ' channel(s) available)')
         return int_id
 
     def da(self, output_id, join_sweeps=False):
@@ -1199,10 +1208,35 @@ class AbfFile(myokit.formats.SweepSource):
                     e_level = round(df * level, n_digits)
                     e_start = round(tf * start, n_digits)
                     e_length = round(tf * duration, n_digits)
-                    p.schedule(e_level, e_start, e_length)
+                    if e_length > 0:
+                        p.schedule(e_level, e_start, e_length)
+                    else:  # pragma: no cover
+                        warnings.warn(f'Skipping {e_length}{tu} protocol step'
+                                      f' at t={start}{tu}.')
+                    start += duration
+
+                elif e['type'] == EPOCH_RAMPED:  # pragma: no cover
+                    assert self._convert_ramps
+                    dur = e['init_duration'] / self._rate
+                    inc = e['duration_inc'] / self._rate
+                    duration = dur + i_sweep * inc
+                    # The "init_level" field in a ramp indicates the _final_
+                    # value. The initial values seems to be the value from the
+                    # previous step.
+                    level = e['init_level'] + e['level_inc'] * i_sweep
 
+                    e_level = round(df * level, n_digits)
+                    e_start = round(tf * start, n_digits)
+                    e_length = round(tf * duration, n_digits)
+                    if e_length > 0:
+                        p.schedule(e_level, e_start, e_length)
+                    else:
+                        warnings.warn(f'Skipping {e_length}{tu} protocol step'
+                                      f' at t={start}{tu}.')
                     start += duration
-                # Note: Only other type can be EPOCH_DISABLED at this point
+
+                else:
+                    assert e['type'] == EPOCH_DISABLED
 
             # End of sweep: event at holding potential
             e_start = round(tf * start, n_digits)

{myokit-1.38.0 → myokit-1.39.1}/myokit/formats/cellml/v1/__init__.py

@@ -7,28 +7,28 @@
 from ._api import (     # noqa
     AnnotatableElement,
     CellMLError,
+    Component,
     clean_identifier,
     create_unit_name,
-    Component,
+    is_identifier,
     Model,
     Units,
     UnitsError,
     UnsupportedBaseUnitsError,
     UnsupportedUnitOffsetError,
     Variable,
-    is_valid_identifier,
 )
 
 from ._parser import (  # noqa
-    parse_file,
-    parse_string,
     CellMLParser,
     CellMLParsingError,
+    parse_file,
+    parse_string,
 )
 
 from ._writer import (  # noqa
+    CellMLWriter,
     write_file,
     write_string,
-    CellMLWriter,
 )