use master code for TimeConstrained.

master is more up to date.

Author: rocky

mathics/builtin/datentime.py

@@ -39,13 +39,9 @@
     SymbolInfinity,
     SymbolRowBox,
 )
+from mathics.eval.datetime import eval_timeconstrained, valid_time_from_expression
 from mathics.settings import TIME_12HOUR
 
-if sys.platform == "emscripten":
-    from timed_threads import SignalTimeout as TimeoutHandler
-else:
-    from timed_threads import ThreadingTimeout as TimeoutHandler
-
 START_TIME = time.time()
 
 TIME_INCREMENTS = {
@@ -1098,34 +1094,35 @@ def evaluate(self, evaluation: Evaluation) -> Expression:
 
 
 class TimeConstrained(Builtin):
-    """
+    r"""
     <url>:WMA link:https://reference.wolfram.com/language/ref/TimeConstrained.html</url>
 
     <dl>
-      <dt>'TimeConstrained[$expr$, $t$]'
+      <dt>'TimeConstrained'[$expr$, $t$]
       <dd>'evaluates $expr$, stopping after $t$ seconds.'
 
-      <dt>'TimeConstrained[$expr$, $t$, $failexpr$]'
+      <dt>'TimeConstrained'[$expr$, $t$, $failexpr$]
       <dd>'returns $failexpr$ if the time constraint is not met.'
     </dl>
 
     Possible issues: for certain time-consuming functions (like simplify)
     which are based on sympy or other libraries, it is possible that
     the evaluation continues after the timeout. However, at the end of the \
-    evaluation, the function will return '$Aborted' and the results will not affect
+    evaluation, the function will return '\$Aborted' and the results will not affect
     the state of the Mathics3 kernel.
 
-    >> TimeConstrained[Pause[5]; a, 1]
-     = $Aborted
-
-    'TimeConstrained' can be nested. In this case, the outer 'TimeConstrained' waits for \
-    2 seconds that the inner sequence be executed. Inner expressions would take in \
-    sequence more than 3 seconds:
-    >> TimeConstrained[TimeConstrained[Pause[1]; Print["First Done"], 2];\
-                  TimeConstrained[Pause[5];Print["Second Done"],2,"inner"], \
-                  2, "outer"]
-     | First Done
-     = outer
+
+    ## >> TimeConstrained[Pause[5]; a, 1]
+    ##  = $Aborted
+
+    ## 'TimeConstrained' can be nested. In this case, the outer 'TimeConstrained' waits for \
+    ## 2 seconds that the inner sequence be executed. Inner expressions would take in \
+    ## sequence more than 3 seconds:
+    ## >> TimeConstrained[TimeConstrained[Pause[1]; Print["First Done"], 2];\
+    ##              TimeConstrained[Pause[5];Print["Second Done"],2,"inner"], \
+    ##              2, "outer"]
+    ## | First Done
+    ## = outer
     """
 
     attributes = A_HOLD_ALL | A_PROTECTED
@@ -1135,36 +1132,30 @@ class TimeConstrained(Builtin):
             "or Infinity."
         ),
     }
+    if sys.platform == "emscripten":
+        messages.update({"tcns": f"TimeConstrained is not supported in {sys.platform}"})
 
     summary_text = "run a command for at most a specified time"
 
-    def eval_2(self, expr, t, evaluation):
+    def eval_with_timeout(self, expr, t, evaluation) -> Optional[BaseElement]:
         "TimeConstrained[expr_, t_]"
-        return self.eval_3(expr, t, SymbolAborted, evaluation)
+        try:
+            timeout = valid_time_from_expression(t, evaluation)
+        except ValueError:
+            evaluation.message("TimeConstrained", "timc", t)
+            return
+        return eval_timeconstrained(expr, timeout, SymbolAborted, evaluation)
 
-    def eval_3(self, expr, t, failexpr, evaluation):
+    def eval_with_timeout_and_failexpr(
+        self, expr, t, failexpr, evaluation
+    ) -> Optional[BaseElement]:
         "TimeConstrained[expr_, t_, failexpr_]"
-        t = t.evaluate(evaluation)
-        if not t.is_numeric(evaluation):
+        try:
+            timeout = valid_time_from_expression(t, evaluation)
+        except ValueError:
             evaluation.message("TimeConstrained", "timc", t)
             return
-        try:
-            timeout = float(t.to_python())
-            evaluation.timeout_queue.append((timeout, datetime.now().timestamp()))
-            request = lambda: expr.evaluate(evaluation)
-            done = False
-            with TimeoutHandler(timeout) as to_ctx_mgr:
-                assert to_ctx_mgr.state == to_ctx_mgr.EXECUTING
-                result = request()
-                done = True
-            if done:
-                evaluation.timeout_queue.pop()
-                return result
-        except Exception:
-            evaluation.timeout_queue.pop()
-            raise
-        evaluation.timeout_queue.pop()
-        return failexpr.evaluate(evaluation)
+        return eval_timeconstrained(expr, timeout, failexpr, evaluation)
 
 
 class TimeZone(Predefined):