Merge pull request #750 from StochSS/hotfix-delete-events

HOTFIX: Delete Events

gillespy2/core/model.py

@@ -343,15 +343,16 @@ def add_species(self, obj):
                 raise ParameterError("Error using {} as a Species. Reason given: {}".format(obj, e))
         return obj
 
-    def delete_species(self, obj):
+    def delete_species(self, name):
         """
         Removes a species object by name.
 
-        :param obj: Name of the species object to be removed
-        :type obj: str
+        :param name: Name of the species object to be removed
+        :type name: str
         """
-        self.listOfSpecies.pop(obj)
-        self._listOfSpecies.pop(obj)
+        self.listOfSpecies.pop(name)
+        if name in self._listOfSpecies:
+            self._listOfSpecies.pop(name)
 
     def delete_all_species(self):
         """
@@ -426,15 +427,16 @@ def add_parameter(self, params):
                 raise ParameterError("Parameter {}  must be of type {}, it is of type {}".format(params, str(type(Parameter)), str(params) ))
         return params
 
-    def delete_parameter(self, obj):
+    def delete_parameter(self, name):
         """
         Removes a parameter object by name.
 
-        :param obj: Name of the parameter object to be removed
-        :type obj: str
+        :param name: Name of the parameter object to be removed
+        :type name: str
         """
-        self.listOfParameters.pop(obj)
-        self._listOfParameters.pop(obj)
+        self.listOfParameters.pop(name)
+        if name in self._listOfParameters:
+            self._listOfParameters.pop(name)
 
     def set_parameter(self, p_name, expression):
         """
@@ -669,12 +671,16 @@ def get_all_reactions(self):
         """
         return self.listOfReactions
 
-    def delete_reaction(self, obj):
+    def delete_reaction(self, name):
         """
-        :param obj: Name of Reaction to be removed
+        Removes a reaction object by name.
+
+        :param name: Name of Reaction to be removed,
+        :type name: str
         """
-        self.listOfReactions.pop(obj)
-        self._listOfReactions.pop(obj)
+        self.listOfReactions.pop(name)
+        if name in self._listOfReactions:
+            self._listOfReactions.pop(name)
 
     def delete_all_reactions(self):
         """
@@ -696,14 +702,16 @@ def get_all_events(self):
         """
         return self.listOfEvents
 
-    def delete_event(self, ename):
+    def delete_event(self, name):
         """
         Removes specified Event from model
 
-        :param ename: Name of Event to be removed
+        :param name: Name of Event to be removed.
+        :type name: str
         """
-        self.listOfEvents.pop(ename)
-        self._listOfEvents.pop(ename)
+        self.listOfEvents.pop(name)
+        if name in self._listOfEvents:
+            self._listOfEvents.pop(name)
 
     def delete_all_events(self):
         """
@@ -725,13 +733,16 @@ def get_all_rate_rules(self):
         """
         return self.listOfRateRules
 
-    def delete_rate_rule(self, rname):
+    def delete_rate_rule(self, name):
         """
         Removes specified Rate Rule from model
-        :param rname: Name of Rate Rule to be removed
+
+        :param name: Name of Rate Rule to be removed.
+        :type name: str
         """
-        self.listOfRateRules.pop(rname)
-        self._listOfRateRules.pop(rname)
+        self.listOfRateRules.pop(name)
+        if name in self._listOfRateRules:
+            self._listOfRateRules.pop(name)
 
     def delete_all_rate_rules(self):
         """
@@ -753,14 +764,16 @@ def get_all_assignment_rules(self):
         """
         return self.listOfAssignmentRules
 
-    def delete_assignment_rule(self, aname):
+    def delete_assignment_rule(self, name):
         """
         Removes an assignment rule from a model
 
-        :param aname: Name of AssignmentRule object to be removed from model
+        :param name: Name of AssignmentRule object to be removed from model.
+        :type name: str
         """
-        self.listOfAssignmentRules.pop(aname)
-        self._listOfAssignmentRules.pop(aname)
+        self.listOfAssignmentRules.pop(name)
+        if name in self._listOfAssignmentRules:
+            self._listOfAssignmentRules.pop(name)
 
     def delete_all_assignment_rules(self):
         """
@@ -782,14 +795,16 @@ def get_all_function_definitions(self):
         """
         return self.listOfFunctionDefinitions
 
-    def delete_function_definition(self, fname):
+    def delete_function_definition(self, name):
         """
         Removes specified Function Definition from model
 
-        :param fname: Name of Function Definition to be removed
+        :param name: Name of Function Definition to be removed
+        :type name: str
         """
-        self.listOfFunctionDefinitions.pop(fname)
-        self._listOfFunctionDefinitions.pop(fname)
+        self.listOfFunctionDefinitions.pop(name)
+        if name in self._listOfFunctionDefinitions:
+            self._listOfFunctionDefinitions.pop(name)
 
     def delete_all_function_definitions(self):
         """

test/run_tests.py

@@ -57,8 +57,10 @@
     import test_check_cpp_support
     import test_jsonify
     import test_notebooks
+    from unit_tests import test_model as unittest_model
 
     modules = [
+        unittest_model,
         test_empty_model,
         test_build_engine,
         test_c_solvers,

test/test_simple_model.py

@@ -86,11 +86,6 @@ def test_addingMultipleSameParameter_ThrowsError(self):
             self.model.add_parameter([k1, k2])
         self.assertIn('Name "{}" is unavailable. A parameter with that name exists.'.format(k1.name), str(ex.exception))
 
-    def test_delete_species(self):
-        self.model.delete_species('A')
-        speciesList = self.model.get_all_species()
-        self.assertNotIn('A', speciesList)
-
     def test_delete_all_species(self):
         self.model.delete_all_species()
         speciesList = self.model.get_all_species()
@@ -149,11 +144,6 @@ def test_set_parameter(self):
         self.assertEqual('100', parameter.expression)
         self.assertIsInstance(parameter, Parameter, msg='{0} has incorrect type'.format(parameter))
 
-    def test_delete_parameter(self):
-        self.model.delete_parameter('k1')
-        parameterList = self.model.get_all_parameters()
-        self.assertNotIn('k1', parameterList)
-
     def test_delete_all_parameters(self):
         self.model.delete_all_parameters()
         parameterList = self.model.get_all_parameters()
@@ -184,11 +174,6 @@ def test_model_has_reactions(self):
         self.assertIsInstance(reactions['r1'], Reaction, msg='{0} has incorrect type'.format(reactions))
         self.assertIsInstance(reactions['r2'], Reaction, msg='{0} has incorrect type'.format(reactions))
 
-    def test_delete_reaction(self):
-        self.model.delete_reaction('r1')
-        reactionList = self.model.get_all_reactions()
-        self.assertNotIn('r1', reactionList)
-
     def test_delete_all_reactions(self):
         self.model.delete_all_reactions()
         reactionList = self.model.get_all_reactions()

test/unit_tests/test_model.py

@@ -0,0 +1,63 @@
+"""
+GillesPy2 is a modeling toolkit for biochemical simulation.
+Copyright (C) 2019-2021 GillesPy2 developers.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
+import sys
+sys.path.insert(1, "../")
+import unittest
+
+from example_models import RobustModel
+from gillespy2.core.gillespyError import *
+
+class TestModel(unittest.TestCase):
+
+    def setUp(self):
+        self.model = RobustModel()
+
+    def test_delete_assignment_rule(self):
+        self.model.delete_assignment_rule('rr2')
+        self.assertNotIn('rr2', self.model.listOfAssignmentRules)
+        self.assertNotIn('rr2', self.model._listOfAssignmentRules)
+
+    def test_delete_event(self):
+        self.model.delete_event('e1')
+        self.assertNotIn('e1', self.model.listOfEvents)
+        self.assertNotIn('e1', self.model._listOfEvents)
+
+    def test_delete_function_definition(self):
+        self.model.delete_function_definition('multiply')
+        self.assertNotIn('multiply', self.model.listOfFunctionDefinitions)
+        self.assertNotIn('multiply', self.model._listOfFunctionDefinitions)
+
+    def test_delete_parameter(self):
+        self.model.delete_parameter('k1')
+        self.assertNotIn('k1', self.model.listOfParameters)
+        self.assertNotIn('k1', self.model._listOfParameters)
+
+    def test_delete_rate_rule(self):
+        self.model.delete_rate_rule('rr1')
+        self.assertNotIn('rr1', self.model.listOfRateRules)
+        self.assertNotIn('rr1', self.model._listOfRateRules)
+
+    def test_delete_reaction(self):
+        self.model.delete_reaction('r1')
+        self.assertNotIn('r1', self.model.listOfReactions)
+        self.assertNotIn('r1', self.model._listOfReactions)
+
+    def test_delete_species(self):
+        self.model.delete_species('s1')
+        self.assertNotIn('s1', self.model.listOfSpecies)
+        self.assertNotIn('s1', self.model._listOfSpecies)