def run():
# Create a `Registry` that contains the default key bindings.
registry = load_key_bindings_for_prompt()
# Add an additional key binding for toggling this flag.
@registry.add_binding(Keys.F4)
def _(event):
" Toggle between Emacs and Vi mode. "
if event.cli.editing_mode == EditingMode.VI:
event.cli.editing_mode = EditingMode.EMACS
else:
event.cli.editing_mode = EditingMode.VI
# Add a bottom toolbar to display the status.
style = style_from_dict({
Token.Toolbar: 'reverse',
})
def get_bottom_toolbar_tokens(cli):
" Display the current input mode. "
text = 'Vi' if cli.editing_mode == EditingMode.VI else 'Emacs'
return [
(Token.Toolbar, ' [F4] %s ' % text)
]
prompt('> ', key_bindings_registry=registry,
get_bottom_toolbar_tokens=get_bottom_toolbar_tokens,
style=style)
def run():
# Create a `Registry` that contains the default key bindings.
registry = load_key_bindings_for_prompt()
# Add an additional key binding for toggling this flag.
@registry.add_binding(Keys.F4)
def _(event):
" Toggle between Emacs and Vi mode. "
if event.cli.editing_mode == EditingMode.VI:
event.cli.editing_mode = EditingMode.EMACS
else:
event.cli.editing_mode = EditingMode.VI
# Add a bottom toolbar to display the status.
style = style_from_dict({
Token.Toolbar: 'reverse',
})
def get_bottom_toolbar_tokens(cli):
" Display the current input mode. "
text = 'Vi' if cli.editing_mode == EditingMode.VI else 'Emacs'
return [(Token.Toolbar, ' [F4] %s ' % text)]
prompt('> ',
key_bindings_registry=registry,
get_bottom_toolbar_tokens=get_bottom_toolbar_tokens,
style=style)
def main(args=sys.argv[1:]):
parser, args = parseargs(args)
if args.debug:
log.setLevel(logging.DEBUG)
loop = asyncio.get_event_loop()
grbl = SerialGrbl(args.device, args.baudrate, loop)
registry = load_key_bindings_for_prompt()
history = InMemoryHistory()
app_loop = create_asyncio_eventloop(loop=loop)
app = create_prompt_application(message='> ',
history=history,
key_bindings_registry=registry)
cli = CommandLineInterface(application=app, eventloop=app_loop)
for key, func in key_to_func.items():
func = functools.partial(func, grbl=grbl, loop=loop)
registry.add_binding(key, eager=True)(func)
try:
main_task = asyncio.ensure_future(main_coro(loop, grbl, cli))
return loop.run_until_complete(main_task)
except (EOFError, KeyboardInterrupt):
main_task.cancel()
return 1
except serial.SerialException as error:
log.fatal(error)
return 1
class KeyBindings(object):
register = load_key_bindings_for_prompt()
@register.add_binding(Keys.ControlE)
def _(event):
event.cli.run_in_terminal(os._exit(0))
@register.add_binding(Keys.ControlC)
def _(event):
""" control c gets current working directory"""
event.cli.current_buffer.insert_text(os.getcwd())
@register.add_binding(Keys.ControlD)
def _(event):
"""control-D for change directory"""
event.cli.current_buffer.insert_text("cdir")
@register.add_binding(Keys.ControlH)
def _(event):
"""short cut to home"""
event.cli.current_buffer.insert_text("h")
@register.add_binding(Keys.ControlS)
def _(event):
"""short cut to sh"""
event.cli.current_buffer.insert_text('sh')
def __init__(self, completer=None, history=None, auto_suggest=None):
self.completer = completer if completer else WordCompleter(
get_all_tags())
self.history = history if history else FileHistory(HISTORY_FILE)
self.auto_suggest = auto_suggest if auto_suggest else AutoSuggestFromHistory(
)
self.registry = load_key_bindings_for_prompt()
def _create_keybindings_registry(self):
registry = load_key_bindings_for_prompt()
for keystroke, callback in self.keybindings:
@registry.add_binding(keystroke)
def _(event):
"""
We use ``run_in_terminal``, because that ensures that the prompt is
hidden right before something gets printed and it's drawn again
after it. (Otherwise this would destroy the output.)
"""
event.cli.run_in_terminal(lambda: callback(None))
return registry
def main():
# We start with a `Registry` of default key bindings.
registry = load_key_bindings_for_prompt()
# Create the decorators to be used for registering text objects and
# operators in this registry.
operator = create_operator_decorator(registry)
text_object = create_text_object_decorator(registry)
# Create a custom operator.
@operator('R')
def _(event, text_object):
" Custom operator that reverses text. "
buff = event.current_buffer
# Get relative start/end coordinates.
start, end = text_object.operator_range(buff.document)
start += buff.cursor_position
end += buff.cursor_position
text = buff.text[start:end]
text = ''.join(reversed(text))
event.cli.current_buffer.text = buff.text[:start] + text + buff.text[
end:]
# Create a text object.
@text_object('A')
def _(event):
" A custom text object that involves everything. "
# Note that a `TextObject` has coordinatens, relative to the cursor position.
buff = event.current_buffer
return TextObject(
-buff.document.cursor_position, # The start.
len(buff.text) - buff.document.cursor_position) # The end.
# Read input.
print('There is a custom text object "A" that applies to everything')
print('and a custom operator "r" that reverses the text object.\n')
print('Things that are possible:')
print('- Riw - reverse inner word.')
print('- yA - yank everything.')
print('- RA - reverse everything.')
text = prompt('> ',
default='hello world',
key_bindings_registry=registry,
editing_mode=EditingMode.VI)
print('You said: %s' % text)
def ask_password(self):
hidden = [True] # Nonlocal
registry = load_key_bindings_for_prompt()
@registry.add_binding(Keys.ControlT)
def _(event):
hidden[0] = not hidden[0]
print('Press Ctrl-T to toggle password visibility')
return prompt('Password: ',
is_password=Condition(lambda cli: hidden[0]),
key_bindings_registry=registry)
def main():
hidden = [True] # Nonlocal
registry = load_key_bindings_for_prompt()
@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 = prompt('Password: '******'You said: %s' % password)
def main():
hidden = [True] # Nonlocal
registry = load_key_bindings_for_prompt()
@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 = prompt('Password: '******'You said: %s' % password)
def main():
# We start with a `Registry` of default key bindings.
registry = load_key_bindings_for_prompt()
# Add our own key binding to the registry of the 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')
@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. However, prompt-toolkit should already give
some visual feedback of the typed character.
"""
event.cli.current_buffer.insert_text('z')
@registry.add_binding('a', 'b', 'c')
def _(event):
" Typing 'abc' should insert 'd'. "
event.cli.current_buffer.insert_text('d')
@registry.add_binding(Keys.ControlT)
def _(event):
"""
Print 'hello world' in the terminal when ControlT is pressed.
We use ``run_in_terminal``, because that ensures that the prompt is
hidden right before ``print_hello`` gets executed and it's drawn again
after it. (Otherwise this would destroy the output.)
"""
def print_hello():
print('hello world')
event.cli.run_in_terminal(print_hello)
# Read input.
print('Press F4 to insert "hello world", type "xy" to insert "z":')
text = prompt('> ', key_bindings_registry=registry)
print('You said: %s' % text)
def main():
# We start with a `Registry` of default key bindings.
registry = load_key_bindings_for_prompt()
# Add our own key binding to the registry of the 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')
@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. However, prompt-toolkit should already give
some visual feedback of the typed character.
"""
event.cli.current_buffer.insert_text('z')
@registry.add_binding('a', 'b', 'c')
def _(event):
" Typing 'abc' should insert 'd'. "
event.cli.current_buffer.insert_text('d')
@registry.add_binding(Keys.ControlT)
def _(event):
"""
Print 'hello world' in the terminal when ControlT is pressed.
We use ``run_in_terminal``, because that ensures that the prompt is
hidden right before ``print_hello`` gets executed and it's drawn again
after it. (Otherwise this would destroy the output.)
"""
def print_hello():
print('hello world')
event.cli.run_in_terminal(print_hello)
# Read input.
print('Press F4 to insert "hello world", type "xy" to insert "z":')
text = prompt('> ', key_bindings_registry=registry)
print('You said: %s' % text)
def main():
# We start with a `Registry` of default key bindings.
registry = load_key_bindings_for_prompt()
# Create the decorators to be used for registering text objects and
# operators in this registry.
operator = create_operator_decorator(registry)
text_object = create_text_object_decorator(registry)
# Create a custom operator.
@operator('R')
def _(event, text_object):
" Custom operator that reverses text. "
buff = event.current_buffer
# Get relative start/end coordinates.
start, end = text_object.operator_range(buff.document)
start += buff.cursor_position
end += buff.cursor_position
text = buff.text[start:end]
text = ''.join(reversed(text))
event.cli.current_buffer.text = buff.text[:start] + text + buff.text[end:]
# Create a text object.
@text_object('A')
def _(event):
" A custom text object that involves everything. "
# Note that a `TextObject` has coordinatens, relative to the cursor position.
buff = event.current_buffer
return TextObject(
-buff.document.cursor_position, # The start.
len(buff.text) - buff.document.cursor_position) # The end.
# Read input.
print('There is a custom text object "A" that applies to everything')
print('and a custom operator "r" that reverses the text object.\n')
print('Things that are possible:')
print('- Riw - reverse inner word.')
print('- yA - yank everything.')
print('- RA - reverse everything.')
text = prompt('> ', default='hello world', key_bindings_registry=registry, editing_mode=EditingMode.VI)
print('You said: %s' % text)
def main():
# We start with a `Registry` that contains the default key bindings.
registry = load_key_bindings_for_prompt()
# We add a custom key binding to space.
@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.
text = prompt('Say something: ', key_bindings_registry=registry)
print('You said: %s' % text)
def main():
# We start with a `Registry` that contains the default key bindings.
registry = load_key_bindings_for_prompt()
# We add a custom key binding to space.
@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.
text = prompt('Say something: ', key_bindings_registry=registry)
print('You said: %s' % text)
def __init__(self,
get_globals=None, get_locals=None, history_filename=None,
vi_mode=False,
# For internal use.
_completer=None, _validator=None,
_lexer=None, _extra_buffers=None, _extra_buffer_processors=None,
_on_start=None,
_extra_layout_body=None, _extra_toolbars=None,
_input_buffer_height=None,
_accept_action=AcceptAction.RETURN_DOCUMENT,
_on_exit=AbortAction.RAISE_EXCEPTION):
self.get_globals = get_globals or (lambda: {})
self.get_locals = get_locals or self.get_globals
self._completer = _completer or PythonCompleter(self.get_globals, self.get_locals)
self._validator = _validator or PythonValidator(self.get_compiler_flags)
self.history = FileHistory(history_filename) if history_filename else InMemoryHistory()
self._lexer = _lexer or PygmentsLexer(PythonLexer)
self._extra_buffers = _extra_buffers
self._accept_action = _accept_action
self._on_exit = _on_exit
self._on_start = _on_start
self._input_buffer_height = _input_buffer_height
self._extra_layout_body = _extra_layout_body or []
self._extra_toolbars = _extra_toolbars or []
self._extra_buffer_processors = _extra_buffer_processors or []
# Settings.
self.show_signature = False
self.show_docstring = False
self.show_meta_enter_message = True
self.completion_visualisation = CompletionVisualisation.MULTI_COLUMN
self.completion_menu_scroll_offset = 1
self.show_line_numbers = False
self.show_status_bar = True
self.wrap_lines = True
self.complete_while_typing = True
self.vi_mode = vi_mode
self.paste_mode = False # When True, don't insert whitespace after newline.
self.confirm_exit = True # Ask for confirmation when Control-D is pressed.
self.accept_input_on_enter = 2 # Accept when pressing Enter 'n' times.
# 'None' means that meta-enter is always required.
self.enable_open_in_editor = True
self.enable_system_bindings = True
self.enable_input_validation = True
self.enable_auto_suggest = False
self.enable_mouse_support = False
self.enable_history_search = False # When True, like readline, going
# back in history will filter the
# history on the records starting
# with the current input.
self.highlight_matching_parenthesis = False
self.show_sidebar = False # Currently show the sidebar.
self.show_sidebar_help = True # When the sidebar is visible, also show the help text.
self.show_exit_confirmation = False # Currently show 'Do you really want to exit?'
self.terminal_title = None # The title to be displayed in the terminal. (None or string.)
self.exit_message = 'Do you really want to exit?'
self.insert_blank_line_after_output = True # (For the REPL.)
# Tokens to be shown at the prompt.
self.prompt_style = 'classic' # The currently active style.
self.all_prompt_styles = { # Styles selectable from the menu.
'ipython': IPythonPrompt(self),
'classic': ClassicPrompt(),
}
self.get_input_prompt_tokens = lambda cli: \
self.all_prompt_styles[self.prompt_style].in_tokens(cli)
self.get_output_prompt_tokens = lambda cli: \
self.all_prompt_styles[self.prompt_style].out_tokens(cli)
#: Load styles.
self.code_styles = get_all_code_styles()
self.ui_styles = get_all_ui_styles()
self._current_code_style_name = 'default'
self._current_ui_style_name = 'default'
if is_windows():
self._current_code_style_name = 'win32'
self._current_style = self._generate_style()
self.true_color = False
# Options to be configurable from the sidebar.
self.options = self._create_options()
self.selected_option_index = 0
#: Incremeting integer counting the current statement.
self.current_statement_index = 1
# Code signatures. (This is set asynchronously after a timeout.)
self.signatures = []
# Create a Registry for the key bindings.
self.key_bindings_registry = MergedRegistry([
ConditionalRegistry(
registry=load_key_bindings_for_prompt(
enable_abort_and_exit_bindings=True,
enable_search=True,
enable_open_in_editor=Condition(lambda cli: self.enable_open_in_editor),
enable_system_bindings=Condition(lambda cli: self.enable_system_bindings),
enable_auto_suggest_bindings=Condition(lambda cli: self.enable_auto_suggest)),
# Disable all default key bindings when the sidebar or the exit confirmation
# are shown.
filter=Condition(lambda cli: not (self.show_sidebar or self.show_exit_confirmation))
),
load_mouse_bindings(),
load_python_bindings(self),
load_sidebar_bindings(self),
load_confirm_exit_bindings(self),
])
# Boolean indicating whether we have a signatures thread running.
# (Never run more than one at the same time.)
self._get_signatures_thread_running = False
#!/usr/bin/env python
from __future__ import unicode_literals
import requests
from prompt_toolkit import prompt, AbortAction
from prompt_toolkit.history import InMemoryHistory
from prompt_toolkit.contrib.completers import WordCompleter
from pygments.token import Token
from prompt_toolkit.key_binding.defaults import load_key_bindings_for_prompt
from prompt_toolkit.keys import Keys
from cheat_prompt.prompt_style import PromptStyle
registry = load_key_bindings_for_prompt()
def create_prompt(cli):
"""Create the prompt"""
return [
(Token.PromptText, 'Choose a cheatsheet '),
(Token.PromptSymbol, '=> '),
]
def create_autocomplete_dictionary():
"""
Create a dictionary for autocomplete from all the files in the path
"""
data = requests.get("http://cheat.sh/:list").text
completion_list = data.split()
def create_prompt_application(layout,
buf=None,
buffers=None,
initial_focussed_buffer=DEFAULT_BUFFER,
default=None,
accept_filter=None,
validator=None,
history=None,
key_bindings_registry=None,
style=None,
mouse_support=False):
assert validator is None or callable(validator) or isinstance(
validator, Validator)
assert style is None or isinstance(style, Mapping)
_validator = validator
if not (_validator is None or isinstance(_validator, Validator)):
class _Validator(Validator):
def validate(self, document):
try:
message = validator(document.text)
except ValidationError:
raise
except Exception as ex:
raise ValidationError(message=ex.message,
cursor_position=len(document.text))
else:
if message is not True:
if message is False:
message = 'invalid input'
raise ValidationError(message=message,
cursor_position=len(
document.text))
_validator = _Validator()
if key_bindings_registry is None:
key_bindings_registry = load_key_bindings_for_prompt(
enable_search=False,
enable_auto_suggest_bindings=False,
enable_system_bindings=True,
)
buf = buf or Buffer(
accept_action=Acceptor(default, accept_filter),
validator=_validator,
history=history,
)
if style is not None:
style = style_from_dict(style)
return Application(
layout=layout,
buffer=buf,
buffers=buffers,
initial_focussed_buffer=initial_focussed_buffer,
style=style or DEFAULT_STYLE,
key_bindings_registry=key_bindings_registry,
mouse_support=mouse_support,
)
def __init__(
self,
get_globals=None,
get_locals=None,
history_filename=None,
vi_mode=False,
# For internal use.
_completer=None,
_validator=None,
_lexer=None,
_extra_buffers=None,
_extra_buffer_processors=None,
_on_start=None,
_extra_layout_body=None,
_extra_toolbars=None,
_input_buffer_height=None,
_accept_action=AcceptAction.RETURN_DOCUMENT,
_on_exit=AbortAction.RAISE_EXCEPTION):
self.get_globals = get_globals or (lambda: {})
self.get_locals = get_locals or self.get_globals
self._completer = _completer or PythonCompleter(
self.get_globals, self.get_locals)
self._validator = _validator or PythonValidator(
self.get_compiler_flags)
self.history = FileHistory(
history_filename) if history_filename else InMemoryHistory()
self._lexer = _lexer or PygmentsLexer(PythonLexer)
self._extra_buffers = _extra_buffers
self._accept_action = _accept_action
self._on_exit = _on_exit
self._on_start = _on_start
self._input_buffer_height = _input_buffer_height
self._extra_layout_body = _extra_layout_body or []
self._extra_toolbars = _extra_toolbars or []
self._extra_buffer_processors = _extra_buffer_processors or []
# Settings.
self.show_signature = False
self.show_docstring = False
self.show_meta_enter_message = True
self.completion_visualisation = CompletionVisualisation.MULTI_COLUMN
self.completion_menu_scroll_offset = 1
self.show_line_numbers = False
self.show_status_bar = True
self.wrap_lines = True
self.complete_while_typing = True
self.vi_mode = vi_mode
self.paste_mode = False # When True, don't insert whitespace after newline.
self.confirm_exit = True # Ask for confirmation when Control-D is pressed.
self.accept_input_on_enter = 2 # Accept when pressing Enter 'n' times.
# 'None' means that meta-enter is always required.
self.enable_open_in_editor = True
self.enable_system_bindings = True
self.enable_input_validation = True
self.enable_auto_suggest = False
self.enable_mouse_support = False
self.enable_history_search = False # When True, like readline, going
# back in history will filter the
# history on the records starting
# with the current input.
self.highlight_matching_parenthesis = False
self.show_sidebar = False # Currently show the sidebar.
self.show_sidebar_help = True # When the sidebar is visible, also show the help text.
self.show_exit_confirmation = False # Currently show 'Do you really want to exit?'
self.terminal_title = None # The title to be displayed in the terminal. (None or string.)
self.exit_message = 'Do you really want to exit?'
self.insert_blank_line_after_output = True # (For the REPL.)
# Tokens to be shown at the prompt.
self.prompt_style = 'classic' # The currently active style.
self.all_prompt_styles = { # Styles selectable from the menu.
'ipython': IPythonPrompt(self),
'classic': ClassicPrompt(),
}
self.get_input_prompt_tokens = lambda cli: \
self.all_prompt_styles[self.prompt_style].in_tokens(cli)
self.get_output_prompt_tokens = lambda cli: \
self.all_prompt_styles[self.prompt_style].out_tokens(cli)
#: Load styles.
self.code_styles = get_all_code_styles()
self.ui_styles = get_all_ui_styles()
self._current_code_style_name = 'default'
self._current_ui_style_name = 'default'
if is_windows():
self._current_code_style_name = 'win32'
self._current_style = self._generate_style()
self.true_color = False
# Options to be configurable from the sidebar.
self.options = self._create_options()
self.selected_option_index = 0
#: Incremeting integer counting the current statement.
self.current_statement_index = 1
# Code signatures. (This is set asynchronously after a timeout.)
self.signatures = []
# Create a Registry for the key bindings.
self.key_bindings_registry = MergedRegistry([
ConditionalRegistry(
registry=load_key_bindings_for_prompt(
enable_abort_and_exit_bindings=True,
enable_search=True,
enable_open_in_editor=Condition(
lambda cli: self.enable_open_in_editor),
enable_system_bindings=Condition(
lambda cli: self.enable_system_bindings),
enable_auto_suggest_bindings=Condition(
lambda cli: self.enable_auto_suggest)),
# Disable all default key bindings when the sidebar or the exit confirmation
# are shown.
filter=Condition(lambda cli: not (self.show_sidebar or self.
show_exit_confirmation))),
load_mouse_bindings(),
load_python_bindings(self),
load_sidebar_bindings(self),
load_confirm_exit_bindings(self),
])
# Boolean indicating whether we have a signatures thread running.
# (Never run more than one at the same time.)
self._get_signatures_thread_running = False
