output_field = TextArea(style='class:output-field',
scrollbar=True,
line_numbers=True,
text=help_text,
search_field=search_field,
lexer=PygmentsLexer(JsonLexer))
input_field = UrlArea(height=3,
prompt='>>> ',
style='class:input-field',
completer=http_completer,
accept_handler=True)
input_field.control.input_processors.append(AppendAutoSuggestion())
container = HSplit([
Label('Request URL'),
HSplit([Frame(input_field), CompletionsToolbar()]),
HSplit([output_field, search_field])
])
root_container = VSplit([
Window(width=10, content=BufferControl(buffer=buffer)),
Window(width=1, char='|'),
container,
ArgToolbar(),
SystemToolbar(),
ValidationToolbar(),
])
layout = Layout(root_container)
"[q] Quit [a] Focus left top [b] Right top [c] Left bottom [d] Right bottom."
)
LIPSUM = """Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Maecenas quis interdum enim. Nam viverra, mauris et blandit malesuada, ante est
bibendum mauris, ac dignissim dui tellus quis ligula. Aenean condimentum leo at
dignissim placerat. In vel dictum ex, vulputate accumsan mi. Donec ut quam
placerat massa tempor elementum. Sed tristique mauris ac suscipit euismod. Ut
tempus vehicula augue non venenatis. Mauris aliquam velit turpis, nec congue
risus aliquam sit amet. Pellentesque blandit scelerisque felis, faucibus
consequat ante. Curabitur tempor tortor a imperdiet tincidunt. Nam sed justo
sit amet odio bibendum congue. Quisque varius ligula nec ligula gravida, sed
convallis augue faucibus. Nunc ornare pharetra bibendum. Praesent blandit ex
quis sodales maximus. """
left_top = Window(BufferControl(Buffer(document=Document(LIPSUM))))
left_bottom = Window(BufferControl(Buffer(document=Document(LIPSUM))))
right_top = Window(BufferControl(Buffer(document=Document(LIPSUM))))
right_bottom = Window(BufferControl(Buffer(document=Document(LIPSUM))))
body = HSplit([
Window(FormattedTextControl(top_text), height=2, style='reverse'),
Window(height=1, char='-'), # Horizontal line in the middle.
VSplit([left_top, Window(width=1, char='|'), right_top]),
Window(height=1, char='-'), # Horizontal line in the middle.
VSplit([left_bottom, Window(width=1, char='|'), right_bottom]),
])
# 2. Key bindings
kb = KeyBindings()
def __init__(
self,
text: str = "",
multiline: FilterOrBool = True,
password: FilterOrBool = False,
lexer: Optional[Lexer] = None,
auto_suggest: Optional[AutoSuggest] = None,
completer: Optional[Completer] = None,
complete_while_typing: FilterOrBool = True,
validator: Optional[Validator] = None,
accept_handler: Optional[BufferAcceptHandler] = None,
history: Optional[History] = None,
focusable: FilterOrBool = True,
focus_on_click: FilterOrBool = False,
wrap_lines: FilterOrBool = True,
read_only: FilterOrBool = False,
width: AnyDimension = None,
height: AnyDimension = None,
dont_extend_height: FilterOrBool = False,
dont_extend_width: FilterOrBool = False,
line_numbers: bool = False,
get_line_prefix: Optional[GetLinePrefixCallable] = None,
scrollbar: bool = False,
style: str = "",
search_field: Optional[SearchToolbar] = None,
preview_search: FilterOrBool = True,
prompt: AnyFormattedText = "",
input_processors: Optional[List[Processor]] = None,
) -> None:
if search_field is None:
search_control = None
elif isinstance(search_field, SearchToolbar):
search_control = search_field.control
if input_processors is None:
input_processors = []
# Writeable attributes.
self.completer = completer
self.complete_while_typing = complete_while_typing
self.lexer = lexer
self.auto_suggest = auto_suggest
self.read_only = read_only
self.wrap_lines = wrap_lines
self.validator = validator
self.buffer = Buffer(
document=Document(text, 0),
multiline=multiline,
read_only=Condition(lambda: is_true(self.read_only)),
completer=DynamicCompleter(lambda: self.completer),
complete_while_typing=Condition(
lambda: is_true(self.complete_while_typing)),
validator=DynamicValidator(lambda: self.validator),
auto_suggest=DynamicAutoSuggest(lambda: self.auto_suggest),
accept_handler=accept_handler,
history=history,
)
self.control = BufferControl(
buffer=self.buffer,
lexer=DynamicLexer(lambda: self.lexer),
input_processors=[
ConditionalProcessor(AppendAutoSuggestion(),
has_focus(self.buffer) & ~is_done),
ConditionalProcessor(processor=PasswordProcessor(),
filter=to_filter(password)),
BeforeInput(prompt, style="class:text-area.prompt"),
] + input_processors,
search_buffer_control=search_control,
preview_search=preview_search,
focusable=focusable,
focus_on_click=focus_on_click,
)
if multiline:
if scrollbar:
right_margins = [ScrollbarMargin(display_arrows=True)]
else:
right_margins = []
if line_numbers:
left_margins = [NumberedMargin()]
else:
left_margins = []
else:
height = D.exact(1)
left_margins = []
right_margins = []
style = "class:text-area " + style
# If no height was given, guarantee height of at least 1.
if height is None:
height = D(min=1)
self.window = Window(
height=height,
width=width,
dont_extend_height=dont_extend_height,
dont_extend_width=dont_extend_width,
content=self.control,
style=style,
wrap_lines=Condition(lambda: is_true(self.wrap_lines)),
left_margins=left_margins,
right_margins=right_margins,
get_line_prefix=get_line_prefix,
)
quis sodales maximus."""
# Create text buffers.
buff = Buffer()
buff.text = LIPSUM
# 1. The layout
color_columns = [
ColorColumn(50),
ColorColumn(80, style='bg:#ff0000'),
ColorColumn(10, style='bg:#ff0000'),
]
body = HSplit([
Window(FormattedTextControl('Press "q" to quit.'), height=1, style='reverse'),
Window(BufferControl(buffer=buff), colorcolumns=color_columns),
])
# 2. Key bindings
kb = KeyBindings()
@kb.add('q')
def _(event):
" Quit application. "
event.app.exit()
# 3. The `Application`
application = Application(
def create_layout(python_input, key_bindings_manager,
lexer=PythonLexer,
extra_body=None, extra_toolbars=None,
extra_buffer_processors=None, input_buffer_height=None):
D = LayoutDimension
extra_body = [extra_body] if extra_body else []
extra_toolbars = extra_toolbars or []
extra_buffer_processors = extra_buffer_processors or []
input_buffer_height = input_buffer_height or D(min=6)
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),
)
return HSplit([
VSplit([
HSplit([
FloatContainer(
content=HSplit(
[create_python_input_window()] + extra_body
),
floats=[
Float(xcursor=True,
ycursor=True,
content=CompletionsMenu(
scroll_offset=Integer.from_callable(
lambda: python_input.completion_menu_scroll_offset),
max_height=12,
extra_filter=show_completions_menu(python_input))),
Float(xcursor=True,
ycursor=True,
content=MultiColumnCompletionsMenu(
extra_filter=show_multi_column_completions_menu(python_input))),
Float(xcursor=True,
ycursor=True,
content=signature_toolbar(python_input)),
Float(left=2,
bottom=1,
content=exit_confirmation(python_input)),
Float(bottom=0, right=0, height=1,
content=meta_enter_message(python_input),
hide_when_covering_content=True),
Float(bottom=1, left=1, right=0, content=python_sidebar_help(python_input)),
]),
ArgToolbar(),
SearchToolbar(),
SystemToolbar(),
ValidationToolbar(),
CompletionsToolbar(extra_filter=show_completions_toolbar(python_input)),
# Docstring region.
ConditionalContainer(
content=Window(height=D.exact(1),
content=FillControl('\u2500', token=Token.Separator)),
filter=HasSignature(python_input) & ShowDocstring(python_input) & ~IsDone()),
ConditionalContainer(
content=Window(
BufferControl(
buffer_name='docstring',
lexer=SimpleLexer(default_token=Token.Docstring),
#lexer=PythonLexer,
),
height=D(max=12)),
filter=HasSignature(python_input) & ShowDocstring(python_input) & ~IsDone(),
),
]),
HSplit([
python_sidebar(python_input),
python_sidebar_navigation(python_input),
])
]),
] + extra_toolbars + [
VSplit([
status_bar(key_bindings_manager, python_input),
show_sidebar_button_info(python_input),
])
])
def __init__(
self,
python_input: "PythonInput",
lexer=PythonLexer,
extra_body=None,
extra_toolbars=None,
extra_buffer_processors=None,
input_buffer_height: Optional[AnyDimension] = None,
) -> None:
D = Dimension
extra_body = [extra_body] if extra_body else []
extra_toolbars = extra_toolbars or []
extra_buffer_processors = extra_buffer_processors or []
input_buffer_height = input_buffer_height or D(min=6)
search_toolbar = SearchToolbar(python_input.search_buffer)
def create_python_input_window():
def menu_position():
"""
When there is no autocompletion menu to be shown, and we have a
signature, set the pop-up position at `bracket_start`.
"""
b = python_input.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=python_input.default_buffer,
search_buffer_control=search_toolbar.control,
lexer=lexer,
include_default_input_processors=False,
input_processors=[
ConditionalProcessor(
processor=HighlightIncrementalSearchProcessor(),
filter=has_focus(SEARCH_BUFFER)
| has_focus(search_toolbar.control),
),
HighlightSelectionProcessor(),
DisplayMultipleCursors(),
# Show matching parentheses, but only while editing.
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(
chars="[](){}"),
filter=has_focus(DEFAULT_BUFFER)
& ~is_done
& Condition(lambda: python_input.
highlight_matching_parenthesis),
),
ConditionalProcessor(processor=AppendAutoSuggestion(),
filter=~is_done),
] + 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.
height=(lambda:
(None if get_app().is_done or python_input.
show_exit_confirmation else input_buffer_height)),
wrap_lines=Condition(lambda: python_input.wrap_lines),
)
sidebar = python_sidebar(python_input)
root_container = HSplit([
VSplit([
HSplit([
FloatContainer(
content=HSplit([create_python_input_window()] +
extra_body),
floats=[
Float(
xcursor=True,
ycursor=True,
content=ConditionalContainer(
content=CompletionsMenu(
scroll_offset=(
lambda: python_input.
completion_menu_scroll_offset),
max_height=12,
),
filter=show_completions_menu(python_input),
),
),
Float(
xcursor=True,
ycursor=True,
content=ConditionalContainer(
content=MultiColumnCompletionsMenu(),
filter=show_multi_column_completions_menu(
python_input),
),
),
Float(
xcursor=True,
ycursor=True,
content=signature_toolbar(python_input),
),
Float(
left=2,
bottom=1,
content=exit_confirmation(python_input),
),
Float(
bottom=0,
right=0,
height=1,
content=meta_enter_message(python_input),
hide_when_covering_content=True,
),
Float(
bottom=1,
left=1,
right=0,
content=python_sidebar_help(python_input),
),
],
),
ArgToolbar(),
search_toolbar,
SystemToolbar(),
ValidationToolbar(),
ConditionalContainer(
content=CompletionsToolbar(),
filter=show_completions_toolbar(python_input)
& ~is_done,
),
# Docstring region.
ConditionalContainer(
content=Window(
height=D.exact(1),
char="\u2500",
style="class:separator",
),
filter=HasSignature(python_input)
& ShowDocstring(python_input)
& ~is_done,
),
ConditionalContainer(
content=Window(
BufferControl(
buffer=python_input.docstring_buffer,
lexer=SimpleLexer(style="class:docstring"),
# lexer=PythonLexer,
),
height=D(max=12),
),
filter=HasSignature(python_input)
& ShowDocstring(python_input)
& ~is_done,
),
]),
ConditionalContainer(
content=HSplit([
sidebar,
Window(style="class:sidebar,separator", height=1),
python_sidebar_navigation(python_input),
]),
filter=ShowSidebar(python_input) & ~is_done,
),
])
] + extra_toolbars + [
VSplit([
status_bar(python_input),
show_sidebar_button_info(python_input)
])
])
self.layout = Layout(root_container)
self.sidebar = sidebar
# Global wrap lines flag.
wrap_lines = True
# The layout
buff = Buffer(complete_while_typing=True)
buff.text = LIPSUM
body = FloatContainer(
content=HSplit([
Window(FormattedTextControl(
'Press "q" to quit. Press "w" to enable/disable wrapping.'),
height=1, style='reverse'),
Window(BufferControl(buffer=buff), get_line_prefix=get_line_prefix,
wrap_lines=Condition(lambda: wrap_lines)),
]),
floats=[
Float(xcursor=True,
ycursor=True,
content=CompletionsMenu(max_height=16, scroll_offset=1))
]
)
# Key bindings
kb = KeyBindings()
@kb.add('q')
def create_default_layout(app,
message='',
lexer=None,
is_password=False,
reserve_space_for_menu=False,
get_prompt_tokens=None,
get_bottom_toolbar_tokens=None,
display_completions_in_columns=False,
extra_input_processors=None,
multiline=False):
"""
Generate default layout.
Returns a ``Layout`` instance.
:param message: Text to be used as prompt.
:param lexer: Lexer to be used for the highlighting.
:param is_password: `bool` or `CLIFilter`. When True, display input as '*'.
:param reserve_space_for_menu: When True, make sure that a minimal height
is allocated in the terminal, in order to display the completion menu.
:param get_prompt_tokens: An optional callable that returns the tokens to
be shown in the menu. (To be used instead of a `message`.)
:param get_bottom_toolbar_tokens: An optional callable that returns the
tokens for a toolbar at the bottom.
:param display_completions_in_columns: `bool` or `CLIFilter`. Display the
completions in multiple columns.
:param multiline: `bool` or `CLIFilter`. When True, prefer a layout that is
more adapted for multiline input. Text after newlines is automatically
indented, and search/arg input is shown below the input, instead of
replacing the prompt.
"""
assert isinstance(message, text_type)
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 (message and get_prompt_tokens)
display_completions_in_columns = to_cli_filter(
display_completions_in_columns)
multiline = to_cli_filter(multiline)
if get_prompt_tokens is None:
get_prompt_tokens = lambda _: [(Token.Prompt, message)]
get_prompt_tokens_1, get_prompt_tokens_2 = _split_multiline_prompt(
get_prompt_tokens)
# `lexer` is supposed to be a `Lexer` instance. But if a Pygments lexer
# class is given, turn it into a PygmentsLexer. (Important for
# backwards-compatibility.)
try:
if issubclass(lexer, Lexer):
lexer = PygmentsLexer(lexer)
except TypeError:
# Happens when lexer is `None` or an instance of something else.
pass
# Create processors list.
# (DefaultPrompt should always be at the end.)
input_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.)
HighlightSearchProcessor(preview_search=Always()),
HasFocus(SEARCH_BUFFER)),
HighlightSelectionProcessor(),
ConditionalProcessor(AppendAutoSuggestion(),
HasFocus(DEFAULT_BUFFER) & ~IsDone()),
ConditionalProcessor(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.)
input_processors.append(
ConditionalProcessor(DefaultPrompt(get_prompt_tokens), ~multiline))
# Create bottom toolbar.
if get_bottom_toolbar_tokens:
toolbars = [
ConditionalContainer(Window(TokenListControl(
get_bottom_toolbar_tokens,
default_char=Char(' ', Token.Toolbar)),
height=LayoutDimension.exact(1)),
filter=~IsDone() & RendererHeightIsKnown())
]
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()
def separator():
return ConditionalContainer(content=Window(
height=LayoutDimension.exact(1),
content=FillControl(u'\u2500', token=Token.Separator)),
filter=HasDocumentation(app) & ~IsDone())
# Create and return Layout instance.
return HSplit([
ConditionalContainer(
Window(TokenListControl(get_prompt_tokens_1),
dont_extend_height=True),
filter=multiline,
),
VSplit([
# In multiline mode, the prompt is displayed in a left pane.
ConditionalContainer(
Window(
TokenListControl(get_prompt_tokens_2),
dont_extend_width=True,
),
filter=multiline,
),
# The main input, with completion menus floating on top of it.
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(),
focus_on_click=True,
),
get_height=get_height,
),
[
Float(xcursor=True,
ycursor=True,
content=CompletionsMenu(
max_height=16,
scroll_offset=1,
extra_filter=(HasFocus(DEFAULT_BUFFER)
& ~display_completions_in_columns
))), # noqa E501
Float(xcursor=True,
ycursor=True,
content=MultiColumnCompletionsMenu(
extra_filter=(HasFocus(DEFAULT_BUFFER)
& display_completions_in_columns),
show_meta=Always()))
]),
]),
separator(),
ConditionalContainer(
content=Window(BufferControl(
focus_on_click=True,
buffer_name=u'clidocs',
),
height=LayoutDimension(max=15)),
filter=HasDocumentation(app) & ~IsDone(),
),
separator(),
ValidationToolbar(),
SystemToolbar(),
# In multiline mode, we use two toolbars for 'arg' and 'search'.
ConditionalContainer(ArgToolbar(), multiline),
ConditionalContainer(SearchToolbar(), multiline),
] + toolbars)
def __init__(self, my_app: "sqlApp") -> None:
self.my_app = my_app
self.search_field = SearchToolbar()
history_file = config_location() + 'history'
ensure_dir_exists(history_file)
hist = ThreadedHistory(FileHistory(expanduser(history_file)))
self.input_buffer = Buffer(
name="defaultbuffer",
tempfile_suffix=".py",
multiline=MultilineFilter(self.my_app),
history=hist,
completer=DynamicCompleter(
lambda: ThreadedCompleter(self.my_app.completer)),
# lambda: self.my_app.completer),
auto_suggest=ThreadedAutoSuggest(AutoSuggestFromHistory()),
complete_while_typing=Condition(
lambda: self.my_app.active_conn is not None))
main_win_control = BufferControl(
buffer=self.input_buffer,
lexer=PygmentsLexer(SqlLexer),
search_buffer_control=self.search_field.control,
include_default_input_processors=False,
input_processors=[AppendAutoSuggestion()],
preview_search=True)
self.main_win = Window(
main_win_control,
height=(
lambda:
(None if get_app().is_done else
(Dimension(min=self.my_app.min_num_menu_lines)
if not self.my_app.show_preview else Dimension(
min=self.my_app.min_num_menu_lines, preferred=180)))),
get_line_prefix=partial(sql_line_prefix, my_app=self.my_app),
scroll_offsets=ScrollOffsets(bottom=1, left=4, right=4))
self.lprompt = login_prompt(self.my_app)
self.preview = preview_element(self.my_app)
self.disconnect_dialog = disconnect_dialog(self.my_app)
container = HSplit([
VSplit([
FloatContainer(
content=HSplit([
self.main_win,
self.search_field,
]),
floats=[
Float(
bottom=1,
left=1,
right=0,
content=sql_sidebar_help(self.my_app),
),
Float(content=self.lprompt),
Float(content=self.preview, ),
Float(content=self.disconnect_dialog, ),
Float(left=2,
bottom=1,
content=exit_confirmation(self.my_app)),
Float(xcursor=True,
ycursor=True,
transparent=True,
content=CompletionsMenu(scroll_offset=1,
max_height=16,
extra_filter=has_focus(
self.input_buffer)))
]),
ConditionalContainer(
content=sql_sidebar(self.my_app),
filter=ShowSidebar(self.my_app) & ~is_done,
)
]),
VSplit([
status_bar(self.my_app),
show_sidebar_button_info(self.my_app)
])
])
def accept(buff):
app = get_app()
app.exit(result=["non-preview", buff.text])
app.pre_run_callables.append(buff.reset)
return True
self.input_buffer.accept_handler = accept
self.layout = Layout(container, focused_element=self.main_win)
def get_descript(lexer):
""" command description window """
return Window(
content=BufferControl(
buffer_name="description",
lexer=lexer))
def get_param(lexer):
""" parameter description window """
return Window(
content=BufferControl(
buffer_name="parameter",
lexer=lexer))
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):
pdb.Pdb.__init__(self)
# Cache for the grammar.
self._grammar_cache = None # (current_pdb_commands, grammar) tuple.
self.completer = None
self.validator = None
self.lexer = None
self._source_code_window = Window(BufferControl(
buffer_name='source_code',
lexer=PygmentsLexer(PythonLexer),
input_processors=[
HighlightSearchProcessor(preview_search=True),
HighlightSelectionProcessor(),
],
),
left_margins=[
SourceCodeMargin(self),
NumberredMargin(),
],
right_margins=[ScrollbarMargin()],
scroll_offsets=ScrollOffsets(
top=2, bottom=2),
height=LayoutDimension(preferred=10))
# Callstack window.
callstack = CallStack(weakref.ref(self))
self.callstack_focussed = False # When True, show cursor there, and allow navigation through it.
self.callstack_selected_frame = 0 # Top frame.
show_pdb_content_filter = ~IsDone() & Condition(
lambda cli: not self.python_input.show_exit_confirmation)
self.python_input = PythonInput(
get_locals=lambda: self.curframe.f_locals,
get_globals=lambda: self.curframe.f_globals,
_completer=DynamicCompleter(lambda: self.completer),
_validator=DynamicValidator(lambda: self.validator),
_accept_action=self._create_accept_action(),
_extra_buffers={'source_code': Buffer(read_only=True)},
_input_buffer_height=LayoutDimension(min=2, max=4),
_lexer=PdbLexer(),
_extra_buffer_processors=[
ConditionalProcessor(processor=CompletionHint(),
filter=~IsDone())
],
_extra_layout_body=ConditionalContainer(
HSplit([
VSplit([
HSplit([
SourceTitlebar(weakref.ref(self)),
FloatContainer(
content=self._source_code_window,
floats=[
Float(right=0,
bottom=0,
content=BreakPointInfoToolbar(
weakref.ref(self)))
]),
]),
HSplit([
Window(width=LayoutDimension.exact(1),
height=LayoutDimension.exact(1),
content=FillControl(
'\u252c', token=Token.Toolbar.Title)),
Window(width=LayoutDimension.exact(1),
content=FillControl('\u2502',
token=Token.Separator)),
]),
HSplit([
StackTitlebar(weakref.ref(self)),
Window(callstack,
scroll_offsets=ScrollOffsets(top=2,
bottom=2),
right_margins=[ScrollbarMargin()],
height=LayoutDimension(preferred=10)),
]),
]),
]),
filter=show_pdb_content_filter),
_extra_toolbars=[
ConditionalContainer(PdbShortcutsToolbar(weakref.ref(self)),
show_pdb_content_filter)
],
history_filename=os.path.expanduser('~/.ptpdb_history'),
)
# Override prompt style.
self.python_input.all_prompt_styles['pdb'] = PdbPromptStyle(
self._get_current_pdb_commands())
self.python_input.prompt_style = 'pdb'
# Override exit message.
self.python_input.exit_message = 'Do you want to quit BDB? This raises BdbQuit.'
# Set UI styles.
self.python_input.ui_styles = {
'ptpdb': get_ui_style(),
}
self.python_input.use_ui_colorscheme('ptpdb')
# Set autocompletion style. (Multi-column works nicer.)
self.python_input.completion_visualisation = CompletionVisualisation.MULTI_COLUMN
# Load additional key bindings.
load_custom_pdb_key_bindings(self,
self.python_input.key_bindings_registry)
self.cli = CommandLineInterface(
eventloop=create_eventloop(),
application=self.python_input.create_application())
def __init__(self, text='', multiline=True, password=False,
lexer=None, auto_suggest=None, completer=None,
complete_while_typing=True, accept_handler=None, history=None,
focusable=True, focus_on_click=False, wrap_lines=True,
read_only=False, width=None, height=None,
dont_extend_height=False, dont_extend_width=False,
line_numbers=False, get_line_prefix=None, scrollbar=False,
style='', search_field=None, preview_search=True, prompt='',
input_processors=None):
assert isinstance(text, six.text_type)
assert search_field is None or isinstance(search_field, SearchToolbar)
if search_field is None:
search_control = None
elif isinstance(search_field, SearchToolbar):
search_control = search_field.control
if input_processors is None:
input_processors = []
# Writeable attributes.
self.completer = completer
self.complete_while_typing = complete_while_typing
self.lexer = lexer
self.auto_suggest = auto_suggest
self.read_only = read_only
self.wrap_lines = wrap_lines
self.buffer = Buffer(
document=Document(text, 0),
multiline=multiline,
read_only=Condition(lambda: is_true(self.read_only)),
completer=DynamicCompleter(lambda: self.completer),
complete_while_typing=Condition(
lambda: is_true(self.complete_while_typing)),
auto_suggest=DynamicAutoSuggest(lambda: self.auto_suggest),
accept_handler=accept_handler,
history=history)
self.control = BufferControl(
buffer=self.buffer,
lexer=DynamicLexer(lambda: self.lexer),
input_processors=[
ConditionalProcessor(
AppendAutoSuggestion(),
has_focus(self.buffer) & ~is_done),
ConditionalProcessor(
processor=PasswordProcessor(),
filter=to_filter(password)
),
BeforeInput(prompt, style='class:text-area.prompt'),
] + input_processors,
search_buffer_control=search_control,
preview_search=preview_search,
focusable=focusable,
focus_on_click=focus_on_click)
if multiline:
if scrollbar:
right_margins = [ScrollbarMargin(display_arrows=True)]
else:
right_margins = []
if line_numbers:
left_margins = [NumberedMargin()]
else:
left_margins = []
else:
height = D.exact(1)
left_margins = []
right_margins = []
style = 'class:text-area ' + style
self.window = Window(
height=height,
width=width,
dont_extend_height=dont_extend_height,
dont_extend_width=dont_extend_width,
content=self.control,
style=style,
wrap_lines=Condition(lambda: is_true(self.wrap_lines)),
left_margins=left_margins,
right_margins=right_margins,
get_line_prefix=get_line_prefix)
def __init__(self, pager: "Pager") -> None:
self.pager = pager
self.dynamic_body = _DynamicBody(pager)
# Build an interface.
has_colon = HasColon(pager)
self.examine_control: BufferControl = BufferControl(
buffer=pager.examine_buffer,
lexer=SimpleLexer(style="class:examine,examine-text"),
input_processors=[
BeforeInput(lambda: [("class:examine", " Examine: ")])
],
)
self.search_toolbar = SearchToolbar(vi_mode=True,
search_buffer=pager.search_buffer)
self.container = FloatContainer(
content=HSplit([
ConditionalContainer(
content=Titlebar(pager),
filter=Condition(lambda: pager.display_titlebar),
),
self.dynamic_body,
self.search_toolbar,
SystemToolbar(),
ConditionalContainer(
content=VSplit([
Window(
height=1,
content=FormattedTextControl(
self._get_statusbar_left_tokens),
style="class:statusbar",
),
Window(
height=1,
content=FormattedTextControl(
self._get_statusbar_right_tokens),
style="class:statusbar.cursorposition",
align=WindowAlign.RIGHT,
),
]),
filter=~HasSearch()
& ~has_focus(SYSTEM_BUFFER)
& ~has_colon
& ~has_focus("EXAMINE"),
),
ConditionalContainer(
content=Window(FormattedTextControl(" :"),
height=1,
style="class:examine"),
filter=has_colon,
),
ConditionalContainer(
content=Window(self.examine_control,
height=1,
style="class:examine"),
filter=has_focus(pager.examine_buffer),
),
]),
floats=[
Float(right=0, height=1, bottom=1, content=_Arg()),
Float(
bottom=1,
left=0,
right=0,
height=1,
content=ConditionalContainer(
content=MessageToolbarBar(pager),
filter=Condition(lambda: bool(pager.message)),
),
),
Float(
right=0,
height=1,
bottom=1,
content=ConditionalContainer(
content=FormattedTextToolbar(
lambda: [("class:loading", " Loading... ")], ),
filter=Condition(lambda: pager.current_source_info.
waiting_for_input_stream),
),
),
Float(xcursor=True,
ycursor=True,
content=MultiColumnCompletionsMenu()),
],
)
params = []
if command in runOptions:
runOptions[command][0](params)
else:
printResponceOutput(
"Command: '" + command + "' not found. Run 'help' to view all posible commands")
left_buffer.insert_line_below()
left_buffer = Buffer(accept_handler=runCommand,
multiline=False,
completer=mainCompleter(),
history=FileHistory('history.txt'),
complete_while_typing=True
)
left_window = Window(BufferControl(buffer=left_buffer))
responseOutput = TextArea(
text="FTP Communication Responses(and commands)",
scrollbar=True,
line_numbers=True,
)
systemOutput = TextArea(
text="System Output",
scrollbar=True,
line_numbers=True,
)
def printResponceOutput(text):
currentText=responseOutput.document.text
from prompt_toolkit.key_binding import KeyBindings
buffer1 = Buffer() # Editable buffer.
kb = KeyBindings()
@kb.add('q')
def exit_(event):
event.app.exit()
root_container = VSplit([
# One window that holds the BufferControl with the default buffer on
# the left.
Window(content=BufferControl(buffer=buffer1)),
# A vertical line in the middle. We explicitly specify the width, to
# make sure that the layout engine will not try to divide the whole
# width by three for all these windows. The window will simply fill its
# content by repeating this character.
Window(width=1, char='|'),
# Display the text 'Hello world' on the right.
Window(content=FormattedTextControl(text='Hello world')),
])
layout = Layout(root_container)
app = Application(
layout=layout,
def __init__(self, debugger):
self._filename = None
self.sources = {}
self.debugger = debugger
self.debugger.events.on_stop += self.on_stop
self.current_address_margin = CurrentAddressMargin()
kb = KeyBindings()
self.locals_processor = DisplayVariablesProcessor()
self.source_buffer = Buffer(multiline=True)
self.bar_buffer = Buffer(multiline=True)
self.register_buffer = Buffer(multiline=True)
self.logs_buffer = Buffer(multiline=True)
@kb.add(Keys.F10, eager=True)
def quit_(event):
event.app.exit()
@kb.add(Keys.F8)
def clear_breakpoint_(event):
if self.has_source():
filename, row = self.get_current_location()
self.debugger.clear_breakpoint(filename, row)
@kb.add(Keys.F7)
def set_breakpoint_(event):
if self.has_source():
filename, row = self.get_current_location()
self.debugger.set_breakpoint(filename, row)
@kb.add(Keys.F6)
def step_(event):
self.debugger.step()
@kb.add(Keys.F5)
def run_(event):
self.debugger.run()
@kb.add(Keys.F4)
def stop_(event):
self.debugger.stop()
@kb.add(Keys.PageUp)
def scroll_up_(event):
self.source_buffer.cursor_up(count=15)
@kb.add(Keys.PageDown)
def scroll_down_(event):
self.source_buffer.cursor_down(count=15)
src_lexer = PygmentsLexer(CLexer)
source_code_window = Window(
content=BufferControl(
buffer=self.source_buffer,
lexer=src_lexer,
input_processors=[self.locals_processor],
),
left_margins=[self.current_address_margin,
NumberredMargin()],
right_margins=[ScrollbarMargin(display_arrows=True)],
cursorline=True,
)
register_window = Window(
content=BufferControl(buffer=self.register_buffer), width=20)
title_text = "Welcome to the ppci debugger version {}".format(
ppci_version)
help_text = ("F4=stop F5=run F6=step F7=set breakpoint" +
" F8=clear breakpoint F10=exit")
# Application layout:
layout = HSplit([
Window(content=FormattedTextControl(text=title_text), height=1),
VSplit([
HSplit([
Frame(body=source_code_window),
Window(
content=BufferControl(buffer=self.logs_buffer),
height=2,
),
]),
Frame(body=register_window, title="registers"),
]),
Window(
content=FormattedTextControl(self.get_status_tokens),
height=1,
),
Window(content=FormattedTextControl(help_text), height=1),
])
style = style_from_pygments(get_style_by_name("vim"))
log_handler = MyHandler(self.logs_buffer)
fmt = logging.Formatter(fmt=logformat)
log_handler.setFormatter(fmt)
log_handler.setLevel(logging.DEBUG)
logging.getLogger().setLevel(logging.DEBUG)
logging.getLogger().addHandler(log_handler)
self.application = Application(layout=layout,
style=style,
key_bindings=kb,
full_screen=True)
'rat',
'snake',
'spider',
'turkey',
'turtle',
],
ignore_case=True)
# The layout
buff = Buffer(completer=animal_completer, complete_while_typing=True)
body = FloatContainer(content=HSplit([
Window(FormattedTextControl('Press "q" to quit.'),
height=1,
style='reverse'),
Window(BufferControl(buffer=buff)),
]),
floats=[
Float(xcursor=True,
ycursor=True,
content=CompletionsMenu(max_height=16,
scroll_offset=1))
])
# Key bindings
kb = KeyBindings()
@kb.add('q')
@kb.add('c-c')
def _(event):
def run(self, query, data):
self.load_config()
if data or query is not None:
self.format = self.format_stdin
self.echo.verbose = False
if self.echo.verbose:
show_version()
if not self.connect():
return
if self.client:
self.client.settings = self.settings
self.client.cli_settings = {
'multiline': self.multiline,
'vi_mode': self.vi_mode,
'format': self.format,
'format_stdin': self.format_stdin,
'show_formatted_query': self.show_formatted_query,
'highlight': self.highlight,
'highlight_output': self.highlight_output,
'refresh_metadata_on_start': self.refresh_metadata_on_start,
'refresh_metadata_on_query': self.refresh_metadata_on_query,
}
if data and query is None:
# cat stuff.sql | clickhouse-cli
# clickhouse-cli stuff.sql
for subdata in data:
self.handle_input(subdata.read(),
verbose=False,
refresh_metadata=False)
return
if not data and query is not None:
# clickhouse-cli -q 'SELECT 1'
return self.handle_query(query, stream=False)
if data and query is not None:
# cat stuff.csv | clickhouse-cli -q 'INSERT INTO stuff'
# clickhouse-cli -q 'INSERT INTO stuff' stuff.csv
for subdata in data:
compress = 'gzip' if os.path.splitext(
subdata.name)[1] == '.gz' else False
self.handle_query(query,
data=subdata,
stream=True,
compress=compress)
return
buffer = CLIBuffer(
client=self.client,
multiline=self.multiline,
metadata=self.metadata,
)
root_container = Window(content=BufferControl(buffer=buffer))
layout = Layout(root_container)
hist = FileHistory(
filename=os.path.expanduser('~/.clickhouse-cli_history'))
self.completer = CHCompleter(self.client, self.metadata)
self.session = PromptSession(
style=get_ch_style(self.highlight_theme)
if self.highlight else None,
lexer=PygmentsLexer(CHLexer) if self.highlight else None,
message=get_prompt_tokens()[0][1],
prompt_continuation=get_continuation_tokens()[0][1],
multiline=is_multiline(self.multiline),
vi_mode=self.vi_mode,
history=hist,
key_bindings=kb,
complete_while_typing=self.complete_while_typing,
completer=ThreadedCompleter(
DynamicCompleter(lambda: self.completer)),
)
self.app = Application(layout=layout,
# buffer=buffer,
)
if self.refresh_metadata_on_start:
self.app.current_buffer.completer.refresh_metadata()
try:
while True:
try:
cli_input = self.session.prompt()
self.handle_input(cli_input)
except KeyboardInterrupt:
# Attempt to terminate queries
for query_id in self.query_ids:
self.client.kill_query(query_id)
self.echo.error("\nQuery was terminated.")
finally:
self.query_ids = []
except EOFError:
self.echo.success("Bye.")
def create_default_layout(get_prompt_tokens,
get_error_tokens=None,
extra_input_processors=None,
hide_cursor=False,
hint=None,
extra_hint_filter=None,
reactive_window_factory=None,
transformer=None):
has_before_tokens, get_prompt_tokens_1, get_prompt_tokens_2 = _split_multiline_prompt(
get_prompt_tokens)
assert get_prompt_tokens is None or callable(get_prompt_tokens)
assert get_error_tokens is None or callable(get_error_tokens)
reactive_windows = []
if callable(reactive_window_factory):
reactive_windows = reactive_window_factory()
has_reactive = to_cli_filter(reactive_windows is not None)
has_hint = to_cli_filter(hint is not None)
hint_filter = has_hint
if extra_hint_filter is not None:
hint_filter = hint_filter & extra_hint_filter
input_processors = []
if extra_input_processors is not None:
input_processors.extend(extra_input_processors)
input_processors.extend([
ConditionalProcessor(HintProcessor(hint), hint_filter & ~IsDone()),
ConditionalProcessor(TransformProcessor(transformer), IsDone()),
Prompt(get_prompt_tokens_2),
])
return HSplit([
ConditionalContainer(
Window(
TokenListControl(get_prompt_tokens_1),
dont_extend_height=True,
wrap_lines=True,
),
Condition(has_before_tokens),
),
Window(
BufferControl(input_processors=input_processors, ),
always_hide_cursor=hide_cursor,
dont_extend_height=True,
wrap_lines=True,
),
ConditionalContainer(
HSplit(reactive_windows),
filter=has_reactive & ~IsDone(),
),
ConditionalContainer(
Window(
TokenListControl(get_error_tokens
or _get_default_error_tokens),
dont_extend_height=True,
wrap_lines=True,
),
filter=HasValidationError() & ~IsDone(),
),
])
/ ____/ ____/ / ____/___ _/ /____
/ __/ / __/ / / / __ `/ / ___/
/ /___/ /___ / /___/ /_/ / / /__ Vim
/_____/_____/ \____/\__,_/_/\___/ Edition
"""
# 3. Create the buffers
# ------------------
margin_buffer = Buffer()
left_buffer = Buffer()
right_buffer = Buffer()
# 1. First we create the layout
# --------------------------
margin_window = Window(BufferControl(buffer=margin_buffer), width=4)
left_window = Window(BufferControl(buffer=left_buffer))
right_window = Window(BufferControl(buffer=right_buffer))
body = VSplit([
margin_window,
left_window,
# A vertical line in the middle. We explicitly specify the width, to make
# sure that the layout engine will not try to divide the whole width by
# three for all these windows.
Window(
width=1,
char='|',
style='class:line',
),
def _create_layout(self):
"""
Create `Layout` for this prompt.
"""
dyncond = self._dyncond
# Create functions that will dynamically split the prompt. (If we have
# a multiline prompt.)
has_before_fragments, get_prompt_text_1, get_prompt_text_2 = \
_split_multiline_prompt(self._get_prompt)
default_buffer = self.default_buffer
search_buffer = self.search_buffer
# Create processors list.
all_input_processors = [
HighlightIncrementalSearchProcessor(),
HighlightSelectionProcessor(),
ConditionalProcessor(AppendAutoSuggestion(),
has_focus(default_buffer) & ~is_done),
ConditionalProcessor(PasswordProcessor(), dyncond('is_password')),
DisplayMultipleCursors(),
# Users can insert processors here.
DynamicProcessor(lambda: merge_processors(self.input_processors or [])),
# For single line mode, show the prompt before the input.
ConditionalProcessor(
merge_processors([
BeforeInput(get_prompt_text_2),
ShowArg(),
]),
~dyncond('multiline'))
]
# Create bottom toolbars.
bottom_toolbar = ConditionalContainer(
Window(FormattedTextControl(
lambda: self.bottom_toolbar,
style='class:bottom-toolbar.text'),
style='class:bottom-toolbar',
dont_extend_height=True,
height=Dimension(min=1)),
filter=~is_done & renderer_height_is_known &
Condition(lambda: self.bottom_toolbar is not None))
search_toolbar = SearchToolbar(
search_buffer,
ignore_case=dyncond('search_ignore_case'))
search_buffer_control = SearchBufferControl(
buffer=search_buffer,
input_processors=[
ReverseSearchProcessor(),
ShowArg(),
],
ignore_case=dyncond('search_ignore_case'))
system_toolbar = SystemToolbar(
enable_global_bindings=dyncond('enable_system_prompt'))
def get_search_buffer_control():
" Return the UIControl to be focused when searching start. "
if _true(self.multiline):
return search_toolbar.control
else:
return search_buffer_control
default_buffer_control = BufferControl(
buffer=default_buffer,
search_buffer_control=get_search_buffer_control,
input_processors=all_input_processors,
include_default_input_processors=False,
lexer=DynamicLexer(lambda: self.lexer),
preview_search=True)
default_buffer_window = Window(
default_buffer_control,
height=self._get_default_buffer_control_height,
left_margins=[
# In multiline mode, use the window margin to display
# the prompt and continuation fragments.
ConditionalMargin(
PromptMargin(get_prompt_text_2, self._get_continuation),
filter=dyncond('multiline'),
)
],
wrap_lines=dyncond('wrap_lines'))
@Condition
def multi_column_complete_style():
return self.complete_style == CompleteStyle.MULTI_COLUMN
# Build the layout.
layout = HSplit([
# The main input, with completion menus floating on top of it.
FloatContainer(
HSplit([
ConditionalContainer(
Window(
FormattedTextControl(get_prompt_text_1),
dont_extend_height=True),
Condition(has_before_fragments)
),
ConditionalContainer(
default_buffer_window,
Condition(lambda:
get_app().layout.current_control != search_buffer_control),
),
ConditionalContainer(
Window(search_buffer_control),
Condition(lambda:
get_app().layout.current_control == search_buffer_control),
),
]),
[
# Completion menus.
Float(xcursor=True,
ycursor=True,
content=CompletionsMenu(
max_height=16,
scroll_offset=1,
extra_filter=has_focus(default_buffer) &
~multi_column_complete_style)),
Float(xcursor=True,
ycursor=True,
content=MultiColumnCompletionsMenu(
show_meta=True,
extra_filter=has_focus(default_buffer) &
multi_column_complete_style)),
# The right prompt.
Float(right=0, top=0, hide_when_covering_content=True,
content=_RPrompt(lambda: self.rprompt)),
]
),
ConditionalContainer(
ValidationToolbar(),
filter=~is_done),
ConditionalContainer(
system_toolbar,
dyncond('enable_system_prompt') & ~is_done),
# In multiline mode, we use two toolbars for 'arg' and 'search'.
ConditionalContainer(
Window(FormattedTextControl(self._get_arg_text), height=1),
dyncond('multiline') & has_arg),
ConditionalContainer(search_toolbar, dyncond('multiline') & ~is_done),
bottom_toolbar,
])
return Layout(layout, default_buffer_window)
def __init__(self, editor, window_arrangement):
self.editor = editor # Back reference to editor.
self.window_arrangement = window_arrangement
# Mapping from (`window_arrangement.Window`, `EditorBuffer`) to a frame
# (Layout instance).
# We keep this as a cache in order to easily reuse the same frames when
# the layout is updated. (We don't want to create new frames on every
# update call, because that way, we would loose some state, like the
# vertical scroll offset.)
self._frames = {}
self._fc = FloatContainer(
content=VSplit([
Window(BufferControl()) # Dummy window
]),
floats=[
Float(xcursor=True,
ycursor=True,
content=CompletionsMenu(
max_height=12,
scroll_offset=2,
extra_filter=~has_focus(editor.command_buffer))),
Float(content=BufferListOverlay(editor), bottom=1, left=0),
Float(bottom=1,
left=0,
right=0,
height=1,
content=ConditionalContainer(
CompletionsToolbar(),
filter=has_focus(editor.command_buffer)
& ~_bufferlist_overlay_visible(editor)
& Condition(lambda: editor.show_wildmenu))),
Float(bottom=1,
left=0,
right=0,
height=1,
content=ValidationToolbar()),
Float(bottom=1,
left=0,
right=0,
height=1,
content=MessageToolbarBar(editor)),
Float(content=WelcomeMessageWindow(editor),
height=WELCOME_MESSAGE_HEIGHT,
width=WELCOME_MESSAGE_WIDTH),
])
search_toolbar = SearchToolbar(vi_mode=True,
search_buffer=editor.search_buffer)
self.search_control = search_toolbar.control
self.layout = Layout(
FloatContainer(content=HSplit([
TabsToolbar(editor),
self._fc,
CommandLine(editor),
ReportMessageToolbar(editor),
SystemToolbar(),
search_toolbar,
]),
floats=[
Float(right=0,
height=1,
bottom=0,
width=5,
content=SimpleArgToolbar()),
]))
def __init__(self, history):
search_toolbar = SearchToolbar()
self.help_buffer_control = BufferControl(buffer=history.help_buffer,
lexer=PygmentsLexer(RstLexer))
help_window = _create_popup_window(
title="History Help",
body=Window(
content=self.help_buffer_control,
right_margins=[ScrollbarMargin(display_arrows=True)],
scroll_offsets=ScrollOffsets(top=2, bottom=2),
),
)
self.default_buffer_control = BufferControl(
buffer=history.default_buffer,
input_processors=[GrayExistingText(history.history_mapping)],
lexer=PygmentsLexer(PythonLexer),
)
self.history_buffer_control = BufferControl(
buffer=history.history_buffer,
lexer=PygmentsLexer(PythonLexer),
search_buffer_control=search_toolbar.control,
preview_search=True,
)
history_window = Window(
content=self.history_buffer_control,
wrap_lines=False,
left_margins=[HistoryMargin(history)],
scroll_offsets=ScrollOffsets(top=2, bottom=2),
)
self.root_container = HSplit([
# Top title bar.
Window(
content=FormattedTextControl(_get_top_toolbar_fragments),
align=WindowAlign.CENTER,
style="class:status-toolbar",
),
FloatContainer(
content=VSplit([
# Left side: history.
history_window,
# Separator.
Window(
width=D.exact(1),
char=BORDER.LIGHT_VERTICAL,
style="class:separator",
),
# Right side: result.
Window(
content=self.default_buffer_control,
wrap_lines=False,
left_margins=[ResultMargin(history)],
scroll_offsets=ScrollOffsets(top=2, bottom=2),
),
]),
floats=[
# Help text as a float.
Float(
width=60,
top=3,
bottom=2,
content=ConditionalContainer(
content=help_window,
filter=has_focus(history.help_buffer),
),
)
],
),
# Bottom toolbars.
ArgToolbar(),
search_toolbar,
Window(
content=FormattedTextControl(
partial(_get_bottom_toolbar_fragments, history=history)),
style="class:status-toolbar",
),
])
self.layout = Layout(self.root_container, history_window)
def __init__(self):
available_archs = [
"arm",
"x86_64",
"riscv",
"avr",
"or1k",
"xtensa",
"microblaze",
"msp430",
]
# State variables:
self.arch = available_archs[-1]
self.stage = "asm"
self.show_log = False
self.optimize = False
self.archs = cycle(available_archs)
self.stages = cycle(["ir", "ast", "asm"])
# Some key bindings:
kb = KeyBindings()
@kb.add(Keys.F10, eager=True)
def quit_(event):
with open(self.cache_filename, "w") as f:
f.write(self.source_buffer.text)
event.app.exit()
kb.add(Keys.F6, eager=True)(self.cycle_stage)
kb.add(Keys.F7, eager=True)(self.next_architecture)
kb.add(Keys.F8, eager=True)(self.toggle_optimize)
kb.add(Keys.F9, eager=True)(self.toggle_log)
kb.add("tab")(focus_next)
kb.add("s-tab")(focus_previous)
log_buffer = Buffer(multiline=True)
show_log = Condition(lambda: self.show_log)
self.errors_processor = DisplayErrorsProcessor()
# Source:
self.source_buffer = Buffer(multiline=True)
src_lexer = PygmentsLexer(CLexer)
code_edit = Window(
content=BufferControl(
buffer=self.source_buffer,
lexer=src_lexer,
input_processors=[self.errors_processor],
),
left_margins=[NumberedMargin()],
right_margins=[ScrollbarMargin(display_arrows=True)],
)
# Output:
self.output_buffer = Buffer(multiline=True)
result_window = Window(
content=BufferControl(self.output_buffer),
right_margins=[ScrollbarMargin(display_arrows=True)],
)
layout = Layout(
HSplit([
Window(
FormattedTextControl(self.get_title_bar_tokens),
height=1,
),
VSplit([
Frame(body=code_edit, title="source code"),
Frame(body=result_window, title="assembly output"),
ConditionalContainer(
Window(content=BufferControl(log_buffer)),
filter=show_log,
),
]),
Window(
FormattedTextControl(text="F9=toggle log F10=exit"),
height=1,
style="class:status",
),
]))
style = style_from_pygments_cls(get_style_by_name("vim"))
log_handler = MyHandler(log_buffer)
fmt = logging.Formatter(fmt=logformat)
log_handler.setFormatter(fmt)
log_handler.setLevel(logging.DEBUG)
logging.getLogger().setLevel(logging.INFO)
logging.getLogger().addHandler(log_handler)
self.source_buffer.on_text_changed += self.on_change
self.application = Application(layout=layout,
key_bindings=kb,
style=style,
full_screen=True)
if os.path.exists(self.cache_filename):
with open(self.cache_filename, "r") as f:
src = f.read()
else:
src = DEMO_SOURCE
self.source_buffer.text = src
def __init__(self,
text='',
multiline=True,
password=False,
lexer=None,
completer=None,
accept_handler=None,
focusable=True,
wrap_lines=True,
read_only=False,
width=None,
height=None,
dont_extend_height=False,
dont_extend_width=False,
line_numbers=False,
scrollbar=False,
style='',
search_field=None,
preview_search=True,
prompt=''):
assert isinstance(text, six.text_type)
assert search_field is None or isinstance(search_field, SearchToolbar)
if search_field is None:
search_control = None
elif isinstance(search_field, SearchToolbar):
search_control = search_field.control
self.buffer = Buffer(
document=Document(text, 0),
multiline=multiline,
read_only=read_only,
completer=completer,
complete_while_typing=True,
accept_handler=lambda buff: accept_handler and accept_handler())
self.control = BufferControl(
buffer=self.buffer,
lexer=lexer,
input_processors=[
ConditionalProcessor(processor=PasswordProcessor(),
filter=to_filter(password)),
BeforeInput(prompt, style='class:text-area.prompt'),
],
search_buffer_control=search_control,
preview_search=preview_search,
focusable=focusable)
if multiline:
if scrollbar:
right_margins = [ScrollbarMargin(display_arrows=True)]
else:
right_margins = []
if line_numbers:
left_margins = [NumberedMargin()]
else:
left_margins = []
else:
wrap_lines = False # Never wrap for single line input.
height = D.exact(1)
left_margins = []
right_margins = []
style = 'class:text-area ' + style
self.window = Window(height=height,
width=width,
dont_extend_height=dont_extend_height,
dont_extend_width=dont_extend_width,
content=self.control,
style=style,
wrap_lines=wrap_lines,
left_margins=left_margins,
right_margins=right_margins)
def _create_layout(self,
message='',
lexer=None,
is_password=False,
reserve_space_for_menu=8,
get_prompt_tokens=None,
get_continuation_tokens=None,
get_rprompt_tokens=None,
get_bottom_toolbar_tokens=None,
get_url_tokens=None,
display_completions_in_columns=False,
extra_input_processors=None,
multiline=False,
wrap_lines=True):
"""
Create a :class:`.Container` instance for a prompt.
:param message: Text to be used as prompt.
:param lexer: :class:`~prompt_toolkit.layout.lexers.Lexer` to be used for
the highlighting.
:param is_password: `bool` or :class:`~prompt_toolkit.filters.CLIFilter`.
When True, display input as '*'.
:param reserve_space_for_menu: Space to be reserved for the menu. When >0,
make sure that a minimal height is allocated in the terminal, in order
to display the completion menu.
:param get_prompt_tokens: An optional callable that returns the tokens to be
shown in the menu. (To be used instead of a `message`.)
:param get_continuation_tokens: An optional callable that takes a
CommandLineInterface and width as input and returns a list of (Token,
text) tuples to be used for the continuation.
:param get_bottom_toolbar_tokens: An optional callable that returns the
tokens for a toolbar at the bottom.
:param display_completions_in_columns: `bool` or
:class:`~prompt_toolkit.filters.CLIFilter`. Display the completions in
multiple columns.
:param multiline: `bool` or :class:`~prompt_toolkit.filters.CLIFilter`.
When True, prefer a layout that is more adapted for multiline input.
Text after newlines is automatically indented, and search/arg input is
shown below the input, instead of replacing the prompt.
:param wrap_lines: `bool` or :class:`~prompt_toolkit.filters.CLIFilter`.
When True (the default), automatically wrap long lines instead of
scrolling horizontally.
"""
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 get_rprompt_tokens is None or callable(get_rprompt_tokens)
assert not (message and get_prompt_tokens)
display_completions_in_columns = to_cli_filter(
display_completions_in_columns)
multiline = to_cli_filter(multiline)
if get_prompt_tokens is None:
get_prompt_tokens = lambda _: [(Token.Prompt, message)]
has_before_tokens, get_prompt_tokens_1, get_prompt_tokens_2 = \
_split_multiline_prompt(get_prompt_tokens)
# `lexer` is supposed to be a `Lexer` instance. But if a Pygments lexer
# class is given, turn it into a PygmentsLexer. (Important for
# backwards-compatibility.)
try:
if pygments_Lexer and issubclass(lexer, pygments_Lexer):
lexer = PygmentsLexer(lexer, sync_from_start=True)
except TypeError: # Happens when lexer is `None` or an instance of something else.
pass
# Create processors list.
input_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.)
HighlightSearchProcessor(preview_search=True),
HasFocus(SEARCH_BUFFER)),
HighlightSelectionProcessor(),
ConditionalProcessor(AppendAutoSuggestion(),
HasFocus(DEFAULT_BUFFER) & ~IsDone()),
ConditionalProcessor(PasswordProcessor(), is_password),
DisplayMultipleCursors(DEFAULT_BUFFER),
]
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(
ConditionalProcessor(DefaultPrompt(get_prompt_tokens_2),
~multiline))
# Create bottom toolbar.
if get_bottom_toolbar_tokens:
toolbars = [
ConditionalContainer(VSplit([
Window(TokenListControl(get_url_tokens,
default_char=Char(
' ', Token.Toolbar)),
height=LayoutDimension.exact(1)),
Window(TokenListControl(get_bottom_toolbar_tokens,
default_char=Char(
' ', Token.Toolbar),
align_right=True),
height=LayoutDimension.exact(1))
]),
filter=~IsDone()
& RendererHeightIsKnown())
]
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:
buff = cli.current_buffer
# Reserve the space, either when there are completions, or when
# `complete_while_typing` is true and we expect completions very
# soon.
if buff.complete_while_typing(
) or buff.complete_state is not None:
return LayoutDimension(min=reserve_space_for_menu)
return LayoutDimension()
# Create and return Container instance.
return HSplit([
# The main input, with completion menus floating on top of it.
FloatContainer(
HSplit([
ConditionalContainer(
Window(TokenListControl(get_prompt_tokens_1),
dont_extend_height=True),
Condition(has_before_tokens)),
Window(
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=get_height,
left_margins=[
# In multiline mode, use the window margin to display
# the prompt and continuation tokens.
ConditionalMargin(PromptMargin(
get_prompt_tokens_2, get_continuation_tokens),
filter=multiline)
],
wrap_lines=wrap_lines,
),
]),
[
# Completion menus.
Float(xcursor=True,
ycursor=True,
content=CompletionsMenu(
max_height=16,
scroll_offset=1,
extra_filter=HasFocus(DEFAULT_BUFFER)
& ~display_completions_in_columns)),
Float(xcursor=True,
ycursor=True,
content=MultiColumnCompletionsMenu(
extra_filter=HasFocus(DEFAULT_BUFFER)
& display_completions_in_columns,
show_meta=True)),
# The right prompt.
Float(right=0,
top=0,
hide_when_covering_content=True,
content=_RPrompt(get_rprompt_tokens)),
]),
ValidationToolbar(),
SystemToolbar(),
# In multiline mode, we use two toolbars for 'arg' and 'search'.
ConditionalContainer(ArgToolbar(), multiline),
ConditionalContainer(SearchToolbar(), multiline),
] + toolbars)
def create_layout(self):
# Create functions that will dynamically split the prompt. (If we have
# a multiline prompt.)
has_before_fragments, get_prompt_text_1, get_prompt_text_2 = \
_split_multiline_prompt(self.formatted_message)
default_buffer = ModalBuffer(
name=DEFAULT_BUFFER,
complete_while_typing=Condition(lambda: self.complete_while_typing),
completer=DynamicCompleter(lambda: self.completer),
history=self.history,
enable_history_search=True,
accept_handler=self.accept,
get_tempfile_suffix=lambda: self.tempfile_suffix)
search_buffer = Buffer(name=SEARCH_BUFFER)
search_toolbar = SearchToolbar(
search_buffer,
get_search_state=lambda: default_buffer_control.get_search_state())
input_processor = merge_processors([
ConditionalProcessor(
HighlightSearchProcessor(preview_search=True),
has_focus(search_buffer)),
HighlightSelectionProcessor(),
HighlightMatchingBracketProcessor(),
DisplayMultipleCursors()
])
default_buffer_control = BufferControl(
buffer=default_buffer,
search_buffer_control=search_toolbar.control,
input_processor=input_processor,
lexer=DynamicLexer(lambda: self.lexer),
preview_search=True)
def get_default_buffer_control_height():
# 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.
space = self.reserve_space_for_menu
if space and not get_app().is_done:
buff = default_buffer
if buff.complete_while_typing() or buff.complete_state is not None:
return Dimension(min=space)
return Dimension()
def get_continuation(width):
prompt_continuation = self.prompt_continuation
if callable(prompt_continuation):
prompt_continuation = prompt_continuation(width)
return to_formatted_text(
prompt_continuation, style='class:prompt-continuation')
default_buffer_window = Window(
default_buffer_control,
height=get_default_buffer_control_height,
left_margins=[
PromptMargin(get_prompt_text_2, get_continuation)
],
wrap_lines=True)
def get_arg_text():
arg = self.app.key_processor.arg
if arg == '-':
arg = '-1'
return [
('class:arg-toolbar', 'Repeat: '),
('class:arg-toolbar.text', arg)
]
# Build the layout.
layout = HSplit([
# The main input, with completion menus floating on top of it.
FloatContainer(
HSplit([
ConditionalContainer(
Window(
FormattedTextControl(get_prompt_text_1),
dont_extend_height=True),
Condition(has_before_fragments)
),
default_buffer_window,
]),
[
# Completion menus.
Float(xcursor=True,
ycursor=True,
content=MultiColumnCompletionsMenu(
show_meta=True,
extra_filter=has_focus(default_buffer)))
]
),
ConditionalContainer(
Window(FormattedTextControl(get_arg_text), height=1), has_arg),
search_toolbar
])
return Layout(layout, default_buffer_window)
def source(self, event):
"""
Show and modify source of the object under cursor.
"""
source_is_already_open = False
for tab in self.session.tabs:
if tab.name == 'Source':
source_is_already_open = True
if not source_is_already_open:
cursor_row_index = self.python_code_buffer.document.cursor_position_row
cursor_col_index = self.python_code_buffer.document.cursor_position_col
current_row = self.python_code_buffer.document.lines[
cursor_row_index]
text_before_cursor = current_row[:cursor_col_index]
self.inspected_class_object, self.inspected_method_object, source_code = inspect_code(
text_before_cursor, self.interface)
self.source_code_original = source_code
self.source_code_buffer = Buffer()
self.source_code_buffer.document = Document(text=source_code)
formatted_text = BufferControl(buffer=self.source_code_buffer,
lexer=PythonLexer(
self.source_code_buffer))
source_window = Window(formatted_text, width=120, wrap_lines=True)
tab_index = self.session.add_tab(Tab("Source", source_window))
self.tabs_container.set_selected_tab(tab_index)
# Source float is already exist, so saving the modified version of the source and closing the float.
else:
# Source code modifications only works on method right now.
# so it only works if source code inspector return both class ans method object.
if self.inspected_class_object and \
self.inspected_method_object and \
self.source_code_original != self.source_code_buffer.document.text: # Only modify the method object if the code has actually changed
try:
# Should be method definition
source = self.source_code_buffer.document.text
# Evaluting the method object (with the original name)
exec(source, self.interface)
method_name = self.inspected_method_object.__name__
# The moment we evaluated the new method in the exec above,
# we can get a pointer to that method using its name in the local context(scope)
new_method_object = eval(method_name, self.interface)
setattr(
self.inspected_class_object, method_name,
new_method_object.__get__(
self.inspected_class_object,
type(self.inspected_class_object)))
# setattr(class_object, method_name, eval(method_name))
except Exception as e:
self.__send_to_output("Exception: {}".format(e))
self.session.remove_tab_by_name("Source")
self.tabs_container.update_selected_tab()