def _build_cli(self):
layout = create_prompt_layout(
message='{0}> '.format(self.args['username']),
lexer=PygmentsLexer(SqlLexer),
)
buf = Buffer(completer=self.completer,
history=self.history,
complete_while_typing=Always(),
accept_action=AcceptAction.RETURN_DOCUMENT)
key_binding_manager = KeyBindingManager(
enable_abort_and_exit_bindings=True, )
application = Application(
layout=layout,
buffer=buf,
key_bindings_registry=key_binding_manager.registry,
on_exit=AbortAction.RAISE_EXCEPTION,
on_abort=AbortAction.RETRY,
ignore_case=True)
cli = CommandLineInterface(application=application,
eventloop=self.eventloop)
return cli
def create_cli(message='',
multiline=False,
is_password=False,
vi_mode=False,
lexer=None,
enable_system_prompt=False,
enable_open_in_editor=False,
validator=None,
completer=None,
style=None,
history=None,
get_bottom_toolbar_tokens=None):
# Create history instance.
if history is None:
history = History()
# Load all key bindings.
manager = KeyBindingManager(enable_vi_mode=vi_mode,
enable_system_prompt=enable_system_prompt,
enable_open_in_editor=enable_open_in_editor)
# Create interface.
return CommandLineInterface(
layout=create_default_layout(message=message, lexer=lexer, is_password=is_password,
reserve_space_for_menu=(completer is not None),
get_bottom_toolbar_tokens=get_bottom_toolbar_tokens),
buffer=Buffer(
is_multiline=multiline,
history=history,
validator=validator,
completer=completer,
),
key_bindings_registry=manager.registry,
style=style)
class KeyHandlers(object):
"""Contains all handlers registered with key bindings
"""
__single_instance = None
__key_binding_manager = KeyBindingManager(
enable_abort_and_exit_bindings=bool(egc.KB_ABORT_EXIT_BIND),
enable_system_bindings=bool(egc.KB_SYSTEM_BIND),
enable_search=bool(egc.KB_SEARCH),
enable_open_in_editor=bool(egc.KB_OPEN_IN_EDITOR),
enable_extra_page_navigation=bool(egc.KB_PAGE_SCROLL),
enable_auto_suggest_bindings=bool(egc.KB_AUTO_SUGGEST)
)
registry = __key_binding_manager.registry
def __new__(cls):
"""docstring for __new__"""
if cls != type(cls.__single_instance):
cls.__single_instance = object.__new__(cls)
return cls.__single_instance
def get_key_binding_manager(self):
"""docstring for get_key_binding_manager"""
return KeyHandlers.__key_binding_manager
def get_key_binding_registry(self):
"""docstring for get_key_binding_registry"""
return KeyHandlers.registry
def get_key_manager(set_long_options, get_long_options, set_fuzzy_match,
get_fuzzy_match):
"""
Create and initialize keybinding manager
:return: KeyBindingManager
"""
assert callable(set_long_options)
assert callable(get_long_options)
assert callable(set_fuzzy_match)
assert callable(get_fuzzy_match)
manager = KeyBindingManager(enable_system_bindings=True)
@manager.registry.add_binding(Keys.F2)
def _(event):
"""
When F2 has been pressed, fill in the "help" command.
"""
event.cli.current_buffer.insert_text("help")
@manager.registry.add_binding(Keys.F3)
def _(_):
"""
Enable/Disable long option name suggestion.
"""
set_long_options(not get_long_options())
@manager.registry.add_binding(Keys.F4)
def _(_):
"""
Enable/Disable fuzzy matching.
"""
set_fuzzy_match(not get_fuzzy_match())
@manager.registry.add_binding(Keys.F10)
def _(event):
"""
When F10 has been pressed, quit.
"""
# Unused parameters for linter.
raise EOFError
@manager.registry.add_binding(Keys.ControlSpace)
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.
"""
b = event.cli.current_buffer
if b.complete_state:
b.complete_next()
else:
event.cli.start_completion(select_first=False)
return manager
def main():
# We start with a `KeyBindingManager` instance, because this will already
# nicely load all the default key bindings.
key_bindings_manager = KeyBindingManager()
# We add a custom key binding to space.
@key_bindings_manager.registry.add_binding(' ')
def _(event):
"""
When space is pressed, we check the word before the cursor, and
autocorrect that.
"""
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(' ')
# Read input.
print('Say something')
text = get_input(key_bindings_registry=key_bindings_manager.registry)
print('You said: %s' % text)
def main():
# We start with a `KeyBindingManager` instance, because this will already
# nicely load all the default key bindings.
key_bindings_manager = KeyBindingManager()
# Add our own key binding to the registry of the key bindings manager.
@key_bindings_manager.registry.add_binding(Keys.F4)
def _(event):
"""
When F4 has been pressed. Insert "hello world" as text.
"""
event.cli.current_buffer.insert_text('hello world')
@key_bindings_manager.registry.add_binding('x', 'y')
def _(event):
"""
(Useless, but for demoing.)
Typing 'xy' will insert 'z'.
Note that when you type for instance 'xa', the insertion of 'x' is
postponed until the 'a' is typed. because we don't know earlier whether
or not a 'y' will follow.
"""
event.cli.current_buffer.insert_text('z')
# Read input.
print('Press F4 to insert "hello world", type "xy" to insert "z":')
text = get_input(key_bindings_registry=key_bindings_manager.registry)
print('You said: %s' % text)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.history = setup_history()
self.pt_completer = PromptToolkitCompleter(self.completer, self.ctx)
self.key_bindings_manager = KeyBindingManager(
enable_search=True, enable_abort_and_exit_bindings=True)
load_xonsh_bindings(self.key_bindings_manager)
def create_cli(eventloop,
message='',
multiline=False,
is_password=False,
vi_mode=False,
lexer=None,
enable_system_prompt=False,
enable_open_in_editor=False,
validator=None,
completer=None,
style=None,
history=None,
get_prompt_tokens=None,
get_bottom_toolbar_tokens=None,
extra_input_processors=None,
key_bindings_registry=None,
output=None,
on_abort=AbortAction.RAISE_EXCEPTION,
on_exit=AbortAction.RAISE_EXCEPTION,
on_accept=AcceptAction.RETURN_DOCUMENT):
"""
Create a `CommandLineInterface` instance.
"""
assert isinstance(eventloop, EventLoop)
# Create history instance.
if history is None:
history = History()
# Use default registry from KeyBindingManager if none was given.
if key_bindings_registry is None:
key_bindings_registry = KeyBindingManager(
enable_vi_mode=vi_mode,
enable_system_prompt=enable_system_prompt,
enable_open_in_editor=enable_open_in_editor).registry
# Create interface.
return CommandLineInterface(
eventloop=eventloop,
layout=create_default_layout(
message=message,
lexer=lexer,
is_password=is_password,
reserve_space_for_menu=(completer is not None),
get_prompt_tokens=get_prompt_tokens,
get_bottom_toolbar_tokens=get_bottom_toolbar_tokens,
extra_input_processors=extra_input_processors),
buffer=Buffer(
is_multiline=(Always() if multiline else Never()),
history=history,
validator=validator,
completer=completer,
),
key_bindings_registry=key_bindings_registry,
style=style,
output=output,
on_abort=on_abort,
on_exit=on_exit)
def test_bindings(self):
mngr = KeyBindingManager(enable_search=True,
enable_abort_and_exit_bindings=True,
enable_system_bindings=True,
enable_open_in_editor=True)
bind_keys(mngr.registry)
self.assertTrue(
'on_backspace' in handlers_for_key(mngr, Keys.Backspace))
self.assertTrue('on_tab' in handlers_for_key(mngr, Keys.Tab))
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.history = setup_history()
self.pt_completer = PromptToolkitCompleter(self.completer, self.ctx)
self.key_bindings_manager = KeyBindingManager(
enable_auto_suggest_bindings=True,
enable_search=True,
enable_abort_and_exit_bindings=True,
enable_vi_mode=Condition(lambda cli: builtins.__xonsh_env__.get('VI_MODE')),
enable_open_in_editor=True)
load_xonsh_bindings(self.key_bindings_manager)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.prompter = Prompter()
self.history = PromptToolkitHistory()
self.pt_completer = PromptToolkitCompleter(self.completer, self.ctx)
key_bindings_manager_args = {
'enable_auto_suggest_bindings': True,
'enable_search': True,
'enable_abort_and_exit_bindings': True,
}
self.key_bindings_manager = KeyBindingManager(**key_bindings_manager_args)
load_xonsh_bindings(self.key_bindings_manager)
def main():
hidden = [True] # Nonlocal
key_bindings_manager = KeyBindingManager()
@key_bindings_manager.registry.add_binding(Keys.ControlT)
def _(event):
' When ControlT has been pressed, toggle visibility. '
hidden[0] = not hidden[0]
print('Type Control-T to toggle password visible.')
password = get_input('Password: '******'You said: %s' % password)
def create_cli(self):
## KeyBindings configuration
key_binding = KeyBindingManager(enable_search=True,
enable_abort_and_exit_bindings=True,
enable_system_bindings=True,
enable_auto_suggest_bindings=True,
enable_open_in_editor=False)
## Buffer configuration
default_buffer = Buffer(history=self.file_history,
auto_suggest=AutoSuggestFromHistory(),
enable_history_search=True,
completer=self.completer,
complete_while_typing=Always(),
accept_action=AcceptAction.RETURN_DOCUMENT)
## Style configuration
try:
style = get_style_by_name(self._config.highlighter_style)
except ClassNotFound:
style = get_style_by_name('native')
styles = {}
styles.update(style.styles)
styles.update(default_style_extensions)
styles.update({
Token.Menu.Completions.Completion: 'bg:#003fff #ffffff',
Token.Menu.Completions.Completion.Current: 'bg:#5ab300 #000000',
Token.Menu.Completions.Meta.Current: 'bg:#5ab300 #ffffff',
Token.Menu.Completions.Meta: 'bg:#ffffff #000000',
Token.Scrollbar: 'bg:#003fff',
Token.Scrollbar.Button: 'bg:#003333',
})
prompt_style = style_from_dict(styles)
## Application
application = Application(
layout=self.create_cli_layout(),
mouse_support=False,
style=prompt_style,
buffer=default_buffer,
on_abort=AbortAction.RETRY,
on_exit=AbortAction.RAISE_EXCEPTION,
on_input_timeout=self.on_input_timeout,
key_bindings_registry=key_binding.registry,
)
cli = CommandLineInterface(application=application,
eventloop=create_eventloop())
return cli
def loop(cmd, history_file):
key_binding_manager = KeyBindingManager(
enable_search=True, enable_abort_and_exit_bindings=True)
layout = create_prompt_layout(
message=u'cr> ',
multiline=True,
lexer=SqlLexer,
extra_input_processors=[
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone())
])
buffer = CrashBuffer(history=TruncatedFileHistory(
history_file, max_length=MAX_HISTORY_LENGTH),
accept_action=AcceptAction.RETURN_DOCUMENT,
completer=SQLCompleter(cmd))
buffer.complete_while_typing = lambda cli=None: cmd.should_autocomplete()
application = Application(
layout=layout,
buffer=buffer,
style=PygmentsStyle.from_defaults(pygments_style_cls=CrateStyle),
key_bindings_registry=key_binding_manager.registry,
editing_mode=_get_editing_mode(),
on_exit=AbortAction.RAISE_EXCEPTION,
on_abort=AbortAction.RETRY,
)
eventloop = create_eventloop()
output = create_output()
cli = CommandLineInterface(application=application,
eventloop=eventloop,
output=output)
def get_num_columns_override():
return output.get_size().columns
cmd.get_num_columns = get_num_columns_override
while True:
try:
doc = cli.run(reset_current_buffer=True)
if doc:
cmd.process(doc.text)
except KeyboardInterrupt:
cmd.logger.warn(
"Query not cancelled. Run KILL <jobId> to cancel it")
except EOFError:
cmd.logger.warn(u'Bye!')
return
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.prompter = Prompter()
self.history = PromptToolkitHistory()
self.pt_completer = PromptToolkitCompleter(self.completer, self.ctx)
key_bindings_manager_args = {
'enable_auto_suggest_bindings': True,
'enable_search': True,
'enable_abort_and_exit_bindings': True,
}
self.key_bindings_manager = KeyBindingManager(
**key_bindings_manager_args)
load_xonsh_bindings(self.key_bindings_manager)
# This assumes that PromptToolkitShell is a singleton
events.on_ptk_create.fire(self.prompter, self.history,
self.pt_completer, self.key_bindings_manager)
def main():
if len(sys.argv) > 1:
logout()
else:
studentID = raw_input("Please Input Your Student ID:")
hidden = [True] # Nonlocal
key_bindings_manager = KeyBindingManager()
@key_bindings_manager.registry.add_binding(Keys.ControlT)
def _(event):
hidden[0] = not hidden[0]
passwd = prompt('Password: ',
is_password=Condition(lambda cli: hidden[0]),
key_bindings_registry=key_bindings_manager.registry)
login(studentID, passwd)
def __init__(self, opt_ns, srv_c, inst_xml):
manager = KeyBindingManager() # Start with the `KeyBindingManager`.
self.srv_text = ServiceOutput(opt_ns, srv_c, inst_xml)
layout = HSplit(
[
# One window that holds the BufferControl with the default buffer on the
# left.
Window(
height=D.exact(1),
content=TokenListControl(
self.get_title_line,
default_char=Char(" ", token=Token.String.ICSW.Header)
)
),
Window(
height=D.exact(1),
content=FillControl('-', token=Token.Line)
),
# Display the text 'Hello world' on the right.
Window(
content=TokenListControl(
self.get_icsw_output,
)
),
]
)
self._updating = False
@manager.registry.add_binding(Keys.ControlC, eager=True)
@manager.registry.add_binding("q", eager=True)
def _handler_data(event):
event.cli.set_return_value(0)
our_style = style_from_dict(logging_tools.get_icsw_prompt_styles())
application = Application(
layout=layout,
use_alternate_screen=True,
style=our_style,
on_input_timeout=self.input_timeout,
key_bindings_registry=manager.registry,
)
event_loop = create_eventloop()
self.application = application
self.event_loop = event_loop
def key_bindings_registry():
manager = KeyBindingManager()
registry = manager.registry
@registry.add_binding(Keys.ControlQ)
def _(event):
event.cli.set_return_value(None)
@registry.add_binding(Keys.Tab)
def __(event):
buff = event.cli.current_buffer
doc = buff.document
if doc.cursor_position_row == 0:
_all_imports = imports(doc.text)
if _all_imports:
buff.delete_before_cursor(len(doc.text))
buff.insert_text('\n'.join('import "%s"' %i for i in _all_imports))
return
if doc.current_line.strip() == 'main':
buff.delete_before_cursor(len(doc.current_line))
buff.insert_text(_main, move_cursor=False)
buff.cursor_down(count=1)
buff.cursor_right(count=4)
return
buff.insert_text(' ' * 4)
@registry.add_binding(Keys.F4)
def ___(event):
buff = event.cli.current_buffer
text = buff.document.text
new_text = ''
if text:
new_text = '\n'.join('import "%s"' % t for t in text.split()) + '\n'
buff.delete_before_cursor(len(text))
buff.insert_text(new_text, move_cursor=True)
#buff.cursor_down(1 + len(text.split()))
#buff.cursor_right(4)
return registry
def get_key_manager(set_long_options, get_long_options): #pragma: no cover
assert callable(set_long_options)
assert callable(get_long_options)
manager = KeyBindingManager(enable_search=True,
enable_system_bindings=True,
enable_abort_and_exit_bindings=True)
@manager.registry.add_binding(Keys.F2)
def opt_help(event):
"""
When F2 has been pressed, fill in the "help" command.
"""
event.cli.current_buffer.insert_text("help")
@manager.registry.add_binding(Keys.F3)
def opt_set_options_length(_):
"""
Enable/Disable long option name suggestion.
"""
set_long_options(not get_long_options())
@manager.registry.add_binding(Keys.F10)
def opt_exit(_):
"""
When F10 has been pressed, quit.
"""
# Unused parameters for linter.
raise EOFError
@manager.registry.add_binding(Keys.ControlSpace)
def opt_auto_complete(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.
"""
buf = event.cli.current_buffer
if buf.complete_state:
buf.complete_next()
else:
event.cli.start_completion(select_first=False)
return manager
def __init__(self):
def get_toolbar(self):
return [(Token.Toolbar.Status.Key, '[msx] Help [ctrl+q] Exit')
]
updated_style = style_from_pygments(
TangoStyle, {
Token.Menu.Completions.Completion.Current:
'bg:#acba36 #000000',
Token.Menu.Completions.Completion: 'bg:#008888 #ffffff',
Token.Menu.Completions.ProgressBar: 'bg:#acba36',
Token.Scrollbar: 'bg:#acba36',
Token.Scrollbar.Button: 'bg:#003333',
Token.Toolbar: '#ffffff bg:#333333',
Token: '#00ffff bold',
Token.Toolbar.Status.Key: '#ff0000'
})
history = InMemoryHistory()
layout = create_default_layout(message=u'musixli:$>> ',
get_bottom_toolbar_tokens=get_toolbar)
cli_buffer = Buffer(history=history,
auto_suggest=AutoSuggestFromHistory(),
enable_history_search=True,
completer=self.musix_completer,
complete_while_typing=Always(),
accept_action=AcceptAction.RETURN_DOCUMENT)
loop = create_eventloop()
self.manager = KeyBindingManager()
@self.manager.registry.add_binding(Keys.ControlQ, eager=True)
def exit_(event):
sys.exit()
application = Application(
key_bindings_registry=self.manager.registry,
layout=layout,
mouse_support=False,
buffer=cli_buffer,
style=updated_style,
ignore_case=True,
)
self.cli = CommandLineInterface(application=application,
eventloop=loop)
def __init__(self, context, plugin, usagelogger):
self._ctx = context
self._command_registry = self._ctx.registry
self._plugin = plugin
self._blacklist = self._plugin.getBlacklistPlugin()
self._status_bar = self._plugin.get_status_bar(context)
self._manager = KeyBindingManager(
enable_abort_and_exit_bindings=True,
enable_system_bindings=True,
enable_search=True,
enable_auto_suggest_bindings=True,
)
self._registry = self._manager.registry
self._cli = None
self._suggestor = AutoSuggestFromHistory()
self._completer = ShellCompleter(self._command_registry)
self._command_registry.register_listener(self)
self._usagelogger = usagelogger
def key_bindings_registry():
#binding the registry keys to action for handling reactive state change
manager = KeyBindingManager()
registry = manager.registry
@registry.add_binding(Keys.ControlQ)
def _(event):
event.cli.set_return_value(None)
@registry.add_binding(Keys.Tab)
def _R(event):
buff = event.cli.current_buffer
buff.insert_text(' ' * 4)
@registry.add_binding(Keys.F4)
def ___(event):
buff = event.cli.current_buffer
buff.always_multiline = not buff.always_multiline
return registry
def pgcli_bindings(vi_mode=False):
"""
Custom key bindings for pgcli.
"""
key_binding_manager = KeyBindingManager(enable_vi_mode=vi_mode)
@key_binding_manager.registry.add_binding(Keys.F2)
def _(event):
"""
Enable/Disable SmartCompletion Mode.
"""
_logger.debug('Detected F2 key.')
buf = event.cli.current_buffer
buf.completer.smart_completion = not buf.completer.smart_completion
@key_binding_manager.registry.add_binding(Keys.F3)
def _(event):
"""
Enable/Disable Multiline Mode.
"""
_logger.debug('Detected F3 key.')
buf = event.cli.current_buffer
buf.always_multiline = not buf.always_multiline
@key_binding_manager.registry.add_binding(Keys.F4)
def _(event):
"""
Toggle between Vi and Emacs mode.
"""
_logger.debug('Detected F4 key.')
key_binding_manager.enable_vi_mode = not key_binding_manager.enable_vi_mode
@key_binding_manager.registry.add_binding(Keys.ControlSpace)
def _(event):
"""
Force autocompletion at cursor.
"""
_logger.debug('Detected <C-Space> key.')
event.cli.current_buffer.complete_next()
return key_binding_manager
def _create_key_manager(self):
"""Create and initialize the keybinding manager.
:rtype: :class:`prompt_toolkit.key_binding.manager.
KeyBindingManager`
:return: An instance of `prompt_toolkit.key_binding.manager.
KeyBindingManager`.
"""
self.manager = KeyBindingManager(enable_search=True,
enable_abort_and_exit_bindings=True,
enable_system_bindings=True,
enable_auto_suggest_bindings=True)
@self.manager.registry.add_binding(Keys.F10)
def handle_f10(_):
"""Quit when the `F10` key is pressed.
:type _: :class:`prompt_toolkit.Event`
:param _: (Unused)
:raises: :class:`EOFError` to quit the app.
"""
raise EOFError
@self.manager.registry.add_binding(Keys.ControlSpace)
def handle_ctrl_space(event):
"""Initialize autocompletion at the 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.
:type event: :class:`prompt_toolkit.Event`
:param event: An instance of `prompt_toolkit.Event`.
"""
b = event.cli.current_buffer
if b.complete_state:
b.complete_next()
else:
event.cli.start_completion(select_first=False)
def __init__(self, **kwargs):
super().__init__(**kwargs)
if ON_WINDOWS:
winutils.enable_virtual_terminal_processing()
self._first_prompt = True
self.prompter = Prompter()
self.history = PromptToolkitHistory()
self.pt_completer = PromptToolkitCompleter(self.completer, self.ctx, self)
key_bindings_manager_args = {
'enable_auto_suggest_bindings': True,
'enable_search': True,
'enable_abort_and_exit_bindings': True,
}
self.key_bindings_manager = KeyBindingManager(**key_bindings_manager_args)
load_xonsh_bindings(self.key_bindings_manager)
# This assumes that PromptToolkitShell is a singleton
events.on_ptk_create.fire(
prompter=self.prompter,
history=self.history,
completer=self.pt_completer,
bindings=self.key_bindings_manager,
)
def mycli_bindings():
key_binding_manager = KeyBindingManager(
enable_open_in_editor=True,
enable_system_bindings=True,
enable_auto_suggest_bindings=True,
enable_search=True,
enable_abort_and_exit_bindings=True)
@key_binding_manager.registry.add_binding(Keys.Tab)
def _(event):
"""
Force autocompletion at cursor.
"""
#print('Detected <Tab> key.')
b = event.cli.current_buffer
#print b.complete_state
if b.complete_state:
b.complete_next()
else:
event.cli.start_completion(select_first=True)
return key_binding_manager
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.prompter = Prompter()
self.history = PromptToolkitHistory()
self.pt_completer = PromptToolkitCompleter(self.completer, self.ctx)
key_bindings_manager_args = {
'enable_auto_suggest_bindings': True,
'enable_search': True,
'enable_abort_and_exit_bindings': True,
'enable_open_in_editor': True,
}
major, minor = ptk_version_info()[:2]
self.new_vi_mode_flag = (major, minor) >= (1, 0) \
and ptk_version() != '<0.57'
if not self.new_vi_mode_flag:
# enable_vi_mode is deprecated acoording to prompt_toolset 1.0 document.
key_bindings_manager_args['enable_vi_mode'] = Condition(
lambda cli: builtins.__xonsh_env__.get('VI_MODE'))
self.key_bindings_manager = KeyBindingManager(
**key_bindings_manager_args)
load_xonsh_bindings(self.key_bindings_manager)
def get_key_manager(set_long_options, get_long_options, set_fuzzy_match,
get_fuzzy_match):
assert callable(set_long_options)
assert callable(get_long_options)
assert callable(set_fuzzy_match)
assert callable(get_fuzzy_match)
manager = KeyBindingManager(enable_search=True,
enable_system_bindings=True,
enable_abort_and_exit_bindings=True)
@manager.registry.add_binding(Keys.F2)
def _(event):
click.echo_via_pager(help())
@manager.registry.add_binding(Keys.F3)
def _(_):
set_long_options(not get_long_options())
@manager.registry.add_binding(Keys.F4)
def _(_):
set_fuzzy_match(not get_fuzzy_match())
@manager.registry.add_binding(Keys.F10)
def _(event):
raise EOFError
@manager.registry.add_binding(Keys.ControlSpace)
def _(event):
b = event.cli.current_buffer
if b.complete_state:
b.complete_next()
else:
event.cli.start_completion(select_first=False)
return manager
""" makes all the key bindings for the app """
from __future__ import print_function
from prompt_toolkit.key_binding.manager import KeyBindingManager
from prompt_toolkit.filters import Filter
from prompt_toolkit.keys import Keys
from prompt_toolkit import prompt
import azclishell.configuration
manager = KeyBindingManager(
enable_system_bindings=True,
enable_auto_suggest_bindings=True,
)
registry = manager.registry
_SECTION = 1
PROMPTING = False
EXAMPLE_REPL = False
SHOW_DEFAULT = False
SYMBOLS = False
class _PromptFilter(Filter):
def __call__(self, *a, **kw):
return not PROMPTING
class _ExampleFilter(Filter):
def __call__(self, *a, **kw):
return not EXAMPLE_REPL
import sys
import os
from prompt_toolkit import Application, CommandLineInterface, AbortAction
from prompt_toolkit.key_binding.manager import KeyBindingManager
from prompt_toolkit.keys import Keys
from prompt_toolkit.shortcuts import create_eventloop
from prompt_toolkit.styles import PygmentsStyle
from vault_shell.vault_commandhelper import VaultCommandHelper
from vault_shell.style import VaultStyle
from vault_shell.layout import VaultLayout
from vault_shell.layout import VaultBuffer
VaultKeyBinder = KeyBindingManager(enable_search=True,
enable_abort_and_exit_bindings=True,
enable_system_bindings=True,
enable_auto_suggest_bindings=True)
manager = KeyBindingManager.for_prompt()
@manager.registry.add_binding(Keys.ControlQ)
def _controlQKey(event):
def print_hello():
print "Key pressed"
event.cli.run_in_terminal(print_hello)
def run():
cli_buffer = VaultBuffer()
vault_layout = VaultLayout(multiwindow=True)
