Only enable "resume hinting" with right arrow if at the EOL (#14052)

Fixes  #14051

IPython/terminal/shortcuts/__init__.py

@@ -1,627 +1,629 b''
 """
 Module to define and register Terminal IPython shortcuts with
 :mod:`prompt_toolkit`
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import os
 import signal
 import sys
 import warnings
 from dataclasses import dataclass
 from typing import Callable, Any, Optional, List
 
 from prompt_toolkit.application.current import get_app
 from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.key_binding.key_processor import KeyPressEvent
 from prompt_toolkit.key_binding.bindings import named_commands as nc
 from prompt_toolkit.key_binding.bindings.completion import (
     display_completions_like_readline,
 )
 from prompt_toolkit.key_binding.vi_state import InputMode, ViState
 from prompt_toolkit.filters import Condition
 
 from IPython.core.getipython import get_ipython
 from IPython.terminal.shortcuts import auto_match as match
 from IPython.terminal.shortcuts import auto_suggest
 from IPython.terminal.shortcuts.filters import filter_from_string
 from IPython.utils.decorators import undoc
 
 from prompt_toolkit.enums import DEFAULT_BUFFER
 
 __all__ = ["create_ipython_shortcuts"]
 
 
 @dataclass
 class BaseBinding:
     command: Callable[[KeyPressEvent], Any]
     keys: List[str]
 
 
 @dataclass
 class RuntimeBinding(BaseBinding):
     filter: Condition
 
 
 @dataclass
 class Binding(BaseBinding):
     # while filter could be created by referencing variables directly (rather
     # than created from strings), by using strings we ensure that users will
     # be able to create filters in configuration (e.g. JSON) files too, which
     # also benefits the documentation by enforcing human-readable filter names.
     condition: Optional[str] = None
 
     def __post_init__(self):
         if self.condition:
             self.filter = filter_from_string(self.condition)
         else:
             self.filter = None
 
 
 def create_identifier(handler: Callable):
     parts = handler.__module__.split(".")
     name = handler.__name__
     package = parts[0]
     if len(parts) > 1:
         final_module = parts[-1]
         return f"{package}:{final_module}.{name}"
     else:
         return f"{package}:{name}"
 
 
 AUTO_MATCH_BINDINGS = [
     *[
         Binding(
             cmd, [key], "focused_insert & auto_match & followed_by_closing_paren_or_end"
         )
         for key, cmd in match.auto_match_parens.items()
     ],
     *[
         # raw string
         Binding(cmd, [key], "focused_insert & auto_match & preceded_by_raw_str_prefix")
         for key, cmd in match.auto_match_parens_raw_string.items()
     ],
     Binding(
         match.double_quote,
         ['"'],
         "focused_insert"
         " & auto_match"
         " & not_inside_unclosed_string"
         " & preceded_by_paired_double_quotes"
         " & followed_by_closing_paren_or_end",
     ),
     Binding(
         match.single_quote,
         ["'"],
         "focused_insert"
         " & auto_match"
         " & not_inside_unclosed_string"
         " & preceded_by_paired_single_quotes"
         " & followed_by_closing_paren_or_end",
     ),
     Binding(
         match.docstring_double_quotes,
         ['"'],
         "focused_insert"
         " & auto_match"
         " & not_inside_unclosed_string"
         " & preceded_by_two_double_quotes",
     ),
     Binding(
         match.docstring_single_quotes,
         ["'"],
         "focused_insert"
         " & auto_match"
         " & not_inside_unclosed_string"
         " & preceded_by_two_single_quotes",
     ),
     Binding(
         match.skip_over,
         [")"],
         "focused_insert & auto_match & followed_by_closing_round_paren",
     ),
     Binding(
         match.skip_over,
         ["]"],
         "focused_insert & auto_match & followed_by_closing_bracket",
     ),
     Binding(
         match.skip_over,
         ["}"],
         "focused_insert & auto_match & followed_by_closing_brace",
     ),
     Binding(
         match.skip_over, ['"'], "focused_insert & auto_match & followed_by_double_quote"
     ),
     Binding(
         match.skip_over, ["'"], "focused_insert & auto_match & followed_by_single_quote"
     ),
     Binding(
         match.delete_pair,
         ["backspace"],
         "focused_insert"
         " & preceded_by_opening_round_paren"
         " & auto_match"
         " & followed_by_closing_round_paren",
     ),
     Binding(
         match.delete_pair,
         ["backspace"],
         "focused_insert"
         " & preceded_by_opening_bracket"
         " & auto_match"
         " & followed_by_closing_bracket",
     ),
     Binding(
         match.delete_pair,
         ["backspace"],
         "focused_insert"
         " & preceded_by_opening_brace"
         " & auto_match"
         " & followed_by_closing_brace",
     ),
     Binding(
         match.delete_pair,
         ["backspace"],
         "focused_insert"
         " & preceded_by_double_quote"
         " & auto_match"
         " & followed_by_double_quote",
     ),
     Binding(
         match.delete_pair,
         ["backspace"],
         "focused_insert"
         " & preceded_by_single_quote"
         " & auto_match"
         " & followed_by_single_quote",
     ),
 ]
 
 AUTO_SUGGEST_BINDINGS = [
     # there are two reasons for re-defining bindings defined upstream:
     # 1) prompt-toolkit does not execute autosuggestion bindings in vi mode,
     # 2) prompt-toolkit checks if we are at the end of text, not end of line
     #    hence it does not work in multi-line mode of navigable provider
     Binding(
         auto_suggest.accept_or_jump_to_end,
         ["end"],
         "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
     ),
     Binding(
         auto_suggest.accept_or_jump_to_end,
         ["c-e"],
         "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
     ),
     Binding(
         auto_suggest.accept,
         ["c-f"],
         "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
     ),
     Binding(
         auto_suggest.accept,
         ["right"],
         "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
     ),
     Binding(
         auto_suggest.accept_word,
         ["escape", "f"],
         "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
     ),
     Binding(
         auto_suggest.accept_token,
         ["c-right"],
         "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
     ),
     Binding(
         auto_suggest.discard,
         ["escape"],
         # note this one is using `emacs_insert_mode`, not `emacs_like_insert_mode`
         # as in `vi_insert_mode` we do not want `escape` to be shadowed (ever).
         "has_suggestion & default_buffer_focused & emacs_insert_mode",
     ),
     Binding(
         auto_suggest.discard,
         ["delete"],
         "has_suggestion & default_buffer_focused & emacs_insert_mode",
     ),
     Binding(
         auto_suggest.swap_autosuggestion_up,
         ["c-up"],
         "navigable_suggestions"
         " & ~has_line_above"
         " & has_suggestion"
         " & default_buffer_focused",
     ),
     Binding(
         auto_suggest.swap_autosuggestion_down,
         ["c-down"],
         "navigable_suggestions"
         " & ~has_line_below"
         " & has_suggestion"
         " & default_buffer_focused",
     ),
     Binding(
         auto_suggest.up_and_update_hint,
         ["c-up"],
         "has_line_above & navigable_suggestions & default_buffer_focused",
     ),
     Binding(
         auto_suggest.down_and_update_hint,
         ["c-down"],
         "has_line_below & navigable_suggestions & default_buffer_focused",
     ),
     Binding(
         auto_suggest.accept_character,
         ["escape", "right"],
         "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
     ),
     Binding(
         auto_suggest.accept_and_move_cursor_left,
         ["c-left"],
         "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
     ),
     Binding(
         auto_suggest.accept_and_keep_cursor,
         ["escape", "down"],
         "has_suggestion & default_buffer_focused & emacs_insert_mode",
     ),
     Binding(
         auto_suggest.backspace_and_resume_hint,
         ["backspace"],
         # no `has_suggestion` here to allow resuming if no suggestion
         "default_buffer_focused & emacs_like_insert_mode",
     ),
     Binding(
         auto_suggest.resume_hinting,
         ["right"],
-        "default_buffer_focused & emacs_like_insert_mode",
+        "is_cursor_at_the_end_of_line"
+        " & default_buffer_focused"
+        " & emacs_like_insert_mode",
     ),
 ]
 
 
 SIMPLE_CONTROL_BINDINGS = [
     Binding(cmd, [key], "vi_insert_mode & default_buffer_focused & ebivim")
     for key, cmd in {
         "c-a": nc.beginning_of_line,
         "c-b": nc.backward_char,
         "c-k": nc.kill_line,
         "c-w": nc.backward_kill_word,
         "c-y": nc.yank,
         "c-_": nc.undo,
     }.items()
 ]
 
 
 ALT_AND_COMOBO_CONTROL_BINDINGS = [
     Binding(cmd, list(keys), "vi_insert_mode & default_buffer_focused & ebivim")
     for keys, cmd in {
         # Control Combos
         ("c-x", "c-e"): nc.edit_and_execute,
         ("c-x", "e"): nc.edit_and_execute,
         # Alt
         ("escape", "b"): nc.backward_word,
         ("escape", "c"): nc.capitalize_word,
         ("escape", "d"): nc.kill_word,
         ("escape", "h"): nc.backward_kill_word,
         ("escape", "l"): nc.downcase_word,
         ("escape", "u"): nc.uppercase_word,
         ("escape", "y"): nc.yank_pop,
         ("escape", "."): nc.yank_last_arg,
     }.items()
 ]
 
 
 def add_binding(bindings: KeyBindings, binding: Binding):
     bindings.add(
         *binding.keys,
         **({"filter": binding.filter} if binding.filter is not None else {}),
     )(binding.command)
 
 
 def create_ipython_shortcuts(shell, skip=None) -> KeyBindings:
     """Set up the prompt_toolkit keyboard shortcuts for IPython.
 
     Parameters
     ----------
     shell: InteractiveShell
         The current IPython shell Instance
     skip: List[Binding]
         Bindings to skip.
 
     Returns
     -------
     KeyBindings
         the keybinding instance for prompt toolkit.
 
     """
     kb = KeyBindings()
     skip = skip or []
     for binding in KEY_BINDINGS:
         skip_this_one = False
         for to_skip in skip:
             if (
                 to_skip.command == binding.command
                 and to_skip.filter == binding.filter
                 and to_skip.keys == binding.keys
             ):
                 skip_this_one = True
                 break
         if skip_this_one:
             continue
         add_binding(kb, binding)
 
     def get_input_mode(self):
         app = get_app()
         app.ttimeoutlen = shell.ttimeoutlen
         app.timeoutlen = shell.timeoutlen
 
         return self._input_mode
 
     def set_input_mode(self, mode):
         shape = {InputMode.NAVIGATION: 2, InputMode.REPLACE: 4}.get(mode, 6)
         cursor = "\x1b[{} q".format(shape)
 
         sys.stdout.write(cursor)
         sys.stdout.flush()
 
         self._input_mode = mode
 
     if shell.editing_mode == "vi" and shell.modal_cursor:
         ViState._input_mode = InputMode.INSERT  # type: ignore
         ViState.input_mode = property(get_input_mode, set_input_mode)  # type: ignore
 
     return kb
 
 
 def reformat_and_execute(event):
     """Reformat code and execute it"""
     shell = get_ipython()
     reformat_text_before_cursor(
         event.current_buffer, event.current_buffer.document, shell
     )
     event.current_buffer.validate_and_handle()
 
 
 def reformat_text_before_cursor(buffer, document, shell):
     text = buffer.delete_before_cursor(len(document.text[: document.cursor_position]))
     try:
         formatted_text = shell.reformat_handler(text)
         buffer.insert_text(formatted_text)
     except Exception as e:
         buffer.insert_text(text)
 
 
 def handle_return_or_newline_or_execute(event):
     shell = get_ipython()
     if getattr(shell, "handle_return", None):
         return shell.handle_return(shell)(event)
     else:
         return newline_or_execute_outer(shell)(event)
 
 
 def newline_or_execute_outer(shell):
     def newline_or_execute(event):
         """When the user presses return, insert a newline or execute the code."""
         b = event.current_buffer
         d = b.document
 
         if b.complete_state:
             cc = b.complete_state.current_completion
             if cc:
                 b.apply_completion(cc)
             else:
                 b.cancel_completion()
             return
 
         # If there's only one line, treat it as if the cursor is at the end.
         # See https://github.com/ipython/ipython/issues/10425
         if d.line_count == 1:
             check_text = d.text
         else:
             check_text = d.text[: d.cursor_position]
         status, indent = shell.check_complete(check_text)
 
         # if all we have after the cursor is whitespace: reformat current text
         # before cursor
         after_cursor = d.text[d.cursor_position :]
         reformatted = False
         if not after_cursor.strip():
             reformat_text_before_cursor(b, d, shell)
             reformatted = True
         if not (
             d.on_last_line
             or d.cursor_position_row >= d.line_count - d.empty_line_count_at_the_end()
         ):
             if shell.autoindent:
                 b.insert_text("\n" + indent)
             else:
                 b.insert_text("\n")
             return
 
         if (status != "incomplete") and b.accept_handler:
             if not reformatted:
                 reformat_text_before_cursor(b, d, shell)
             b.validate_and_handle()
         else:
             if shell.autoindent:
                 b.insert_text("\n" + indent)
             else:
                 b.insert_text("\n")
 
     return newline_or_execute
 
 
 def previous_history_or_previous_completion(event):
     """
     Control-P in vi edit mode on readline is history next, unlike default prompt toolkit.
 
     If completer is open this still select previous completion.
     """
     event.current_buffer.auto_up()
 
 
 def next_history_or_next_completion(event):
     """
     Control-N in vi edit mode on readline is history previous, unlike default prompt toolkit.
 
     If completer is open this still select next completion.
     """
     event.current_buffer.auto_down()
 
 
 def dismiss_completion(event):
     """Dismiss completion"""
     b = event.current_buffer
     if b.complete_state:
         b.cancel_completion()
 
 
 def reset_buffer(event):
     """Reset buffer"""
     b = event.current_buffer
     if b.complete_state:
         b.cancel_completion()
     else:
         b.reset()
 
 
 def reset_search_buffer(event):
     """Reset search buffer"""
     if event.current_buffer.document.text:
         event.current_buffer.reset()
     else:
         event.app.layout.focus(DEFAULT_BUFFER)
 
 
 def suspend_to_bg(event):
     """Suspend to background"""
     event.app.suspend_to_background()
 
 
 def quit(event):
     """
     Quit application with ``SIGQUIT`` if supported or ``sys.exit`` otherwise.
 
     On platforms that support SIGQUIT, send SIGQUIT to the current process.
     On other platforms, just exit the process with a message.
     """
     sigquit = getattr(signal, "SIGQUIT", None)
     if sigquit is not None:
         os.kill(0, signal.SIGQUIT)
     else:
         sys.exit("Quit")
 
 
 def indent_buffer(event):
     """Indent buffer"""
     event.current_buffer.insert_text(" " * 4)
 
 
 def newline_autoindent(event):
     """Insert a newline after the cursor indented appropriately.
 
     Fancier version of former ``newline_with_copy_margin`` which should
     compute the correct indentation of the inserted line. That is to say, indent
     by 4 extra space after a function definition, class definition, context
     manager... And dedent by 4 space after ``pass``, ``return``, ``raise ...``.
     """
     shell = get_ipython()
     inputsplitter = shell.input_transformer_manager
     b = event.current_buffer
     d = b.document
 
     if b.complete_state:
         b.cancel_completion()
     text = d.text[: d.cursor_position] + "\n"
     _, indent = inputsplitter.check_complete(text)
     b.insert_text("\n" + (" " * (indent or 0)), move_cursor=False)
 
 
 def open_input_in_editor(event):
     """Open code from input in external editor"""
     event.app.current_buffer.open_in_editor()
 
 
 if sys.platform == "win32":
     from IPython.core.error import TryNext
     from IPython.lib.clipboard import (
         ClipboardEmpty,
         tkinter_clipboard_get,
         win32_clipboard_get,
     )
 
     @undoc
     def win_paste(event):
         try:
             text = win32_clipboard_get()
         except TryNext:
             try:
                 text = tkinter_clipboard_get()
             except (TryNext, ClipboardEmpty):
                 return
         except ClipboardEmpty:
             return
         event.current_buffer.insert_text(text.replace("\t", " " * 4))
 
 else:
 
     @undoc
     def win_paste(event):
         """Stub used on other platforms"""
         pass
 
 
 KEY_BINDINGS = [
     Binding(
         handle_return_or_newline_or_execute,
         ["enter"],
         "default_buffer_focused & ~has_selection & insert_mode",
     ),
     Binding(
         reformat_and_execute,
         ["escape", "enter"],
         "default_buffer_focused & ~has_selection & insert_mode & ebivim",
     ),
     Binding(quit, ["c-\\"]),
     Binding(
         previous_history_or_previous_completion,
         ["c-p"],
         "vi_insert_mode & default_buffer_focused",
     ),
     Binding(
         next_history_or_next_completion,
         ["c-n"],
         "vi_insert_mode & default_buffer_focused",
     ),
     Binding(dismiss_completion, ["c-g"], "default_buffer_focused & has_completions"),
     Binding(reset_buffer, ["c-c"], "default_buffer_focused"),
     Binding(reset_search_buffer, ["c-c"], "search_buffer_focused"),
     Binding(suspend_to_bg, ["c-z"], "supports_suspend"),
     Binding(
         indent_buffer,
         ["tab"],  # Ctrl+I == Tab
         "default_buffer_focused"
         " & ~has_selection"
         " & insert_mode"
         " & cursor_in_leading_ws",
     ),
     Binding(newline_autoindent, ["c-o"], "default_buffer_focused & emacs_insert_mode"),
     Binding(open_input_in_editor, ["f2"], "default_buffer_focused"),
     *AUTO_MATCH_BINDINGS,
     *AUTO_SUGGEST_BINDINGS,
     Binding(
         display_completions_like_readline,
         ["c-i"],
         "readline_like_completions"
         " & default_buffer_focused"
         " & ~has_selection"
         " & insert_mode"
         " & ~cursor_in_leading_ws",
     ),
     Binding(win_paste, ["c-v"], "default_buffer_focused & ~vi_mode & is_windows_os"),
     *SIMPLE_CONTROL_BINDINGS,
     *ALT_AND_COMOBO_CONTROL_BINDINGS,
 ]

IPython/terminal/shortcuts/filters.py

@@ -1,282 +1,290 b''
 """
 Filters restricting scope of IPython Terminal shortcuts.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import ast
 import re
 import signal
 import sys
 from typing import Callable, Dict, Union
 
 from prompt_toolkit.application.current import get_app
 from prompt_toolkit.enums import DEFAULT_BUFFER, SEARCH_BUFFER
 from prompt_toolkit.filters import Condition, emacs_insert_mode, has_completions
 from prompt_toolkit.filters import has_focus as has_focus_impl
 from prompt_toolkit.filters import (
     Always,
     Never,
     has_selection,
     has_suggestion,
     vi_insert_mode,
     vi_mode,
 )
 from prompt_toolkit.layout.layout import FocusableElement
 
 from IPython.core.getipython import get_ipython
 from IPython.core.guarded_eval import _find_dunder, BINARY_OP_DUNDERS, UNARY_OP_DUNDERS
 from IPython.terminal.shortcuts import auto_suggest
 from IPython.utils.decorators import undoc
 
 
 @undoc
 @Condition
 def cursor_in_leading_ws():
     before = get_app().current_buffer.document.current_line_before_cursor
     return (not before) or before.isspace()
 
 
 def has_focus(value: FocusableElement):
     """Wrapper around has_focus adding a nice `__name__` to tester function"""
     tester = has_focus_impl(value).func
     tester.__name__ = f"is_focused({value})"
     return Condition(tester)
 
 
 @undoc
 @Condition
 def has_line_below() -> bool:
     document = get_app().current_buffer.document
     return document.cursor_position_row < len(document.lines) - 1
 
 
 @undoc
 @Condition
+def is_cursor_at_the_end_of_line() -> bool:
+    document = get_app().current_buffer.document
+    return document.is_cursor_at_the_end_of_line
+
+
+@undoc
+@Condition
 def has_line_above() -> bool:
     document = get_app().current_buffer.document
     return document.cursor_position_row != 0
 
 
 @Condition
 def ebivim():
     shell = get_ipython()
     return shell.emacs_bindings_in_vi_insert_mode
 
 
 @Condition
 def supports_suspend():
     return hasattr(signal, "SIGTSTP")
 
 
 @Condition
 def auto_match():
     shell = get_ipython()
     return shell.auto_match
 
 
 def all_quotes_paired(quote, buf):
     paired = True
     i = 0
     while i < len(buf):
         c = buf[i]
         if c == quote:
             paired = not paired
         elif c == "\\":
             i += 1
         i += 1
     return paired
 
 
 _preceding_text_cache: Dict[Union[str, Callable], Condition] = {}
 _following_text_cache: Dict[Union[str, Callable], Condition] = {}
 
 
 def preceding_text(pattern: Union[str, Callable]):
     if pattern in _preceding_text_cache:
         return _preceding_text_cache[pattern]
 
     if callable(pattern):
 
         def _preceding_text():
             app = get_app()
             before_cursor = app.current_buffer.document.current_line_before_cursor
             # mypy can't infer if(callable): https://github.com/python/mypy/issues/3603
             return bool(pattern(before_cursor))  # type: ignore[operator]
 
     else:
         m = re.compile(pattern)
 
         def _preceding_text():
             app = get_app()
             before_cursor = app.current_buffer.document.current_line_before_cursor
             return bool(m.match(before_cursor))
 
         _preceding_text.__name__ = f"preceding_text({pattern!r})"
 
     condition = Condition(_preceding_text)
     _preceding_text_cache[pattern] = condition
     return condition
 
 
 def following_text(pattern):
     try:
         return _following_text_cache[pattern]
     except KeyError:
         pass
     m = re.compile(pattern)
 
     def _following_text():
         app = get_app()
         return bool(m.match(app.current_buffer.document.current_line_after_cursor))
 
     _following_text.__name__ = f"following_text({pattern!r})"
 
     condition = Condition(_following_text)
     _following_text_cache[pattern] = condition
     return condition
 
 
 @Condition
 def not_inside_unclosed_string():
     app = get_app()
     s = app.current_buffer.document.text_before_cursor
     # remove escaped quotes
     s = s.replace('\\"', "").replace("\\'", "")
     # remove triple-quoted string literals
     s = re.sub(r"(?:\"\"\"[\s\S]*\"\"\"|'''[\s\S]*''')", "", s)
     # remove single-quoted string literals
     s = re.sub(r"""(?:"[^"]*["\n]|'[^']*['\n])""", "", s)
     return not ('"' in s or "'" in s)
 
 
 @Condition
 def navigable_suggestions():
     shell = get_ipython()
     return isinstance(shell.auto_suggest, auto_suggest.NavigableAutoSuggestFromHistory)
 
 
 @Condition
 def readline_like_completions():
     shell = get_ipython()
     return shell.display_completions == "readlinelike"
 
 
 @Condition
 def is_windows_os():
     return sys.platform == "win32"
 
 
 # these one is callable and re-used multiple times hence needs to be
 # only defined once beforhand so that transforming back to human-readable
 # names works well in the documentation.
 default_buffer_focused = has_focus(DEFAULT_BUFFER)
 
 KEYBINDING_FILTERS = {
     "always": Always(),
     # never is used for exposing commands which have no default keybindings
     "never": Never(),
     "has_line_below": has_line_below,
     "has_line_above": has_line_above,
+    "is_cursor_at_the_end_of_line": is_cursor_at_the_end_of_line,
     "has_selection": has_selection,
     "has_suggestion": has_suggestion,
     "vi_mode": vi_mode,
     "vi_insert_mode": vi_insert_mode,
     "emacs_insert_mode": emacs_insert_mode,
     # https://github.com/ipython/ipython/pull/12603 argued for inclusion of
     # emacs key bindings with a configurable `emacs_bindings_in_vi_insert_mode`
     # toggle; when the toggle is on user can access keybindigns like `ctrl + e`
     # in vi insert mode. Because some of the emacs bindings involve `escape`
     # followed by another key, e.g. `escape` followed by `f`, prompt-toolkit
     # needs to wait to see if there will be another character typed in before
     # executing pure `escape` keybinding; in vi insert mode `escape` switches to
     # command mode which is common and performance critical action for vi users.
     # To avoid the delay users employ a workaround:
     # https://github.com/ipython/ipython/issues/13443#issuecomment-1032753703
     # which involves switching `emacs_bindings_in_vi_insert_mode` off.
     #
     # For the workaround to work:
     # 1) end users need to toggle `emacs_bindings_in_vi_insert_mode` off
     # 2) all keybindings which would involve `escape` need to respect that
     #    toggle by including either:
     #      - `vi_insert_mode & ebivim` for actions which have emacs keybindings
     #        predefined upstream in prompt-toolkit, or
     #      - `emacs_like_insert_mode` for actions which do not have existing
     #        emacs keybindings predefined upstream (or need overriding of the
     #        upstream bindings to modify behaviour), defined below.
     "emacs_like_insert_mode": (vi_insert_mode & ebivim) | emacs_insert_mode,
     "has_completions": has_completions,
     "insert_mode": vi_insert_mode | emacs_insert_mode,
     "default_buffer_focused": default_buffer_focused,
     "search_buffer_focused": has_focus(SEARCH_BUFFER),
     # `ebivim` stands for emacs bindings in vi insert mode
     "ebivim": ebivim,
     "supports_suspend": supports_suspend,
     "is_windows_os": is_windows_os,
     "auto_match": auto_match,
     "focused_insert": (vi_insert_mode | emacs_insert_mode) & default_buffer_focused,
     "not_inside_unclosed_string": not_inside_unclosed_string,
     "readline_like_completions": readline_like_completions,
     "preceded_by_paired_double_quotes": preceding_text(
         lambda line: all_quotes_paired('"', line)
     ),
     "preceded_by_paired_single_quotes": preceding_text(
         lambda line: all_quotes_paired("'", line)
     ),
     "preceded_by_raw_str_prefix": preceding_text(r".*(r|R)[\"'](-*)$"),
     "preceded_by_two_double_quotes": preceding_text(r'^.*""$'),
     "preceded_by_two_single_quotes": preceding_text(r"^.*''$"),
     "followed_by_closing_paren_or_end": following_text(r"[,)}\]]|$"),
     "preceded_by_opening_round_paren": preceding_text(r".*\($"),
     "preceded_by_opening_bracket": preceding_text(r".*\[$"),
     "preceded_by_opening_brace": preceding_text(r".*\{$"),
     "preceded_by_double_quote": preceding_text('.*"$'),
     "preceded_by_single_quote": preceding_text(r".*'$"),
     "followed_by_closing_round_paren": following_text(r"^\)"),
     "followed_by_closing_bracket": following_text(r"^\]"),
     "followed_by_closing_brace": following_text(r"^\}"),
     "followed_by_double_quote": following_text('^"'),
     "followed_by_single_quote": following_text("^'"),
     "navigable_suggestions": navigable_suggestions,
     "cursor_in_leading_ws": cursor_in_leading_ws,
 }
 
 
 def eval_node(node: Union[ast.AST, None]):
     if node is None:
         return None
     if isinstance(node, ast.Expression):
         return eval_node(node.body)
     if isinstance(node, ast.BinOp):
         left = eval_node(node.left)
         right = eval_node(node.right)
         dunders = _find_dunder(node.op, BINARY_OP_DUNDERS)
         if dunders:
             return getattr(left, dunders[0])(right)
         raise ValueError(f"Unknown binary operation: {node.op}")
     if isinstance(node, ast.UnaryOp):
         value = eval_node(node.operand)
         dunders = _find_dunder(node.op, UNARY_OP_DUNDERS)
         if dunders:
             return getattr(value, dunders[0])()
         raise ValueError(f"Unknown unary operation: {node.op}")
     if isinstance(node, ast.Name):
         if node.id in KEYBINDING_FILTERS:
             return KEYBINDING_FILTERS[node.id]
         else:
             sep = "\n  - "
             known_filters = sep.join(sorted(KEYBINDING_FILTERS))
             raise NameError(
                 f"{node.id} is not a known shortcut filter."
                 f" Known filters are: {sep}{known_filters}."
             )
     raise ValueError("Unhandled node", ast.dump(node))
 
 
 def filter_from_string(code: str):
     expression = ast.parse(code, mode="eval")
     return eval_node(expression)
 
 
 __all__ = ["KEYBINDING_FILTERS", "filter_from_string"]