First cut at adding an interrupt handler

Author: rocky

mathicsscript/__main__.py

@@ -24,13 +24,12 @@
 from pygments import highlight
 
 from mathicsscript.asymptote import asymptote_version
+from mathicsscript.interrupt import setup_signal_handler
 from mathicsscript.settings import definitions
 from mathicsscript.termshell import ShellEscapeException, mma_lexer
 from mathicsscript.termshell_gnu import TerminalShellGNUReadline
-from mathicsscript.termshell_prompt import (
-    TerminalShellCommon,
-    TerminalShellPromptToolKit,
-)
+from mathicsscript.termshell import TerminalShellCommon
+from mathicsscript.termshell_prompt import TerminalShellPromptToolKit
 from mathicsscript.version import __version__
 
 try:
@@ -123,7 +122,7 @@ def load_settings(shell):
                     continue
                 evaluation.evaluate(query)
         except KeyboardInterrupt:
-            print("\nKeyboardInterrupt")
+            shell.errmsg("\nKeyboardInterrupt")
     return True
 
 
@@ -145,16 +144,17 @@ def interactive_eval_loop(
     shell: TerminalShellCommon,
     unicode,
     prompt,
-    matplotlib: bool,
-    asymptote: bool,
     strict_wl_output: bool,
 ):
+    setup_signal_handler()
+
     def identity(x: Any) -> Any:
         return x
 
     def fmt_fun(query: Any) -> Any:
         return highlight(str(query), mma_lexer, shell.terminal_formatter)
 
+    shell.fmt_fn = fmt_fun
     while True:
         try:
             if have_readline and shell.using_readline:
@@ -173,6 +173,11 @@ def fmt_fun(query: Any) -> Any:
                     fmt = fmt_fun
 
             evaluation = Evaluation(shell.definitions, output=TerminalOutput(shell))
+
+            # Store shell into the evaluation so that an interrupt handler
+            # has access to this
+            evaluation.shell = shell
+
             query, source_code = evaluation.parse_feeder_returning_code(shell)
             if mathics_core.PRE_EVALUATION_HOOK is not None:
                 mathics_core.PRE_EVALUATION_HOOK(query, evaluation)
@@ -214,7 +219,7 @@ def fmt_fun(query: Any) -> Any:
                 try:
                     print(open(source_code[2:], "r").read())
                 except Exception:
-                    print(str(sys.exc_info()[1]))
+                    shell.errmsg(str(sys.exc_info()[1]))
             else:
                 subprocess.run(source_code[1:], shell=True)
 
@@ -224,13 +229,13 @@ def fmt_fun(query: Any) -> Any:
                 # shell.definitions.increment_line(1)
 
         except KeyboardInterrupt:
-            print("\nKeyboardInterrupt")
+            shell.errmsg("\nKeyboardInterrupt")
         except EOFError:
             if prompt:
-                print("\n\nGoodbye!\n")
+                shell.errmsg("\n\nGoodbye!\n")
             break
         except SystemExit:
-            print("\n\nGoodbye!\n")
+            shell.errmsg("\n\nGoodbye!\n")
             # raise to pass the error code on, e.g. Quit[1]
             raise
         finally:
@@ -526,9 +531,7 @@ def main(
     )
 
     definitions.set_line_no(0)
-    interactive_eval_loop(
-        shell, charset, prompt, asymptote, matplotlib, strict_wl_output
-    )
+    interactive_eval_loop(shell, charset, prompt, strict_wl_output)
     return exit_rc
 
 

mathicsscript/completion.py

@@ -23,7 +23,12 @@
 from mathics.core.symbols import strip_context
 from mathics_scanner import named_characters
 from mathics_pygments.lexer import Regex
-from prompt_toolkit.completion import CompleteEvent, Completion, WordCompleter
+from prompt_toolkit.completion import (
+    CompleteEvent,
+    Completer,
+    Completion,
+    WordCompleter,
+)
 from prompt_toolkit.document import Document
 
 SYMBOLS = rf"[`]?({Regex.IDENTIFIER}|{Regex.NAMED_CHARACTER})(`({Regex.IDENTIFIER}|{Regex.NAMED_CHARACTER}))+[`]?"
@@ -54,6 +59,28 @@ def get_datadir():
     return osp.realpath(datadir)
 
 
+class InterruptCompleter(Completer):
+    """
+    Completer for the simple command set: 'continue', 'abort', 'exit', 'show'.
+    """
+
+    COMMANDS = [
+        "abort",
+        "continue",
+        "exit",
+        "inspect",
+        "show",
+    ]
+
+    def get_completions(
+        self, document: Document, complete_event
+    ) -> Iterable[Completion]:
+        word = document.get_word_before_cursor()
+        for cmd in self.COMMANDS:
+            if cmd.startswith(word):
+                yield Completion(cmd, -len(word))
+
+
 class MathicsCompleter(WordCompleter):
     def __init__(self, definitions):
         self.definitions = definitions

mathicsscript/interrupt.py

@@ -0,0 +1,221 @@
+"""
+mathicsscript Interrupt routines.
+
+Note: other environments may build on or use other interrupt handlers
+"""
+
+import signal
+import subprocess
+import sys
+from types import FrameType
+from typing import Callable, Optional
+
+from numpy import true_divide
+
+from mathics import settings
+from mathics.core.evaluation import Evaluation
+from mathics.core.interrupt import AbortInterrupt, ReturnInterrupt, TimeoutInterrupt
+from mathics.eval.stackframe import find_Mathics3_evaluation_method, get_eval_Expression
+
+
+# See also __main__'s interactive_eval_loop
+def inspect_eval_loop(evaluation: Evaluation):
+    """
+    A read eval/loop for an Interrupt's "inspect" command.
+    """
+    shell = evaluation.shell
+    if shell is not None:
+        was_inside_interrupt = shell.is_inside_interrupt
+        shell.is_inside_interrupt = True
+    else:
+        was_inside_interrupt = False
+
+    previous_recursion_depth = evaluation.recursion_depth
+    while True:
+        try:
+            # Reset line number within an In[] line number.
+            # Note: this is not setting as, say, In[5]
+            # to back to In[1], but instead it sets the line number position *within*
+            # In[5]. The user input for "In[5]" might have several continuation lines.
+            if shell is not None and hasattr(shell, "lineno"):
+                shell.lineno = 0
+
+            query, source_code = evaluation.parse_feeder_returning_code(shell)
+            # show_echo(source_code, evaluation)
+            if len(source_code) and source_code[0] == "!" and shell is not None:
+                subprocess.run(source_code[1:], shell=True)
+                if shell.definitions is not None:
+                    shell.definitions.increment_line_no(1)
+                continue
+            if query is None:
+                continue
+            result = evaluation.evaluate(query, timeout=settings.TIMEOUT)
+            if result is not None and shell is not None:
+                shell.print_result(result, prompt=False, strict_wl_output=True)
+        except TimeoutInterrupt:
+            print("\nTimeout occurred - ignored.")
+            pass
+        except ReturnInterrupt:
+            evaluation.last_eval = None
+            evaluation.exc_result = None
+            evaluation.message("Interrupt", "dgend")
+            raise
+        except KeyboardInterrupt:
+            print("\nKeyboardInterrupt")
+        except EOFError:
+            print()
+            raise
+        except SystemExit:
+            # raise to pass the error code on, e.g. Quit[1]
+            raise
+        finally:
+            evaluation.recursion_depth = previous_recursion_depth
+            if shell is not None:
+                shell.is_inside_interrupt = was_inside_interrupt
+
+
+def Mathics3_interrupt_handler(
+    evaluation: Optional[Evaluation], interrupted_frame: FrameType, print_fn: Callable
+):
+
+    shell = evaluation.shell
+    incolors = shell.incolors
+    if hasattr(shell, "bottom_toolbar"):
+        from mathicsscript.completion import InterruptCompleter
+
+        is_prompt_toolkit = True
+        use_HTML = True
+        completer = InterruptCompleter()
+    else:
+        is_prompt_toolkit = False
+        use_HTML = False
+        completer = None
+    while True:
+        try:
+            prompt = (
+                "<b>interrupt> </b>"
+                if is_prompt_toolkit
+                else f"{incolors[0]}interrupt> {incolors[3]}"
+            )
+            user_input = shell.read_line(prompt, completer, use_HTML).strip()
+            if user_input in ("a", "abort"):
+                print_fn("aborting")
+                raise AbortInterrupt
+            elif user_input in ("continue", "c"):
+                print_fn("continuing")
+                break
+            elif user_input in ("exit", "quit"):
+                print_fn("Mathics3 exited because of an interrupt.")
+                sys.exit(3)
+            elif user_input in ("inspect", "i"):
+                print_fn("inspecting")
+                if evaluation is not None:
+                    evaluation.message("Interrupt", "dgbgn")
+                    inspect_eval_loop(evaluation)
+
+            elif user_input in ("show", "s"):
+                # In some cases we can better, by going back to the caller
+                # and reconstructing the actual call with arguments.
+                eval_frame = find_Mathics3_evaluation_method(interrupted_frame)
+                if eval_frame is None:
+                    continue
+                eval_method_name = eval_frame.f_code.co_name
+                eval_method = getattr(eval_frame.f_locals.get("self"), eval_method_name)
+                if eval_method:
+                    print_fn(eval_method.__doc__)
+                eval_expression = get_eval_Expression()
+                if eval_expression is not None:
+                    print_fn(shell.fmt_fn(eval_expression))
+                break
+            elif user_input in ("trace", "t"):
+                print_fn("tracing")
+            else:
+                print_fn(
+                    """Your options are:
+	abort (or a) to abort current calculation
+	continue (or c) to continue
+	exit (or quit) to exit Mathics3
+	inspect (or i) to enter an interactive dialog
+	show (or s) to show current operation (and then continue)
+"""
+                )
+        except KeyboardInterrupt:
+            print_fn("\nKeyboardInterrupt")
+        except EOFError:
+            print_fn("")
+            break
+        except TimeoutInterrupt:
+            # There might have been a Pause[] set before we entered
+            # this handler. If that happens, we can clear the
+            # error. Ideally the interrupt REPL would would have clear
+            # all timeout signals, but Python doesn't support that, as
+            # far as I know.
+            #
+            # Here, we note we have time'd out. This also silences
+            # other handlers that we've handled this.
+            if evaluation is not None:
+                evaluation.timeout = True
+            break
+        except ReturnInterrupt:
+            # the interrupt shell probably isssued a Return[].
+            # Respect that.
+            break
+        except RuntimeError:
+            break
+        finally:
+            pass
+
+
+def Mathics3_basic_signal_handler(sig: int, interrupted_frame: Optional[FrameType]):
+    """
+    Custom signal handler for SIGINT (Ctrl+C).
+    """
+    evaluation: Optional[Evaluation] = None
+    # Find an evaluation object to pass to the Mathics3 interrupt handler
+    while interrupted_frame is not None:
+        if (
+            evaluation := interrupted_frame.f_locals.get("evaluation")
+        ) is not None and isinstance(evaluation, Evaluation):
+            break
+        interrupted_frame = interrupted_frame.f_back
+    print_fn = evaluation.print_out if evaluation is not None else print
+    print_fn("")
+    if interrupted_frame is None:
+        print("Unable to find Evaluation frame to start on")
+    Mathics3_interrupt_handler(evaluation, interrupted_frame, print_fn)
+
+
+def Mathics3_USR1_signal_handler(sig: int, interrupted_frame: Optional[FrameType]):
+    """
+    Custom signal handler for SIGUSR1. When we get this signal, try to
+    find an Expression that is getting evaluated, and print that. Then
+    continue.
+    """
+    shell = None
+    print_fn = print
+    while interrupted_frame is not None:
+        if (
+            evaluation := interrupted_frame.f_locals.get("evaluation")
+        ) is not None and isinstance(evaluation, Evaluation):
+            print_fn = evaluation.shell.errmsg
+            break
+        interrupted_frame = interrupted_frame.f_back
+
+    print_fn(f"USR1 ({sig}) interrupt")
+    if (eval_expression := get_eval_Expression()) is not None:
+        # If eval string is long, take just the first 100 characters
+        # of it.
+        if shell is not None:
+            eval_expression_str = shell.fmt_fn(eval_expression)
+        else:
+            eval_expression_str = str(eval_expression)
+
+        if len(eval_expression_str) > 100:
+            eval_expression_str = eval_expression_str[:100] + "..."
+
+        print(f"Expression: {eval_expression_str}")
+
+
+def setup_signal_handler():
+    signal.signal(signal.SIGINT, Mathics3_basic_signal_handler)
+    signal.signal(signal.SIGUSR1, Mathics3_USR1_signal_handler)