0.2.5

.gitignore

@@ -50,6 +50,8 @@ coverage.xml
 .hypothesis/
 .pytest_cache/
 cover/
+
+# test taking too long to run
 tests/biomodels/*
 tests/test_biomodels.py
 

README.md

@@ -193,6 +193,7 @@ python -m unittest
 * Separated model reading from analysis
 * Tested on 1054 biomodels and fixed bugs
 * Added check_model method to allow user to use the package with one line
+* Solved when running sympy with sympy builtin symbols that raise error such as "S", a reaction like "S->P;k1*S" would work now
 
 ## Contributing
 
@@ -214,7 +215,7 @@ Contributions to `ratesb_python` are welcomed! Whether it's bug reports, feature
 
 ## Known Issues
 
-There are some sympy builtin symbols that will raise error such as "S", so a reaction like "S->P; k1*S" would not work.
+N/A
 
 ## Contact
 

ratesb_python/common/analyzer.py

@@ -381,16 +381,12 @@ def _check_flux_increasing_with_reactant(self, **kwargs):
             A warning message to results specifying if the flux is not increasing as reactant increases.
         """
         reaction_id = kwargs["reaction_id"]
+        ids_list = kwargs["ids_list"]
         reactant_list = kwargs["reactant_list"]
         kinetics = kwargs["kinetics"]
 
-        # first check if kinetics can be sympified, TODO: support functions in MathML 
-        try:
-            sympified_kinetics = sp.sympify(kinetics)
-        except:
-            return
 
-        if not util.check_symbols_derivative(sympified_kinetics, reactant_list):
+        if not util.check_kinetics_derivative(kinetics, ids_list, reactant_list):
             self.data.results.add_message(
                 reaction_id, 1003, "Flux is not increasing as reactant increases.")
 
@@ -409,15 +405,15 @@ def _check_flux_decreasing_with_product(self, **kwargs):
             A warning message to results specifying if the flux is not decreasing as product increases.
         """
         reaction_id = kwargs["reaction_id"]
+        ids_list = kwargs["ids_list"]
         is_reversible = kwargs["is_reversible"]
         product_list = kwargs["product_list"]
         kinetics = kwargs["kinetics"]
 
         # first check if kinetics can be sympified, TODO: support functions in MathML 
         if is_reversible:
             try:
-                sympified_kinetics = sp.sympify(kinetics)
-                if not util.check_symbols_derivative(sympified_kinetics, product_list, False):
+                if not util.check_kinetics_derivative(kinetics, ids_list, product_list, is_positive_derivative=False):
                     self.data.results.add_message(
                         reaction_id, 1004, "Flux is not decreasing as product increases.")
             except:
@@ -587,8 +583,10 @@ def _numerator_denominator(self, kinetics_sim, ids_list):
 
         strange_func = 0
         pre_symbols = ''
-        for i in range(len(ids_list)):
-            pre_symbols += ids_list[i]
+        ids_with_underscore = []
+        kinetics_with_underscore = util.add_underscore_to_ids(ids_list, kinetics_sim, ids_with_underscore)
+        for i in range(len(ids_with_underscore)):
+            pre_symbols += ids_with_underscore[i]
             pre_symbols += ' '
         pre_symbols = pre_symbols[:-1]  # remove the space at the end
         pre_symbols_comma = pre_symbols.replace(" ", ",")
@@ -600,7 +598,7 @@ def _numerator_denominator(self, kinetics_sim, ids_list):
 
         try:  # check if there is strange func (i.e. delay) in kinetic law;
             # sometimes ids_list is not enough for all the ids in kinetics
-            eq_stat = "kinetics_eq = " + kinetics_sim
+            eq_stat = "kinetics_eq = " + kinetics_with_underscore
             exec(eq_stat, globals())
         except:
             strange_func = 1
@@ -615,6 +613,9 @@ def _numerator_denominator(self, kinetics_sim, ids_list):
                 eq[1] = denominator
             except:
                 pass
+
+        eq[0] = util.remove_underscore_from_ids(ids_list, eq[0])
+        eq[1] = util.remove_underscore_from_ids(ids_list, eq[1])
 
         return eq
 

ratesb_python/common/util.py

@@ -78,52 +78,74 @@ def check_equal(expr1, expr2, n=4, sample_min=1, sample_max=10):
             return False
     return True
 
-def check_symbols_derivative(expr, symbols, is_positive_derivative=True):
-    """check if the derivative to symbols of a expression are always strictly positive where variables are positive
+def check_kinetics_derivative(kinetics, ids_list, species_list, is_positive_derivative=True):
+    """check if the derivative to ids_list of a kinetics are always strictly positive where variables are positive
 
     Args:
-        expr (sympy.Expr): sympy expression to evaluate
-        symbols (List): list of symbols to check derivative
-        ids_list (List): all symbols in expression
+        kinetics (str): kinetics expression
+        ids_list (List): all ids in expression
+        species_list (List): all species in expression
         is_positive_derivative (bool, optional): if we are checking the derivative is positive, checking negative otherwise. Defaults to True.
 
     Returns:
         bool: if every symbol's derivative if strictly positive if is_positive_derivative, strictively negative if not is_positive_derivative
     """
-    # Numeric (brute force) equality testing n-times
-    for symbol in symbols:
-        temp_expr = expr
-        for other_symbol in expr.free_symbols:
-            if str(other_symbol) != symbol:
-                temp_expr = temp_expr.subs(other_symbol, sp.Float(1))
+    for symbol in ids_list:
+        if symbol not in species_list:
+            kinetics = kinetics.replace(symbol, "1")
+    for species in species_list:
+        curr_kinetics = kinetics
+        for other_species in species_list:
+            if other_species != species:
+                curr_kinetics = curr_kinetics.replace(other_species, "1")
         if is_positive_derivative:
             prev = -math.inf
         else:
             prev = math.inf
         for i in range(1, 1001, 10):
-            try:
-                curr = sp.Float(temp_expr.subs(symbol, sp.Float(i/100)))
-                if is_positive_derivative:
-                    if curr <= prev:
-                        return False
-                else:
-                    if curr >= prev:
-                        return False
-                prev = curr
-            except:
-                return False
+            expr = curr_kinetics.replace(species, str(i/100))
+            curr = eval(expr)
+            if is_positive_derivative:
+                if curr <= prev:
+                    return False
+            else:
+                if curr >= prev:
+                    return False
+            prev = curr
     return True
 
 
-def substitute_sympy_builtin_symbols_with_underscore(symbol):
+def add_underscore_to_ids(ids_list, kinetics, ids_to_add):
+    """Add "___" to the ids in the ids_list, without changing the original ids_list
+        add the new ids to the ids_to_add list
+        change the ids in the kinetics to the new ids
+    Args:
+        ids_list (List): list of ids
+        kinetics (str): kinetics expression
+        ids_to_add (List): empty list to add the new ids
+    
+    Returns:
+        str: kinetics expression with new ids
     """
-    Substitute sympy built-in symbols with underscored symbols
-    This method recognizes which symbols are built-in sympy symbols and substitutes them with underscored symbols
+    for symbol in ids_list:
+        new_id = "___" + symbol
+        ids_to_add.append(new_id)
+        kinetics = kinetics.replace(symbol, new_id)
+    return kinetics
 
+def remove_underscore_from_ids(ids_list, kinetics):
+    """Remove "___" from the ids in the kinetics
+        ids_list should not contain "___"
     Args:
-        symbol (sympy.Symbol): symbol to substitute
-
+        ids_list (List): list of ids without "___"
+        kinetics (str): kinetics expression
+    
     Returns:
-        str: symbol name with underscore in front of the symbol
+        str: kinetics expression with new ids
     """
-
+
+    for symbol in ids_list:
+        # assert symbol does not start with "___"
+        assert symbol[:3] != "___"
+        kinetics = kinetics.replace("___" + symbol, symbol)
+    return kinetics

tests/test_util.py

@@ -8,7 +8,7 @@
 common_dir = os.path.join(parent_dir, 'ratesb_python', 'common')
 sys.path.append(common_dir)
 
-from util import get_model_str, get_json_str, check_equal, check_symbols_derivative
+from util import get_model_str, get_json_str, check_equal, check_kinetics_derivative, add_underscore_to_ids, remove_underscore_from_ids
 
 class TestUtil(unittest.TestCase):
     def test_get_model_str(self):
@@ -68,25 +68,40 @@ def test_check_equal(self):
         self.assertFalse(check_equal(expr5, expr7))
         self.assertFalse(check_equal(expr6, expr7))
 
-    def test_check_symbols_derivative(self):
-        x, y, z = sp.symbols('x y z')
-        expr1 = x + y + z
-        expr2 = x + z - 2 * y
-        expr3 = 1 / x
-        expr4 = x * y * z
-        expr5 = x * y / (1 + y)
+    def test_check_kinetics_derivative(self):
+        expr1 = "x + y + z"
+        expr2 = "x + z - 2 * y"
+        expr3 = "1 / x"
+        expr4 = "x * y * z"
+        expr5 = "x * y / (1 + y)"
         symbols = ["x", "y", "z"]
 
-        self.assertTrue(check_symbols_derivative(expr1, symbols))
-        self.assertFalse(check_symbols_derivative(expr1, symbols, False))
-        self.assertFalse(check_symbols_derivative(expr2, symbols))
-        self.assertFalse(check_symbols_derivative(expr2, symbols, False))
-        self.assertTrue(check_symbols_derivative(expr3, ["x"], False))
-        self.assertFalse(check_symbols_derivative(expr3, ["x"]))
-        self.assertTrue(check_symbols_derivative(expr4, symbols))
-        self.assertFalse(check_symbols_derivative(expr4, symbols, False))
-        self.assertTrue(check_symbols_derivative(expr5, ["x", "y"]))
-        self.assertFalse(check_symbols_derivative(expr5, ["x", "y"], False))
+        self.assertTrue(check_kinetics_derivative(expr1, symbols, symbols))
+        self.assertFalse(check_kinetics_derivative(expr1, symbols, symbols, False))
+        self.assertFalse(check_kinetics_derivative(expr2, symbols, symbols))
+        self.assertFalse(check_kinetics_derivative(expr2, symbols, symbols, False))
+        self.assertTrue(check_kinetics_derivative(expr3, symbols, ["x"], False))
+        self.assertFalse(check_kinetics_derivative(expr3, symbols, ["x"]))
+        self.assertTrue(check_kinetics_derivative(expr4, symbols, symbols))
+        self.assertFalse(check_kinetics_derivative(expr4, symbols, symbols, False))
+        self.assertTrue(check_kinetics_derivative(expr5, symbols, ["x", "y"]))
+        self.assertFalse(check_kinetics_derivative(expr5, symbols, ["x", "y"], False))
+
+    def test_add_underscore_to_ids(self):
+        ids_list = ["x", "y", "z"]
+        kinetics = "x + y + z"
+        ids_to_add = []
+        kinetics = add_underscore_to_ids(ids_list, kinetics, ids_to_add)
+        self.assertEqual(kinetics, "___x + ___y + ___z")
+        self.assertEqual(ids_to_add, ["___x", "___y", "___z"])
+        self.assertEqual(ids_list, ["x", "y", "z"])
+
+    def test_remove_underscore_from_ids(self):
+        ids_list = ["x", "y", "z"]
+        kinetics = "___x + ___y + ___z"
+        kinetics = remove_underscore_from_ids(ids_list, kinetics)
+        self.assertEqual(kinetics, "x + y + z")
+        self.assertEqual(ids_list, ["x", "y", "z"])
 
 if __name__ == "__main__":
     unittest.main()