def python_sidebar_navigation(python_input):
"""
Create the `Layout` showing the navigation information for the sidebar.
"""
def get_tokens(cli):
tokens = []
T = Token.Sidebar
# Show navigation info.
tokens.extend([
(T.Separator, ' ' * 43 + '\n'),
(T, ' '),
(T.Key, '[Arrows]'),
(T, ' '),
(T.Key.Description, 'Navigate'),
(T, ' '),
(T.Key, '[Enter]'),
(T, ' '),
(T.Key.Description, 'Hide menu'),
])
return tokens
return ConditionalContainer(content=Window(
TokenListControl(get_tokens, Char(token=Token.Sidebar)),
width=LayoutDimension.exact(43),
height=LayoutDimension.exact(2)),
filter=ShowSidebar(python_input) & ~IsDone())
def create_python_input_window():
def menu_position(cli):
"""
When there is no autocompletion menu to be shown, and we have a signature,
set the pop-up position at `bracket_start`.
"""
b = cli.buffers[DEFAULT_BUFFER]
if b.complete_state is None and python_input.signatures:
row, col = python_input.signatures[0].bracket_start
index = b.document.translate_row_col_to_index(row - 1, col)
return index
return Window(
BufferControl(
buffer_name=DEFAULT_BUFFER,
lexer=lexer,
input_processors=[
ConditionalProcessor(
processor=HighlightSearchProcessor(preview_search=True),
filter=HasFocus(SEARCH_BUFFER),
),
HighlightSelectionProcessor(),
# Show matching parentheses, but only while editing.
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone() &
Condition(lambda cli: python_input.highlight_matching_parenthesis)),
ConditionalProcessor(
processor=AppendAutoSuggestion(),
filter=~IsDone())
] + extra_buffer_processors,
menu_position=menu_position,
# Make sure that we always see the result of an reverse-i-search:
preview_search=True,
),
left_margins=[PythonPromptMargin(python_input)],
# Scroll offsets. The 1 at the bottom is important to make sure the
# cursor is never below the "Press [Meta+Enter]" message which is a float.
scroll_offsets=ScrollOffsets(bottom=1, left=4, right=4),
# As long as we're editing, prefer a minimal height of 6.
get_height=(lambda cli: (
None if cli.is_done or python_input.show_exit_confirmation
else input_buffer_height)),
wrap_lines=Condition(lambda cli: python_input.wrap_lines),
)
def _build_cli(self, history):
def set_vi_mode(value):
self.vi_mode = value
key_binding_manager = pgcli_bindings(
get_vi_mode_enabled=lambda: self.vi_mode,
set_vi_mode_enabled=set_vi_mode)
def prompt_tokens(_):
return [(Token.Prompt, self.get_prompt(self.prompt_format))]
def get_continuation_tokens(cli, width):
return [(Token.Continuation, '.' * (width - 1) + ' ')]
get_toolbar_tokens = create_toolbar_tokens_func(
lambda: self.vi_mode, self.completion_refresher.is_refreshing,
self.pgexecute.failed_transaction,
self.pgexecute.valid_transaction)
layout = create_prompt_layout(
lexer=PygmentsLexer(PostgresLexer),
reserve_space_for_menu=4,
get_prompt_tokens=prompt_tokens,
get_continuation_tokens=get_continuation_tokens,
get_bottom_toolbar_tokens=get_toolbar_tokens,
display_completions_in_columns=self.wider_completion_menu,
multiline=True,
extra_input_processors=[
# Highlight matching brackets while editing.
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(
chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone()),
])
with self._completer_lock:
buf = PGBuffer(always_multiline=self.multi_line,
multiline_mode=self.multiline_mode,
completer=self.completer,
history=history,
complete_while_typing=Always(),
accept_action=AcceptAction.RETURN_DOCUMENT)
editing_mode = EditingMode.VI if self.vi_mode else EditingMode.EMACS
application = Application(
style=style_factory(self.syntax_style, self.cli_style),
layout=layout,
buffer=buf,
key_bindings_registry=key_binding_manager.registry,
on_exit=AbortAction.RAISE_EXCEPTION,
on_abort=AbortAction.RETRY,
ignore_case=True,
editing_mode=editing_mode)
cli = CommandLineInterface(application=application,
eventloop=self.eventloop)
return cli
def __init__(self, max_height=None, extra_filter=Always()):
super(CompletionsMenu, self).__init__(
content=CompletionsMenuControl(),
width=LayoutDimension(min=8),
height=LayoutDimension(min=1, max=max_height),
# Show when there are completions but not at the point we are
# returning the input.
filter=HasCompletions() & ~IsDone() & extra_filter)
def status_bar(key_bindings_manager, python_input):
"""
Create the `Layout` for the status bar.
"""
TB = Token.Toolbar.Status
@if_mousedown
def toggle_paste_mode(cli, mouse_event):
python_input.paste_mode = not python_input.paste_mode
@if_mousedown
def enter_history(cli, mouse_event):
python_input.enter_history(cli)
def get_tokens(cli):
python_buffer = cli.buffers[DEFAULT_BUFFER]
result = []
append = result.append
append((TB, ' '))
result.extend(get_inputmode_tokens(cli, python_input))
append((TB, ' '))
# Position in history.
append((TB, '%i/%i ' % (python_buffer.working_index + 1,
len(python_buffer._working_lines))))
# Shortcuts.
if not python_input.vi_mode and cli.current_buffer_name == SEARCH_BUFFER:
append((TB, '[Ctrl-G] Cancel search [Enter] Go to this position.'))
elif bool(cli.current_buffer.selection_state
) and not python_input.vi_mode:
# Emacs cut/copy keys.
append(
(TB,
'[Ctrl-W] Cut [Meta-W] Copy [Ctrl-Y] Paste [Ctrl-G] Cancel'))
else:
result.extend([
(TB.Key, '[F3]', enter_history),
(TB, ' History ', enter_history),
(TB.Key, '[F6]', toggle_paste_mode),
(TB, ' ', toggle_paste_mode),
])
if python_input.paste_mode:
append((TB.PasteModeOn, 'Paste mode (on)', toggle_paste_mode))
else:
append((TB, 'Paste mode', toggle_paste_mode))
return result
return TokenListToolbar(
get_tokens,
default_char=Char(token=TB),
filter=~IsDone() & RendererHeightIsKnown()
& Condition(lambda cli: python_input.show_status_bar and
not python_input.show_exit_confirmation))
def _build_cli(self):
eventloop = create_eventloop()
if self._options.persistent_history:
history = FileHistory(
os.path.join(
os.path.expanduser("~"), ".{}_history".format(self._ctx.binary_name)
)
)
else:
history = InMemoryHistory()
layout = create_prompt_layout(
lexer=PygmentsLexer(NubiaLexer),
reserve_space_for_menu=5,
get_prompt_tokens=self.get_prompt_tokens,
get_rprompt_tokens=self._status_bar.get_rprompt_tokens,
get_bottom_toolbar_tokens=self._status_bar.get_tokens,
display_completions_in_columns=False,
multiline=True,
extra_input_processors=[
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(chars="[](){}"),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone(),
)
],
)
buf = Buffer(
completer=self._completer,
history=history,
auto_suggest=self._suggestor,
complete_while_typing=Always(),
accept_action=AcceptAction.RETURN_DOCUMENT,
)
# If EDITOR does not exist, take EMACS
# if it does, try fit the EMACS/VI pattern using upper
editor = getattr(
EditingMode,
os.environ.get("EDITOR", EditingMode.EMACS).upper(),
EditingMode.EMACS,
)
application = Application(
style=shell_style,
buffer=buf,
editing_mode=editor,
key_bindings_registry=self._registry,
layout=layout,
on_exit=AbortAction.RAISE_EXCEPTION,
on_abort=AbortAction.RETRY,
ignore_case=True,
)
cli = CommandLineInterface(application=application, eventloop=eventloop)
return cli
def _build_cli(self, history):
def get_message():
prompt = self.get_prompt(self.prompt_format)
return [(u'class:prompt', prompt)]
def get_continuation(width):
continuation = self.multiline_continuation_char * (width - 1) + ' '
return [(u'class:continuation', continuation)]
get_toolbar_tokens = create_toolbar_tokens_func(self)
if self.wider_completion_menu:
complete_style = CompleteStyle.MULTI_COLUMN
else:
complete_style = CompleteStyle.COLUMN
with self._completer_lock:
self.prompt_session = PromptSession(
message=get_message,
style=style_factory(self.syntax_style, self.cli_style),
# Layout options.
lexer=PygmentsLexer(PostgresLexer),
prompt_continuation=get_continuation,
bottom_toolbar=get_toolbar_tokens,
complete_style=complete_style,
input_processors=[
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(
chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER)
& ~IsDone()), #FIXME: what is this?
# Render \t as 4 spaces instead of "^I"
TabsProcessor(char1=u' ', char2=u' ')
],
reserve_space_for_menu=self.min_num_menu_lines,
# Buffer options.
multiline=mssql_is_multiline(self),
completer=ThreadedCompleter(
DynamicCompleter(lambda: self.completer)),
history=history,
auto_suggest=AutoSuggestFromHistory(),
complete_while_typing=True,
# Key bindings.
enable_system_prompt=True,
enable_open_in_editor=True,
# Other options.
key_bindings=mssqlcli_bindings(self),
editing_mode=EditingMode.VI
if self.vi_mode else EditingMode.EMACS,
search_ignore_case=True)
return self.prompt_session
def _create_cli(self):
"""Creates the prompt_toolkit's CommandLineInterface.
Args:
* None.
Returns:
None.
"""
history = FileHistory(os.path.expanduser('~/.saws-history'))
toolbar = Toolbar(self.get_color,
self.get_fuzzy_match,
self.get_shortcut_match)
layout = create_default_layout(
message='saws> ',
reserve_space_for_menu=8,
lexer=CommandLexer,
get_bottom_toolbar_tokens=toolbar.handler,
extra_input_processors=[
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(
chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone())
]
)
cli_buffer = Buffer(
history=history,
auto_suggest=AutoSuggestFromHistory(),
enable_history_search=True,
completer=self.completer,
complete_while_typing=Always(),
accept_action=AcceptAction.RETURN_DOCUMENT)
self.key_manager = KeyManager(
self.set_color,
self.get_color,
self.set_fuzzy_match,
self.get_fuzzy_match,
self.set_shortcut_match,
self.get_shortcut_match,
self.refresh_resources_and_options,
self.handle_docs)
style_factory = StyleFactory(self.theme)
application = Application(
mouse_support=False,
style=style_factory.style,
layout=layout,
buffer=cli_buffer,
key_bindings_registry=self.key_manager.manager.registry,
on_exit=AbortAction.RAISE_EXCEPTION,
on_abort=AbortAction.RETRY,
ignore_case=True)
eventloop = create_eventloop()
self.aws_cli = CommandLineInterface(
application=application,
eventloop=eventloop)
def create_default_layout(message='', lexer=None, is_password=False,
reserve_space_for_menu=False, get_bottom_toolbar_tokens=None):
"""
Generate default layout.
"""
assert get_bottom_toolbar_tokens is None or callable(get_bottom_toolbar_tokens)
# Create processors list.
input_processors = [HighlightSearchProcessor(), HighlightSelectionProcessor()]
if is_password:
input_processors.extend([PasswordProcessor(), DefaultPrompt(message)])
else:
input_processors.append(DefaultPrompt(message))
# Create bottom toolbar.
if get_bottom_toolbar_tokens:
toolbars = [Window(TokenListControl(get_bottom_toolbar_tokens,
default_char=Char(' ', Token.Toolbar)),
height=LayoutDimension.exact(1),
filter=~IsDone())]
else:
toolbars = []
def get_height(cli):
# If there is an autocompletion menu to be shown, make sure that our
# layout has at least a minimal height in order to display it.
if reserve_space_for_menu and not cli.is_done:
return LayoutDimension(min=8)
else:
return LayoutDimension()
# Create and return Layout instance.
return HSplit([
FloatContainer(
Window(
BufferControl(
input_processors=input_processors,
lexer=lexer,
# Enable preview_search, we want to have immediate feedback
# in reverse-i-search mode.
preview_search=Always()),
get_height=get_height,
),
[
Float(xcursor=True,
ycursor=True,
content=CompletionsMenu(max_height=16,
extra_filter=HasFocus(DEFAULT_BUFFER)))
]
),
ValidationToolbar(),
SystemToolbar(),
] + toolbars)
def loop(cmd, history_file):
buf = create_buffer(cmd, history_file)
key_bindings = KeyBindings()
bind_keys(buf, key_bindings)
layout = create_layout(
buffer=buf,
multiline=True,
lexer=SqlLexer,
extra_input_processors=[
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone())
],
get_bottom_toolbar_tokens=lambda: get_toolbar_tokens(cmd),
get_prompt_tokens=lambda: [('class:prompt', 'cr> ')])
output = get_default_output()
app = Application(layout=layout,
style=style_from_pygments_cls(CrateStyle),
key_bindings=merge_key_bindings(
[key_bindings,
load_open_in_editor_bindings()]),
editing_mode=_get_editing_mode(),
output=output)
cmd.get_num_columns = lambda: output.get_size().columns
while True:
try:
text = app.run()
if text:
cmd.process(text)
buf.reset()
except ProgrammingError as e:
if '401' in e.message:
username = cmd.username
password = cmd.password
cmd.username = input('Username: '******'Bye!')
return
def create_layout(self, exam_lex, toolbar_lex):
""" creates the layout """
lexer, exam_lex, toolbar_lex = get_lexers(self.shell_ctx.lexer,
exam_lex, toolbar_lex)
if not any(
isinstance(processor, DefaultPrompt)
for processor in self.input_processors):
self.input_processors.append(DefaultPrompt(self.get_prompt_tokens))
layout_lower = ConditionalContainer(HSplit([
get_anyhline(self.shell_ctx.config),
get_descriptions(self.shell_ctx.config, exam_lex, lexer),
get_examplehline(self.shell_ctx.config),
get_example(self.shell_ctx.config, exam_lex),
ConditionalContainer(get_hline(),
filter=self.show_default | self.show_symbol),
ConditionalContainer(Window(content=BufferControl(
buffer_name='default_values', lexer=lexer)),
filter=self.show_default),
ConditionalContainer(get_hline(),
filter=self.show_default & self.show_symbol),
ConditionalContainer(Window(
content=BufferControl(buffer_name='symbols', lexer=exam_lex)),
filter=self.show_symbol),
ConditionalContainer(Window(
content=BufferControl(buffer_name='progress', lexer=lexer)),
filter=self.show_progress),
Window(content=BufferControl(buffer_name='bottom_toolbar',
lexer=toolbar_lex), ),
]),
filter=~IsDone()
& RendererHeightIsKnown())
layout_full = HSplit([
FloatContainer(
Window(
BufferControl(input_processors=self.input_processors,
lexer=lexer,
preview_search=Always()),
get_height=get_height,
), [
Float(xcursor=True,
ycursor=True,
content=CompletionsMenu(
max_height=MAX_COMPLETION,
scroll_offset=1,
extra_filter=(HasFocus(DEFAULT_BUFFER))))
]), layout_lower
])
return layout_full
def __init__(self, settings):
super(SignatureToolbar, self).__init__(
SignatureControl(settings),
height=LayoutDimension.exact(1),
filter=
# Show only when there is a signature
HasSignature(settings) &
# And there are no completions to be shown. (would cover signature pop-up.)
(~HasCompletions() | ~ShowCompletionsMenu(settings))
# Signature needs to be shown.
& ShowSignature(settings) &
# Not done yet.
~IsDone())
def create_cli_layout(self):
from .lexer import AzureShellLexer
lexer = AzureShellLexer
return create_default_layout(
message=u'azure> ',
reserve_space_for_menu=8,
lexer=lexer,
extra_input_processors=[
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(
chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone())
])
def _build_prompt_app(self, history):
key_bindings = cli_bindings(self)
def get_message():
prompt = self.get_prompt(self.prompt)
if len(prompt) > self.MAX_LEN_PROMPT:
prompt = self.get_prompt('\\r:\\d> ')
return [('class:prompt', prompt)]
def get_continuation(width, line_number, is_soft_wrap):
continuation = ' ' * (width - 1) + ' '
return [('class:continuation', continuation)]
def show_suggestion_tip():
return self.iterations < 2
get_toolbar_tokens = create_toolbar_tokens_func(
self, show_suggestion_tip)
with self._completer_lock:
if self.key_bindings == 'vi':
editing_mode = EditingMode.VI
else:
editing_mode = EditingMode.EMACS
self.prompt_app = PromptSession(
lexer=PygmentsLexer(Lexer),
reserve_space_for_menu=self.get_reserved_space(),
message=get_message,
prompt_continuation=get_continuation,
bottom_toolbar=get_toolbar_tokens,
complete_style=CompleteStyle.COLUMN,
input_processors=[
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(
chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone())
],
tempfile_suffix='.sql',
completer=DynamicCompleter(lambda: self.completer),
history=history,
auto_suggest=AutoSuggestFromHistory(),
complete_while_typing=True,
multiline=cli_is_multiline(self),
style=style_factory(self.syntax_style, self.cli_style),
include_default_pygments_style=False,
key_bindings=key_bindings,
enable_open_in_editor=True,
enable_system_prompt=True,
editing_mode=editing_mode,
search_ignore_case=True)
def create_default_layout(message='', lexer=None, is_password=False,
reserve_space_for_menu=False, get_bottom_toolbar_tokens=None):
"""
Generate default layout.
"""
assert get_bottom_toolbar_tokens is None or callable(get_bottom_toolbar_tokens)
# Create processors list.
if is_password:
input_processors = [PasswordProcessor(), DefaultPrompt(message)]
else:
input_processors = [DefaultPrompt(message)]
# Create bottom toolbar.
if get_bottom_toolbar_tokens:
toolbars = [Window(TokenListControl(get_bottom_toolbar_tokens,
default_char=Char(' ', Token.Toolbar)),
height=LayoutDimension.exact(1),
filter=~IsDone())]
else:
toolbars = []
def get_height(cli):
# If there is an autocompletion menu to be shown, make sure that our
# layout has at least a minimal height in order to display it.
if reserve_space_for_menu and not cli.is_done:
return LayoutDimension(min=8)
else:
return LayoutDimension()
# Create and return Layout instance.
return HSplit([
FloatContainer(
Window(
BufferControl(
input_processors=input_processors,
lexer=lexer),
get_height=get_height,
),
[
Float(xcursor=True,
ycursor=True,
content=CompletionsMenu(max_height=16,
extra_filter=HasFocus('default')))
]
),
ValidationToolbar(),
SystemToolbar(),
] + toolbars)
def __init__(self,
key_bindings_manager,
settings,
token=Token.Toolbar.Status):
def get_tokens(cli):
_, python_buffer = current_python_buffer(cli, settings)
if not python_buffer:
return []
TB = token
result = []
append = result.append
append((TB, ' '))
result.extend(get_inputmode_tokens(TB, key_bindings_manager, cli))
append((TB, ' '))
# Position in history.
append((TB, '%i/%i ' % (python_buffer.working_index + 1,
len(python_buffer._working_lines))))
# Shortcuts.
if not key_bindings_manager.enable_vi_mode and cli.focus_stack.current == 'search':
append((TB,
'[Ctrl-G] Cancel search [Enter] Go to this position.'))
elif bool(cli.current_buffer.selection_state
) and not key_bindings_manager.enable_vi_mode:
# Emacs cut/copy keys.
append((
TB,
'[Ctrl-W] Cut [Meta-W] Copy [Ctrl-Y] Paste [Ctrl-G] Cancel'
))
else:
append((TB, ' '))
if settings.paste_mode:
append((TB.On, '[F6] Paste mode (on) '))
else:
append((TB.Off, '[F6] Paste mode (off) '))
if python_buffer.is_multiline:
append((TB, ' [Meta+Enter] Execute'))
return result
super(PythonToolbar,
self).__init__(get_tokens,
default_char=Char(token=token),
filter=~IsDone() & RendererHeightIsKnown())
def main():
hy_repl = HyREPL()
eventloop = create_eventloop()
validator = HyValidator()
history = FileHistory(expanduser("~/.pthy_history"))
def src_is_multiline():
if app and app.buffer:
text = app.buffer.document.text
if '\n' in text:
return True
return False
app = create_default_application(
"λ: ",
validator=validator,
multiline=Condition(src_is_multiline),
lexer=HyLexer,
style=HyStyle,
history=history,
completer=HyCompleter(hy_repl),
display_completions_in_columns=True,
extra_input_processors=[
ConditionalProcessor(processor=HighlightMatchingBracketProcessor(),
filter=~IsDone())
])
# Somewhat ugly trick to add a margin to the multiline input
# without needing to define a custom layout
app.layout.children[0].children[
1].content.content.margin = ConditionalMargin(NumberredMargin(),
filter=IsMultiline())
cli = CommandLineInterface(application=app, eventloop=eventloop)
load_modified_bindings(app.key_bindings_registry)
hy_repl.cli = cli
try:
while True:
try:
code_obj = cli.run()
hy_repl.evaluate(code_obj.text)
except KeyboardInterrupt:
pass
except EOFError:
pass
finally:
eventloop.close()
def create_inquirer_layout(ic: InquirerControl,
get_prompt_tokens: Callable[[], List[Tuple[Text,
Text]]],
**kwargs) -> Layout:
"""Create a layout combining question and inquirer selection."""
ps = PromptSession(get_prompt_tokens, reserve_space_for_menu=0, **kwargs)
_fix_unecessary_blank_lines(ps)
return Layout(
HSplit([
ps.layout.container,
ConditionalContainer(Window(ic), filter=~IsDone())
]))
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 _extra_prompt_options(self):
"""
Return the current layout option for the current Terminal InteractiveShell
"""
def get_message():
return PygmentsTokens(self.prompts.in_prompt_tokens())
if self.editing_mode == 'emacs':
# with emacs mode the prompt is (usually) static, so we call only
# the function once. With VI mode it can toggle between [ins] and
# [nor] so we can't precompute.
# here I'm going to favor the default keybinding which almost
# everybody uses to decrease CPU usage.
# if we have issues with users with custom Prompts we can see how to
# work around this.
get_message = get_message()
options = {
'complete_in_thread':
False,
'lexer':
IPythonPTLexer(),
'reserve_space_for_menu':
self.space_for_menu,
'message':
get_message,
'prompt_continuation':
(lambda width, lineno, is_soft_wrap: PygmentsTokens(
self.prompts.continuation_prompt_tokens(width))),
'multiline':
True,
'complete_style':
self.pt_complete_style,
# Highlight matching brackets, but only when this setting is
# enabled, and only when the DEFAULT_BUFFER has the focus.
'input_processors': [
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(
chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone()
& Condition(lambda: self.highlight_matching_brackets))
],
}
if not PTK3:
options['inputhook'] = self.inputhook
return options
def __init__(self, max_height=None, scroll_offset=0, extra_filter=True, display_arrows=False):
extra_filter = to_cli_filter(extra_filter)
display_arrows = to_cli_filter(display_arrows)
super(CompletionsMenu, self).__init__(
content=Window(
content=CompletionsMenuControl(),
width=LayoutDimension(min=8),
height=LayoutDimension(min=1, max=max_height),
scroll_offsets=ScrollOffsets(top=scroll_offset, bottom=scroll_offset),
right_margins=[ScrollbarMargin(display_arrows=display_arrows)],
dont_extend_width=True,
),
# Show when there are completions but not at the point we are
# returning the input.
filter=HasCompletions() & ~IsDone() & extra_filter)
def _build_cli(self, history):
def set_vi_mode(value):
self.vi_mode = value
key_binding_manager = pgcli_bindings(
get_vi_mode_enabled=lambda: self.vi_mode,
set_vi_mode_enabled=set_vi_mode)
def prompt_tokens(_):
return [(Token.Prompt, '%s> ' % self.pgexecute.dbname)]
get_toolbar_tokens = create_toolbar_tokens_func(
lambda: self.vi_mode, self.completion_refresher.is_refreshing)
layout = create_default_layout(
lexer=PostgresLexer,
reserve_space_for_menu=True,
get_prompt_tokens=prompt_tokens,
get_bottom_toolbar_tokens=get_toolbar_tokens,
display_completions_in_columns=self.wider_completion_menu,
multiline=True,
extra_input_processors=[
# Highlight matching brackets while editing.
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(
chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone()),
])
with self._completer_lock:
buf = PGBuffer(always_multiline=self.multi_line,
completer=self.completer,
history=history,
complete_while_typing=Always())
application = Application(
style=style_factory(self.syntax_style, self.cli_style),
layout=layout,
buffer=buf,
key_bindings_registry=key_binding_manager.registry,
on_exit=AbortAction.RAISE_EXCEPTION,
ignore_case=True)
cli = CommandLineInterface(application=application,
eventloop=create_eventloop())
return cli
def _build_cli(self):
eventloop = create_eventloop()
history = FileHistory(
os.path.join(
os.path.expanduser("~"),
".{}_history".format(self._ctx.binary_name),
))
layout = create_prompt_layout(
lexer=PygmentsLexer(NubiaLexer),
reserve_space_for_menu=5,
get_prompt_tokens=self.get_prompt_tokens,
get_rprompt_tokens=self._status_bar.get_rprompt_tokens,
get_bottom_toolbar_tokens=self._status_bar.get_tokens,
display_completions_in_columns=False,
multiline=True,
extra_input_processors=[
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(
chars="[](){}"),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone(),
)
],
)
buf = Buffer(
completer=self._completer,
history=history,
auto_suggest=self._suggestor,
complete_while_typing=Always(),
accept_action=AcceptAction.RETURN_DOCUMENT,
)
application = Application(
style=shell_style,
buffer=buf,
key_bindings_registry=self._registry,
layout=layout,
on_exit=AbortAction.RAISE_EXCEPTION,
on_abort=AbortAction.RETRY,
ignore_case=True,
)
cli = CommandLineInterface(application=application,
eventloop=eventloop)
return cli
def create_layout(lex, exam_lex, toolbar_lex):
""" creates the layout """
config = azclishell.configuration.CONFIGURATION
lexer, exam_lex, toolbar_lex = get_lexers(lex, exam_lex, toolbar_lex)
input_processors.append(DefaultPrompt(get_prompt_tokens))
layout_lower = ConditionalContainer(HSplit([
get_anyhline(config),
get_descriptions(config, exam_lex, lexer),
get_examplehline(config),
get_example(config, exam_lex),
ConditionalContainer(get_hline(), filter=ShowDefault() | ShowSymbol()),
ConditionalContainer(Window(
content=BufferControl(buffer_name='default_values', lexer=lexer)),
filter=ShowDefault()),
ConditionalContainer(get_hline(), filter=ShowDefault() & ShowSymbol()),
ConditionalContainer(Window(
content=BufferControl(buffer_name='symbols', lexer=exam_lex)),
filter=ShowSymbol()),
ConditionalContainer(
Window(content=BufferControl(buffer_name='progress', lexer=lexer)),
filter=ShowProgress()),
Window(content=BufferControl(buffer_name='bottom_toolbar',
lexer=toolbar_lex), ),
]),
filter=~IsDone()
& RendererHeightIsKnown())
layout_full = HSplit([
FloatContainer(
Window(
BufferControl(input_processors=input_processors,
lexer=lexer,
preview_search=Always()),
get_height=get_height,
), [
Float(xcursor=True,
ycursor=True,
content=CompletionsMenu(
max_height=MAX_COMPLETION,
scroll_offset=1,
extra_filter=(HasFocus(DEFAULT_BUFFER))))
]), layout_lower
])
return layout_full
def _factory():
return [
window_class(
control,
height=LayoutDimension(max=page_size),
dont_extend_height=True,
wrap_lines=True,
),
ConditionalContainer(
Window(
TokenListControl(_get_default_pager_tokens),
dont_extend_height=True,
wrap_lines=True,
),
filter=NeedsScrollTip(page_size) & ~IsDone(),
),
]
def __init__(self, project=None, instance=None, database=None, credentials=None, with_pager=False,
inp=None, output=None):
# setup environment variables
# less option for pager
if not os.environ.get(config.EnvironmentVariables.LESS):
os.environ[config.EnvironmentVariables.LESS] = config.Constants.LESS_FLAG
self.with_pager = with_pager
self.logger = logging.getLogger('spanner-cli')
self.logger.debug("Staring spanner-cli project=%s, instance=%s, database=%s", project, instance, database)
self.project = project
with warnings.catch_warnings(record=True) as warns:
warnings.simplefilter("always")
self.client = spanner.Client(
project=self.project,
credentials=credentials,
client_info=client_info.ClientInfo(user_agent=__name__),
)
if len(warns) > 0:
for w in warns:
self.logger.debug(w)
click.echo(message=w.message, err=True, nl=True)
self.instance = self.client.instance(instance)
self.database = self.instance.database(database)
self.prompt_message = self.get_prompt_message()
self.completer = SQLCompleter()
self.open_history_file()
self.rehash()
self.session = PromptSession(
message=self.prompt_message,
lexer=PygmentsLexer(lexer.SpannerLexer),
completer=DynamicCompleter(lambda: self.completer),
style=style_from_pygments_cls(get_style_by_name(config.get_pygment_style())),
history=self.history,
auto_suggest=AutoSuggestFromHistory(),
input_processors=[ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(
chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone() # pylint: disable=invalid-unary-operand-type
)],
input=inp,
output=output,
)
self.formatter = tabular_output.TabularOutputFormatter('ascii')
def exit_confirmation(python_input, token=Token.ExitConfirmation):
"""
Create `Layout` for the exit message.
"""
def get_tokens(cli):
# Show "Do you really want to exit?"
return [
(token, '\n %s ([y]/n)' % python_input.exit_message),
(Token.SetCursorPosition, ''),
(token, ' \n'),
]
visible = ~IsDone() & Condition(lambda cli: python_input.show_exit_confirmation)
return ConditionalContainer(
content=Window(TokenListControl(
get_tokens, default_char=Char(token=token), has_focus=visible)),
filter=visible)
def __init__(self, pdb_ref):
token = Token.Toolbar.Shortcuts
def get_tokens(cli):
if pdb_ref().callstack_focussed:
return [
(token.Description, ' '),
(token.Key, '[Ctrl-X]'),
(token.Description, ' Focus CLI '),
(token.Key, '[Enter]'),
(token.Description, ' Go to frame '),
(token.Key, '[Arrows]'),
(token.Description, ' Navigate '),
]
elif cli.current_buffer_name == 'source_code':
return [
(token.Description, ' '),
(token.Key, '[Ctrl-X]'),
(token.Description, ' Focus CLI '),
(token.Key, '[s]'),
(token.Description, 'tep '),
(token.Key, '[n]'),
(token.Description, 'ext '),
(token.Key, '[c]'),
(token.Description, 'ontinue '),
(token.Key, '[q]'),
(token.Description, 'uit '),
(token.Key, '[b]'),
(token.Description, 'reak '),
(token.Key, '[Arrows]'),
(token.Description, ' Navigate '),
]
else:
return [
(token.Description, ' '),
(token.Key, '[Ctrl-X]'),
(token.Description, ' Focus source code '),
]
super(PdbShortcutsToolbar,
self).__init__(get_tokens,
default_char=Char(token=token.Description),
filter=~IsDone())
def _layout_options(self):
"""
Return the current layout option for the current Terminal InteractiveShell
"""
return {
'lexer':IPythonPTLexer(),
'reserve_space_for_menu':self.space_for_menu,
'get_prompt_tokens':self.prompts.in_prompt_tokens,
'get_continuation_tokens':self.prompts.continuation_prompt_tokens,
'multiline':True,
'display_completions_in_columns': (self.display_completions == 'multicolumn'),
# Highlight matching brackets, but only when this setting is
# enabled, and only when the DEFAULT_BUFFER has the focus.
'extra_input_processors': [ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone() &
Condition(lambda cli: self.highlight_matching_brackets))],
}
def meta_enter_message(python_input):
"""
Create the `Layout` for the 'Meta+Enter` message.
"""
def get_tokens(cli):
return [(Token.AcceptMessage, ' [Meta+Enter] Execute ')]
def extra_condition(cli):
" Only show when... "
b = cli.buffers[DEFAULT_BUFFER]
return (python_input.show_meta_enter_message
and (not b.document.is_cursor_at_the_end
or python_input.accept_input_on_enter is None)
and b.is_multiline())
visible = ~IsDone() & HasFocus(DEFAULT_BUFFER) & Condition(extra_condition)
return ConditionalContainer(content=Window(TokenListControl(get_tokens)),
filter=visible)
