def register_ipython_shortcuts(registry, shell): """Set up the prompt_toolkit keyboard shortcuts for IPython""" insert_mode = ViInsertMode() | EmacsInsertMode() # Ctrl+J == Enter, seemingly registry.add_binding(Keys.ControlJ, filter=(HasFocus(DEFAULT_BUFFER) & ~HasSelection() & insert_mode))( newline_or_execute_outer(shell)) registry.add_binding(Keys.ControlBackslash)(force_exit) registry.add_binding(Keys.ControlP, filter=(ViInsertMode() & HasFocus(DEFAULT_BUFFER) ))(previous_history_or_previous_completion) registry.add_binding( Keys.ControlN, filter=(ViInsertMode() & HasFocus(DEFAULT_BUFFER)))(next_history_or_next_completion) registry.add_binding(Keys.ControlG, filter=(HasFocus(DEFAULT_BUFFER) & HasCompletions()))(dismiss_completion) registry.add_binding(Keys.ControlC, filter=HasFocus(DEFAULT_BUFFER))(reset_buffer) registry.add_binding(Keys.ControlC, filter=HasFocus(SEARCH_BUFFER))(reset_search_buffer) supports_suspend = Condition(lambda cli: hasattr(signal, 'SIGTSTP')) registry.add_binding(Keys.ControlZ, filter=supports_suspend)(suspend_to_bg) # Ctrl+I == Tab registry.add_binding(Keys.ControlI, filter=(HasFocus(DEFAULT_BUFFER) & ~HasSelection() & insert_mode & cursor_in_leading_ws))(indent_buffer) registry.add_binding( Keys.ControlO, filter=(HasFocus(DEFAULT_BUFFER) & EmacsInsertMode()))(newline_with_copy_margin) if shell.display_completions == 'readlinelike': registry.add_binding( Keys.ControlI, filter=( HasFocus(DEFAULT_BUFFER) & ~HasSelection() & insert_mode & ~cursor_in_leading_ws))(display_completions_like_readline) if sys.platform == 'win32': registry.add_binding(Keys.ControlV, filter=(HasFocus(DEFAULT_BUFFER) & ~ViMode()))(win_paste)
def configure(repl): repl.vi_mode = True @repl.add_key_binding('j', 'k', filter=ViInsertMode()) def _(event): " Map 'jk' to Escape. " event.cli.input_processor.feed(KeyPress(Keys.Escape))
def custom_keybindings(bindings, **kw): from prompt_toolkit.filters import EmacsInsertMode, ViInsertMode from xonsh.ptk_shell.key_bindings import carriage_return handler = bindings.add insert_mode = ViInsertMode() | EmacsInsertMode() abbrev = Abbreviation() @handler(" ", filter=IsMultiline() & insert_mode) def handle_space(event): buffer = event.app.current_buffer add_space = True if not abbrev.revert(buffer): position_changed = abbrev.expand(buffer) if position_changed: add_space = False if add_space: buffer.insert_text(" ") @handler(Keys.ControlJ, filter=IsMultiline() & insert_mode & ~completion_is_selected) @handler(Keys.ControlM, filter=IsMultiline() & insert_mode & ~completion_is_selected) def multiline_carriage_return(event): buffer = event.app.current_buffer current_char = buffer.document.current_char if not current_char or current_char.isspace(): abbrev.expand(buffer) carriage_return(buffer, event.cli)
def custom_keybindings(bindings, **kw): from xonsh2.ptk_shell.key_bindings import carriage_return from prompt_toolkit.filters import EmacsInsertMode, ViInsertMode handler = bindings.add insert_mode = ViInsertMode() | EmacsInsertMode() @handler(" ", filter=IsMultiline() & insert_mode) def handle_space(event): buffer = event.app.current_buffer if not revert_abbrev(buffer): expand_abbrev(buffer) if last_expanded is None or not set_cursor_position(buffer): buffer.insert_text(" ") @handler(Keys.ControlJ, filter=IsMultiline() & insert_mode & ~completion_is_selected) @handler(Keys.ControlM, filter=IsMultiline() & insert_mode & ~completion_is_selected) def multiline_carriage_return(event): buffer = event.app.current_buffer current_char = buffer.document.current_char if not current_char or current_char.isspace(): expand_abbrev(buffer) carriage_return(buffer, event.cli)
def custom_keybindings(bindings, **kw): if ptk_shell_type() == "prompt_toolkit2": from xonsh.ptk2.key_bindings import carriage_return from prompt_toolkit.filters import EmacsInsertMode, ViInsertMode handler = bindings.add insert_mode = ViInsertMode() | EmacsInsertMode() else: from xonsh.ptk.key_bindings import carriage_return from prompt_toolkit.filters import to_filter handler = bindings.registry.add_binding insert_mode = to_filter(True) @handler(" ", filter=IsMultiline() & insert_mode) def handle_space(event): buffer = event.app.current_buffer expand_abbrev(buffer) buffer.insert_text(" ") @handler( Keys.ControlJ, filter=IsMultiline() & insert_mode & ~completion_is_selected ) @handler( Keys.ControlM, filter=IsMultiline() & insert_mode & ~completion_is_selected ) def multiline_carriage_return(event): buffer = event.app.current_buffer current_char = buffer.document.current_char if not current_char or current_char.isspace(): expand_abbrev(buffer) carriage_return(buffer, event.cli)
def test_prefix_meta(): # Test the prefix-meta command. b = KeyBindings() b.add('j', 'j', filter=ViInsertMode())(prefix_meta) result, cli = _feed_cli_with_input( 'hellojjIX\r', key_bindings=b, editing_mode=EditingMode.VI) assert result.text == 'Xhello'
def configure(repl): """ Configuration method. This is called during the start-up of ptpython. :param repl: `PythonRepl` instance. """ # Vi mode. repl.vi_mode = True repl.vi_start_in_navigation_mode = True repl.vi_keep_last_used_mode = True # History Search. # When True, going back in history will filter the history on the records # starting with the current input. (Like readline.) # Note: When enable, please disable the `complete_while_typing` option. # otherwise, when there is a completion available, the arrows will # browse through the available completions instead of the history. repl.enable_history_search = False # Enable open-in-editor. Pressing C-X C-E in emacs mode or 'v' in # Vi navigation mode will open the input in the current editor. repl.enable_open_in_editor = True # Ask for confirmation on exit. repl.confirm_exit = False # Enable input validation. (Don't try to execute when the input contains # syntax errors.) repl.enable_input_validation = True # Set colour scheme for hotkey window if os.environ.get("ITERM_PROFILE") == "Hotkey Window": repl.use_code_colorscheme("paraiso-dark") # Use C-K, C-J to navigate history in the Insert mode @repl.add_key_binding(Keys.ControlK, filter=ViInsertMode()) def _(event): event.current_buffer.auto_up() @repl.add_key_binding(Keys.ControlJ, filter=ViInsertMode()) def _(event): event.current_buffer.auto_down()
def configure(repl): # Vi mode. repl.vi_mode = True # Show function signature (bool). repl.show_signature = True # Highlight matching parethesis. repl.highlight_matching_parenthesis = True # Colorscheme repl.use_code_colorscheme('monokai') @repl.add_key_binding('k', 'j', filter=ViInsertMode()) def _(event): " Map 'kj' to Escape. " event.cli.key_processor.feed(KeyPress(Keys.Escape)) @repl.add_key_binding('j', 'k', filter=ViInsertMode()) def _(event): " Map 'kj' to Escape. " event.cli.key_processor.feed(KeyPress(Keys.Escape))
def custom_keybindings(bindings, **kw): handler = bindings.registry.add_binding insert_mode = ViInsertMode() | EmacsInsertMode() @Condition def last_command_exists(cli): return len(__xonsh_history__) > 0 @handler(Keys.Escape, '.', filter=last_command_exists & insert_mode) def recall_last_arg(event): arg = __xonsh_history__[-1].cmd.split()[-1] event.current_buffer.insert_text(arg)
def load_bindings(key_bindings_manager): handle = key_bindings_manager.registry.add_binding has_selection = HasSelection() @key_bindings_manager.registry.add_binding(Keys.ControlL)#, eager=True) def clear_(event): clear() print(env.welcome) PROMPT = env.prompt PROMPT = PROMPT.replace(r"\u", env.user).replace(r"\w", env.directory) print(unicode_(PROMPT), end="") @key_bindings_manager.registry.add_binding(Keys.ControlB) def list_(event): print("\n".join(ls(env, [], {}))) PROMPT = env.prompt PROMPT = PROMPT.replace(r"\u", env.user).replace(r"\w", env.directory) print(env.default_color, end="") print(unicode_(PROMPT), end="") @handle(Keys.ControlJ, filter= ~has_selection & (ViInsertMode() | EmacsInsertMode()) & HasFocus(DEFAULT_BUFFER) & IsMultiline()) def _(event): """ Behaviour of the Enter key. Auto indent after newline/Enter. (When not in Vi navigaton mode, and when multiline is enabled.) """ b = event.current_buffer empty_lines_required = 2 def at_the_end(b): """ we consider the cursor at the end when there is no text after the cursor, or only whitespace. """ text = b.document.text_after_cursor return text == '' or (text.isspace() and not '\n' in text) if at_the_end(b) and (b.document.text.replace(' ', '').endswith('\n' * (empty_lines_required - 1)) or (b.document.text.replace("\n", "").endswith(";"))): # When the cursor is at the end, and we have an empty line: # drop the empty lines, but return the value. b.document = Document( text=b.text.rstrip(), cursor_position=len(b.text.rstrip())) b.accept_action.validate_and_handle(event.cli, b) else: _auto_newline(b)
def custom_keybindings(bindings, **kw): if ptk_shell_type() == "prompt_toolkit2": handler = bindings.add else: handler = bindings.registry.add_binding insert_mode = ViInsertMode() | EmacsInsertMode() @Condition def last_command_exists(): return len(__xonsh__.history) > 0 @handler(Keys.Escape, ".", filter=last_command_exists & insert_mode) def recall_last_arg(event): arg = __xonsh__.history[-1].cmd.split()[-1] event.current_buffer.insert_text(arg)
def load_ipython_extension(ip): insert_mode = ViInsertMode() | EmacsInsertMode() def insert_unexpected(event): # buf = event.current_buffer # buf.insert_text("view(_)") # get_by_name('accept-line').handler(event) view(ip.user_ns['_']) # Register the shortcut if IPython is using prompt_toolkit if getattr(ip, "pt_app", None): registry = ip.pt_app.key_bindings registry.add_binding( Keys.ControlT, filter=(HasFocus(DEFAULT_BUFFER) & ~HasSelection() & insert_mode) )(insert_unexpected)
def pt_init(self): def get_prompt_tokens(cli): return [(Token.Prompt, self.prompt)] def patch_stdout(**kwargs): return self.pt_cli.patch_stdout_context(**kwargs) if self._ptcomp is None: compl = IPCompleter( shell=self.shell, namespace={}, global_namespace={}, use_readline=False, parent=self.shell, ) self._ptcomp = IPythonPTCompleter(compl, patch_stdout=patch_stdout) kbmanager = KeyBindingManager.for_prompt() supports_suspend = Condition(lambda cli: hasattr(signal, 'SIGTSTP')) kbmanager.registry.add_binding(Keys.ControlZ, filter=supports_suspend)(suspend_to_bg) if self.shell.display_completions == 'readlinelike': kbmanager.registry.add_binding( Keys.ControlI, filter=(HasFocus(DEFAULT_BUFFER) & ~HasSelection() & ViInsertMode() | EmacsInsertMode() & ~cursor_in_leading_ws ))(display_completions_like_readline) multicolumn = (self.shell.display_completions == 'multicolumn') self._pt_app = create_prompt_application( editing_mode=getattr(EditingMode, self.shell.editing_mode.upper()), key_bindings_registry=kbmanager.registry, history=self.shell.debugger_history, completer=self._ptcomp, enable_history_search=True, mouse_support=self.shell.mouse_support, get_prompt_tokens=get_prompt_tokens, display_completions_in_columns=multicolumn, ) self.pt_cli = CommandLineInterface(self._pt_app, eventloop=self.shell._eventloop)
def __custom_keybindings(bindings, **kw): handler = bindings.add insert_mode = ViInsertMode() @handler(Keys.ControlW) def __ctrl_w(event): buf = event.current_buffer # type: prompt_toolkit.buffer.Buffer text = buf.text[:buf.cursor_position] # type: str m = re.search(r"[/,.=\-\s][^/,.=\-\s]+[/,.=\-\s]?$", text) if m is not None: buf.delete_before_cursor(len(text) - m.start() - 1) return buf.delete_before_cursor(len(text)) @handler(Keys.ControlK) def __ctrl_k(event): if event.current_buffer.suggestion: event.current_buffer.insert_text( event.current_buffer.suggestion.text) @handler(Keys.ControlR, filter=insert_mode) def __ctrl_r_event(event): ctrl_r.select(event.current_buffer)
def parse_vim_mapping(vim_mapping): """Parses a single mapping string""" mapping_regex = r'^\s*(?P<mode>[inv])?map (?P<input>{key}+) (?P<output>{key}+)\s*$'.format( key=KEY_REGEX) mapping_match = re.search(mapping_regex, vim_mapping) if mapping_match is None: raise VimScriptSyntaxError( "The provided string is not a valid vim mapping") mode_letter = mapping_match.group('mode') if mode_letter == 'i': mode = ViInsertMode() elif mode_letter == 'n': mode = ViNavigationMode() elif mode_letter == 'v': mode = ViSelectionMode() else: mode = ViMode() input = mapping_match.group('input') output = mapping_match.group('output') return VimMapping(input, output, mode)
def configure(repl): """ Configuration method. This is called during the start-up of ptpython. :param repl: `PythonRepl` instance. """ repl.enable_mouse_support = True repl.vi_mode = True # Enable open-in-editor. Pressing C-X C-E in emacs mode or 'v' in # Vi navigation mode will open the input in the current editor. repl.enable_open_in_editor = True repl.confirm_exit = False repl.use_code_colorscheme('paraiso-dark') # Typing 'jk' in Vi Insert mode, should send escape. (Go back to navigation # mode.) @repl.add_key_binding('j', 'k', filter=ViInsertMode()) def _(event): " Map 'jk' to Escape. " event.cli.key_processor.feed(KeyPress(Keys.Escape))
def init_prompt_toolkit_cli(self): self._app = None if self.simple_prompt: # Fall back to plain non-interactive output for tests. # This is very limited, and only accepts a single line. def prompt(): return cast_unicode_py2( input('In [%d]: ' % self.execution_count)) self.prompt_for_code = prompt return kbmanager = KeyBindingManager.for_prompt() insert_mode = ViInsertMode() | EmacsInsertMode() # Ctrl+J == Enter, seemingly @kbmanager.registry.add_binding(Keys.ControlJ, filter=(HasFocus(DEFAULT_BUFFER) & ~HasSelection() & insert_mode)) def _(event): 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 not (d.on_last_line or d.cursor_position_row >= d.line_count - d.empty_line_count_at_the_end()): b.newline() return status, indent = self.input_splitter.check_complete(d.text + '\n') if (status != 'incomplete') and b.accept_action.is_returnable: b.accept_action.validate_and_handle(event.cli, b) else: b.insert_text('\n' + (' ' * (indent or 0))) @kbmanager.registry.add_binding(Keys.ControlP, filter=(ViInsertMode() & HasFocus(DEFAULT_BUFFER))) 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() @kbmanager.registry.add_binding(Keys.ControlN, filter=(ViInsertMode() & HasFocus(DEFAULT_BUFFER))) 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() @kbmanager.registry.add_binding(Keys.ControlG, filter=(HasFocus(DEFAULT_BUFFER) & HasCompletions())) def _dismiss_completion(event): b = event.current_buffer if b.complete_state: b.cancel_completion() @kbmanager.registry.add_binding(Keys.ControlC, filter=HasFocus(DEFAULT_BUFFER)) def _reset_buffer(event): b = event.current_buffer if b.complete_state: b.cancel_completion() else: b.reset() @kbmanager.registry.add_binding(Keys.ControlC, filter=HasFocus(SEARCH_BUFFER)) def _reset_search_buffer(event): if event.current_buffer.document.text: event.current_buffer.reset() else: event.cli.push_focus(DEFAULT_BUFFER) supports_suspend = Condition(lambda cli: hasattr(signal, 'SIGTSTP')) @kbmanager.registry.add_binding(Keys.ControlZ, filter=supports_suspend) def _suspend_to_bg(event): event.cli.suspend_to_background() @Condition def cursor_in_leading_ws(cli): before = cli.application.buffer.document.current_line_before_cursor return (not before) or before.isspace() # Ctrl+I == Tab @kbmanager.registry.add_binding(Keys.ControlI, filter=(HasFocus(DEFAULT_BUFFER) & ~HasSelection() & insert_mode & cursor_in_leading_ws)) def _indent_buffer(event): event.current_buffer.insert_text(' ' * 4) if self.display_completions == 'readlinelike': @kbmanager.registry.add_binding(Keys.ControlI, filter=(HasFocus(DEFAULT_BUFFER) & ~HasSelection() & insert_mode & ~cursor_in_leading_ws)) def _disaply_compl(ev): display_completions_like_readline(ev) if sys.platform == 'win32': from IPython.lib.clipboard import (ClipboardEmpty, win32_clipboard_get, tkinter_clipboard_get) @kbmanager.registry.add_binding(Keys.ControlV, filter=(HasFocus(DEFAULT_BUFFER) & ~ViMode())) def _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)) # Pre-populate history from IPython's history database history = InMemoryHistory() last_cell = u"" for __, ___, cell in self.history_manager.get_tail( self.history_load_length, include_latest=True): # Ignore blank lines and consecutive duplicates cell = cell.rstrip() if cell and (cell != last_cell): history.append(cell) self._style = self._make_style_from_name(self.highlighting_style) style = DynamicStyle(lambda: self._style) editing_mode = getattr(EditingMode, self.editing_mode.upper()) self._app = create_prompt_application( editing_mode=editing_mode, key_bindings_registry=kbmanager.registry, history=history, completer=IPythonPTCompleter(self.Completer), enable_history_search=True, style=style, mouse_support=self.mouse_support, **self._layout_options()) self._eventloop = create_eventloop(self.inputhook) self.pt_cli = CommandLineInterface(self._app, eventloop=self._eventloop)
def init_prompt_toolkit_cli(self): if ('IPY_TEST_SIMPLE_PROMPT' in os.environ) or not sys.stdin.isatty(): # Fall back to plain non-interactive output for tests. # This is very limited, and only accepts a single line. def prompt(): return cast_unicode_py2( input('In [%d]: ' % self.execution_count)) self.prompt_for_code = prompt return kbmanager = KeyBindingManager.for_prompt() insert_mode = ViInsertMode() | EmacsInsertMode() # Ctrl+J == Enter, seemingly @kbmanager.registry.add_binding(Keys.ControlJ, filter=(HasFocus(DEFAULT_BUFFER) & ~HasSelection() & insert_mode)) def _(event): b = event.current_buffer d = b.document if not (d.on_last_line or d.cursor_position_row >= d.line_count - d.empty_line_count_at_the_end()): b.newline() return status, indent = self.input_splitter.check_complete(d.text) if (status != 'incomplete') and b.accept_action.is_returnable: b.accept_action.validate_and_handle(event.cli, b) else: b.insert_text('\n' + (' ' * (indent or 0))) @kbmanager.registry.add_binding(Keys.ControlC, filter=HasFocus(DEFAULT_BUFFER)) def _reset_buffer(event): event.current_buffer.reset() @kbmanager.registry.add_binding(Keys.ControlC, filter=HasFocus(SEARCH_BUFFER)) def _reset_search_buffer(event): if event.current_buffer.document.text: event.current_buffer.reset() else: event.cli.push_focus(DEFAULT_BUFFER) supports_suspend = Condition(lambda cli: hasattr(signal, 'SIGTSTP')) @kbmanager.registry.add_binding(Keys.ControlZ, filter=supports_suspend) def _suspend_to_bg(event): event.cli.suspend_to_background() @Condition def cursor_in_leading_ws(cli): before = cli.application.buffer.document.current_line_before_cursor return (not before) or before.isspace() # Ctrl+I == Tab @kbmanager.registry.add_binding(Keys.ControlI, filter=(HasFocus(DEFAULT_BUFFER) & ~HasSelection() & insert_mode & cursor_in_leading_ws)) def _indent_buffer(event): event.current_buffer.insert_text(' ' * 4) # Pre-populate history from IPython's history database history = InMemoryHistory() last_cell = u"" for __, ___, cell in self.history_manager.get_tail( self.history_load_length, include_latest=True): # Ignore blank lines and consecutive duplicates cell = cell.rstrip() if cell and (cell != last_cell): history.append(cell) self._style = self._make_style_from_name(self.highlighting_style) style = DynamicStyle(lambda: self._style) editing_mode = getattr(EditingMode, self.editing_mode.upper()) self._app = create_prompt_application( editing_mode=editing_mode, key_bindings_registry=kbmanager.registry, history=history, completer=IPythonPTCompleter(self.Completer), enable_history_search=True, style=style, mouse_support=self.mouse_support, **self._layout_options()) self._eventloop = create_eventloop(self.inputhook) self.pt_cli = CommandLineInterface(self._app, eventloop=self._eventloop)
from IPython import get_ipython from prompt_toolkit.enums import DEFAULT_BUFFER from prompt_toolkit.filters import HasFocus, ViInsertMode from prompt_toolkit.key_binding.vi_state import InputMode from prompt_toolkit.keys import Keys from prompt_toolkit.key_binding.bindings import named_commands ip = get_ipython() registry = ip.pt_app.key_bindings # Control ## A registry.add_binding(Keys.ControlA, filter=(HasFocus(DEFAULT_BUFFER) & ViInsertMode()))( named_commands.beginning_of_line) ## B registry.add_binding(Keys.ControlB, filter=(HasFocus(DEFAULT_BUFFER) & ViInsertMode()))( named_commands.backward_char) ## D already works ## E registry.add_binding(Keys.ControlE, filter=(HasFocus(DEFAULT_BUFFER) & ViInsertMode()))( named_commands.end_of_line) ## F
def configure(repl): """ Configuration method. This is called during the start-up of ptpython. :param repl: `PythonRepl` instance. """ # Show function signature (bool). repl.show_signature = True # Show docstring (bool). repl.show_docstring = False # Show the "[Meta+Enter] Execute" message when pressing [Enter] only # inserts a newline instead of executing the code. repl.show_meta_enter_message = True # Show completions. (NONE, POP_UP, MULTI_COLUMN or TOOLBAR) repl.completion_visualisation = CompletionVisualisation.POP_UP # When CompletionVisualisation.POP_UP has been chosen, use this # scroll_offset in the completion menu. repl.completion_menu_scroll_offset = 0 # Show line numbers (when the input contains multiple lines.) repl.show_line_numbers = True # Show status bar. repl.show_status_bar = True # When the sidebar is visible, also show the help text. repl.show_sidebar_help = True # Swap light/dark colors on or off repl.swap_light_and_dark = False # Highlight matching parethesis. repl.highlight_matching_parenthesis = True # Line wrapping. (Instead of horizontal scrolling.) repl.wrap_lines = True # Mouse support. repl.enable_mouse_support = True # Complete while typing. (Don't require tab before the # completion menu is shown.) repl.complete_while_typing = True # Fuzzy and dictionary completion. repl.enable_fuzzy_completion = True repl.enable_dictionary_completion = True # Vi mode. repl.vi_mode = True # Paste mode. (When True, don't insert whitespace after new line.) repl.paste_mode = False # Use the classic prompt. (Display '>>>' instead of 'In [1]'.) repl.prompt_style = "ipython" # 'classic' or 'ipython' # Don't insert a blank line after the output. repl.insert_blank_line_after_output = False # History Search. # When True, going back in history will filter the history on the records # starting with the current input. (Like readline.) # Note: When enable, please disable the `complete_while_typing` option. # otherwise, when there is a completion available, the arrows will # browse through the available completions instead of the history. repl.enable_history_search = False # Enable auto suggestions. (Pressing right arrow will complete the input, # based on the history.) repl.enable_auto_suggest = False # Enable open-in-editor. Pressing C-x C-e in emacs mode or 'v' in # Vi navigation mode will open the input in the current editor. repl.enable_open_in_editor = True # Enable system prompt. Pressing meta-! will display the system prompt. # Also enables Control-Z suspend. repl.enable_system_bindings = True # Ask for confirmation on exit. repl.confirm_exit = True # Enable input validation. (Don't try to execute when the input contains # syntax errors.) repl.enable_input_validation = True # Use this colorscheme for the code. repl.use_code_colorscheme("inkpot") # Set color depth (keep in mind that not all terminals support true color). # repl.color_depth = 'DEPTH_1_BIT' # Monochrome. # repl.color_depth = 'DEPTH_4_BIT' # ANSI colors only. # repl.color_depth = "DEPTH_8_BIT" # The default, 256 colors. repl.color_depth = 'DEPTH_24_BIT' # True color. # Syntax. repl.enable_syntax_highlighting = True @repl.add_key_binding('j', 'j', filter=ViInsertMode()) def _(event): " Map 'jj' to Escape. " event.cli.key_processor.feed(KeyPress(Keys.Escape))
def configure(repl): """ Configuration method. This is called during the start-up of ptpython. :param repl: `PythonRepl` instance. """ # Show function signature (bool). repl.show_signature = True # Show docstring (bool). repl.show_docstring = True # Show the "[Meta+Enter] Execute" message when pressing [Enter] only # inserts a newline instead of executing the code. repl.show_meta_enter_message = True # Show completions. (NONE, POP_UP, MULTI_COLUMN or TOOLBAR) repl.completion_visualisation = CompletionVisualisation.POP_UP # When CompletionVisualisation.POP_UP has been chosen, use this # scroll_offset in the completion menu. repl.completion_menu_scroll_offset = 0 # Show line numbers (when the input contains multiple lines.) repl.show_line_numbers = False # Show status bar. repl.show_status_bar = True # When the sidebar is visible, also show the help text. repl.show_sidebar_help = True # Swap light/dark colors on or off repl.swap_light_and_dark = False # Highlight matching parethesis. repl.highlight_matching_parenthesis = True # Line wrapping. (Instead of horizontal scrolling.) repl.wrap_lines = True # Mouse support. repl.enable_mouse_support = True # Complete while typing. (Don't require tab before the # completion menu is shown.) repl.complete_while_typing = True # Fuzzy and dictionary completion. repl.enable_fuzzy_completion = True repl.enable_dictionary_completion = True # Vi mode. repl.vi_mode = True # Paste mode. (When True, don't insert whitespace after new line.) repl.paste_mode = False # Use the classic prompt. (Display '>>>' instead of 'In [1]'.) repl.prompt_style = "ipython" # 'classic' or 'ipython' # Don't insert a blank line after the output. repl.insert_blank_line_after_output = False # History Search. # When True, going back in history will filter the history on the records # starting with the current input. (Like readline.) # Note: When enable, please disable the `complete_while_typing` option. # otherwise, when there is a completion available, the arrows will # browse through the available completions instead of the history. repl.enable_history_search = True # Enable auto suggestions. (Pressing right arrow will complete the input, # based on the history.) repl.enable_auto_suggest = True # Enable open-in-editor. Pressing C-x C-e in emacs mode or 'v' in # Vi navigation mode will open the input in the current editor. repl.enable_open_in_editor = True # Enable system prompt. Pressing meta-! will display the system prompt. # Also enables Control-Z suspend. repl.enable_system_bindings = True # Ask for confirmation on exit. repl.confirm_exit = True # Enable input validation. (Don't try to execute when the input contains # syntax errors.) repl.enable_input_validation = True # Use this colorscheme for the code. repl.use_code_colorscheme("gruvbox-dark") # repl.use_code_colorscheme("pastie") # Set color depth (keep in mind that not all terminals support true color). # repl.color_depth = "DEPTH_1_BIT" # Monochrome. # repl.color_depth = "DEPTH_4_BIT" # ANSI colors only. # repl.color_depth = "DEPTH_8_BIT" # The default, 256 colors. repl.color_depth = "DEPTH_24_BIT" # True color. # Min/max brightness repl.min_brightness = 0.0 # Increase for dark terminal backgrounds. repl.max_brightness = 1.0 # Decrease for light terminal backgrounds. # Syntax. repl.enable_syntax_highlighting = True # Get into Vi navigation mode at startup repl.vi_start_in_navigation_mode = False # Preserve last used Vi input mode between main loop iterations repl.vi_keep_last_used_mode = False # Install custom colorscheme named 'my-colorscheme' and use it. """ repl.install_ui_colorscheme("my-colorscheme", Style.from_dict(_custom_ui_colorscheme)) repl.use_ui_colorscheme("my-colorscheme") """ # Add custom key binding for PDB. """ @repl.add_key_binding("c-b") def _(event): " Pressing Control-B will insert "pdb.set_trace()" " event.cli.current_buffer.insert_text("\nimport pdb; pdb.set_trace()\n") """ # Typing ControlE twice should also execute the current command. # (Alternative for Meta-Enter.) """ @repl.add_key_binding("c-e", "c-e") def _(event): event.current_buffer.validate_and_handle() """ # Typing 'jj' in Vi Insert mode, should send escape. (Go back to navigation # mode.) @repl.add_key_binding("e", "u", filter=ViInsertMode()) def _(event): " Map 'eu' to Escape. " event.cli.key_processor.feed(KeyPress(Keys("escape"))) # Custom key binding for some simple autocorrection while typing. """ corrections = { "impotr": "import", "pritn": "print", } @repl.add_key_binding(" ") def _(event): " When a space is pressed. Check & correct word before cursor. " b = event.cli.current_buffer w = b.document.get_word_before_cursor() if w is not None: if w in corrections: b.delete_before_cursor(count=len(w)) b.insert_text(corrections[w]) b.insert_text(" ") """ # Add a custom title to the status bar. This is useful when ptpython is # embedded in other applications. """
def load_basic_bindings(): registry = Registry() insert_mode = ViInsertMode() | EmacsInsertMode() handle = registry.add_binding has_selection = HasSelection() @handle(Keys.ControlA) @handle(Keys.ControlB) @handle(Keys.ControlC) @handle(Keys.ControlD) @handle(Keys.ControlE) @handle(Keys.ControlF) @handle(Keys.ControlG) @handle(Keys.ControlH) @handle(Keys.ControlI) @handle(Keys.ControlJ) @handle(Keys.ControlK) @handle(Keys.ControlL) @handle(Keys.ControlM) @handle(Keys.ControlN) @handle(Keys.ControlO) @handle(Keys.ControlP) @handle(Keys.ControlQ) @handle(Keys.ControlR) @handle(Keys.ControlS) @handle(Keys.ControlT) @handle(Keys.ControlU) @handle(Keys.ControlV) @handle(Keys.ControlW) @handle(Keys.ControlX) @handle(Keys.ControlY) @handle(Keys.ControlZ) @handle(Keys.F1) @handle(Keys.F2) @handle(Keys.F3) @handle(Keys.F4) @handle(Keys.F5) @handle(Keys.F6) @handle(Keys.F7) @handle(Keys.F8) @handle(Keys.F9) @handle(Keys.F10) @handle(Keys.F11) @handle(Keys.F12) @handle(Keys.F13) @handle(Keys.F14) @handle(Keys.F15) @handle(Keys.F16) @handle(Keys.F17) @handle(Keys.F18) @handle(Keys.F19) @handle(Keys.F20) @handle(Keys.ControlSpace) @handle(Keys.ControlBackslash) @handle(Keys.ControlSquareClose) @handle(Keys.ControlCircumflex) @handle(Keys.ControlUnderscore) @handle(Keys.Backspace) @handle(Keys.Up) @handle(Keys.Down) @handle(Keys.Right) @handle(Keys.Left) @handle(Keys.ShiftUp) @handle(Keys.ShiftDown) @handle(Keys.ShiftRight) @handle(Keys.ShiftLeft) @handle(Keys.Home) @handle(Keys.End) @handle(Keys.Delete) @handle(Keys.ShiftDelete) @handle(Keys.ControlDelete) @handle(Keys.PageUp) @handle(Keys.PageDown) @handle(Keys.BackTab) @handle(Keys.Tab) @handle(Keys.ControlLeft) @handle(Keys.ControlRight) @handle(Keys.ControlUp) @handle(Keys.ControlDown) @handle(Keys.Insert) @handle(Keys.Ignore) def _(event): """ First, for any of these keys, Don't do anything by default. Also don't catch them in the 'Any' handler which will insert them as data. If people want to insert these characters as a literal, they can always do by doing a quoted insert. (ControlQ in emacs mode, ControlV in Vi mode.) """ pass # Readline-style bindings. handle(Keys.Home)(get_by_name('beginning-of-line')) handle(Keys.End)(get_by_name('end-of-line')) handle(Keys.Left)(get_by_name('backward-char')) handle(Keys.Right)(get_by_name('forward-char')) handle(Keys.ControlUp)(get_by_name('previous-history')) handle(Keys.ControlDown)(get_by_name('next-history')) handle(Keys.ControlL)(get_by_name('clear-screen')) handle(Keys.ControlK, filter=insert_mode)(get_by_name('kill-line')) handle(Keys.ControlU, filter=insert_mode)(get_by_name('unix-line-discard')) handle(Keys.ControlH, filter=insert_mode, save_before=if_no_repeat)( get_by_name('backward-delete-char')) handle(Keys.Backspace, filter=insert_mode, save_before=if_no_repeat)( get_by_name('backward-delete-char')) handle(Keys.Delete, filter=insert_mode, save_before=if_no_repeat)( get_by_name('delete-char')) handle(Keys.ShiftDelete, filter=insert_mode, save_before=if_no_repeat)( get_by_name('delete-char')) handle(Keys.Any, filter=insert_mode, save_before=if_no_repeat)( get_by_name('self-insert')) handle(Keys.ControlT, filter=insert_mode)(get_by_name('transpose-chars')) handle(Keys.ControlW, filter=insert_mode)(get_by_name('unix-word-rubout')) handle(Keys.ControlI, filter=insert_mode)(get_by_name('menu-complete')) handle(Keys.BackTab, filter=insert_mode)(get_by_name('menu-complete-backward')) handle(Keys.PageUp, filter= ~has_selection)(get_by_name('previous-history')) handle(Keys.PageDown, filter= ~has_selection)(get_by_name('next-history')) # CTRL keys. text_before_cursor = Condition(lambda cli: cli.current_buffer.text) handle(Keys.ControlD, filter=text_before_cursor & insert_mode)(get_by_name('delete-char')) is_multiline = Condition(lambda cli: cli.current_buffer.is_multiline()) is_returnable = Condition(lambda cli: cli.current_buffer.accept_action.is_returnable) @handle(Keys.ControlJ, filter=is_multiline & insert_mode) def _(event): " Newline (in case of multiline input. " event.current_buffer.newline(copy_margin=not event.cli.in_paste_mode) @handle(Keys.ControlJ, filter=~is_multiline & is_returnable) def _(event): " Enter, accept input. " buff = event.current_buffer buff.accept_action.validate_and_handle(event.cli, buff) # Delete the word before the cursor. @handle(Keys.Up) def _(event): event.current_buffer.auto_up(count=event.arg) @handle(Keys.Down) def _(event): event.current_buffer.auto_down(count=event.arg) @handle(Keys.Delete, filter=has_selection) def _(event): data = event.current_buffer.cut_selection() event.cli.clipboard.set_data(data) # Global bindings. @handle(Keys.ControlZ) def _(event): """ By default, control-Z should literally insert Ctrl-Z. (Ansi Ctrl-Z, code 26 in MSDOS means End-Of-File. In a Python REPL for instance, it's possible to type Control-Z followed by enter to quit.) When the system bindings are loaded and suspend-to-background is supported, that will override this binding. """ event.current_buffer.insert_text(event.data) @handle(Keys.CPRResponse, save_before=lambda e: False) def _(event): """ Handle incoming Cursor-Position-Request response. """ # The incoming data looks like u'\x1b[35;1R' # Parse row/col information. row, col = map(int, event.data[2:-1].split(';')) # Report absolute cursor position to the renderer. event.cli.renderer.report_absolute_cursor_row(row) @handle(Keys.BracketedPaste) def _(event): " Pasting from clipboard. " data = event.data # Be sure to use \n as line ending. # Some terminals (Like iTerm2) seem to paste \r\n line endings in a # bracketed paste. See: https://github.com/ipython/ipython/issues/9737 data = data.replace('\r\n', '\n') data = data.replace('\r', '\n') event.current_buffer.insert_text(data) @handle(Keys.Any, filter=Condition(lambda cli: cli.quoted_insert), eager=True) def _(event): """ Handle quoted insert. """ event.current_buffer.insert_text(event.data, overwrite=False) event.cli.quoted_insert = False return registry
from IPython import get_ipython from prompt_toolkit.enums import DEFAULT_BUFFER from prompt_toolkit.filters import HasFocus, ViInsertMode from prompt_toolkit.key_binding.vi_state import InputMode ip = get_ipython() if getattr(ip, 'pt_app'): kbs = ip.pt_app.key_bindings @kbs.add(u'j', u'j', filter=(HasFocus(DEFAULT_BUFFER) & ViInsertMode())) def _(event): vi_state = event.cli.vi_state vi_state.input_mode = InputMode.NAVIGATION
def configure(repl): """ Configuration method. This is called during the start-up of ptpython. :param repl: `PythonRepl` instance. """ # Show function signature (bool). repl.show_signature = True # Show docstring (bool). repl.show_docstring = True # Show the "[Meta+Enter] Execute" message when pressing [Enter] only # inserts a newline instead of executing the code. repl.show_meta_enter_message = True # Show completions. (NONE, POP_UP, MULTI_COLUMN or TOOLBAR) repl.completion_visualisation = CompletionVisualisation.MULTI_COLUMN # When CompletionVisualisation.POP_UP has been chosen, use this # scroll_offset in the completion menu. repl.completion_menu_scroll_offset = 0 # Show line numbers (when the input contains multiple lines.) repl.show_line_numbers = True # Show status bar. repl.show_status_bar = True # When the sidebar is visible, also show the help text. repl.show_sidebar_help = True # Highlight matching parethesis. repl.highlight_matching_parenthesis = True # Line wrapping. (Instead of horizontal scrolling.) repl.wrap_lines = True # Mouse support. repl.enable_mouse_support = False # Complete while typing. (Don't require tab before the # completion menu is shown.) repl.complete_while_typing = True # Vi mode. repl.vi_mode = True # Paste mode. (When True, don't insert whitespace after new line.) repl.paste_mode = False # Use the classic prompt. (Display '>>>' instead of 'In [1]'.) repl.prompt_style = 'classic' # 'classic' or 'ipython' # Don't insert a blank line after the output. repl.insert_blank_line_after_output = False # History Search. # When True, going back in history will filter the history on the records # starting with the current input. (Like readline.) # Note: When enable, please disable the `complete_while_typing` option. # otherwise, when there is a completion available, the arrows will # browse through the available completions instead of the history. repl.enable_history_search = False # Enable auto suggestions. (Pressing right arrow will complete the input, # based on the history.) repl.enable_auto_suggest = False # Enable open-in-editor. Pressing C-X C-E in emacs mode or 'v' in # Vi navigation mode will open the input in the current editor. repl.enable_open_in_editor = False # Enable system prompt. Pressing meta-! will display the system prompt. # Also enables Control-Z suspend. repl.enable_system_bindings = True # Ask for confirmation on exit. repl.confirm_exit = True # Enable input validation. (Don't try to execute when the input contains # syntax errors.) repl.enable_input_validation = True # Use this colorscheme for the code. repl.use_code_colorscheme('fruity') # Enable 24bit True color. (Not all terminals support this. -- maybe check # $TERM before changing.) repl.true_color = True # Install custom colorscheme named 'my-colorscheme' and use it. """ repl.install_ui_colorscheme('my-colorscheme', _custom_ui_colorscheme) repl.use_ui_colorscheme('my-colorscheme') """ # Add custom key binding for PDB. @repl.add_key_binding(Keys.ControlB) def _(event): ' Pressing Control-B will insert "pdb.set_trace()" ' event.cli.current_buffer.insert_text('\nimport pdb; pdb.set_trace()\n') # Typing 'jj' in Vi Insert mode, should send escape. (Go back to navigation # mode.) @repl.add_key_binding('j', 'j', filter=ViInsertMode()) def _(event): " Map 'jj' to Escape. " event.cli.input_processor.feed(KeyPress(Keys.Escape)) """
def init_prompt_toolkit_cli(self): if self.simple_prompt or ('JUPYTER_CONSOLE_TEST' in os.environ): # Simple restricted interface for tests so we can find prompts with # pexpect. Multi-line input not supported. def prompt(): return cast_unicode_py2( input('In [%d]: ' % self.execution_count)) self.prompt_for_code = prompt self.print_out_prompt = \ lambda: print('Out[%d]: ' % self.execution_count, end='') return kbmanager = KeyBindingManager.for_prompt() insert_mode = ViInsertMode() | EmacsInsertMode() # Ctrl+J == Enter, seemingly @kbmanager.registry.add_binding(Keys.ControlJ, filter=(HasFocus(DEFAULT_BUFFER) & ~HasSelection() & insert_mode)) def _(event): b = event.current_buffer d = b.document if not (d.on_last_line or d.cursor_position_row >= d.line_count - d.empty_line_count_at_the_end()): b.newline() return # Pressing enter flushes any pending display. This also ensures # the displayed execution_count is correct. self.handle_iopub() more, indent = self.check_complete(d.text) if (not more) and b.accept_action.is_returnable: b.accept_action.validate_and_handle(event.cli, b) else: b.insert_text('\n' + indent) @kbmanager.registry.add_binding(Keys.ControlC, filter=HasFocus(DEFAULT_BUFFER)) def _(event): event.current_buffer.reset() @kbmanager.registry.add_binding(Keys.ControlBackslash, filter=HasFocus(DEFAULT_BUFFER)) def _(event): raise EOFError # Pre-populate history from IPython's history database history = InMemoryHistory() last_cell = u"" for _, _, cell in self.history_manager.get_tail( self.history_load_length, include_latest=True): # Ignore blank lines and consecutive duplicates cell = cast_unicode_py2(cell.rstrip()) if cell and (cell != last_cell): history.append(cell) style_overrides = { Token.Prompt: '#009900', Token.PromptNum: '#00ff00 bold', Token.OutPrompt: '#ff2200', Token.OutPromptNum: '#ff0000 bold', } if self.highlighting_style: style_cls = get_style_by_name(self.highlighting_style) else: style_cls = get_style_by_name('default') # 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_overrides.update({ Token.Number: '#007700', Token.Operator: 'noinherit', Token.String: '#BB6622', Token.Name.Function: '#2080D0', Token.Name.Class: 'bold #2080D0', Token.Name.Namespace: 'bold #2080D0', }) style_overrides.update(self.highlighting_style_overrides) style = PygmentsStyle.from_defaults(pygments_style_cls=style_cls, style_dict=style_overrides) editing_mode = getattr(EditingMode, self.editing_mode.upper()) langinfo = self.kernel_info.get('language_info', {}) lexer = langinfo.get('pygments_lexer', langinfo.get('name', 'text')) app = create_prompt_application( multiline=True, editing_mode=editing_mode, lexer=PygmentsLexer(get_pygments_lexer(lexer)), get_prompt_tokens=self.get_prompt_tokens, get_continuation_tokens=self.get_continuation_tokens, key_bindings_registry=kbmanager.registry, history=history, completer=JupyterPTCompleter(self.Completer), enable_history_search=True, style=style, ) self._eventloop = create_eventloop() self.pt_cli = CommandLineInterface( app, eventloop=self._eventloop, output=create_output(true_color=self.true_color), )
def configure(repl): """ Configuration method. This is called during the start-up of ptpython. :param repl: `PythonRepl` instance. """ # Show function signature (bool). repl.show_signature = True # Show docstring (bool). repl.show_docstring = True # Show the "[Meta+Enter] Execute" message when pressing [Enter] only # inserts a newline instead of executing the code. repl.show_meta_enter_message = True # Show completions. (NONE, POP_UP, MULTI_COLUMN or TOOLBAR) repl.completion_visualisation = CompletionVisualisation.MULTI_COLUMN # When CompletionVisualisation.POP_UP has been chosen, use this # scroll_offset in the completion menu. # repl.completion_menu_scroll_offset = 0 # Show line numbers (when the input contains multiple lines.) repl.show_line_numbers = True # Show status bar. repl.show_status_bar = True # When the sidebar is visible, also show the help text. repl.show_sidebar_help = True # Swap light/dark colors on or off repl.swap_light_and_dark = True # Highlight matching parethesis. repl.highlight_matching_parenthesis = True # Line wrapping. (Instead of horizontal scrolling.) repl.wrap_lines = True # Mouse support. repl.enable_mouse_support = False # Complete while typing. (Don't require tab before the # completion menu is shown.) repl.complete_while_typing = False # Fuzzy and dictionary completion. repl.enable_fuzzy_completion = True repl.enable_dictionary_completion = False # Vi mode. repl.vi_mode = True # Paste mode. (When True, don't insert whitespace after new line.) repl.paste_mode = False # Use the classic prompt. (Display '>>>' instead of 'In [1]'.) repl.prompt_style = "ipython" # 'classic' or 'ipython' # Don't insert a blank line after the output. repl.insert_blank_line_after_output = False # History Search. # When True, going back in history will filter the history on the records # starting with the current input. (Like readline.) # Note: When enable, please disable the `complete_while_typing` option. # otherwise, when there is a completion available, the arrows will # browse through the available completions instead of the history. repl.enable_history_search = True # Enable auto suggestions. (Pressing right arrow will complete the input, # based on the history.) repl.enable_auto_suggest = True # Enable open-in-editor. Pressing C-x C-e in emacs mode or 'v' in # Vi navigation mode will open the input in the current editor. repl.enable_open_in_editor = True # Enable system prompt. Pressing meta-! will display the system prompt. # Also enables Control-Z suspend. repl.enable_system_bindings = True # Ask for confirmation on exit. repl.confirm_exit = True # Enable input validation. (Don't try to execute when the input contains # syntax errors.) repl.enable_input_validation = True # Use this colorscheme for the code. repl.use_code_colorscheme("paraiso-light") # pastie # Set color depth (keep in mind that not all terminals support true color). # repl.color_depth = 'DEPTH_1_BIT' # Monochrome. # repl.color_depth = 'DEPTH_4_BIT' # ANSI colors only. repl.color_depth = "DEPTH_8_BIT" # The default, 256 colors. # repl.color_depth = 'DEPTH_24_BIT' # True color. # Syntax. repl.enable_syntax_highlighting = True # Install custom colorscheme named 'my-colorscheme' and use it. # Custom colorscheme for the UI. See `ptpython/layout.py` and # `ptpython/style.py` for all possible tokens. """ _custom_ui_colorscheme = { # Blue prompt. Token.Layout.Prompt: "bg:#eeeeff #000000 bold", # Make the status toolbar red. Token.Toolbar.Status: "bg:#ff0000 #000000", } repl.install_ui_colorscheme('my-colorscheme', _custom_ui_colorscheme) repl.use_ui_colorscheme('my-colorscheme') """ # Add custom key binding for PDB. """ @repl.add_key_binding(Keys.ControlB) def _(event): ' Pressing Control-B will insert "pdb.set_trace()" ' event.cli.current_buffer.insert_text('\nimport pdb; pdb.set_trace()\n') """ # Typing ControlE twice should also execute the current command. # (Alternative for Meta-Enter.) """ @repl.add_key_binding(Keys.ControlE, Keys.ControlE) def _(event): event.current_buffer.validate_and_handle() """ @repl.add_key_binding('k', 'j', filter=ViInsertMode()) def _(event): " Map 'kj' to Escape. " event.cli.key_processor.feed(KeyPress(Keys.Escape)) # Custom key binding for some simple autocorrection while typing. corrections = { 'impotr': 'import', 'pritn': 'print', } @repl.add_key_binding(' ') def _(event): ' When a space is pressed. Check & correct word before cursor. ' b = event.cli.current_buffer w = b.document.get_word_before_cursor() if w is not None: if w in corrections: b.delete_before_cursor(count=len(w)) b.insert_text(corrections[w]) b.insert_text(' ')
def load_xonsh_bindings(key_bindings_manager): """ Load custom key bindings. """ handle = key_bindings_manager.registry.add_binding has_selection = HasSelection() insert_mode = ViInsertMode() | EmacsInsertMode() @handle(Keys.Tab, filter=tab_insert_indent) def insert_indent(event): """ If there are only whitespaces before current cursor position insert indent instead of autocompleting. """ event.cli.current_buffer.insert_text(env.get('INDENT')) @handle(Keys.ControlX, Keys.ControlE, filter=~has_selection) def open_editor(event): """ Open current buffer in editor """ event.current_buffer.open_in_editor(event.cli) @handle(Keys.BackTab, filter=insert_mode) def insert_literal_tab(event): """ Insert literal tab on Shift+Tab instead of autocompleting """ b = event.current_buffer if b.complete_state: b.complete_previous() else: event.cli.current_buffer.insert_text(env.get('INDENT')) @handle('(', filter=autopair_condition) def insert_right_parens(event): event.cli.current_buffer.insert_text('(') event.cli.current_buffer.insert_text(')', move_cursor=False) @handle(')', filter=autopair_condition) def overwrite_right_parens(event): buffer = event.cli.current_buffer if buffer.document.current_char == ')': buffer.cursor_position += 1 else: buffer.insert_text(')') @handle('[', filter=autopair_condition) def insert_right_bracket(event): event.cli.current_buffer.insert_text('[') event.cli.current_buffer.insert_text(']', move_cursor=False) @handle(']', filter=autopair_condition) def overwrite_right_bracket(event): buffer = event.cli.current_buffer if buffer.document.current_char == ']': buffer.cursor_position += 1 else: buffer.insert_text(']') @handle('\'', filter=autopair_condition) def insert_right_quote(event): buffer = event.cli.current_buffer if buffer.document.current_char == '\'': buffer.cursor_position += 1 else: buffer.insert_text('\'') buffer.insert_text('\'', move_cursor=False) @handle('"', filter=autopair_condition) def insert_right_double_quote(event): buffer = event.cli.current_buffer if buffer.document.current_char == '"': buffer.cursor_position += 1 else: buffer.insert_text('"') buffer.insert_text('"', move_cursor=False) @handle(Keys.ControlD, filter=ctrl_d_condition) def call_exit_alias(event): """Use xonsh exit function""" b = event.cli.current_buffer b.accept_action.validate_and_handle(event.cli, b) xonsh_exit([]) @handle(Keys.ControlJ, filter=IsMultiline()) def multiline_carriage_return(event): """ Wrapper around carriage_return multiline parser """ b = event.cli.current_buffer carriage_return(b, event.cli) @handle(Keys.ControlJ, filter=should_confirm_completion) def enter_confirm_completion(event): """Ignore <enter> (confirm completion)""" event.current_buffer.complete_state = None @handle(Keys.Escape, filter=should_confirm_completion) def esc_cancel_completion(event): """Use <ESC> to cancel completion""" event.cli.current_buffer.cancel_completion() @handle(Keys.Escape, Keys.ControlJ) def execute_block_now(event): """Execute a block of text irrespective of cursor position""" b = event.cli.current_buffer b.accept_action.validate_and_handle(event.cli, b) @handle(Keys.Left, filter=beginning_of_line) def wrap_cursor_back(event): """Move cursor to end of previous line unless at beginning of document """ b = event.cli.current_buffer b.cursor_up(count=1) relative_end_index = b.document.get_end_of_line_position() b.cursor_right(count=relative_end_index) @handle(Keys.Right, filter=end_of_line) def wrap_cursor_forward(event): """Move cursor to beginning of next line unless at end of document""" b = event.cli.current_buffer relative_begin_index = b.document.get_start_of_line_position() b.cursor_left(count=abs(relative_begin_index)) b.cursor_down(count=1) @handle(Keys.ControlI, filter=insert_mode) def generate_completions(event): """ Tab-completion: where the first tab completes the common suffix and the second tab lists all the completions. Notes ----- This method was forked from the mainline prompt-toolkit repo. Copyright (c) 2014, Jonathan Slenders, All rights reserved. """ b = event.current_buffer def second_tab(): if b.complete_state: b.complete_next() else: event.cli.start_completion(select_first=False) # On the second tab-press, or when already navigating through # completions. if event.is_repeat or b.complete_state: second_tab() else: event.cli.start_completion(insert_common_part=True, select_first=False)
# -*- coding: utf-8 -*- from IPython import get_ipython from prompt_toolkit.enums import DEFAULT_BUFFER from prompt_toolkit.keys import Keys from prompt_toolkit.filters import HasFocus, HasSelection, ViInsertMode, EmacsInsertMode from prompt_toolkit.key_binding.bindings.named_commands import get_by_name ip = get_ipython() insert_mode = ViInsertMode() | EmacsInsertMode() cursor_left = lambda ev: ev.current_buffer.cursor_left() cursor_right = lambda ev: ev.current_buffer.cursor_right() default_filters = HasFocus(DEFAULT_BUFFER) & ~HasSelection() & insert_mode # Register the shortcut if IPython is using prompt_toolkit if getattr(ip, 'pt_cli'): registry = ip.pt_cli.application.key_bindings_registry registry.add_binding(Keys.ControlH, filter=default_filters)(cursor_left) registry.add_binding(Keys.ControlL, filter=default_filters)(cursor_right) registry.add_binding(Keys.ControlB, filter=default_filters)(get_by_name('backward-word'))
from IPython import get_ipython from prompt_toolkit.enums import DEFAULT_BUFFER from prompt_toolkit.filters import HasFocus, ViInsertMode from prompt_toolkit.key_binding.vi_state import InputMode ip = get_ipython() def switch_to_navigation_mode(event): vi_state = event.cli.vi_state vi_state.input_mode = InputMode.NAVIGATION if getattr(ip, 'pt_app', None): registry = ip.pt_app.key_bindings registry.add_binding(u'j', u'k', filter=(HasFocus(DEFAULT_BUFFER) & ViInsertMode()))(switch_to_navigation_mode)
def mycli_bindings(mycli): """Custom key bindings for mycli.""" kb = KeyBindings() @kb.add("k", "j", filter=ViInsertMode()) def _(event): """ Typing 'kj' in Insert mode, should go back to navigation mode. """ _logger.debug('Detected kj keys.') event.cli.key_processor.feed(KeyPress(Keys.Escape)) @kb.add('f2') def _(event): """Enable/Disable SmartCompletion Mode.""" _logger.debug('Detected F2 key.') mycli.completer.smart_completion = not mycli.completer.smart_completion @kb.add('f3') def _(event): """Enable/Disable Multiline Mode.""" _logger.debug('Detected F3 key.') mycli.multi_line = not mycli.multi_line @kb.add('f4') def _(event): """Toggle between Vi and Emacs mode.""" _logger.debug('Detected F4 key.') if mycli.key_bindings == "vi": event.app.editing_mode = EditingMode.EMACS mycli.key_bindings = "emacs" else: event.app.editing_mode = EditingMode.VI mycli.key_bindings = "vi" @kb.add('tab') def _(event): """Force autocompletion at cursor.""" _logger.debug('Detected <Tab> key.') b = event.app.current_buffer if b.complete_state: b.complete_next() else: b.start_completion(select_first=True) @kb.add('c-space') def _(event): """ Initialize autocompletion at cursor. If the autocompletion menu is not showing, display it with the appropriate completions for the context. If the menu is showing, select the next completion. """ _logger.debug('Detected <C-Space> key.') b = event.app.current_buffer if b.complete_state: b.complete_next() else: b.start_completion(select_first=False) @kb.add('enter', filter=completion_is_selected) def _(event): """Makes the enter key work as the tab key only when showing the menu. In other words, don't execute query when enter is pressed in the completion dropdown menu, instead close the dropdown menu (accept current selection). """ _logger.debug('Detected enter key.') event.current_buffer.complete_state = None b = event.app.current_buffer b.complete_state = None @kb.add('escape', 'enter') def _(event): """Introduces a line break in multi-line mode, or dispatches the command in single-line mode.""" _logger.debug('Detected alt-enter key.') if mycli.multi_line: event.app.current_buffer.validate_and_handle() else: event.app.current_buffer.insert_text('\n') return kb