handlig timeout in sympy evaluation

Author: mmatera

mathics/builtin/datentime.py

@@ -1055,7 +1055,13 @@ def eval(self, n, evaluation):
             )
             return
 
-        time.sleep(sleeptime)
+        steps = int(1000 * sleeptime)
+        while steps > 0:
+            time.sleep(0.001)
+            if evaluation.timeout:
+                return SymbolNull
+            steps = steps - 1
+
         return SymbolNull
 
 
@@ -1103,7 +1109,7 @@ def evaluate(self, evaluation):
         return Expression(SymbolDateObject.evaluate(evaluation))
 
 
-if sys.platform != "win32" and not hasattr(sys, "pyston_version_info"):
+if True:
 
     class TimeConstrained(Builtin):
         """
@@ -1124,23 +1130,6 @@ class TimeConstrained(Builtin):
         the state of the Mathics3 kernel.
         """
 
-        # FIXME: these tests sometimes cause SEGVs which probably means
-        # that TimeConstraint has bugs.
-
-        # Consider testing via unit tests.
-        # >> TimeConstrained[Integrate[Sin[x]^1000000,x],1]
-        # = $Aborted
-
-        # >> TimeConstrained[Integrate[Sin[x]^1000000,x], 1, Integrate[Cos[x],x]]
-        # = Sin[x]
-
-        # >> s=TimeConstrained[Integrate[Sin[x] ^ 3, x], a]
-        #  : Number of seconds a is not a positive machine-sized number or Infinity.
-        #  = TimeConstrained[Integrate[Sin[x] ^ 3, x], a]
-
-        # >> a=1; s
-        # =  Cos[x] (-5 + Cos[2 x]) / 6
-
         attributes = A_HOLD_ALL | A_PROTECTED
         messages = {
             "timc": (

mathics/core/builtin.py

@@ -58,7 +58,7 @@
 from mathics.core.convert.expression import to_expression
 from mathics.core.convert.op import ascii_operator_to_symbol
 from mathics.core.convert.python import from_bool
-from mathics.core.convert.sympy import from_sympy, to_numeric_sympy_args
+from mathics.core.convert.sympy import from_sympy
 from mathics.core.definitions import Definition, Definitions
 from mathics.core.evaluation import Evaluation
 from mathics.core.exceptions import MessageException
@@ -91,6 +91,7 @@
 from mathics.eval.numbers.numbers import cancel
 from mathics.eval.numerify import numerify
 from mathics.eval.scoping import dynamic_scoping
+from mathics.eval.sympy import eval_sympy
 
 try:
     import ujson
@@ -582,14 +583,7 @@ def eval(self, z, evaluation: Evaluation):
         # converted to python and the result is converted from sympy
         #
         # "%(name)s[z__]"
-        sympy_args = to_numeric_sympy_args(z, evaluation)
-        if self.sympy_name is None:
-            return
-        sympy_fn = getattr(sympy, self.sympy_name)
-        try:
-            return from_sympy(tracing.run_sympy(sympy_fn, *sympy_args))
-        except Exception:
-            return
+        return eval_sympy(self, z, evaluation)
 
     def get_constant(self, precision, evaluation, have_mpmath=False):
         try:

mathics/core/evaluation.py

@@ -131,6 +131,7 @@ def run_with_timeout_and_stack(request, timeout, evaluation):
     if thread.is_alive():
         evaluation.timeout = True
         while thread.is_alive():
+            time.sleep(0.001)
             pass
         evaluation.timeout = False
         evaluation.stopped = False
@@ -140,7 +141,7 @@ def run_with_timeout_and_stack(request, timeout, evaluation):
     if success:
         return result
     else:
-        raise result[0].with_traceback(result[1], result[2])
+        raise result[1].with_traceback(result[1], result[2])
 
 
 class _Out(KeyComparable):

mathics/eval/sympy.py

@@ -0,0 +1,56 @@
+"""
+Evaluation of sympy functions
+"""
+
+import sys
+from queue import Queue
+from threading import Thread
+
+import sympy
+
+import mathics.eval.tracing as tracing
+from mathics.core.convert.sympy import from_sympy, to_numeric_sympy_args
+
+
+def eval_sympy(self, z, evaluation):
+    """
+    Evaluate expr using `Sympy`
+    """
+
+    def evaluate():
+        sympy_args = to_numeric_sympy_args(z, evaluation)
+        if self.sympy_name is None:
+            return
+        sympy_fn = getattr(sympy, self.sympy_name)
+        try:
+            return from_sympy(tracing.run_sympy(sympy_fn, *sympy_args))
+        except Exception:
+            return
+
+    if evaluation.timeout is None:
+        return evaluate()
+
+    def _thread_target(request, queue) -> None:
+        try:
+            result = evaluate()
+            queue.put((True, result))
+        except BaseException:
+            exc_info = sys.exc_info()
+            queue.put((False, exc_info))
+
+    queue = Queue(maxsize=1)  # stores the result or exception
+    thread = Thread(target=_thread_target, args=(evaluate, queue))
+    thread.start()
+    while thread.is_alive():
+        thread.join(0.001)
+        if evaluation.timeout:
+            # I can kill the thread.
+            # just leave it...
+            return None
+
+    # pick the result and return
+    success, result = queue.get()
+    if success:
+        return result
+    else:
+        raise result[0].with_traceback(result[1], result[2])

test/builtin/test_datentime.py

@@ -10,26 +10,26 @@
 import pytest
 
 
-@pytest.mark.skipif(
-    sys.platform in ("win32", "emscripten") or hasattr(sys, "pyston_version_info"),
-    reason="TimeConstrained needs to be rewritten",
-)
+# @pytest.mark.skipif(
+#    sys.platform in ("win32", "emscripten") or hasattr(sys, "pyston_version_info"),
+#    reason="TimeConstrained needs to be rewritten",
+# )
 def test_timeremaining():
     str_expr = "TimeConstrained[1+2; TimeRemaining[], 0.9]"
     result = evaluate(str_expr)
     assert result is None or 0 < result.to_python() < 9
 
 
-@pytest.mark.skip(reason="TimeConstrained needs to be rewritten")
+# @pytest.mark.skip(reason="TimeConstrained needs to be rewritten")
 def test_timeconstrained1():
     #
-    str_expr1 = "a=1.; TimeConstrained[Do[Pause[.1];a=a+1,{1000}],1]"
+    str_expr1 = "a=1.; TimeConstrained[Do[Pause[.01];a=a+1,{1000}],.1]"
     result = evaluate(str_expr1)
     str_expected = "$Aborted"
     expected = evaluate(str_expected)
     assert result == expected
     time.sleep(1)
-    assert evaluate("a").to_python() == 10
+    assert evaluate("a").to_python() < 10
 
 
 def test_datelist():
@@ -109,6 +109,34 @@ def test_datestring():
             "Thu 6 Jun 1991 00:00:00",
             "Specified separators",
         ),
+        ##
+        (
+            "TimeConstrained[Integrate[Sin[x]^100,x],.5]",
+            None,
+            "$Aborted",
+            "TimeConstrained with two arguments",
+        ),
+        (
+            "TimeConstrained[Integrate[Sin[x]^100,x],.5, Integrate[Cos[x],x]]",
+            None,
+            "Sin[x]",
+            "TimeConstrained with three arguments",
+        ),
+        (
+            "a=.;s=TimeConstrained[Integrate[Sin[x] ^ 3, x], a]",
+            (
+                "Number of seconds a is not a positive machine-sized number or Infinity.",
+            ),
+            "TimeConstrained[Integrate[Sin[x] ^ 3, x], a]",
+            "TimeConstrained unevaluated because the second argument is not numeric",
+        ),
+        (
+            "a=1; s",
+            None,
+            "Cos[x] (-3 + Cos[x] ^ 2) / 3",
+            "s is now evaluated because `a` is a number.",
+        ),
+        ("a=.;s=.;", None, "Null", None),
     ],
 )
 def test_private_doctests_datetime(str_expr, msgs, str_expected, fail_msg):