myokit 1.37.0__py3-none-any.whl → 1.37.2__py3-none-any.whl

myokit/tests/test_formats_exporters_run.py

@@ -104,6 +104,9 @@ class ExportTest(unittest.TestCase):
             name = 'test_' + name + '_exporter'
             self.assertIn(name, methods)
 
+    def test_sbml_exporter(self):
+        self._test(myokit.formats.exporter('sbml'))
+
     def test_ansic_exporter(self):
         self._test(myokit.formats.exporter('ansic'))
 
@@ -128,6 +131,9 @@ class ExportTest(unittest.TestCase):
     def test_cuda_kernel_rl_exporter(self):
         self._test(myokit.formats.exporter('cuda-kernel-rl'))
 
+    def test_diffsl_exporter(self):
+        self._test(myokit.formats.exporter('diffsl'))
+
     def test_easyml_exporter(self):
         self._test(myokit.formats.exporter('easyml'))
 

myokit/tests/test_formats_sbml.py

@@ -15,7 +15,63 @@ import myokit.formats
 import myokit.formats.sbml
 
 # from shared import DIR_FORMATS, WarningCollector
-from myokit.tests import DIR_FORMATS, WarningCollector
+from myokit.tests import DIR_FORMATS, WarningCollector, TemporaryDirectory
+
+
+class SBMLExporterTest(unittest.TestCase):
+    """
+    Tests for :class:`myokit.formats.sbml.SBMLExporter`.
+    """
+
+    def test_capability_reporting(self):
+        # Test if the right capabilities are reported.
+        e = myokit.formats.exporter('sbml')
+        self.assertTrue(e.supports_model())
+        self.assertFalse(e.supports_runnable())
+
+    def test_stimulus_generation(self):
+        # Tests if protocols allow a stimulus current to be added
+
+        e = myokit.formats.exporter('sbml')
+        i = myokit.formats.importer('sbml')
+
+        # Load input model
+        m1, p1, _ = myokit.load('example')
+        org_code = m1.code()
+
+        # 1. Export without a protocol
+        with TemporaryDirectory() as d:
+            path = d.path('model.sbml')
+            with WarningCollector() as w:
+                e.model(path, m1)
+            m2 = i.model(path)
+        self.assertFalse(w.has_warnings())
+        self.assertTrue(isinstance(m2.get('global.pace').rhs(), myokit.Number))
+
+        # 2. Export with protocol, but without variable bound to pacing
+        m1.get('engine.pace').set_binding(None)
+        with TemporaryDirectory() as d:
+            path = d.path('model.sbml')
+            with WarningCollector() as w:
+                e.model(path, m1, p1)
+            m2 = i.model(path)
+        self.assertTrue(w.has_warnings())
+        self.assertTrue(isinstance(m2.get('global.pace').rhs(), myokit.Number))
+
+        # 3. Export with protocol and variable bound to pacing
+        m1.get('engine.pace').set_binding('pace')
+        with TemporaryDirectory() as d:
+            path = d.path('model.cellml')
+            with WarningCollector() as w:
+                e.model(path, m1, p1)
+            m2 = i.model(path)
+        self.assertFalse(w.has_warnings())
+        rhs = m2.get('global.i_stim').rhs()
+        self.assertTrue(rhs, myokit.Multiply)
+        self.assertTrue(isinstance(rhs[0], myokit.Piecewise))
+
+        # Check original model is unchanged
+        self.assertEqual(org_code, m1.code())
 
 
 class SBMLImporterTest(unittest.TestCase):

myokit/tests/test_sbml_api.py

@@ -2181,6 +2181,96 @@ class SBMLTestMyokitModel(unittest.TestCase):
             myokit.Plus(myokit.Number(1), myokit.Name(m.time())))
 
 
+class SBMLTestModelFromMyokit(unittest.TestCase):
+    def test_basic(self):
+        m = myokit.Model()
+        c = m.add_component('comp')
+        v = c.add_variable('var')
+        v.set_rhs(myokit.Number(3))
+        t = c.add_variable('time')
+        t.set_binding('time')
+        t.set_rhs(myokit.Number(0))
+
+        s = sbml.Model.from_myokit_model(m)
+        compartment_names = [c.sid() for c in s.compartments()]
+        self.assertCountEqual(compartment_names, [])
+        parameter_names = [v.sid() for v in s.parameters()]
+        self.assertCountEqual(parameter_names, ['var'])
+
+    def test_vars_with_same_name(self):
+        m = myokit.Model()
+        c = m.add_component('comp')
+        v = c.add_variable('var')
+        v.set_rhs(myokit.Number(3))
+        c = m.add_component('comp2')
+        v = c.add_variable('var')
+        v.set_rhs(myokit.Number(3))
+        t = c.add_variable('time')
+        t.set_binding('time')
+        t.set_rhs(myokit.Number(0))
+
+        s = sbml.Model.from_myokit_model(m)
+        compartment_names = [c.sid() for c in s.compartments()]
+        self.assertCountEqual(compartment_names, [])
+        parameter_names = [v.sid() for v in s.parameters()]
+        self.assertCountEqual(parameter_names, ['comp2_var', 'comp_var'])
+
+    def test_rate_eqn_with_unit(self):
+        m = myokit.Model()
+        c = m.add_component('comp')
+
+        t = c.add_variable('time', rhs=myokit.Number(0))
+        t.set_unit(myokit.units.second)
+        t.set_binding('time')
+
+        p = c.add_variable('param')
+        p.set_rhs(myokit.Number(2))
+
+        v = c.add_variable('var', initial_value=myokit.Number(1))
+        v_unit = 1e3 * myokit.units.meter
+        v.set_unit(v_unit)
+        v.set_rhs(myokit.Multiply(myokit.Number(4), myokit.Name(p)))
+
+        v = c.add_variable('var2', initial_value=myokit.Number(1))
+        v.set_unit(myokit.units.meter)
+        v.set_rhs(myokit.Number(4))
+
+        s = sbml.Model.from_myokit_model(m)
+        parameter_names = [v.sid() for v in s.parameters()]
+        self.assertCountEqual(parameter_names, ['var', 'var2', 'param'])
+        # only non-base unit is kilometer
+        self.assertCountEqual(s.units().values(), [v_unit])
+        self.assertEqual(s.time_units(), myokit.units.second)
+        v = s.parameter('var')
+        self.assertEqual(v.initial_value(), myokit.Number(1))
+        self.assertEqual(
+            v.value(),
+            myokit.Multiply(myokit.Number(4), myokit.Name(p))
+        )
+
+    def test_incompatible_unit(self):
+        m = myokit.Model()
+        c = m.add_component('comp')
+
+        t = c.add_variable('time', rhs=myokit.Number(0))
+        t.set_unit(myokit.units.second)
+        t.set_binding('time')
+
+        p = c.add_variable('param')
+        p.set_rhs(myokit.Number(2))
+        p.set_unit(myokit.units.meter)
+
+        v = c.add_variable('var', initial_value=myokit.Number(1))
+        v.set_rhs(myokit.Plus(myokit.Name(p), myokit.Name(t)))
+
+        s = sbml.Model.from_myokit_model(m)
+        parameter_names = [v.sid() for v in s.parameters()]
+        self.assertCountEqual(parameter_names, ['var', 'param'])
+
+        p = s.parameter('var')
+        self.assertIsNone(p.units())
+
+
 if __name__ == '__main__':
     import warnings
     warnings.simplefilter('always')

myokit/tests/test_sbml_export.py

@@ -0,0 +1,327 @@
+#!/usr/bin/env python3
+#
+# Tests Myokit's SBML support.
+#
+# This file is part of Myokit.
+# See http://myokit.org for copyright, sharing, and licensing details.
+#
+import unittest
+
+import myokit
+import myokit.formats
+
+import myokit.formats.sbml
+from myokit.formats.sbml._api import Model
+from myokit.formats.sbml._writer import write_string
+import myokit.formats.sbml as sbml
+
+
+class TestSBMLExport(unittest.TestCase):
+    """
+    Unit tests for the SBML export functionality.
+    """
+
+    def test_empty_model(self):
+        # Test exporting an empty model
+        model = Model()
+        sbml_str = write_string(model).decode("utf8")
+        self.assertIn("<sbml", sbml_str)
+        self.assertIn("</sbml>", sbml_str)
+        self.assertIn('<model id="unnamed_model"/>', sbml_str)
+
+    def test_time_unit(self):
+        # Test setting the time unit
+        model = Model()
+        model.set_time_units(myokit.units.second)
+        sbml_str = write_string(model).decode("utf8")
+        self.assertIn('timeUnits="second"', sbml_str)
+
+        model = Model()
+        model.set_time_units(1e3 * myokit.units.second)
+        sbml_str = write_string(model).decode("utf8")
+        self.assertIn('<listOfUnitDefinitions>', sbml_str)
+        self.assertIn('<unitDefinition id="s_times_1e3">', sbml_str)
+
+    def test_area_unit(self):
+        # Test setting the area unit
+        model = Model()
+        model.set_area_units(myokit.units.metre)
+        sbml_str = write_string(model).decode("utf8")
+        self.assertIn('areaUnits="metre"', sbml_str)
+
+    def test_volume_unit(self):
+        # Test setting the volume unit
+        model = Model()
+        model.set_volume_units(myokit.units.litre)
+        sbml_str = write_string(model).decode("utf8")
+        self.assertIn('volumeUnits="litre"', sbml_str)
+
+    def test_substance_unit(self):
+        # Test setting the substance unit
+        model = Model()
+        model.set_substance_units(myokit.units.mole)
+        sbml_str = write_string(model).decode("utf8")
+        self.assertIn('substanceUnits="mole"', sbml_str)
+
+    def test_extent_unit(self):
+        # Test setting the extent unit
+        model = Model()
+        model.set_extent_units(myokit.units.mole)
+        sbml_str = write_string(model).decode("utf8")
+        self.assertIn('extentUnits="mole"', sbml_str)
+
+    def test_length_unit(self):
+        # Test setting the length unit
+        model = Model()
+        model.set_length_units(myokit.units.metre)
+        sbml_str = write_string(model).decode("utf8")
+        self.assertIn('lengthUnits="metre"', sbml_str)
+
+    def test_list_of_unit_definitions(self):
+        # Test setting a list of unit definitions
+        model = Model()
+        model.add_unit("my_unit", myokit.units.ampere)
+        model.add_unit("my_unit2", 2 * myokit.units.dimensionless)
+        sbml_str = write_string(model).decode("utf8")
+        self.assertIn("<listOfUnitDefinitions>", sbml_str)
+        self.assertIn('<unitDefinition id="my_unit">', sbml_str)
+        self.assertIn(
+            '<unit kind="ampere" exponent="1.0" multiplier="1.0"/>',
+            sbml_str
+        )
+        self.assertIn('<unitDefinition id="my_unit2">', sbml_str)
+        self.assertIn(
+            '<unit kind="dimensionless" multiplier="2.0"/>',
+            sbml_str
+        )
+
+    def test_list_of_compartments(self):
+        # Test setting a list of compartments
+        model = Model()
+        c = model.add_compartment("my_compartment")
+        c.set_size_units(myokit.units.litre)
+        c.set_spatial_dimensions(3)
+        c = model.add_compartment("my_compartment2")
+        c.set_size_units(1e3 * myokit.units.metre ** 3)
+        sbml_str = write_string(model).decode("utf8")
+        self.assertIn("<listOfCompartments>", sbml_str)
+        self.assertIn(
+            '<compartment id="my_compartment" units="litre" spatialDimensions="3.0"/>',  # noqa: E501
+            sbml_str
+        )
+        self.assertIn(
+            '<compartment id="my_compartment2" units="m3_times_1e3"/>',
+            sbml_str
+        )
+        self.assertIn("<listOfUnitDefinitions>", sbml_str)
+        self.assertIn('<unitDefinition id="m3_times_1e3">', sbml_str)
+
+    def test_constants_and_literals(self):
+        m = myokit.Model()
+        c = m.add_component('comp')
+        t = c.add_variable('time', rhs=myokit.Number(0))
+        t.set_unit(myokit.units.second)
+        t.set_binding('time')
+        v = c.add_variable('my_parameter')
+        v.set_rhs(myokit.Number(1))
+        v2 = c.add_variable('my_parameter2')
+        v2.set_rhs(myokit.Multiply(myokit.Number(2), myokit.Name(v)))
+
+        # check that the equation is exported correctly to sbml.Model
+        s = sbml.Model.from_myokit_model(m)
+        parameter_names = [v.sid() for v in s.parameters()]
+        self.assertCountEqual(
+            parameter_names, ['my_parameter', 'my_parameter2']
+        )
+        sbml_v = s.parameter('my_parameter')
+        sbml_v2 = s.parameter('my_parameter2')
+        self.assertEqual(sbml_v.value(), myokit.Number(1))
+        self.assertIsNone(sbml_v.initial_value())
+        self.assertEqual(
+            sbml_v2.initial_value(),
+            myokit.Multiply(myokit.Number(2), myokit.Name(v))
+        )
+        self.assertIsNone(sbml_v2.value())
+        self.assertTrue(sbml_v.is_constant())
+        self.assertTrue(sbml_v2.is_constant())
+        self.assertFalse(sbml_v2.is_literal())
+        self.assertTrue(sbml_v.is_literal())
+
+    def test_list_of_parameters(self):
+        # Test setting a list of parameters
+        model = Model()
+        p = model.add_parameter("my_parameter")
+        p.set_value(myokit.Number(1))
+        p = model.add_parameter("my_parameter2")
+        p.set_units(1e3 * myokit.units.metre / myokit.units.second)
+        p.set_value(myokit.Number(2))
+        sbml_str = write_string(model).decode("utf8")
+        self.assertIn("<listOfParameters>", sbml_str)
+        self.assertIn(
+            '<parameter id="my_parameter" constant="true" value="1.0"/>',
+            sbml_str
+        )
+        self.assertIn(
+            '<parameter id="my_parameter2" units="m_per_s_times_1e3" constant="true" value="2.0"/>',  # noqa: E501
+            sbml_str
+        )
+        self.assertNotIn("<listOfRules>", sbml_str)
+        self.assertNotIn("<listOfInitialAssignments>", sbml_str)
+        self.assertIn("<listOfUnitDefinitions>", sbml_str)
+        self.assertIn('<unitDefinition id="m_per_s_times_1e3">', sbml_str)
+
+        # Test setting a constant parameter that depends on another parameter
+        model = Model()
+        p = model.add_parameter("my_parameter")
+        p.set_value(myokit.Number(1))
+        p = model.add_parameter("my_parameter2")
+        p.set_initial_value(
+            myokit.Multiply(myokit.Name("my_parameter"), myokit.Number(2))
+        )
+        sbml_str = write_string(model).decode("utf8")
+        self.assertIn("<listOfParameters>", sbml_str)
+        self.assertIn(
+            '<parameter id="my_parameter" constant="true" value="1.0"/>',
+            sbml_str
+        )
+        self.assertIn(
+            '<parameter id="my_parameter2" constant="true"/>',  # noqa: E501
+            sbml_str
+        )
+        self.assertNotIn("<listOfRules>", sbml_str)
+        self.assertIn("<listOfInitialAssignments>", sbml_str)
+        self.assertIn('<initialAssignment symbol="my_parameter2">', sbml_str)
+        self.assertIn("<times/>\n            <ci>my_parameter</ci>\n            <cn>2.0</cn>", sbml_str)  # noqa: E501
+
+        model = Model()
+        p = model.add_parameter("my_parameter", is_constant=False)
+        p.set_initial_value(myokit.Number(1))
+        p.set_value(myokit.Number(2))
+        sbml_str = write_string(model).decode("utf8")
+        self.assertIn("<listOfRules>", sbml_str)
+        self.assertIn('<assignmentRule variable="my_parameter">', sbml_str)
+        self.assertIn("<cn>2.0</cn>", sbml_str)
+        self.assertIn("<listOfInitialAssignments>", sbml_str)
+        self.assertIn('<initialAssignment symbol="my_parameter">', sbml_str)
+        self.assertIn("<cn>1.0</cn>", sbml_str)
+
+    def test_list_of_species(self):
+        # Test setting a list of species
+        model = Model()
+        c = model.add_compartment("my_compartment")
+        s = model.add_species(c, "my_species")
+        s.set_substance_units(myokit.units.mole / myokit.units.litre)
+        s.set_value(myokit.Number(1), True)
+        s.set_initial_value(myokit.Number(2))
+        s = model.add_species(c, "my_species2")
+        s.set_substance_units(myokit.units.mole)
+        s.set_value(myokit.Number(1), True)
+        s.set_initial_value(myokit.Number(2), in_amount=True)
+        s = model.add_species(c, "my_species3", is_amount=True)
+        s.set_value(myokit.Number(1), True)
+        s.set_initial_value(myokit.Number(2))
+        s = model.add_species(c, "my_species4", is_amount=True)
+        s.set_value(myokit.Number(1), True)
+        s.set_initial_value(myokit.Number(2), in_amount=False)
+        s = model.add_species(c, "my_species5")
+        s.set_value(myokit.Number(1), False)
+        sbml_str = write_string(model).decode("utf8")
+        self.assertIn("<listOfSpecies>", sbml_str)
+        self.assertIn(
+            '<species id="my_species" compartment="my_compartment" initialConcentration="2.0" constant="False" units="M" boundaryCondition="False"/>',  # noqa: E501
+            sbml_str,
+        )
+        self.assertIn(
+            '<species id="my_species2" compartment="my_compartment" initialAmount="2.0" constant="False" units="mole" boundaryCondition="False"/>',  # noqa: E501
+            sbml_str,
+        )
+        self.assertIn(
+            '<species id="my_species3" compartment="my_compartment" initialAmount="2.0" constant="False" boundaryCondition="False"/>',  # noqa: E501
+            sbml_str,
+        )
+        self.assertIn(
+            '<species id="my_species4" compartment="my_compartment" initialConcentration="2.0" constant="False" boundaryCondition="False"/>',  # noqa: E501
+            sbml_str,
+        )
+        self.assertIn("<listOfRules>", sbml_str)
+        self.assertIn('<rateRule variable="my_species">', sbml_str)
+        self.assertIn("<cn>1.0</cn>", sbml_str)
+        self.assertIn('<assignmentRule variable="my_species5">', sbml_str)
+
+    def test_list_of_reactions(self):
+        # test kinetic law
+        model = Model()
+        c = model.add_compartment("my_compartment")
+        s = model.add_species(c, "my_species")
+        s2 = model.add_species(c, "my_species2")
+        r = model.add_reaction("my_reaction")
+        r.add_reactant(s, "my_reaction_reactant")
+        r.add_product(s)
+        r.add_modifier(s)
+        r.add_modifier(s2, "my_modifier")
+        r.set_kinetic_law(myokit.Number(1))
+        sbml_str = write_string(model).decode("utf8")
+        self.assertIn("<listOfReactions>", sbml_str)
+        self.assertIn('<reaction id="my_reaction">', sbml_str)
+        self.assertIn("<listOfReactants>", sbml_str)
+        self.assertIn("<listOfProducts>", sbml_str)
+        self.assertIn('<speciesReference species="my_species"/>', sbml_str)
+        self.assertIn('<speciesReference species="my_species" id="my_reaction_reactant"/>', sbml_str)  # noqa: E501
+        self.assertIn("<listOfModifiers>", sbml_str)
+        self.assertIn(
+            '<modifierSpeciesReference species="my_species"/>',
+            sbml_str
+        )
+        self.assertIn(
+            '<modifierSpeciesReference species="my_species2" id="my_modifier"/>',  # noqa: E501
+            sbml_str
+        )
+        self.assertIn("<kineticLaw>", sbml_str)
+        self.assertIn("<cn>1.0</cn>", sbml_str)
+
+        # test stochoimetry
+        model = Model()
+        c = model.add_compartment("my_compartment")
+        s = model.add_species(c, "my_species")
+        r = model.add_reaction("my_reaction")
+        react = r.add_reactant(s)
+        react.set_value(myokit.Number(1))
+        r.add_product(s)
+        sbml_str = write_string(model).decode("utf8")
+        self.assertIn(
+            '<speciesReference species="my_species" stoichiometry="1.0"/>',
+            sbml_str
+        )
+
+    def test_expressions_multiple_compartments(self):
+        m = myokit.Model()
+        c = m.add_component('comp')
+        t = c.add_variable('time', rhs=myokit.Number(0))
+        t.set_unit(myokit.units.second)
+        t.set_binding('time')
+        c2 = m.add_component('comp2')
+        v = c.add_variable('var', initial_value=3)
+        v.set_rhs(myokit.Name(t))
+        v2 = c2.add_variable('var', initial_value=3)
+        v2.set_rhs(myokit.Name(v))
+
+        # check that the equation is exported correctly to sbml.Model
+        s = sbml.Model.from_myokit_model(m)
+        parameter_names = [v.sid() for v in s.parameters()]
+        self.assertCountEqual(parameter_names, ['comp_var', 'comp2_var'])
+        v2_sbml = s.parameter('comp2_var')
+        self.assertEqual(
+            v2_sbml.value(),
+            myokit.Name(v)
+        )
+
+        # check that the equation is exported correctly to sbml string
+        sbml_str = write_string(s).decode("utf8")
+        self.assertIn('<rateRule variable="comp2_var">', sbml_str)
+        self.assertIn('<ci>comp_var</ci>', sbml_str)
+        self.assertIn('<rateRule variable="comp_var">', sbml_str)
+        self.assertIn(
+            '<ci>http://www.sbml.org/sbml/symbols/time</ci>',
+            sbml_str
+        )
+

{myokit-1.37.0.dist-info → myokit-1.37.2.dist-info}/LICENSE.txt

@@ -3,7 +3,7 @@ BSD 3-Clause License
 Copyright (c) 2011-2017 Maastricht University. All rights reserved.
 Copyright (c) 2017-2020 University of Oxford. All rights reserved.
 (University of Oxford means the Chancellor, Masters and Scholars of the University of Oxford, having an administrative office at Wellington Square, Oxford OX1 2JD, UK).
-Copyright (c) 2020-2024 University of Nottingham. All rights reserved.
+Copyright (c) 2020-2025 University of Nottingham. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:

{myokit-1.37.0.dist-info → myokit-1.37.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: myokit
-Version: 1.37.0
+Version: 1.37.2
 Summary: A modeling and simulation tool for cardiac cellular electrophysiology
 Home-page: http://myokit.org
 Author: Michael Clerx
@@ -25,14 +25,14 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: configparser
 Requires-Dist: lxml
-Requires-Dist: matplotlib (>=2.2)
+Requires-Dist: matplotlib >=2.2
 Requires-Dist: numpy
 Requires-Dist: setuptools
 Provides-Extra: dev
 Requires-Dist: coverage ; extra == 'dev'
-Requires-Dist: flake8 (>=3) ; extra == 'dev'
+Requires-Dist: flake8 >=3 ; extra == 'dev'
 Provides-Extra: docs
-Requires-Dist: sphinx (>=1.7.4) ; extra == 'docs'
+Requires-Dist: sphinx >=1.7.4 ; extra == 'docs'
 Provides-Extra: gui
 Requires-Dist: pyqt6 ; extra == 'gui'
 Requires-Dist: sip ; extra == 'gui'