Allow to customize shortcuts

IPython/terminal/shortcuts/filters.py

@@ -0,0 +1,258 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,
+    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 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(),
+    "has_line_below": has_line_below,
+    "has_line_above": has_line_above,
+    "has_selection": has_selection,
+    "has_suggestion": has_suggestion,
+    "vi_mode": vi_mode,
+    "vi_insert_mode": vi_insert_mode,
+    "emacs_insert_mode": 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": 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,
+    "focused_insert_vi": vi_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"[,)}\]]|$"),
+    # match
+    "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"]

IPython/terminal/interactiveshell.py

@@ -1,808 +1,955 b''
 """IPython terminal interface using prompt_toolkit"""
 
 import asyncio
 import os
 import sys
 from warnings import warn
 from typing import Union as UnionType
 
 from IPython.core.async_helpers import get_asyncio_loop
 from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC
 from IPython.utils.py3compat import input
 from IPython.utils.terminal import toggle_set_term_title, set_term_title, restore_term_title
 from IPython.utils.process import abbrev_cwd
 from traitlets import (
     Bool,
     Unicode,
     Dict,
     Integer,
+    List,
     observe,
     Instance,
     Type,
     default,
     Enum,
     Union,
     Any,
     validate,
     Float,
 )
 
 from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
 from prompt_toolkit.enums import DEFAULT_BUFFER, EditingMode
-from prompt_toolkit.filters import (HasFocus, Condition, IsDone)
+from prompt_toolkit.filters import HasFocus, Condition, IsDone
 from prompt_toolkit.formatted_text import PygmentsTokens
 from prompt_toolkit.history import History
 from prompt_toolkit.layout.processors import ConditionalProcessor, HighlightMatchingBracketProcessor
 from prompt_toolkit.output import ColorDepth
 from prompt_toolkit.patch_stdout import patch_stdout
 from prompt_toolkit.shortcuts import PromptSession, CompleteStyle, print_formatted_text
 from prompt_toolkit.styles import DynamicStyle, merge_styles
 from prompt_toolkit.styles.pygments import style_from_pygments_cls, style_from_pygments_dict
 from prompt_toolkit import __version__ as ptk_version
 
 from pygments.styles import get_style_by_name
 from pygments.style import Style
 from pygments.token import Token
 
 from .debugger import TerminalPdb, Pdb
 from .magics import TerminalMagics
 from .pt_inputhooks import get_inputhook_name_and_func
 from .prompts import Prompts, ClassicPrompts, RichPromptDisplayHook
 from .ptutils import IPythonPTCompleter, IPythonPTLexer
-from .shortcuts import create_ipython_shortcuts
+from .shortcuts import (
+    create_ipython_shortcuts,
+    create_identifier,
+    RuntimeBinding,
+    Binding,
+    add_binding,
+)
+from .shortcuts.filters import KEYBINDING_FILTERS, filter_from_string
 from .shortcuts.auto_suggest import (
     NavigableAutoSuggestFromHistory,
     AppendAutoSuggestionInAnyLine,
 )
 
 PTK3 = ptk_version.startswith('3.')
 
 
 class _NoStyle(Style): pass
 
 
 
 _style_overrides_light_bg = {
             Token.Prompt: '#ansibrightblue',
             Token.PromptNum: '#ansiblue bold',
             Token.OutPrompt: '#ansibrightred',
             Token.OutPromptNum: '#ansired bold',
 }
 
 _style_overrides_linux = {
             Token.Prompt: '#ansibrightgreen',
             Token.PromptNum: '#ansigreen bold',
             Token.OutPrompt: '#ansibrightred',
             Token.OutPromptNum: '#ansired bold',
 }
 
 def get_default_editor():
     try:
         return os.environ['EDITOR']
     except KeyError:
         pass
     except UnicodeError:
         warn("$EDITOR environment variable is not pure ASCII. Using platform "
              "default editor.")
 
     if os.name == 'posix':
         return 'vi'  # the only one guaranteed to be there!
     else:
         return 'notepad' # same in Windows!
 
 # conservatively check for tty
 # overridden streams can result in things like:
 # - sys.stdin = None
 # - no isatty method
 for _name in ('stdin', 'stdout', 'stderr'):
     _stream = getattr(sys, _name)
     try:
         if not _stream or not hasattr(_stream, "isatty") or not _stream.isatty():
             _is_tty = False
             break
     except ValueError:
         # stream is closed
         _is_tty = False
         break
 else:
     _is_tty = True
 
 
 _use_simple_prompt = ('IPY_TEST_SIMPLE_PROMPT' in os.environ) or (not _is_tty)
 
 def black_reformat_handler(text_before_cursor):
     """
     We do not need to protect against error,
     this is taken care at a higher level where any reformat error is ignored.
     Indeed we may call reformatting on incomplete code.
     """
     import black
 
     formatted_text = black.format_str(text_before_cursor, mode=black.FileMode())
     if not text_before_cursor.endswith("\n") and formatted_text.endswith("\n"):
         formatted_text = formatted_text[:-1]
     return formatted_text
 
 
 def yapf_reformat_handler(text_before_cursor):
     from yapf.yapflib import file_resources
     from yapf.yapflib import yapf_api
 
     style_config = file_resources.GetDefaultStyleForDir(os.getcwd())
     formatted_text, was_formatted = yapf_api.FormatCode(
         text_before_cursor, style_config=style_config
     )
     if was_formatted:
         if not text_before_cursor.endswith("\n") and formatted_text.endswith("\n"):
             formatted_text = formatted_text[:-1]
         return formatted_text
     else:
         return text_before_cursor
 
 
 class PtkHistoryAdapter(History):
     """
     Prompt toolkit has it's own way of handling history, Where it assumes it can
     Push/pull from history.
 
     """
 
     def __init__(self, shell):
         super().__init__()
         self.shell = shell
         self._refresh()
 
     def append_string(self, string):
         # we rely on sql for that.
         self._loaded = False
         self._refresh()
 
     def _refresh(self):
         if not self._loaded:
             self._loaded_strings = list(self.load_history_strings())
 
     def load_history_strings(self):
         last_cell = ""
         res = []
         for __, ___, cell in self.shell.history_manager.get_tail(
             self.shell.history_load_length, include_latest=True
         ):
             # Ignore blank lines and consecutive duplicates
             cell = cell.rstrip()
             if cell and (cell != last_cell):
                 res.append(cell)
                 last_cell = cell
         yield from res[::-1]
 
     def store_string(self, string: str) -> None:
         pass
 
 class TerminalInteractiveShell(InteractiveShell):
     mime_renderers = Dict().tag(config=True)
 
     space_for_menu = Integer(6, help='Number of line at the bottom of the screen '
                                      'to reserve for the tab completion menu, '
                                      'search history, ...etc, the height of '
                                      'these menus will at most this value. '
                                      'Increase it is you prefer long and skinny '
                                      'menus, decrease for short and wide.'
                             ).tag(config=True)
 
     pt_app: UnionType[PromptSession, None] = None
     auto_suggest: UnionType[
         AutoSuggestFromHistory, NavigableAutoSuggestFromHistory, None
     ] = None
     debugger_history = None
 
     debugger_history_file = Unicode(
         "~/.pdbhistory", help="File in which to store and read history"
     ).tag(config=True)
 
     simple_prompt = Bool(_use_simple_prompt,
         help="""Use `raw_input` for the REPL, without completion and prompt colors.
 
             Useful when controlling IPython as a subprocess, and piping STDIN/OUT/ERR. Known usage are:
             IPython own testing machinery, and emacs inferior-shell integration through elpy.
 
             This mode default to `True` if the `IPY_TEST_SIMPLE_PROMPT`
             environment variable is set, or the current terminal is not a tty."""
             ).tag(config=True)
 
     @property
     def debugger_cls(self):
         return Pdb if self.simple_prompt else TerminalPdb
 
     confirm_exit = Bool(True,
         help="""
         Set to confirm when you try to exit IPython with an EOF (Control-D
         in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
         you can force a direct exit without any confirmation.""",
     ).tag(config=True)
 
     editing_mode = Unicode('emacs',
         help="Shortcut style to use at the prompt. 'vi' or 'emacs'.",
     ).tag(config=True)
 
     emacs_bindings_in_vi_insert_mode = Bool(
         True,
         help="Add shortcuts from 'emacs' insert mode to 'vi' insert mode.",
     ).tag(config=True)
 
     modal_cursor = Bool(
         True,
         help="""
        Cursor shape changes depending on vi mode: beam in vi insert mode,
        block in nav mode, underscore in replace mode.""",
     ).tag(config=True)
 
     ttimeoutlen = Float(
         0.01,
         help="""The time in milliseconds that is waited for a key code
        to complete.""",
     ).tag(config=True)
 
     timeoutlen = Float(
         0.5,
         help="""The time in milliseconds that is waited for a mapped key
        sequence to complete.""",
     ).tag(config=True)
 
     autoformatter = Unicode(
         None,
         help="Autoformatter to reformat Terminal code. Can be `'black'`, `'yapf'` or `None`",
         allow_none=True
     ).tag(config=True)
 
     auto_match = Bool(
         False,
         help="""
         Automatically add/delete closing bracket or quote when opening bracket or quote is entered/deleted.
         Brackets: (), [], {}
         Quotes: '', \"\"
         """,
     ).tag(config=True)
 
     mouse_support = Bool(False,
         help="Enable mouse support in the prompt\n(Note: prevents selecting text with the mouse)"
     ).tag(config=True)
 
     # We don't load the list of styles for the help string, because loading
     # Pygments plugins takes time and can cause unexpected errors.
     highlighting_style = Union([Unicode('legacy'), Type(klass=Style)],
         help="""The name or class of a Pygments style to use for syntax
         highlighting. To see available styles, run `pygmentize -L styles`."""
     ).tag(config=True)
 
     @validate('editing_mode')
     def _validate_editing_mode(self, proposal):
         if proposal['value'].lower() == 'vim':
             proposal['value']= 'vi'
         elif proposal['value'].lower() == 'default':
             proposal['value']= 'emacs'
 
         if hasattr(EditingMode, proposal['value'].upper()):
             return proposal['value'].lower()
 
         return self.editing_mode
 
 
     @observe('editing_mode')
     def _editing_mode(self, change):
         if self.pt_app:
             self.pt_app.editing_mode = getattr(EditingMode, change.new.upper())
 
     def _set_formatter(self, formatter):
         if formatter is None:
             self.reformat_handler = lambda x:x
         elif formatter == 'black':
             self.reformat_handler = black_reformat_handler
         elif formatter == "yapf":
             self.reformat_handler = yapf_reformat_handler
         else:
             raise ValueError
 
     @observe("autoformatter")
     def _autoformatter_changed(self, change):
         formatter = change.new
         self._set_formatter(formatter)
 
     @observe('highlighting_style')
     @observe('colors')
     def _highlighting_style_changed(self, change):
         self.refresh_style()
 
     def refresh_style(self):
         self._style = self._make_style_from_name_or_cls(self.highlighting_style)
 
 
     highlighting_style_overrides = Dict(
         help="Override highlighting format for specific tokens"
     ).tag(config=True)
 
     true_color = Bool(False,
         help="""Use 24bit colors instead of 256 colors in prompt highlighting.
         If your terminal supports true color, the following command should
         print ``TRUECOLOR`` in orange::
 
             printf \"\\x1b[38;2;255;100;0mTRUECOLOR\\x1b[0m\\n\"
         """,
     ).tag(config=True)
 
     editor = Unicode(get_default_editor(),
         help="Set the editor used by IPython (default to $EDITOR/vi/notepad)."
     ).tag(config=True)
 
     prompts_class = Type(Prompts, help='Class used to generate Prompt token for prompt_toolkit').tag(config=True)
 
     prompts = Instance(Prompts)
 
     @default('prompts')
     def _prompts_default(self):
         return self.prompts_class(self)
 
 #    @observe('prompts')
 #    def _(self, change):
 #        self._update_layout()
 
     @default('displayhook_class')
     def _displayhook_class_default(self):
         return RichPromptDisplayHook
 
     term_title = Bool(True,
         help="Automatically set the terminal title"
     ).tag(config=True)
 
     term_title_format = Unicode("IPython: {cwd}",
         help="Customize the terminal title format.  This is a python format string. " +
              "Available substitutions are: {cwd}."
     ).tag(config=True)
 
     display_completions = Enum(('column', 'multicolumn','readlinelike'),
         help= ( "Options for displaying tab completions, 'column', 'multicolumn', and "
                 "'readlinelike'. These options are for `prompt_toolkit`, see "
                 "`prompt_toolkit` documentation for more information."
                 ),
         default_value='multicolumn').tag(config=True)
 
     highlight_matching_brackets = Bool(True,
         help="Highlight matching brackets.",
     ).tag(config=True)
 
     extra_open_editor_shortcuts = Bool(False,
         help="Enable vi (v) or Emacs (C-X C-E) shortcuts to open an external editor. "
              "This is in addition to the F2 binding, which is always enabled."
     ).tag(config=True)
 
     handle_return = Any(None,
         help="Provide an alternative handler to be called when the user presses "
              "Return. This is an advanced option intended for debugging, which "
              "may be changed or removed in later releases."
     ).tag(config=True)
 
     enable_history_search = Bool(True,
         help="Allows to enable/disable the prompt toolkit history search"
     ).tag(config=True)
 
     autosuggestions_provider = Unicode(
         "NavigableAutoSuggestFromHistory",
         help="Specifies from which source automatic suggestions are provided. "
         "Can be set to ``'NavigableAutoSuggestFromHistory'`` (:kbd:`up` and "
         ":kbd:`down` swap suggestions), ``'AutoSuggestFromHistory'``, "
         " or ``None`` to disable automatic suggestions. "
         "Default is `'NavigableAutoSuggestFromHistory`'.",
         allow_none=True,
     ).tag(config=True)
 
     def _set_autosuggestions(self, provider):
         # disconnect old handler
         if self.auto_suggest and isinstance(
             self.auto_suggest, NavigableAutoSuggestFromHistory
         ):
             self.auto_suggest.disconnect()
         if provider is None:
             self.auto_suggest = None
         elif provider == "AutoSuggestFromHistory":
             self.auto_suggest = AutoSuggestFromHistory()
         elif provider == "NavigableAutoSuggestFromHistory":
             self.auto_suggest = NavigableAutoSuggestFromHistory()
         else:
             raise ValueError("No valid provider.")
         if self.pt_app:
             self.pt_app.auto_suggest = self.auto_suggest
 
     @observe("autosuggestions_provider")
     def _autosuggestions_provider_changed(self, change):
         provider = change.new
         self._set_autosuggestions(provider)
 
+    shortcuts = List(
+        trait=Dict(
+            key_trait=Enum(
+                [
+                    "command",
+                    "match_keys",
+                    "match_filter",
+                    "new_keys",
+                    "new_filter",
+                    "create",
+                ]
+            ),
+            per_key_traits={
+                "command": Unicode(),
+                "match_keys": List(Unicode()),
+                "match_filter": Unicode(),
+                "new_keys": List(Unicode()),
+                "new_filter": Unicode(),
+                "create": Bool(default=False),
+            },
+        ),
+        help=f"""Add, disable or modifying shortcuts.
+
+        Each entry on the list should be a dictionary with ``command`` key
+        identifying the target function executed by the shortcut and at least
+        one of the following::
+        - ``match_keys``: list of keys used to match an existing shortcut,
+        - ``match_filter``: shortcut filter used to match an existing shortcut,
+        - ``new_keys``: list of keys to set,
+        - ``new_filter``: a new shortcut filter to set
+
+        The filters have to be composed of pre-defined verbs and joined by one
+        of the following conjunctions: ``&`` (and), ``|` (or), ``~`` (not).
+        The pre-defined verbs are: ({', '.join(KEYBINDING_FILTERS)}).
+
+        To disable a shortcut set ``new_keys`` to an empty list.
+        To add a shortcut add key ``create`` with value ``True``.
+
+        When modifying/disabling shortcuts, ``match_keys``/``match_filter`` can
+        be omitted if the provided specification uniquely identifies a shortcut
+        to be modified/disabled. When modifying a shortcut ``new_filter`` or
+        ``new_keys`` can be omitted which will result in reuse of the existing
+        filter/keys.
+
+        Only shortcuts defined in IPython (and not default prompt toolkit
+        shortcuts) can be modified or disabled.
+        """,
+    ).tag(config=True)
+
+    @observe("shortcuts")
+    def _shortcuts_changed(self, change):
+        user_shortcuts = change.new
+        # rebuild the bindings list from scratch
+        key_bindings = create_ipython_shortcuts(self)
+
+        # for now we only allow adding shortcuts for commands which are already
+        # registered; this is a security precaution.
+        known_commands = {
+            create_identifier(binding.handler): binding.handler
+            for binding in key_bindings.bindings
+        }
+        shortcuts_to_skip = []
+        shortcuts_to_add = []
+
+        for shortcut in user_shortcuts:
+            command_id = shortcut["command"]
+            if command_id not in known_commands:
+                allowed_commands = "\n - ".join(known_commands)
+                raise ValueError(
+                    f"{command_id} is not a known shortcut command."
+                    f" Allowed commands are: \n - {allowed_commands}"
+                )
+            old_keys = shortcut.get("match_keys", None)
+            old_filter = (
+                filter_from_string(shortcut["match_filter"])
+                if "match_filter" in shortcut
+                else None
+            )
+            matching = [
+                binding
+                for binding in key_bindings.bindings
+                if (
+                    (old_filter is None or binding.filter == old_filter)
+                    and (old_keys is None or [k for k in binding.keys] == old_keys)
+                    and create_identifier(binding.handler) == command_id
+                )
+            ]
+
+            new_keys = shortcut.get("new_keys", None)
+            new_filter = shortcut.get("new_filter", None)
+
+            command = known_commands[command_id]
+
+            creating_new = shortcut.get("create", False)
+            modifying_existing = not creating_new and (
+                new_keys is not None or new_filter
+            )
+
+            if creating_new and new_keys == []:
+                raise ValueError("Cannot add a shortcut without keys")
+
+            if modifying_existing:
+                specification = {
+                    key: shortcut[key]
+                    for key in ["command", "filter"]
+                    if key in shortcut
+                }
+                if len(matching) == 0:
+                    raise ValueError(f"No shortcuts matching {specification} found")
+                elif len(matching) > 1:
+                    raise ValueError(
+                        f"Multiple shortcuts matching {specification} found,"
+                        f" please add keys/filter to select one of: {matching}"
+                    )
+
+                for matched in matching:
+                    shortcuts_to_skip.append(
+                        RuntimeBinding(
+                            command,
+                            keys=[k for k in matching[0].keys],
+                            filter=matching[0].filter,
+                        )
+                    )
+
+            if new_keys != []:
+                shortcuts_to_add.append(
+                    Binding(
+                        command,
+                        keys=new_keys,
+                        condition=new_filter if new_filter is not None else "always",
+                    )
+                )
+
+        # rebuild the bindings list from scratch
+        key_bindings = create_ipython_shortcuts(self, skip=shortcuts_to_skip)
+        for binding in shortcuts_to_add:
+            add_binding(key_bindings, binding)
+        self.pt_app.key_bindings = key_bindings
+
     prompt_includes_vi_mode = Bool(True,
         help="Display the current vi mode (when using vi editing mode)."
     ).tag(config=True)
 
     @observe('term_title')
     def init_term_title(self, change=None):
         # Enable or disable the terminal title.
         if self.term_title and _is_tty:
             toggle_set_term_title(True)
             set_term_title(self.term_title_format.format(cwd=abbrev_cwd()))
         else:
             toggle_set_term_title(False)
 
     def restore_term_title(self):
         if self.term_title and _is_tty:
             restore_term_title()
 
     def init_display_formatter(self):
         super(TerminalInteractiveShell, self).init_display_formatter()
         # terminal only supports plain text
         self.display_formatter.active_types = ["text/plain"]
 
     def init_prompt_toolkit_cli(self):
         if self.simple_prompt:
             # Fall back to plain non-interactive output for tests.
             # This is very limited.
             def prompt():
                 prompt_text = "".join(x[1] for x in self.prompts.in_prompt_tokens())
                 lines = [input(prompt_text)]
                 prompt_continuation = "".join(x[1] for x in self.prompts.continuation_prompt_tokens())
                 while self.check_complete('\n'.join(lines))[0] == 'incomplete':
                     lines.append( input(prompt_continuation) )
                 return '\n'.join(lines)
             self.prompt_for_code = prompt
             return
 
         # Set up keyboard shortcuts
         key_bindings = create_ipython_shortcuts(self)
 
 
         # Pre-populate history from IPython's history database
         history = PtkHistoryAdapter(self)
 
         self._style = self._make_style_from_name_or_cls(self.highlighting_style)
         self.style = DynamicStyle(lambda: self._style)
 
         editing_mode = getattr(EditingMode, self.editing_mode.upper())
 
         self.pt_loop = asyncio.new_event_loop()
         self.pt_app = PromptSession(
             auto_suggest=self.auto_suggest,
             editing_mode=editing_mode,
             key_bindings=key_bindings,
             history=history,
             completer=IPythonPTCompleter(shell=self),
             enable_history_search=self.enable_history_search,
             style=self.style,
             include_default_pygments_style=False,
             mouse_support=self.mouse_support,
             enable_open_in_editor=self.extra_open_editor_shortcuts,
             color_depth=self.color_depth,
             tempfile_suffix=".py",
-            **self._extra_prompt_options()
+            **self._extra_prompt_options(),
         )
         if isinstance(self.auto_suggest, NavigableAutoSuggestFromHistory):
             self.auto_suggest.connect(self.pt_app)
 
     def _make_style_from_name_or_cls(self, name_or_cls):
         """
         Small wrapper that make an IPython compatible style from a style name
 
         We need that to add style for prompt ... etc.
         """
         style_overrides = {}
         if name_or_cls == 'legacy':
             legacy = self.colors.lower()
             if legacy == 'linux':
                 style_cls = get_style_by_name('monokai')
                 style_overrides = _style_overrides_linux
             elif legacy == 'lightbg':
                 style_overrides = _style_overrides_light_bg
                 style_cls = get_style_by_name('pastie')
             elif legacy == 'neutral':
                 # The default theme needs to be visible on both a dark background
                 # and a light background, because we can't tell what the terminal
                 # looks like. These tweaks to the default theme help with that.
                 style_cls = get_style_by_name('default')
                 style_overrides.update({
                     Token.Number: '#ansigreen',
                     Token.Operator: 'noinherit',
                     Token.String: '#ansiyellow',
                     Token.Name.Function: '#ansiblue',
                     Token.Name.Class: 'bold #ansiblue',
                     Token.Name.Namespace: 'bold #ansiblue',
                     Token.Name.Variable.Magic: '#ansiblue',
                     Token.Prompt: '#ansigreen',
                     Token.PromptNum: '#ansibrightgreen bold',
                     Token.OutPrompt: '#ansired',
                     Token.OutPromptNum: '#ansibrightred bold',
                 })
 
                 # Hack: Due to limited color support on the Windows console
                 # the prompt colors will be wrong without this
                 if os.name == 'nt':
                     style_overrides.update({
                         Token.Prompt: '#ansidarkgreen',
                         Token.PromptNum: '#ansigreen bold',
                         Token.OutPrompt: '#ansidarkred',
                         Token.OutPromptNum: '#ansired bold',
                     })
             elif legacy =='nocolor':
                 style_cls=_NoStyle
                 style_overrides = {}
             else :
                 raise ValueError('Got unknown colors: ', legacy)
         else :
             if isinstance(name_or_cls, str):
                 style_cls = get_style_by_name(name_or_cls)
             else:
                 style_cls = name_or_cls
             style_overrides = {
                 Token.Prompt: '#ansigreen',
                 Token.PromptNum: '#ansibrightgreen bold',
                 Token.OutPrompt: '#ansired',
                 Token.OutPromptNum: '#ansibrightred bold',
             }
         style_overrides.update(self.highlighting_style_overrides)
         style = merge_styles([
             style_from_pygments_cls(style_cls),
             style_from_pygments_dict(style_overrides),
         ])
 
         return style
 
     @property
     def pt_complete_style(self):
         return {
             'multicolumn': CompleteStyle.MULTI_COLUMN,
             'column': CompleteStyle.COLUMN,
             'readlinelike': CompleteStyle.READLINE_LIKE,
         }[self.display_completions]
 
     @property
     def color_depth(self):
         return (ColorDepth.TRUE_COLOR if self.true_color else None)
 
     def _extra_prompt_options(self):
         """
         Return the current layout option for the current Terminal InteractiveShell
         """
         def get_message():
             return PygmentsTokens(self.prompts.in_prompt_tokens())
 
         if self.editing_mode == 'emacs':
             # with emacs mode the prompt is (usually) static, so we call only
             # the function once. With VI mode it can toggle between [ins] and
             # [nor] so we can't precompute.
             # here I'm going to favor the default keybinding which almost
             # everybody uses to decrease CPU usage.
             # if we have issues with users with custom Prompts we can see how to
             # work around this.
             get_message = get_message()
 
         options = {
             "complete_in_thread": False,
             "lexer": IPythonPTLexer(),
             "reserve_space_for_menu": self.space_for_menu,
             "message": get_message,
             "prompt_continuation": (
                 lambda width, lineno, is_soft_wrap: PygmentsTokens(
                     self.prompts.continuation_prompt_tokens(width)
                 )
             ),
             "multiline": True,
             "complete_style": self.pt_complete_style,
             "input_processors": [
                 # Highlight matching brackets, but only when this setting is
                 # enabled, and only when the DEFAULT_BUFFER has the focus.
                 ConditionalProcessor(
                     processor=HighlightMatchingBracketProcessor(chars="[](){}"),
                     filter=HasFocus(DEFAULT_BUFFER)
                     & ~IsDone()
                     & Condition(lambda: self.highlight_matching_brackets),
                 ),
                 # Show auto-suggestion in lines other than the last line.
                 ConditionalProcessor(
                     processor=AppendAutoSuggestionInAnyLine(),
                     filter=HasFocus(DEFAULT_BUFFER)
                     & ~IsDone()
                     & Condition(
                         lambda: isinstance(
                             self.auto_suggest, NavigableAutoSuggestFromHistory
                         )
                     ),
                 ),
             ],
         }
         if not PTK3:
             options['inputhook'] = self.inputhook
 
         return options
 
     def prompt_for_code(self):
         if self.rl_next_input:
             default = self.rl_next_input
             self.rl_next_input = None
         else:
             default = ''
 
         # In order to make sure that asyncio code written in the
         # interactive shell doesn't interfere with the prompt, we run the
         # prompt in a different event loop.
         # If we don't do this, people could spawn coroutine with a
         # while/true inside which will freeze the prompt.
 
         policy = asyncio.get_event_loop_policy()
         old_loop = get_asyncio_loop()
 
         # FIXME: prompt_toolkit is using the deprecated `asyncio.get_event_loop`
         # to get the current event loop.
         # This will probably be replaced by an attribute or input argument,
         # at which point we can stop calling the soon-to-be-deprecated `set_event_loop` here.
         if old_loop is not self.pt_loop:
             policy.set_event_loop(self.pt_loop)
         try:
             with patch_stdout(raw=True):
                 text = self.pt_app.prompt(
                     default=default,
                     **self._extra_prompt_options())
         finally:
             # Restore the original event loop.
             if old_loop is not None and old_loop is not self.pt_loop:
                 policy.set_event_loop(old_loop)
 
         return text
 
     def enable_win_unicode_console(self):
         # Since IPython 7.10 doesn't support python < 3.6 and PEP 528, Python uses the unicode APIs for the Windows
         # console by default, so WUC shouldn't be needed.
         warn("`enable_win_unicode_console` is deprecated since IPython 7.10, does not do anything and will be removed in the future",
              DeprecationWarning,
              stacklevel=2)
 
     def init_io(self):
         if sys.platform not in {'win32', 'cli'}:
             return
 
         import colorama
         colorama.init()
 
     def init_magics(self):
         super(TerminalInteractiveShell, self).init_magics()
         self.register_magics(TerminalMagics)
 
     def init_alias(self):
         # The parent class defines aliases that can be safely used with any
         # frontend.
         super(TerminalInteractiveShell, self).init_alias()
 
         # Now define aliases that only make sense on the terminal, because they
         # need direct access to the console in a way that we can't emulate in
         # GUI or web frontend
         if os.name == 'posix':
             for cmd in ('clear', 'more', 'less', 'man'):
                 self.alias_manager.soft_define_alias(cmd, cmd)
 
 
     def __init__(self, *args, **kwargs) -> None:
         super(TerminalInteractiveShell, self).__init__(*args, **kwargs)
         self._set_autosuggestions(self.autosuggestions_provider)
         self.init_prompt_toolkit_cli()
         self.init_term_title()
         self.keep_running = True
         self._set_formatter(self.autoformatter)
 
 
     def ask_exit(self):
         self.keep_running = False
 
     rl_next_input = None
 
     def interact(self):
         self.keep_running = True
         while self.keep_running:
             print(self.separate_in, end='')
 
             try:
                 code = self.prompt_for_code()
             except EOFError:
                 if (not self.confirm_exit) \
                         or self.ask_yes_no('Do you really want to exit ([y]/n)?','y','n'):
                     self.ask_exit()
 
             else:
                 if code:
                     self.run_cell(code, store_history=True)
 
     def mainloop(self):
         # An extra layer of protection in case someone mashing Ctrl-C breaks
         # out of our internal code.
         while True:
             try:
                 self.interact()
                 break
             except KeyboardInterrupt as e:
                 print("\n%s escaped interact()\n" % type(e).__name__)
             finally:
                 # An interrupt during the eventloop will mess up the
                 # internal state of the prompt_toolkit library.
                 # Stopping the eventloop fixes this, see
                 # https://github.com/ipython/ipython/pull/9867
                 if hasattr(self, '_eventloop'):
                     self._eventloop.stop()
 
                 self.restore_term_title()
 
         # try to call some at-exit operation optimistically as some things can't
         # be done during interpreter shutdown. this is technically inaccurate as
         # this make mainlool not re-callable, but that should be a rare if not
         # in existent use case.
 
         self._atexit_once()
 
 
     _inputhook = None
     def inputhook(self, context):
         if self._inputhook is not None:
             self._inputhook(context)
 
     active_eventloop = None
     def enable_gui(self, gui=None):
         if gui and (gui not in {"inline", "webagg"}):
             self.active_eventloop, self._inputhook = get_inputhook_name_and_func(gui)
         else:
             self.active_eventloop = self._inputhook = None
 
         # For prompt_toolkit 3.0. We have to create an asyncio event loop with
         # this inputhook.
         if PTK3:
             import asyncio
             from prompt_toolkit.eventloop import new_eventloop_with_inputhook
 
             if gui == 'asyncio':
                 # When we integrate the asyncio event loop, run the UI in the
                 # same event loop as the rest of the code. don't use an actual
                 # input hook. (Asyncio is not made for nesting event loops.)
                 self.pt_loop = get_asyncio_loop()
 
             elif self._inputhook:
                 # If an inputhook was set, create a new asyncio event loop with
                 # this inputhook for the prompt.
                 self.pt_loop = new_eventloop_with_inputhook(self._inputhook)
             else:
                 # When there's no inputhook, run the prompt in a separate
                 # asyncio event loop.
                 self.pt_loop = asyncio.new_event_loop()
 
     # Run !system commands directly, not through pipes, so terminal programs
     # work correctly.
     system = InteractiveShell.system_raw
 
     def auto_rewrite_input(self, cmd):
         """Overridden from the parent class to use fancy rewriting prompt"""
         if not self.show_rewritten_input:
             return
 
         tokens = self.prompts.rewrite_prompt_tokens()
         if self.pt_app:
             print_formatted_text(PygmentsTokens(tokens), end='',
                                  style=self.pt_app.app.style)
             print(cmd)
         else:
             prompt = ''.join(s for t, s in tokens)
             print(prompt, cmd, sep='')
 
     _prompts_before = None
     def switch_doctest_mode(self, mode):
         """Switch prompts to classic for %doctest_mode"""
         if mode:
             self._prompts_before = self.prompts
             self.prompts = ClassicPrompts(self)
         elif self._prompts_before:
             self.prompts = self._prompts_before
             self._prompts_before = None
 #        self._update_layout()
 
 
 InteractiveShellABC.register(TerminalInteractiveShell)
 
 if __name__ == '__main__':
     TerminalInteractiveShell.instance().interact()

IPython/terminal/shortcuts/__init__.py

@@ -1,670 +1,620 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 re
 import signal
 import sys
 import warnings
-from typing import Callable, Dict, Union
+from dataclasses import dataclass
+from typing import Callable, Any, Optional, List
 
 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 (
-    has_selection,
-    has_suggestion,
-    vi_insert_mode,
-    vi_mode,
-)
 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.layout.layout import FocusableElement
+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
 
 __all__ = ["create_ipython_shortcuts"]
 
 
-@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 has_line_above() -> bool:
-    document = get_app().current_buffer.document
-    return document.cursor_position_row != 0
+@dataclass
+class BaseBinding:
+    command: Callable[[KeyPressEvent], Any]
+    keys: List[str]
 
 
-def create_ipython_shortcuts(shell, for_all_platforms: bool = False) -> KeyBindings:
-    """Set up the prompt_toolkit keyboard shortcuts for IPython.
+@dataclass
+class RuntimeBinding(BaseBinding):
+    filter: Condition
 
-    Parameters
-    ----------
-    shell: InteractiveShell
-        The current IPython shell Instance
-    for_all_platforms: bool (default false)
-        This parameter is mostly used in generating the documentation
-        to create the shortcut binding for all the platforms, and export
-        them.
 
-    Returns
-    -------
-    KeyBindings
-        the keybinding instance for prompt toolkit.
+@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
 
-    """
-    # Warning: if possible, do NOT define handler functions in the locals
-    # scope of this function, instead define functions in the global
-    # scope, or a separate module, and include a user-friendly docstring
-    # describing the action.
-
-    kb = KeyBindings()
-    insert_mode = vi_insert_mode | emacs_insert_mode
-
-    if getattr(shell, "handle_return", None):
-        return_handler = shell.handle_return(shell)
+    def __post_init__(self):
+        if self.condition:
+            self.filter = filter_from_string(self.condition)
     else:
-        return_handler = newline_or_execute_outer(shell)
-
-    kb.add("enter", filter=(has_focus(DEFAULT_BUFFER) & ~has_selection & insert_mode))(
-        return_handler
-    )
-
-    @Condition
-    def ebivim():
-        return shell.emacs_bindings_in_vi_insert_mode
+            self.filter = None
 
-    @kb.add(
-        "escape",
-        "enter",
-        filter=(has_focus(DEFAULT_BUFFER) & ~has_selection & insert_mode & ebivim),
-    )
-    def reformat_and_execute(event):
-        """Reformat code and execute it"""
-        reformat_text_before_cursor(
-            event.current_buffer, event.current_buffer.document, shell
-        )
-        event.current_buffer.validate_and_handle()
-
-    kb.add("c-\\")(quit)
-
-    kb.add("c-p", filter=(vi_insert_mode & has_focus(DEFAULT_BUFFER)))(
-        previous_history_or_previous_completion
-    )
-
-    kb.add("c-n", filter=(vi_insert_mode & has_focus(DEFAULT_BUFFER)))(
-        next_history_or_next_completion
-    )
-
-    kb.add("c-g", filter=(has_focus(DEFAULT_BUFFER) & has_completions))(
-        dismiss_completion
-    )
-
-    kb.add("c-c", filter=has_focus(DEFAULT_BUFFER))(reset_buffer)
-
-    kb.add("c-c", filter=has_focus(SEARCH_BUFFER))(reset_search_buffer)
-
-    supports_suspend = Condition(lambda: hasattr(signal, "SIGTSTP"))
-    kb.add("c-z", filter=supports_suspend)(suspend_to_bg)
-
-    # Ctrl+I == Tab
-    kb.add(
-        "tab",
-        filter=(
-            has_focus(DEFAULT_BUFFER)
-            & ~has_selection
-            & insert_mode
-            & cursor_in_leading_ws
-        ),
-    )(indent_buffer)
-    kb.add("c-o", filter=(has_focus(DEFAULT_BUFFER) & emacs_insert_mode))(
-        newline_autoindent_outer(shell.input_transformer_manager)
-    )
-
-    kb.add("f2", filter=has_focus(DEFAULT_BUFFER))(open_input_in_editor)
-
-    @Condition
-    def auto_match():
-        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
-
-    focused_insert = (vi_insert_mode | emacs_insert_mode) & has_focus(DEFAULT_BUFFER)
-    _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]
 
+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:
-            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})"
+        return f"{package}:{name}"
 
-        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)
-
-    # auto match
-    for key, cmd in match.auto_match_parens.items():
-        kb.add(key, filter=focused_insert & auto_match & following_text(r"[,)}\]]|$"))(
-            cmd
+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
-    for key, cmd in match.auto_match_parens_raw_string.items():
-        kb.add(
-            key,
-            filter=focused_insert & auto_match & preceding_text(r".*(r|R)[\"'](-*)$"),
-        )(cmd)
-
-    kb.add(
-        '"',
-        filter=focused_insert
-        & auto_match
-        & not_inside_unclosed_string
-        & preceding_text(lambda line: all_quotes_paired('"', line))
-        & following_text(r"[,)}\]]|$"),
-    )(match.double_quote)
-
-    kb.add(
-        "'",
-        filter=focused_insert
-        & auto_match
-        & not_inside_unclosed_string
-        & preceding_text(lambda line: all_quotes_paired("'", line))
-        & following_text(r"[,)}\]]|$"),
-    )(match.single_quote)
-
-    kb.add(
-        '"',
-        filter=focused_insert
-        & auto_match
-        & not_inside_unclosed_string
-        & preceding_text(r'^.*""$'),
-    )(match.docstring_double_quotes)
-
-    kb.add(
-        "'",
-        filter=focused_insert
-        & auto_match
-        & not_inside_unclosed_string
-        & preceding_text(r"^.*''$"),
-    )(match.docstring_single_quotes)
-
-    # just move cursor
-    kb.add(")", filter=focused_insert & auto_match & following_text(r"^\)"))(
-        match.skip_over
-    )
-    kb.add("]", filter=focused_insert & auto_match & following_text(r"^\]"))(
-        match.skip_over
-    )
-    kb.add("}", filter=focused_insert & auto_match & following_text(r"^\}"))(
-        match.skip_over
-    )
-    kb.add('"', filter=focused_insert & auto_match & following_text('^"'))(
-        match.skip_over
-    )
-    kb.add("'", filter=focused_insert & auto_match & following_text("^'"))(
-        match.skip_over
-    )
+        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",
+    ),
+]
 
-    kb.add(
-        "backspace",
-        filter=focused_insert
-        & preceding_text(r".*\($")
-        & auto_match
-        & following_text(r"^\)"),
-    )(match.delete_pair)
-    kb.add(
-        "backspace",
-        filter=focused_insert
-        & preceding_text(r".*\[$")
-        & auto_match
-        & following_text(r"^\]"),
-    )(match.delete_pair)
-    kb.add(
-        "backspace",
-        filter=focused_insert
-        & preceding_text(r".*\{$")
-        & auto_match
-        & following_text(r"^\}"),
-    )(match.delete_pair)
-    kb.add(
-        "backspace",
-        filter=focused_insert
-        & preceding_text('.*"$')
-        & auto_match
-        & following_text('^"'),
-    )(match.delete_pair)
-    kb.add(
-        "backspace",
-        filter=focused_insert
-        & preceding_text(r".*'$")
-        & auto_match
-        & following_text(r"^'"),
-    )(match.delete_pair)
-
-    if shell.display_completions == "readlinelike":
-        kb.add(
-            "c-i",
-            filter=(
-                has_focus(DEFAULT_BUFFER)
-                & ~has_selection
-                & insert_mode
-                & ~cursor_in_leading_ws
-            ),
-        )(display_completions_like_readline)
-
-    if sys.platform == "win32" or for_all_platforms:
-        kb.add("c-v", filter=(has_focus(DEFAULT_BUFFER) & ~vi_mode))(win_paste)
-
-    focused_insert_vi = has_focus(DEFAULT_BUFFER) & vi_insert_mode
-
-    # autosuggestions
-    @Condition
-    def navigable_suggestions():
-        return isinstance(
-            shell.auto_suggest, auto_suggest.NavigableAutoSuggestFromHistory
-        )
+AUTO_SUGGEST_BINDINGS = [
+    Binding(
+        auto_suggest.accept_in_vi_insert_mode,
+        ["end"],
+        "default_buffer_focused & (ebivim | ~vi_insert_mode)",
+    ),
+    Binding(
+        auto_suggest.accept_in_vi_insert_mode, ["c-e"], "focused_insert_vi & ebivim"
+    ),
+    Binding(auto_suggest.accept, ["c-f"], "focused_insert_vi"),
+    Binding(auto_suggest.accept_word, ["escape", "f"], "focused_insert_vi & ebivim"),
+    Binding(
+        auto_suggest.accept_token,
+        ["c-right"],
+        "has_suggestion & default_buffer_focused",
+    ),
+    Binding(
+        auto_suggest.discard,
+        ["escape"],
+        "has_suggestion & default_buffer_focused & emacs_insert_mode",
+    ),
+    Binding(
+        auto_suggest.swap_autosuggestion_up,
+        ["up"],
+        "navigable_suggestions"
+        " & ~has_line_above"
+        " & has_suggestion"
+        " & default_buffer_focused",
+    ),
+    Binding(
+        auto_suggest.swap_autosuggestion_down,
+        ["down"],
+        "navigable_suggestions"
+        " & ~has_line_below"
+        " & has_suggestion"
+        " & default_buffer_focused",
+    ),
+    Binding(
+        auto_suggest.up_and_update_hint,
+        ["up"],
+        "has_line_above & navigable_suggestions & default_buffer_focused",
+    ),
+    Binding(
+        auto_suggest.down_and_update_hint,
+        ["down"],
+        "has_line_below & navigable_suggestions & default_buffer_focused",
+    ),
+    Binding(
+        auto_suggest.accept_character,
+        ["right"],
+        "has_suggestion & default_buffer_focused",
+    ),
+    Binding(
+        auto_suggest.accept_and_move_cursor_left,
+        ["c-left"],
+        "has_suggestion & default_buffer_focused",
+    ),
+    Binding(
+        auto_suggest.accept_and_keep_cursor,
+        ["c-down"],
+        "has_suggestion & default_buffer_focused",
+    ),
+    Binding(
+        auto_suggest.backspace_and_resume_hint,
+        ["backspace"],
+        "has_suggestion & default_buffer_focused",
+    ),
+]
 
-    kb.add("end", filter=has_focus(DEFAULT_BUFFER) & (ebivim | ~vi_insert_mode))(
-        auto_suggest.accept_in_vi_insert_mode
-    )
-    kb.add("c-e", filter=focused_insert_vi & ebivim)(
-        auto_suggest.accept_in_vi_insert_mode
-    )
-    kb.add("c-f", filter=focused_insert_vi)(auto_suggest.accept)
-    kb.add("escape", "f", filter=focused_insert_vi & ebivim)(auto_suggest.accept_word)
-    kb.add("c-right", filter=has_suggestion & has_focus(DEFAULT_BUFFER))(
-        auto_suggest.accept_token
-    )
-    kb.add(
-        "escape", filter=has_suggestion & has_focus(DEFAULT_BUFFER) & emacs_insert_mode
-    )(auto_suggest.discard)
-    kb.add(
-        "up",
-        filter=navigable_suggestions
-        & ~has_line_above
-        & has_suggestion
-        & has_focus(DEFAULT_BUFFER),
-    )(auto_suggest.swap_autosuggestion_up(shell.auto_suggest))
-    kb.add(
-        "down",
-        filter=navigable_suggestions
-        & ~has_line_below
-        & has_suggestion
-        & has_focus(DEFAULT_BUFFER),
-    )(auto_suggest.swap_autosuggestion_down(shell.auto_suggest))
-    kb.add(
-        "up", filter=has_line_above & navigable_suggestions & has_focus(DEFAULT_BUFFER)
-    )(auto_suggest.up_and_update_hint)
-    kb.add(
-        "down",
-        filter=has_line_below & navigable_suggestions & has_focus(DEFAULT_BUFFER),
-    )(auto_suggest.down_and_update_hint)
-    kb.add("right", filter=has_suggestion & has_focus(DEFAULT_BUFFER))(
-        auto_suggest.accept_character
-    )
-    kb.add("c-left", filter=has_suggestion & has_focus(DEFAULT_BUFFER))(
-        auto_suggest.accept_and_move_cursor_left
-    )
-    kb.add("c-down", filter=has_suggestion & has_focus(DEFAULT_BUFFER))(
-        auto_suggest.accept_and_keep_cursor
-    )
-    kb.add("backspace", filter=has_suggestion & has_focus(DEFAULT_BUFFER))(
-        auto_suggest.backspace_and_resume_hint
-    )
 
-    # Simple Control keybindings
-    key_cmd_dict = {
+SIMPLE_CONTROL_BINDINGS = [
+    Binding(cmd, [key], "focused_insert_vi & 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()
+]
 
-    for key, cmd in key_cmd_dict.items():
-        kb.add(key, filter=focused_insert_vi & ebivim)(cmd)
 
-    # Alt and Combo Control keybindings
-    keys_cmd_dict = {
+ALT_AND_COMOBO_CONTROL_BINDINGS = [
+    Binding(cmd, list(keys), "focused_insert_vi & 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.
 
-    for keys, cmd in keys_cmd_dict.items():
-        kb.add(*keys, filter=focused_insert_vi & ebivim)(cmd)
+    """
+    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")
 
-    newline_or_execute.__qualname__ = "newline_or_execute"
-
     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)
 
 
 @undoc
 def newline_with_copy_margin(event):
     """
     DEPRECATED since IPython 6.0
 
     See :any:`newline_autoindent_outer` for a replacement.
 
     Preserve margin and cursor position when using
     Control-O to insert a newline in EMACS mode
     """
     warnings.warn(
         "`newline_with_copy_margin(event)` is deprecated since IPython 6.0. "
         "see `newline_autoindent_outer(shell)(event)` for a replacement.",
         DeprecationWarning,
         stacklevel=2,
     )
 
     b = event.current_buffer
     cursor_start_pos = b.document.cursor_position_col
     b.newline(copy_margin=True)
     b.cursor_up(count=1)
     cursor_end_pos = b.document.cursor_position_col
     if cursor_start_pos != cursor_end_pos:
         pos_diff = cursor_start_pos - cursor_end_pos
         b.cursor_right(count=pos_diff)
 
 
-def newline_autoindent_outer(inputsplitter) -> Callable[..., None]:
-    """
-    Return a function suitable for inserting a indented newline after the cursor.
+def newline_autoindent(event):
+    """Insert a newline after the cursor indented appropriately.
 
     Fancier version of deprecated ``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 ...``.
     """
-
-    def newline_autoindent(event):
-        """Insert a newline after the cursor indented appropriately."""
+    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)
 
-    newline_autoindent.__qualname__ = "newline_autoindent"
-
-    return newline_autoindent
-
 
 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 when auto-generating shortcuts for documentation"""
+        """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/auto_match.py

@@ -1,104 +1,104 b''
 """
 Utilities function for keybinding with prompt toolkit. 
 
 This will be bound to specific key press and filter modes, 
 like whether we are in edit mode, and whether the completer is open.
 """
 import re
 from prompt_toolkit.key_binding import KeyPressEvent
 
 
 def parenthesis(event: KeyPressEvent):
     """Auto-close parenthesis"""
     event.current_buffer.insert_text("()")
     event.current_buffer.cursor_left()
 
 
 def brackets(event: KeyPressEvent):
     """Auto-close brackets"""
     event.current_buffer.insert_text("[]")
     event.current_buffer.cursor_left()
 
 
 def braces(event: KeyPressEvent):
     """Auto-close braces"""
     event.current_buffer.insert_text("{}")
     event.current_buffer.cursor_left()
 
 
 def double_quote(event: KeyPressEvent):
     """Auto-close double quotes"""
     event.current_buffer.insert_text('""')
     event.current_buffer.cursor_left()
 
 
 def single_quote(event: KeyPressEvent):
     """Auto-close single quotes"""
     event.current_buffer.insert_text("''")
     event.current_buffer.cursor_left()
 
 
 def docstring_double_quotes(event: KeyPressEvent):
     """Auto-close docstring (double quotes)"""
     event.current_buffer.insert_text('""""')
     event.current_buffer.cursor_left(3)
 
 
 def docstring_single_quotes(event: KeyPressEvent):
     """Auto-close docstring (single quotes)"""
     event.current_buffer.insert_text("''''")
     event.current_buffer.cursor_left(3)
 
 
 def raw_string_parenthesis(event: KeyPressEvent):
     """Auto-close parenthesis in raw strings"""
     matches = re.match(
         r".*(r|R)[\"'](-*)",
         event.current_buffer.document.current_line_before_cursor,
     )
     dashes = matches.group(2) if matches else ""
     event.current_buffer.insert_text("()" + dashes)
     event.current_buffer.cursor_left(len(dashes) + 1)
 
 
 def raw_string_bracket(event: KeyPressEvent):
     """Auto-close bracker in raw strings"""
     matches = re.match(
         r".*(r|R)[\"'](-*)",
         event.current_buffer.document.current_line_before_cursor,
     )
     dashes = matches.group(2) if matches else ""
     event.current_buffer.insert_text("[]" + dashes)
     event.current_buffer.cursor_left(len(dashes) + 1)
 
 
 def raw_string_braces(event: KeyPressEvent):
     """Auto-close braces in raw strings"""
     matches = re.match(
         r".*(r|R)[\"'](-*)",
         event.current_buffer.document.current_line_before_cursor,
     )
     dashes = matches.group(2) if matches else ""
     event.current_buffer.insert_text("{}" + dashes)
     event.current_buffer.cursor_left(len(dashes) + 1)
 
 
 def skip_over(event: KeyPressEvent):
-    """Skip over automatically added parenthesis.
+    """Skip over automatically added parenthesis/quote.
 
-    (rather than adding another parenthesis)"""
+    (rather than adding another parenthesis/quote)"""
     event.current_buffer.cursor_right()
 
 
 def delete_pair(event: KeyPressEvent):
     """Delete auto-closed parenthesis"""
     event.current_buffer.delete()
     event.current_buffer.delete_before_cursor()
 
 
 auto_match_parens = {"(": parenthesis, "[": brackets, "{": braces}
 auto_match_parens_raw_string = {
     "(": raw_string_parenthesis,
     "[": raw_string_bracket,
     "{": raw_string_braces,
 }

IPython/terminal/shortcuts/auto_suggest.py

@@ -1,378 +1,375 b''
 import re
 import tokenize
 from io import StringIO
-from typing import Callable, List, Optional, Union, Generator, Tuple, Sequence
+from typing import Callable, List, Optional, Union, Generator, Tuple
 
 from prompt_toolkit.buffer import Buffer
 from prompt_toolkit.key_binding import KeyPressEvent
 from prompt_toolkit.key_binding.bindings import named_commands as nc
 from prompt_toolkit.auto_suggest import AutoSuggestFromHistory, Suggestion
 from prompt_toolkit.document import Document
 from prompt_toolkit.history import History
 from prompt_toolkit.shortcuts import PromptSession
 from prompt_toolkit.layout.processors import (
     Processor,
     Transformation,
     TransformationInput,
 )
 
+from IPython.core.getipython import get_ipython
 from IPython.utils.tokenutil import generate_tokens
 
 
 def _get_query(document: Document):
     return document.lines[document.cursor_position_row]
 
 
 class AppendAutoSuggestionInAnyLine(Processor):
     """
     Append the auto suggestion to lines other than the last (appending to the
     last line is natively supported by the prompt toolkit).
     """
 
     def __init__(self, style: str = "class:auto-suggestion") -> None:
         self.style = style
 
     def apply_transformation(self, ti: TransformationInput) -> Transformation:
         is_last_line = ti.lineno == ti.document.line_count - 1
         is_active_line = ti.lineno == ti.document.cursor_position_row
 
         if not is_last_line and is_active_line:
             buffer = ti.buffer_control.buffer
 
             if buffer.suggestion and ti.document.is_cursor_at_the_end_of_line:
                 suggestion = buffer.suggestion.text
             else:
                 suggestion = ""
 
             return Transformation(fragments=ti.fragments + [(self.style, suggestion)])
         else:
             return Transformation(fragments=ti.fragments)
 
 
 class NavigableAutoSuggestFromHistory(AutoSuggestFromHistory):
     """
     A subclass of AutoSuggestFromHistory that allow navigation to next/previous
     suggestion from history. To do so it remembers the current position, but it
     state need to carefully be cleared on the right events.
     """
 
     def __init__(
         self,
     ):
         self.skip_lines = 0
         self._connected_apps = []
 
     def reset_history_position(self, _: Buffer):
         self.skip_lines = 0
 
     def disconnect(self):
         for pt_app in self._connected_apps:
             text_insert_event = pt_app.default_buffer.on_text_insert
             text_insert_event.remove_handler(self.reset_history_position)
 
     def connect(self, pt_app: PromptSession):
         self._connected_apps.append(pt_app)
         # note: `on_text_changed` could be used for a bit different behaviour
         # on character deletion (i.e. reseting history position on backspace)
         pt_app.default_buffer.on_text_insert.add_handler(self.reset_history_position)
         pt_app.default_buffer.on_cursor_position_changed.add_handler(self._dismiss)
 
     def get_suggestion(
         self, buffer: Buffer, document: Document
     ) -> Optional[Suggestion]:
         text = _get_query(document)
 
         if text.strip():
             for suggestion, _ in self._find_next_match(
                 text, self.skip_lines, buffer.history
             ):
                 return Suggestion(suggestion)
 
         return None
 
     def _dismiss(self, buffer, *args, **kwargs):
         buffer.suggestion = None
 
     def _find_match(
         self, text: str, skip_lines: float, history: History, previous: bool
     ) -> Generator[Tuple[str, float], None, None]:
         """
         text : str
             Text content to find a match for, the user cursor is most of the
             time at the end of this text.
         skip_lines : float
             number of items to skip in the search, this is used to indicate how
             far in the list the user has navigated by pressing up or down.
             The float type is used as the base value is +inf
         history : History
             prompt_toolkit History instance to fetch previous entries from.
         previous : bool
             Direction of the search, whether we are looking previous match
             (True), or next match (False).
 
         Yields
         ------
         Tuple with:
         str:
             current suggestion.
         float:
             will actually yield only ints, which is passed back via skip_lines,
             which may be a +inf (float)
 
 
         """
         line_number = -1
         for string in reversed(list(history.get_strings())):
             for line in reversed(string.splitlines()):
                 line_number += 1
                 if not previous and line_number < skip_lines:
                     continue
                 # do not return empty suggestions as these
                 # close the auto-suggestion overlay (and are useless)
                 if line.startswith(text) and len(line) > len(text):
                     yield line[len(text) :], line_number
                 if previous and line_number >= skip_lines:
                     return
 
     def _find_next_match(
         self, text: str, skip_lines: float, history: History
     ) -> Generator[Tuple[str, float], None, None]:
         return self._find_match(text, skip_lines, history, previous=False)
 
     def _find_previous_match(self, text: str, skip_lines: float, history: History):
         return reversed(
             list(self._find_match(text, skip_lines, history, previous=True))
         )
 
     def up(self, query: str, other_than: str, history: History) -> None:
         for suggestion, line_number in self._find_next_match(
             query, self.skip_lines, history
         ):
             # if user has history ['very.a', 'very', 'very.b'] and typed 'very'
             # we want to switch from 'very.b' to 'very.a' because a) if the
             # suggestion equals current text, prompt-toolkit aborts suggesting
             # b) user likely would not be interested in 'very' anyways (they
             # already typed it).
             if query + suggestion != other_than:
                 self.skip_lines = line_number
                 break
         else:
             # no matches found, cycle back to beginning
             self.skip_lines = 0
 
     def down(self, query: str, other_than: str, history: History) -> None:
         for suggestion, line_number in self._find_previous_match(
             query, self.skip_lines, history
         ):
             if query + suggestion != other_than:
                 self.skip_lines = line_number
                 break
         else:
             # no matches found, cycle to end
             for suggestion, line_number in self._find_previous_match(
                 query, float("Inf"), history
             ):
                 if query + suggestion != other_than:
                     self.skip_lines = line_number
                     break
 
 
 # Needed for to accept autosuggestions in vi insert mode
 def accept_in_vi_insert_mode(event: KeyPressEvent):
     """Apply autosuggestion if at end of line."""
     buffer = event.current_buffer
     d = buffer.document
     after_cursor = d.text[d.cursor_position :]
     lines = after_cursor.split("\n")
     end_of_current_line = lines[0].strip()
     suggestion = buffer.suggestion
     if (suggestion is not None) and (suggestion.text) and (end_of_current_line == ""):
         buffer.insert_text(suggestion.text)
     else:
         nc.end_of_line(event)
 
 
 def accept(event: KeyPressEvent):
     """Accept autosuggestion"""
     buffer = event.current_buffer
     suggestion = buffer.suggestion
     if suggestion:
         buffer.insert_text(suggestion.text)
     else:
         nc.forward_char(event)
 
 
 def discard(event: KeyPressEvent):
     """Discard autosuggestion"""
     buffer = event.current_buffer
     buffer.suggestion = None
 
 
 def accept_word(event: KeyPressEvent):
     """Fill partial autosuggestion by word"""
     buffer = event.current_buffer
     suggestion = buffer.suggestion
     if suggestion:
         t = re.split(r"(\S+\s+)", suggestion.text)
         buffer.insert_text(next((x for x in t if x), ""))
     else:
         nc.forward_word(event)
 
 
 def accept_character(event: KeyPressEvent):
     """Fill partial autosuggestion by character"""
     b = event.current_buffer
     suggestion = b.suggestion
     if suggestion and suggestion.text:
         b.insert_text(suggestion.text[0])
 
 
 def accept_and_keep_cursor(event: KeyPressEvent):
     """Accept autosuggestion and keep cursor in place"""
     buffer = event.current_buffer
     old_position = buffer.cursor_position
     suggestion = buffer.suggestion
     if suggestion:
         buffer.insert_text(suggestion.text)
         buffer.cursor_position = old_position
 
 
 def accept_and_move_cursor_left(event: KeyPressEvent):
     """Accept autosuggestion and move cursor left in place"""
     accept_and_keep_cursor(event)
     nc.backward_char(event)
 
 
 def _update_hint(buffer: Buffer):
     if buffer.auto_suggest:
         suggestion = buffer.auto_suggest.get_suggestion(buffer, buffer.document)
         buffer.suggestion = suggestion
 
 
 def backspace_and_resume_hint(event: KeyPressEvent):
     """Resume autosuggestions after deleting last character"""
     current_buffer = event.current_buffer
 
     def resume_hinting(buffer: Buffer):
         _update_hint(buffer)
         current_buffer.on_text_changed.remove_handler(resume_hinting)
 
     current_buffer.on_text_changed.add_handler(resume_hinting)
     nc.backward_delete_char(event)
 
 
 def up_and_update_hint(event: KeyPressEvent):
     """Go up and update hint"""
     current_buffer = event.current_buffer
 
     current_buffer.auto_up(count=event.arg)
     _update_hint(current_buffer)
 
 
 def down_and_update_hint(event: KeyPressEvent):
     """Go down and update hint"""
     current_buffer = event.current_buffer
 
     current_buffer.auto_down(count=event.arg)
     _update_hint(current_buffer)
 
 
 def accept_token(event: KeyPressEvent):
     """Fill partial autosuggestion by token"""
     b = event.current_buffer
     suggestion = b.suggestion
 
     if suggestion:
         prefix = _get_query(b.document)
         text = prefix + suggestion.text
 
         tokens: List[Optional[str]] = [None, None, None]
         substrings = [""]
         i = 0
 
         for token in generate_tokens(StringIO(text).readline):
             if token.type == tokenize.NEWLINE:
                 index = len(text)
             else:
                 index = text.index(token[1], len(substrings[-1]))
             substrings.append(text[:index])
             tokenized_so_far = substrings[-1]
             if tokenized_so_far.startswith(prefix):
                 if i == 0 and len(tokenized_so_far) > len(prefix):
                     tokens[0] = tokenized_so_far[len(prefix) :]
                     substrings.append(tokenized_so_far)
                     i += 1
                 tokens[i] = token[1]
                 if i == 2:
                     break
                 i += 1
 
         if tokens[0]:
             to_insert: str
             insert_text = substrings[-2]
             if tokens[1] and len(tokens[1]) == 1:
                 insert_text = substrings[-1]
             to_insert = insert_text[len(prefix) :]
             b.insert_text(to_insert)
             return
 
     nc.forward_word(event)
 
 
 Provider = Union[AutoSuggestFromHistory, NavigableAutoSuggestFromHistory, None]
 
 
 def _swap_autosuggestion(
     buffer: Buffer,
     provider: NavigableAutoSuggestFromHistory,
     direction_method: Callable,
 ):
     """
     We skip most recent history entry (in either direction) if it equals the
     current autosuggestion because if user cycles when auto-suggestion is shown
     they most likely want something else than what was suggested (otherwise
     they would have accepted the suggestion).
     """
     suggestion = buffer.suggestion
     if not suggestion:
         return
 
     query = _get_query(buffer.document)
     current = query + suggestion.text
 
     direction_method(query=query, other_than=current, history=buffer.history)
 
     new_suggestion = provider.get_suggestion(buffer, buffer.document)
     buffer.suggestion = new_suggestion
 
 
-def swap_autosuggestion_up(provider: Provider):
     def swap_autosuggestion_up(event: KeyPressEvent):
         """Get next autosuggestion from history."""
+    shell = get_ipython()
+    provider = shell.auto_suggest
+
         if not isinstance(provider, NavigableAutoSuggestFromHistory):
             return
 
         return _swap_autosuggestion(
             buffer=event.current_buffer, provider=provider, direction_method=provider.up
         )
 
-    swap_autosuggestion_up.__name__ = "swap_autosuggestion_up"
-    return swap_autosuggestion_up
-
 
-def swap_autosuggestion_down(
-    provider: Union[AutoSuggestFromHistory, NavigableAutoSuggestFromHistory, None]
-):
     def swap_autosuggestion_down(event: KeyPressEvent):
         """Get previous autosuggestion from history."""
+    shell = get_ipython()
+    provider = shell.auto_suggest
+
         if not isinstance(provider, NavigableAutoSuggestFromHistory):
             return
 
         return _swap_autosuggestion(
             buffer=event.current_buffer,
             provider=provider,
             direction_method=provider.down,
         )
-
-    swap_autosuggestion_down.__name__ = "swap_autosuggestion_down"
-    return swap_autosuggestion_down

IPython/terminal/tests/test_interactivshell.py

@@ -1,256 +1,255 b''
 # -*- coding: utf-8 -*-
 """Tests for the TerminalInteractiveShell and related pieces."""
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import sys
 import unittest
 import os
 
 from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
 
-from IPython.core.inputtransformer import InputTransformer
+
 from IPython.testing import tools as tt
-from IPython.utils.capture import capture_output
 
 from IPython.terminal.ptutils import _elide, _adjust_completion_text_based_on_context
 from IPython.terminal.shortcuts.auto_suggest import NavigableAutoSuggestFromHistory
 
 
 class TestAutoSuggest(unittest.TestCase):
     def test_changing_provider(self):
         ip = get_ipython()
         ip.autosuggestions_provider = None
         self.assertEqual(ip.auto_suggest, None)
         ip.autosuggestions_provider = "AutoSuggestFromHistory"
         self.assertIsInstance(ip.auto_suggest, AutoSuggestFromHistory)
         ip.autosuggestions_provider = "NavigableAutoSuggestFromHistory"
         self.assertIsInstance(ip.auto_suggest, NavigableAutoSuggestFromHistory)
 
 
 class TestElide(unittest.TestCase):
     def test_elide(self):
         _elide("concatenate((a1, a2, ...), axis", "")  # do not raise
         _elide("concatenate((a1, a2, ..), . axis", "")  # do not raise
         self.assertEqual(
             _elide("aaaa.bbbb.ccccc.dddddd.eeeee.fffff.gggggg.hhhhhh", ""),
             "aaaa.b…g.hhhhhh",
         )
 
         test_string = os.sep.join(["", 10 * "a", 10 * "b", 10 * "c", ""])
         expect_string = (
             os.sep + "a" + "\N{HORIZONTAL ELLIPSIS}" + "b" + os.sep + 10 * "c"
         )
         self.assertEqual(_elide(test_string, ""), expect_string)
 
     def test_elide_typed_normal(self):
         self.assertEqual(
             _elide(
                 "the quick brown fox jumped over the lazy dog",
                 "the quick brown fox",
                 min_elide=10,
             ),
             "the…fox jumped over the lazy dog",
         )
 
     def test_elide_typed_short_match(self):
         """
         if the match is too short we don't elide.
         avoid the "the...the"
         """
         self.assertEqual(
             _elide("the quick brown fox jumped over the lazy dog", "the", min_elide=10),
             "the quick brown fox jumped over the lazy dog",
         )
 
     def test_elide_typed_no_match(self):
         """
         if the match is too short we don't elide.
         avoid the "the...the"
         """
         # here we typed red instead of brown
         self.assertEqual(
             _elide(
                 "the quick brown fox jumped over the lazy dog",
                 "the quick red fox",
                 min_elide=10,
             ),
             "the quick brown fox jumped over the lazy dog",
         )
 
 
 class TestContextAwareCompletion(unittest.TestCase):
     def test_adjust_completion_text_based_on_context(self):
         # Adjusted case
         self.assertEqual(
             _adjust_completion_text_based_on_context("arg1=", "func1(a=)", 7), "arg1"
         )
 
         # Untouched cases
         self.assertEqual(
             _adjust_completion_text_based_on_context("arg1=", "func1(a)", 7), "arg1="
         )
         self.assertEqual(
             _adjust_completion_text_based_on_context("arg1=", "func1(a", 7), "arg1="
         )
         self.assertEqual(
             _adjust_completion_text_based_on_context("%magic", "func1(a=)", 7), "%magic"
         )
         self.assertEqual(
             _adjust_completion_text_based_on_context("func2", "func1(a=)", 7), "func2"
         )
 
 
 # Decorator for interaction loop tests -----------------------------------------
 
 
 class mock_input_helper(object):
     """Machinery for tests of the main interact loop.
 
     Used by the mock_input decorator.
     """
     def __init__(self, testgen):
         self.testgen = testgen
         self.exception = None
         self.ip = get_ipython()
 
     def __enter__(self):
         self.orig_prompt_for_code = self.ip.prompt_for_code
         self.ip.prompt_for_code = self.fake_input
         return self
 
     def __exit__(self, etype, value, tb):
         self.ip.prompt_for_code = self.orig_prompt_for_code
 
     def fake_input(self):
         try:
             return next(self.testgen)
         except StopIteration:
             self.ip.keep_running = False
             return u''
         except:
             self.exception = sys.exc_info()
             self.ip.keep_running = False
             return u''
 
 def mock_input(testfunc):
     """Decorator for tests of the main interact loop.
 
     Write the test as a generator, yield-ing the input strings, which IPython
     will see as if they were typed in at the prompt.
     """
     def test_method(self):
         testgen = testfunc(self)
         with mock_input_helper(testgen) as mih:
             mih.ip.interact()
 
         if mih.exception is not None:
             # Re-raise captured exception
             etype, value, tb = mih.exception
             import traceback
             traceback.print_tb(tb, file=sys.stdout)
             del tb  # Avoid reference loop
             raise value
 
     return test_method
 
 # Test classes -----------------------------------------------------------------
 
 class InteractiveShellTestCase(unittest.TestCase):
     def rl_hist_entries(self, rl, n):
         """Get last n readline history entries as a list"""
         return [rl.get_history_item(rl.get_current_history_length() - x)
                 for x in range(n - 1, -1, -1)]
     
     @mock_input
     def test_inputtransformer_syntaxerror(self):
         ip = get_ipython()
         ip.input_transformers_post.append(syntax_error_transformer)
 
         try:
             #raise Exception
             with tt.AssertPrints('4', suppress=False):
                 yield u'print(2*2)'
 
             with tt.AssertPrints('SyntaxError: input contains', suppress=False):
                 yield u'print(2345) # syntaxerror'
 
             with tt.AssertPrints('16', suppress=False):
                 yield u'print(4*4)'
 
         finally:
             ip.input_transformers_post.remove(syntax_error_transformer)
 
     def test_repl_not_plain_text(self):
         ip = get_ipython()
         formatter = ip.display_formatter
         assert formatter.active_types == ['text/plain']
 
         # terminal may have arbitrary mimetype handler to open external viewer
         # or inline images.
         assert formatter.ipython_display_formatter.enabled
 
         class Test(object):
             def __repr__(self):
                 return "<Test %i>" % id(self)
 
             def _repr_html_(self):
                 return '<html>'
 
         # verify that HTML repr isn't computed
         obj = Test()
         data, _ = formatter.format(obj)
         self.assertEqual(data, {'text/plain': repr(obj)})
 
         class Test2(Test):
             def _ipython_display_(self):
                 from IPython.display import display, HTML
 
                 display(HTML("<custom>"))
 
         # verify that mimehandlers are called
         called = False
 
         def handler(data, metadata):
             print("Handler called")
             nonlocal called
             called = True
 
         ip.display_formatter.active_types.append("text/html")
         ip.display_formatter.formatters["text/html"].enabled = True
         ip.mime_renderers["text/html"] = handler
         try:
             obj = Test()
             display(obj)
         finally:
             ip.display_formatter.formatters["text/html"].enabled = False
             del ip.mime_renderers["text/html"]
 
         assert called == True
 
 
 def syntax_error_transformer(lines):
     """Transformer that throws SyntaxError if 'syntaxerror' is in the code."""
     for line in lines:
         pos = line.find('syntaxerror')
         if pos >= 0:
             e = SyntaxError('input contains "syntaxerror"')
             e.text = line
             e.offset = pos + 1
             raise e
     return lines
 
 
 class TerminalMagicsTestCase(unittest.TestCase):
     def test_paste_magics_blankline(self):
         """Test that code with a blank line doesn't get split (gh-3246)."""
         ip = get_ipython()
         s = ('def pasted_func(a):\n'
              '    b = a+1\n'
              '\n'
              '    return b')
         
         tm = ip.magics_manager.registry['TerminalMagics']
         tm.store_or_execute(s, name=None)
         
         self.assertEqual(ip.user_ns['pasted_func'](54), 55)

IPython/terminal/tests/test_shortcuts.py

@@ -1,318 +1,422 b''
 import pytest
 from IPython.terminal.shortcuts.auto_suggest import (
     accept,
     accept_in_vi_insert_mode,
     accept_token,
     accept_character,
     accept_word,
     accept_and_keep_cursor,
     discard,
     NavigableAutoSuggestFromHistory,
     swap_autosuggestion_up,
     swap_autosuggestion_down,
 )
+from IPython.terminal.shortcuts.auto_match import skip_over
+from IPython.terminal.shortcuts import create_ipython_shortcuts
 
 from prompt_toolkit.history import InMemoryHistory
 from prompt_toolkit.buffer import Buffer
 from prompt_toolkit.document import Document
 from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
 
 from unittest.mock import patch, Mock
 
 
 def make_event(text, cursor, suggestion):
     event = Mock()
     event.current_buffer = Mock()
     event.current_buffer.suggestion = Mock()
     event.current_buffer.text = text
     event.current_buffer.cursor_position = cursor
     event.current_buffer.suggestion.text = suggestion
     event.current_buffer.document = Document(text=text, cursor_position=cursor)
     return event
 
 
 @pytest.mark.parametrize(
     "text, suggestion, expected",
     [
         ("", "def out(tag: str, n=50):", "def out(tag: str, n=50):"),
         ("def ", "out(tag: str, n=50):", "out(tag: str, n=50):"),
     ],
 )
 def test_accept(text, suggestion, expected):
     event = make_event(text, len(text), suggestion)
     buffer = event.current_buffer
     buffer.insert_text = Mock()
     accept(event)
     assert buffer.insert_text.called
     assert buffer.insert_text.call_args[0] == (expected,)
 
 
 @pytest.mark.parametrize(
     "text, suggestion",
     [
         ("", "def out(tag: str, n=50):"),
         ("def ", "out(tag: str, n=50):"),
     ],
 )
 def test_discard(text, suggestion):
     event = make_event(text, len(text), suggestion)
     buffer = event.current_buffer
     buffer.insert_text = Mock()
     discard(event)
     assert not buffer.insert_text.called
     assert buffer.suggestion is None
 
 
 @pytest.mark.parametrize(
     "text, cursor, suggestion, called",
     [
         ("123456", 6, "123456789", True),
         ("123456", 3, "123456789", False),
         ("123456   \n789", 6, "123456789", True),
     ],
 )
 def test_autosuggest_at_EOL(text, cursor, suggestion, called):
     """
     test that autosuggest is only applied at end of line.
     """
 
     event = make_event(text, cursor, suggestion)
     event.current_buffer.insert_text = Mock()
     accept_in_vi_insert_mode(event)
     if called:
         event.current_buffer.insert_text.assert_called()
     else:
         event.current_buffer.insert_text.assert_not_called()
         # event.current_buffer.document.get_end_of_line_position.assert_called()
 
 
 @pytest.mark.parametrize(
     "text, suggestion, expected",
     [
         ("", "def out(tag: str, n=50):", "def "),
         ("d", "ef out(tag: str, n=50):", "ef "),
         ("de ", "f out(tag: str, n=50):", "f "),
         ("def", " out(tag: str, n=50):", " "),
         ("def ", "out(tag: str, n=50):", "out("),
         ("def o", "ut(tag: str, n=50):", "ut("),
         ("def ou", "t(tag: str, n=50):", "t("),
         ("def out", "(tag: str, n=50):", "("),
         ("def out(", "tag: str, n=50):", "tag: "),
         ("def out(t", "ag: str, n=50):", "ag: "),
         ("def out(ta", "g: str, n=50):", "g: "),
         ("def out(tag", ": str, n=50):", ": "),
         ("def out(tag:", " str, n=50):", " "),
         ("def out(tag: ", "str, n=50):", "str, "),
         ("def out(tag: s", "tr, n=50):", "tr, "),
         ("def out(tag: st", "r, n=50):", "r, "),
         ("def out(tag: str", ", n=50):", ", n"),
         ("def out(tag: str,", " n=50):", " n"),
         ("def out(tag: str, ", "n=50):", "n="),
         ("def out(tag: str, n", "=50):", "="),
         ("def out(tag: str, n=", "50):", "50)"),
         ("def out(tag: str, n=5", "0):", "0)"),
         ("def out(tag: str, n=50", "):", "):"),
         ("def out(tag: str, n=50)", ":", ":"),
     ],
 )
 def test_autosuggest_token(text, suggestion, expected):
     event = make_event(text, len(text), suggestion)
     event.current_buffer.insert_text = Mock()
     accept_token(event)
     assert event.current_buffer.insert_text.called
     assert event.current_buffer.insert_text.call_args[0] == (expected,)
 
 
 @pytest.mark.parametrize(
     "text, suggestion, expected",
     [
         ("", "def out(tag: str, n=50):", "d"),
         ("d", "ef out(tag: str, n=50):", "e"),
         ("de ", "f out(tag: str, n=50):", "f"),
         ("def", " out(tag: str, n=50):", " "),
     ],
 )
 def test_accept_character(text, suggestion, expected):
     event = make_event(text, len(text), suggestion)
     event.current_buffer.insert_text = Mock()
     accept_character(event)
     assert event.current_buffer.insert_text.called
     assert event.current_buffer.insert_text.call_args[0] == (expected,)
 
 
 @pytest.mark.parametrize(
     "text, suggestion, expected",
     [
         ("", "def out(tag: str, n=50):", "def "),
         ("d", "ef out(tag: str, n=50):", "ef "),
         ("de", "f out(tag: str, n=50):", "f "),
         ("def", " out(tag: str, n=50):", " "),
         # (this is why we also have accept_token)
         ("def ", "out(tag: str, n=50):", "out(tag: "),
     ],
 )
 def test_accept_word(text, suggestion, expected):
     event = make_event(text, len(text), suggestion)
     event.current_buffer.insert_text = Mock()
     accept_word(event)
     assert event.current_buffer.insert_text.called
     assert event.current_buffer.insert_text.call_args[0] == (expected,)
 
 
 @pytest.mark.parametrize(
     "text, suggestion, expected, cursor",
     [
         ("", "def out(tag: str, n=50):", "def out(tag: str, n=50):", 0),
         ("def ", "out(tag: str, n=50):", "out(tag: str, n=50):", 4),
     ],
 )
 def test_accept_and_keep_cursor(text, suggestion, expected, cursor):
     event = make_event(text, cursor, suggestion)
     buffer = event.current_buffer
     buffer.insert_text = Mock()
     accept_and_keep_cursor(event)
     assert buffer.insert_text.called
     assert buffer.insert_text.call_args[0] == (expected,)
     assert buffer.cursor_position == cursor
 
 
 def test_autosuggest_token_empty():
     full = "def out(tag: str, n=50):"
     event = make_event(full, len(full), "")
     event.current_buffer.insert_text = Mock()
 
     with patch(
         "prompt_toolkit.key_binding.bindings.named_commands.forward_word"
     ) as forward_word:
         accept_token(event)
         assert not event.current_buffer.insert_text.called
         assert forward_word.called
 
 
 def test_other_providers():
     """Ensure that swapping autosuggestions does not break with other providers"""
     provider = AutoSuggestFromHistory()
-    up = swap_autosuggestion_up(provider)
-    down = swap_autosuggestion_down(provider)
+    ip = get_ipython()
+    ip.auto_suggest = provider
     event = Mock()
     event.current_buffer = Buffer()
-    assert up(event) is None
-    assert down(event) is None
+    assert swap_autosuggestion_up(event) is None
+    assert swap_autosuggestion_down(event) is None
 
 
 async def test_navigable_provider():
     provider = NavigableAutoSuggestFromHistory()
     history = InMemoryHistory(history_strings=["very_a", "very", "very_b", "very_c"])
     buffer = Buffer(history=history)
+    ip = get_ipython()
+    ip.auto_suggest = provider
 
     async for _ in history.load():
         pass
 
     buffer.cursor_position = 5
     buffer.text = "very"
 
-    up = swap_autosuggestion_up(provider)
-    down = swap_autosuggestion_down(provider)
+    up = swap_autosuggestion_up
+    down = swap_autosuggestion_down
 
     event = Mock()
     event.current_buffer = buffer
 
     def get_suggestion():
         suggestion = provider.get_suggestion(buffer, buffer.document)
         buffer.suggestion = suggestion
         return suggestion
 
     assert get_suggestion().text == "_c"
 
     # should go up
     up(event)
     assert get_suggestion().text == "_b"
 
     # should skip over 'very' which is identical to buffer content
     up(event)
     assert get_suggestion().text == "_a"
 
     # should cycle back to beginning
     up(event)
     assert get_suggestion().text == "_c"
 
     # should cycle back through end boundary
     down(event)
     assert get_suggestion().text == "_a"
 
     down(event)
     assert get_suggestion().text == "_b"
 
     down(event)
     assert get_suggestion().text == "_c"
 
     down(event)
     assert get_suggestion().text == "_a"
 
 
 async def test_navigable_provider_multiline_entries():
     provider = NavigableAutoSuggestFromHistory()
     history = InMemoryHistory(history_strings=["very_a\nvery_b", "very_c"])
     buffer = Buffer(history=history)
+    ip = get_ipython()
+    ip.auto_suggest = provider
 
     async for _ in history.load():
         pass
 
     buffer.cursor_position = 5
     buffer.text = "very"
-    up = swap_autosuggestion_up(provider)
-    down = swap_autosuggestion_down(provider)
+    up = swap_autosuggestion_up
+    down = swap_autosuggestion_down
 
     event = Mock()
     event.current_buffer = buffer
 
     def get_suggestion():
         suggestion = provider.get_suggestion(buffer, buffer.document)
         buffer.suggestion = suggestion
         return suggestion
 
     assert get_suggestion().text == "_c"
 
     up(event)
     assert get_suggestion().text == "_b"
 
     up(event)
     assert get_suggestion().text == "_a"
 
     down(event)
     assert get_suggestion().text == "_b"
 
     down(event)
     assert get_suggestion().text == "_c"
 
 
 def create_session_mock():
     session = Mock()
     session.default_buffer = Buffer()
     return session
 
 
 def test_navigable_provider_connection():
     provider = NavigableAutoSuggestFromHistory()
     provider.skip_lines = 1
 
     session_1 = create_session_mock()
     provider.connect(session_1)
 
     assert provider.skip_lines == 1
     session_1.default_buffer.on_text_insert.fire()
     assert provider.skip_lines == 0
 
     session_2 = create_session_mock()
     provider.connect(session_2)
     provider.skip_lines = 2
 
     assert provider.skip_lines == 2
     session_2.default_buffer.on_text_insert.fire()
     assert provider.skip_lines == 0
 
     provider.skip_lines = 3
     provider.disconnect()
     session_1.default_buffer.on_text_insert.fire()
     session_2.default_buffer.on_text_insert.fire()
     assert provider.skip_lines == 3
+
+
[e-mail]
+def ipython_with_prompt():
+    ip = get_ipython()
+    ip.pt_app = Mock()
+    ip.pt_app.key_bindings = create_ipython_shortcuts(ip)
+    try:
+        yield ip
+    finally:
+        ip.pt_app = None
+
+
+def find_bindings_by_command(command):
+    ip = get_ipython()
+    return [
+        binding
+        for binding in ip.pt_app.key_bindings.bindings
+        if binding.handler == command
+    ]
+
+
+def test_modify_unique_shortcut(ipython_with_prompt):
+    matched = find_bindings_by_command(accept_token)
+    assert len(matched) == 1
+
+    ipython_with_prompt.shortcuts = [
+        {"command": "IPython:auto_suggest.accept_token", "new_keys": ["a", "b", "c"]}
+    ]
+    matched = find_bindings_by_command(accept_token)
+    assert len(matched) == 1
+    assert list(matched[0].keys) == ["a", "b", "c"]
+
+    ipython_with_prompt.shortcuts = [
+        {"command": "IPython:auto_suggest.accept_token", "new_keys": []}
+    ]
+    matched = find_bindings_by_command(accept_token)
+    assert len(matched) == 0
+
+    ipython_with_prompt.shortcuts = []
+    matched = find_bindings_by_command(accept_token)
+    assert len(matched) == 1
+
+
+def test_modify_shortcut_with_filters(ipython_with_prompt):
+    matched = find_bindings_by_command(skip_over)
+    matched_keys = {m.keys[0] for m in matched}
+    assert matched_keys == {")", "]", "}", "'", '"'}
+
+    with pytest.raises(ValueError, match="Multiple shortcuts matching"):
+        ipython_with_prompt.shortcuts = [
+            {"command": "IPython:auto_match.skip_over", "new_keys": ["x"]}
+        ]
+
+    ipython_with_prompt.shortcuts = [
+        {
+            "command": "IPython:auto_match.skip_over",
+            "new_keys": ["x"],
+            "match_filter": "focused_insert & auto_match & followed_by_single_quote",
+        }
+    ]
+    matched = find_bindings_by_command(skip_over)
+    matched_keys = {m.keys[0] for m in matched}
+    assert matched_keys == {")", "]", "}", "x", '"'}
+
+
+def test_command():
+    pass
+
+
+def test_add_shortcut_for_new_command(ipython_with_prompt):
+    matched = find_bindings_by_command(test_command)
+    assert len(matched) == 0
+
+    with pytest.raises(ValueError, match="test_command is not a known"):
+        ipython_with_prompt.shortcuts = [{"command": "test_command", "new_keys": ["x"]}]
+    matched = find_bindings_by_command(test_command)
+    assert len(matched) == 0
+
+
+def test_add_shortcut_for_existing_command(ipython_with_prompt):
+    matched = find_bindings_by_command(skip_over)
+    assert len(matched) == 5
+
+    with pytest.raises(ValueError, match="Cannot add a shortcut without keys"):
+        ipython_with_prompt.shortcuts = [
+            {"command": "IPython:auto_match.skip_over", "new_keys": [], "create": True}
+        ]
+
+    ipython_with_prompt.shortcuts = [
+        {"command": "IPython:auto_match.skip_over", "new_keys": ["x"], "create": True}
+    ]
+    matched = find_bindings_by_command(skip_over)
+    assert len(matched) == 6
+
+    ipython_with_prompt.shortcuts = []
+    matched = find_bindings_by_command(skip_over)
+    assert len(matched) == 5

docs/autogen_shortcuts.py

@@ -1,221 +1,221 b''
 from dataclasses import dataclass
 from inspect import getsource
 from pathlib import Path
-from typing import cast, Callable, List, Union
+from typing import cast, List, Union
 from html import escape as html_escape
 import re
 
 from prompt_toolkit.keys import KEY_ALIASES
 from prompt_toolkit.key_binding import KeyBindingsBase
 from prompt_toolkit.filters import Filter, Condition
 from prompt_toolkit.shortcuts import PromptSession
 
-from IPython.terminal.shortcuts import create_ipython_shortcuts
+from IPython.terminal.shortcuts import create_ipython_shortcuts, create_identifier
+from IPython.terminal.shortcuts.filters import KEYBINDING_FILTERS
 
 
 @dataclass
 class Shortcut:
     #: a sequence of keys (each element on the list corresponds to pressing one or more keys)
     keys_sequence: list[str]
     filter: str
 
 
 @dataclass
 class Handler:
     description: str
     identifier: str
 
 
 @dataclass
 class Binding:
     handler: Handler
     shortcut: Shortcut
 
 
 class _NestedFilter(Filter):
     """Protocol reflecting non-public prompt_toolkit's `_AndList` and `_OrList`."""
 
     filters: List[Filter]
 
 
 class _Invert(Filter):
     """Protocol reflecting non-public prompt_toolkit's `_Invert`."""
 
     filter: Filter
 
 
-conjunctions_labels = {"_AndList": "and", "_OrList": "or"}
+conjunctions_labels = {"_AndList": "&", "_OrList": "|"}
 
 ATOMIC_CLASSES = {"Never", "Always", "Condition"}
 
 
+HUMAN_NAMES_FOR_FILTERS = {
+    filter_: name for name, filter_ in KEYBINDING_FILTERS.items()
+}
+
+
 def format_filter(
     filter_: Union[Filter, _NestedFilter, Condition, _Invert],
     is_top_level=True,
     skip=None,
 ) -> str:
     """Create easily readable description of the filter."""
     s = filter_.__class__.__name__
     if s == "Condition":
         func = cast(Condition, filter_).func
+        if filter_ in HUMAN_NAMES_FOR_FILTERS:
+            return HUMAN_NAMES_FOR_FILTERS[filter_]
         name = func.__name__
         if name == "<lambda>":
             source = getsource(func)
             return source.split("=")[0].strip()
         return func.__name__
     elif s == "_Invert":
         operand = cast(_Invert, filter_).filter
         if operand.__class__.__name__ in ATOMIC_CLASSES:
-            return f"not {format_filter(operand, is_top_level=False)}"
-        return f"not ({format_filter(operand, is_top_level=False)})"
+            return f"~{format_filter(operand, is_top_level=False)}"
+        return f"~({format_filter(operand, is_top_level=False)})"
     elif s in conjunctions_labels:
         filters = cast(_NestedFilter, filter_).filters
+        if filter_ in HUMAN_NAMES_FOR_FILTERS:
+            return HUMAN_NAMES_FOR_FILTERS[filter_]
         conjunction = conjunctions_labels[s]
         glue = f" {conjunction} "
         result = glue.join(format_filter(x, is_top_level=False) for x in filters)
         if len(filters) > 1 and not is_top_level:
             result = f"({result})"
         return result
     elif s in ["Never", "Always"]:
         return s.lower()
     else:
         raise ValueError(f"Unknown filter type: {filter_}")
 
 
 def sentencize(s) -> str:
     """Extract first sentence"""
     s = re.split(r"\.\W", s.replace("\n", " ").strip())
     s = s[0] if len(s) else ""
     if not s.endswith("."):
         s += "."
     try:
         return " ".join(s.split())
     except AttributeError:
         return s
 
 
 class _DummyTerminal:
     """Used as a buffer to get prompt_toolkit bindings
     """
     handle_return = None
     input_transformer_manager = None
     display_completions = None
     editing_mode = "emacs"
     auto_suggest = 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}"
-
-
 def bindings_from_prompt_toolkit(prompt_bindings: KeyBindingsBase) -> List[Binding]:
     """Collect bindings to a simple format that does not depend on prompt-toolkit internals"""
     bindings: List[Binding] = []
 
     for kb in prompt_bindings.bindings:
         bindings.append(
             Binding(
                 handler=Handler(
                     description=kb.handler.__doc__ or "",
                     identifier=create_identifier(kb.handler),
                 ),
                 shortcut=Shortcut(
                     keys_sequence=[
                         str(k.value) if hasattr(k, "value") else k for k in kb.keys
                     ],
                     filter=format_filter(kb.filter, skip={"has_focus_filter"}),
                 ),
             )
         )
     return bindings
 
 
 INDISTINGUISHABLE_KEYS = {**KEY_ALIASES, **{v: k for k, v in KEY_ALIASES.items()}}
 
 
 def format_prompt_keys(keys: str, add_alternatives=True) -> str:
     """Format prompt toolkit key with modifier into an RST representation."""
 
     def to_rst(key):
         escaped = key.replace("\\", "\\\\")
         return f":kbd:`{escaped}`"
 
     keys_to_press: list[str]
 
     prefixes = {
         "c-s-": [to_rst("ctrl"), to_rst("shift")],
         "s-c-": [to_rst("ctrl"), to_rst("shift")],
         "c-": [to_rst("ctrl")],
         "s-": [to_rst("shift")],
     }
 
     for prefix, modifiers in prefixes.items():
         if keys.startswith(prefix):
             remainder = keys[len(prefix) :]
             keys_to_press = [*modifiers, to_rst(remainder)]
             break
     else:
         keys_to_press = [to_rst(keys)]
 
     result = " + ".join(keys_to_press)
 
     if keys in INDISTINGUISHABLE_KEYS and add_alternatives:
         alternative = INDISTINGUISHABLE_KEYS[keys]
 
         result = (
             result
             + " (or "
             + format_prompt_keys(alternative, add_alternatives=False)
             + ")"
         )
 
     return result
 
+
 if __name__ == '__main__':
     here = Path(__file__).parent
     dest = here / "source" / "config" / "shortcuts"
 
-    ipy_bindings = create_ipython_shortcuts(_DummyTerminal(), for_all_platforms=True)
+    ipy_bindings = create_ipython_shortcuts(_DummyTerminal())
 
     session = PromptSession(key_bindings=ipy_bindings)
     prompt_bindings = session.app.key_bindings
 
     assert prompt_bindings
     # Ensure that we collected the default shortcuts
     assert len(prompt_bindings.bindings) > len(ipy_bindings.bindings)
 
     bindings = bindings_from_prompt_toolkit(prompt_bindings)
 
     def sort_key(binding: Binding):
         return binding.handler.identifier, binding.shortcut.filter
 
     filters = []
     with (dest / "table.tsv").open("w", encoding="utf-8") as csv:
         for binding in sorted(bindings, key=sort_key):
             sequence = ", ".join(
                 [format_prompt_keys(keys) for keys in binding.shortcut.keys_sequence]
             )
             if binding.shortcut.filter == "always":
                 condition_label = "-"
             else:
                 # we cannot fit all the columns as the filters got too complex over time
                 condition_label = "ⓘ"
 
             csv.write(
                 "\t".join(
                     [
                         sequence,
                         sentencize(binding.handler.description)
                         + f" :raw-html:`<br>` `{binding.handler.identifier}`",
                         f':raw-html:`<span title="{html_escape(binding.shortcut.filter)}" style="cursor: help">{condition_label}</span>`',
                     ]
                 )
                 + "\n"
             )