def _CreatePromptApplication(self, config, multiline):
"""Creates a shell prompt Application."""
return pt_application.Application(
layout=layout.CreatePromptLayout(
config=config,
extra_input_processors=[Context()],
get_bottom_status_tokens=self._GetBottomStatusTokens,
get_bottom_toolbar_tokens=self._GetBottomToolbarTokens,
get_continuation_tokens=None,
get_prompt_tokens=None,
is_password=False,
lexer=None,
multiline=filters.Condition(lambda cli: multiline()),
show_help=filters.Condition(
lambda _: self.key_bindings.help_key.toggle),
wrap_lines=True,
),
buffer=self.default_buffer,
clipboard=None,
erase_when_done=False,
get_title=None,
key_bindings_registry=self.key_bindings.MakeRegistry(),
mouse_support=False,
reverse_vi_search_direction=True,
style=interactive_style.GetDocumentStyle(),
)
def _CreatePromptApplication(self):
"""Creates a shell prompt Application."""
# Make sure that complete_while_typing is disabled when
# enable_history_search is enabled. (First convert to SimpleFilter, to
# avoid doing bitwise operations on bool objects.)
complete_while_typing = shortcuts.to_simple_filter(True)
enable_history_search = shortcuts.to_simple_filter(False)
multiline = shortcuts.to_simple_filter(False)
complete_while_typing &= ~enable_history_search
return application.Application(
layout=layout.CreatePromptLayout(
message=self.prompt,
lexer=None,
is_password=False,
reserve_space_for_menu=self.MENU_RESERVE_SPACE,
multiline=filters.Condition(lambda cli: multiline()),
get_prompt_tokens=None,
get_continuation_tokens=None,
get_bottom_toolbar_tokens=self._GetBottomToolbarTokens,
display_completions_in_columns=False,
extra_input_processors=None,
wrap_lines=True,
show_help=filters.Condition(
lambda _: self.key_bindings.help_key.toggle)),
buffer=pt_buffer.Buffer(
enable_history_search=enable_history_search,
complete_while_typing=complete_while_typing,
is_multiline=multiline,
history=pt_history.InMemoryHistory(),
validator=None,
completer=shell_completer.ShellCliCompleter(),
auto_suggest=None,
accept_action=pt_buffer.AcceptAction.RETURN_DOCUMENT,
initial_document=document.Document(''),
),
style=shell_style.GetDocumentStyle(),
clipboard=None,
key_bindings_registry=self.key_bindings.MakeRegistry(),
get_title=None,
mouse_support=False,
erase_when_done=False,
on_abort=application.AbortAction.RAISE_EXCEPTION,
on_exit=application.AbortAction.RAISE_EXCEPTION)
def CreatePromptLayout(config,
lexer=None,
is_password=False,
get_prompt_tokens=None,
get_continuation_tokens=None,
get_bottom_status_tokens=None,
get_bottom_toolbar_tokens=None,
extra_input_processors=None,
multiline=False,
show_help=True,
wrap_lines=True):
"""Create a container instance for the prompt."""
assert get_bottom_status_tokens is None or callable(
get_bottom_status_tokens)
assert get_bottom_toolbar_tokens is None or callable(
get_bottom_toolbar_tokens)
assert get_prompt_tokens is None or callable(get_prompt_tokens)
assert not (config.prompt and get_prompt_tokens)
multi_column_completion_menu = filters.to_cli_filter(
config.multi_column_completion_menu)
multiline = filters.to_cli_filter(multiline)
if get_prompt_tokens is None:
get_prompt_tokens = lambda _: [(token.Token.Prompt, config.prompt)]
has_before_tokens, get_prompt_tokens_1, get_prompt_tokens_2 = (
shortcuts._split_multiline_prompt(get_prompt_tokens)) # pylint: disable=protected-access
# TODO(b/35347840): reimplement _split_multiline_prompt to remove
# protected-access.
# Create processors list.
input_processors = [
processors.ConditionalProcessor(
# By default, only highlight search when the search
# input has the focus. (Note that this doesn't mean
# there is no search: the Vi 'n' binding for instance
# still allows to jump to the next match in
# navigation mode.)
processors.HighlightSearchProcessor(preview_search=True),
filters.HasFocus(enums.SEARCH_BUFFER)),
processors.HighlightSelectionProcessor(),
processors.ConditionalProcessor(
processors.AppendAutoSuggestion(),
filters.HasFocus(enums.DEFAULT_BUFFER)
& ~filters.IsDone()),
processors.ConditionalProcessor(processors.PasswordProcessor(),
is_password),
]
if extra_input_processors:
input_processors.extend(extra_input_processors)
# Show the prompt before the input using the DefaultPrompt processor.
# This also replaces it with reverse-i-search and 'arg' when required.
# (Only for single line mode.)
# (DefaultPrompt should always be at the end of the processors.)
input_processors.append(
processors.ConditionalProcessor(
prompt.DefaultPrompt(get_prompt_tokens_2), ~multiline))
# Create toolbars
toolbars = []
if config.fixed_prompt_position:
help_height = dimension.LayoutDimension.exact(config.help_lines)
help_filter = (show_help & ~filters.IsDone()
& filters.RendererHeightIsKnown())
else:
help_height = dimension.LayoutDimension(preferred=config.help_lines,
max=config.help_lines)
help_filter = (show_help & UserTypingFilter & ~filters.IsDone()
& filters.RendererHeightIsKnown())
toolbars.append(
containers.ConditionalContainer(layout.HSplit([
layout.Window(
controls.FillControl(char=screen.Char('_', token.Token.HSep)),
height=dimension.LayoutDimension.exact(1)),
layout.Window(help_window.HelpWindowControl(
default_char=screen.Char(' ', token.Token.Toolbar)),
height=help_height),
]),
filter=help_filter))
if (config.bottom_status_line and get_bottom_status_tokens
or config.bottom_bindings_line and get_bottom_toolbar_tokens):
windows = []
windows.append(
layout.Window(
controls.FillControl(char=screen.Char('_', token.Token.HSep)),
height=dimension.LayoutDimension.exact(1)))
if config.bottom_status_line and get_bottom_status_tokens:
windows.append(
layout.Window(controls.TokenListControl(
get_bottom_status_tokens,
default_char=screen.Char(' ', token.Token.Toolbar)),
height=dimension.LayoutDimension.exact(1)))
if config.bottom_bindings_line and get_bottom_toolbar_tokens:
windows.append(
layout.Window(controls.TokenListControl(
get_bottom_toolbar_tokens,
default_char=screen.Char(' ', token.Token.Toolbar)),
height=dimension.LayoutDimension.exact(1)))
toolbars.append(
containers.ConditionalContainer(layout.HSplit(windows),
filter=~filters.IsDone()
& filters.RendererHeightIsKnown()))
def GetHeight(cli):
"""Determine the height for the input buffer."""
# 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 cli.config.completion_menu_lines and not cli.is_done:
# Reserve the space, either when there are completions, or when
# `complete_while_typing` is true and we expect completions very
# soon.
buf = cli.current_buffer
# if UserTypingFilter(cli) or not buf.text or buf.complete_state:
if UserTypingFilter(cli) or buf.complete_state:
return dimension.LayoutDimension(
min=cli.config.completion_menu_lines + 1)
return dimension.LayoutDimension()
# Create and return Container instance.
return layout.HSplit([
# The main input, with completion menus floating on top of it.
containers.FloatContainer(
layout.HSplit([
containers.ConditionalContainer(
layout.Window(
controls.TokenListControl(get_prompt_tokens_1),
dont_extend_height=True,
wrap_lines=wrap_lines,
),
filters.Condition(has_before_tokens),
),
layout.Window(
controls.BufferControl(
input_processors=input_processors,
lexer=lexer,
# Enable preview_search, we want to have immediate
# feedback in reverse-i-search mode.
preview_search=True,
),
get_height=GetHeight,
left_margins=[
# In multiline mode, use the window margin to display
# the prompt and continuation tokens.
margins.ConditionalMargin(
margins.PromptMargin(get_prompt_tokens_2,
get_continuation_tokens),
filter=multiline,
),
],
wrap_lines=wrap_lines,
),
]),
[
# Completion menus.
layout.Float(
xcursor=True,
ycursor=True,
content=menus.CompletionsMenu(
max_height=16,
scroll_offset=1,
extra_filter=(filters.HasFocus(enums.DEFAULT_BUFFER)
& ~multi_column_completion_menu),
),
),
layout.Float(
ycursor=True,
content=menus.MultiColumnCompletionsMenu(
show_meta=True,
extra_filter=(filters.HasFocus(enums.DEFAULT_BUFFER)
& multi_column_completion_menu),
),
),
],
),
pt_toolbars.ValidationToolbar(),
pt_toolbars.SystemToolbar(),
# In multiline mode, we use two toolbars for 'arg' and 'search'.
containers.ConditionalContainer(pt_toolbars.ArgToolbar(), multiline),
containers.ConditionalContainer(pt_toolbars.SearchToolbar(),
multiline),
] + toolbars)
def __init__(self, *args, **kwargs):
is_multiline = pt_filters.Condition(self.is_multiline_impl)
super().__init__(*args, is_multiline=is_multiline, **kwargs)
def CreatePromptApplication(
message='',
multiline=False,
wrap_lines=True,
is_password=False,
complete_while_typing=True,
enable_history_search=False,
lexer=None,
enable_system_bindings=False,
enable_open_in_editor=False,
validator=None,
completer=None,
reserve_space_for_menu=5,
auto_suggest=None,
style=None,
history=None,
clipboard=None,
get_prompt_tokens=None,
get_continuation_tokens=None,
get_bottom_toolbar_tokens=None,
display_completions_in_columns=False,
get_title=None,
mouse_support=False,
extra_input_processors=None,
key_bindings_registry=None,
on_abort=application.AbortAction.RAISE_EXCEPTION,
on_exit=application.AbortAction.RAISE_EXCEPTION,
accept_action=pt_buffer.AcceptAction.RETURN_DOCUMENT,
erase_when_done=False,
default='',
get_help_tokens=None):
"""Create the shell prompt Application."""
if key_bindings_registry is None:
key_bindings_registry = manager.KeyBindingManager.for_prompt(
enable_system_bindings=enable_system_bindings,
enable_open_in_editor=enable_open_in_editor).registry
# Make sure that complete_while_typing is disabled when enable_history_search
# is enabled. (First convert to SimpleFilter, to avoid doing bitwise
# operations on bool objects.)
complete_while_typing = shortcuts.to_simple_filter(complete_while_typing)
enable_history_search = shortcuts.to_simple_filter(enable_history_search)
multiline = shortcuts.to_simple_filter(multiline)
complete_while_typing &= ~enable_history_search
# Create application
return application.Application(
layout=layout.CreatePromptLayout(
message=message,
lexer=lexer,
is_password=is_password,
reserve_space_for_menu=(reserve_space_for_menu
if completer is not None else 0),
multiline=filters.Condition(lambda cli: multiline()),
get_prompt_tokens=get_prompt_tokens,
get_continuation_tokens=get_continuation_tokens,
get_bottom_toolbar_tokens=get_bottom_toolbar_tokens,
display_completions_in_columns=display_completions_in_columns,
extra_input_processors=extra_input_processors,
wrap_lines=wrap_lines,
get_help_tokens=get_help_tokens,
show_help=filters.Condition(lambda _: SHOW_HELP_WINDOW)),
buffer=pt_buffer.Buffer(
enable_history_search=enable_history_search,
complete_while_typing=complete_while_typing,
is_multiline=multiline,
history=(history or pt_history.InMemoryHistory()),
validator=validator,
completer=completer,
auto_suggest=auto_suggest,
accept_action=accept_action,
initial_document=document.Document(default),
),
style=style,
clipboard=clipboard,
key_bindings_registry=key_bindings_registry,
get_title=get_title,
mouse_support=mouse_support,
erase_when_done=erase_when_done,
on_abort=on_abort,
on_exit=on_exit)
def __init__(
self,
switchboard_inst: switchboard_base.SwitchboardBase,
device_log_file_name: str,
configuration: console_config.ConsoleConfiguration,
console_input: Optional[prompt_toolkit_input.Input] = None,
console_output: Optional[output.Output] = None) -> None:
"""Initializes a prompt_toolkit console application.
Args:
switchboard_inst: Switchboard capability instance.
device_log_file_name: The device log file to read (stream) logs from.
configuration: Console configuration.
console_input: Console input. Defaults to stdin.
console_output: Console output. Defaults to stdout.
"""
self._device_log_file_name = device_log_file_name
self._window_line_transforms = configuration.window_line_transforms
self._line_to_window_id = configuration.line_to_window_id
self._log_file = None # Set by run().
body_frames = []
self._window_id_to_text_area = collections.OrderedDict()
for window in configuration.windows:
text_area, enclosing_frame = _make_ui_window(window, switchboard_inst)
self._window_id_to_text_area[window.window_id] = text_area
body_frames.append(enclosing_frame)
self._menu_exit_item = widgets.MenuItem("Exit", handler=_do_exit)
if body_frames:
self._default_focused_element = body_frames[0]
else:
self._default_focused_element = self._menu_exit_item
help_window_visibility = _HelpWindowVisibility(
focus_element_on_hide=self._default_focused_element)
close_help_button = widgets.Button(
text="Ok",
handler=help_window_visibility.hide)
help_window_visibility.focus_element_on_show = close_help_button
help_float_dialog = containers.Float(
containers.ConditionalContainer(
content=widgets.Dialog(
title="Console help",
body=widgets.TextArea(
text=_HELP_TEXT,
focusable=True,
read_only=True,
scrollbar=True,
width=_HELP_TEXT_WIDTH,
),
buttons=[close_help_button],
),
filter=filters.Condition(help_window_visibility.is_visible),
),
)
root_container = widgets.MenuContainer(
body=containers.FloatContainer(
content=containers.HSplit(body_frames),
floats=[help_float_dialog],
),
menu_items=[
self._menu_exit_item,
widgets.MenuItem("Help", handler=help_window_visibility.show),
],
)
button_list = switchboard_inst.button_list
button_names = button_list[0].valid_buttons() if button_list else []
if button_names:
button_menu_items = [
_make_button_menu_item(button_name, switchboard_inst, root_container)
for button_name in button_names
]
self._button_dropdown = widgets.MenuItem(
"Buttons", children=button_menu_items)
root_container.menu_items.append(self._button_dropdown)
else:
self._button_dropdown = None
# Global key bindings.
bindings = key_binding.KeyBindings()
bindings.add("tab")(focus.focus_next)
bindings.add("s-tab")(focus.focus_previous)
style = styles.Style.from_dict({
"menu-bar": "bg:#aaaaaa #888888",
})
self._application = application.Application(
layout=layout.Layout(
container=root_container,
focused_element=self._default_focused_element,
),
style=style,
full_screen=True,
key_bindings=bindings,
editing_mode=enums.EditingMode.VI,
input=console_input,
output=console_output,
)
