def start_app(mode, connection):
"""Text-based GUI application"""
cmd = Commands()
completer = WordCompleter(cmd.commands(),
meta_dict=cmd.meta_dict(),
ignore_case=True)
history = InMemoryHistory()
# Individual windows
input_field = TextArea(height=1,
prompt='ctserial> ',
style='class:input-field',
completer=completer)
output_field = TextArea(scrollbar=True,
style='class:output-field',
text='')
statusbar = Window(content=FormattedTextControl(get_statusbar_text),
height=1,
style='class:statusbar')
# Organization of windows
body = FloatContainer(HSplit([
input_field,
Window(height=1, char='-', style='class:line'), output_field, statusbar
]),
floats=[
Float(xcursor=True,
ycursor=True,
content=CompletionsMenu(max_height=16,
scroll_offset=1))
])
# Adding menus
root_container = MenuContainer(
body=body,
menu_items=[
MenuItem('Project ',
children=[
MenuItem('New'),
MenuItem('Open'),
MenuItem('Save'),
MenuItem('Save as...'),
MenuItem('-', disabled=True),
MenuItem('Exit', handler=cmd.do_exit),
]),
MenuItem('View ', children=[
MenuItem('Split'),
]),
MenuItem('Info ', children=[
MenuItem('Help'),
MenuItem('About'),
]),
],
floats=[
Float(xcursor=True,
ycursor=True,
content=CompletionsMenu(max_height=16, scroll_offset=1)),
])
# The key bindings.
kb = KeyBindings()
@kb.add('enter', filter=has_focus(input_field))
def _(event):
# Process commands on prompt after hitting enter key
# tx_bytes = parse_command(input_field.text, event=event)
output_text = cmd.execute(input_field.text, output_field.text, event)
# For commands that do not send data to serial device
if output_text == None:
input_field.text = ''
return
# For invalid commands forcing users to correct them
elif output_text == False:
return
# For invalid commands forcing users to correct them
else:
output_field.buffer.document = Document(
text=output_text, cursor_position=len(output_text))
input_field.text = ''
@kb.add('c-c')
@kb.add('c-q')
def _(event):
" Pressing Ctrl-Q or Ctrl-C will exit the user interface. "
connection.close()
event.app.exit()
@kb.add('c-a')
def _(event):
event.app.mode = 'cmd'
@kb.add('c-d')
def _(event):
"""Press Ctrl-D for debug mode"""
import pdb
pdb.set_trace()
@kb.add('escape')
def _(event):
""" Pressing ESC key will enter toggle input mode"""
input_field.prompt = 'cmd> '
style = Style([
# ('output-field', 'bg:#000000 #ffffff'),
# ('input-field', 'bg:#000000 #ffffff'),
('line', '#004400'),
('statusbar', 'bg:#AAAAAA')
])
# Run application.
application = MyApplication(layout=Layout(root_container,
focused_element=input_field),
key_bindings=kb,
style=style,
mouse_support=True,
full_screen=True)
application.mode = mode
application.connection = connection
application.run()
layout = Layout(container=root_container, focused_element=btn_start)
# Key bindings.
kb = KeyBindings()
kb.add("tab")(focus_next)
kb.add("s-tab")(focus_previous)
kb.add("right")(focus_next)
kb.add("left")(focus_previous)
kb.add("q")(exit_clicked)
# Styling.
style = Style([
("left-pane", "bg:#888800 #000000"),
("right-pane", "bg:#00aa00 #000000"),
("button", "#000000"),
("button-arrow", "#000000"),
("button focused", "bg:#ff0000"),
("red", "#ff0000"),
("green", "#00ff00"),
])
# Build a main application object.
application = Application(layout=layout,
key_bindings=kb,
style=style,
full_screen=True)
def draw():
tomato.update()
text_area.text = tomato.as_formatted_text()
import re
import requests
import os
from colorama import Fore
from prompt_toolkit.validation import Validator
from . import aws_account_util, config_file_util, pre_checks, utils
from prompt_toolkit.styles import Style
custom_style = Style([
("qmark", "fg:#02abab bold"),
("question", "bold"),
("answer", "fg:#02abab bold"),
("pointer", "fg:#02abab bold"),
("highlighted", "fg:#02abab bold"),
("selected", "fg:#02abab"),
("separator", "fg:#02abab"),
("instruction", ""),
("text", ""),
])
AWS_OS_TYPES = {"AmazonLinux2": "linux", "AmazonWindows2019": "windows"}
CancelAnswer = questionary.Choice(title="Cancel")
class Question:
answer: str = None
params: dict = None
#!/usr/bin/env python
# encoding: utf-8
import questionary
from prompt_toolkit.styles import Style
from . import *
style = Style([
("separator", "fg:#6C6C6C"),
("qmark", "fg:#FF9D00 bold"),
("question", ""),
("selected", "fg:#2e82c7 bg:#d9d9d9"),
("pointer", "fg:#FF9D00 bold"),
("answer", "fg:#2e9dd1 bold bg:#363636"),
])
def main():
generator = questionary.autocomplete(
"What do you want to generate?",
choices=[
"Apache Config",
"Windows Install",
],
style=style,
).ask()
if generator == "Apache Config":
gen = ApacheConfigGenerator()
apache_path: str = questionary.path(
def style(self):
return merge_styles([
Style(BaseCommitizen.default_style_config),
Style(self.config.settings["style"]),
])
def main(play_with_engine=False):
search_field = SearchToolbar()
engine = None
if play_with_engine:
engine = chess.engine.SimpleEngine.popen_uci('/usr/bin/stockfish')
board = chess.Board()
chess_completer = WordCompleter([str(x) for x in board.legal_moves])
output_field = TextArea(style="class:output-field", text=board.unicode())
input_field = TextArea(height=1,
prompt=">>> ",
style="class:input-field",
multiline=False,
wrap_lines=False,
search_field=search_field,
completer=chess_completer,
complete_while_typing=True)
container = HSplit([
output_field,
Window(height=1, char="-", style="class:line"),
input_field,
search_field,
])
def accept(buff):
new_move = chess.Move.from_uci(input_field.text)
board.push(new_move)
if engine:
result = engine.play(board, chess.engine.Limit(time=0.1))
board.push(result.move)
output = board.unicode()
output_field.buffer.document = Document(text=output)
input_field.completer = WordCompleter(
[str(x) for x in board.legal_moves])
input_field.accept_handler = accept
kb = KeyBindings()
@kb.add("c-c")
def app_exit(event):
event.app.exit()
style = Style([
("output-field", "bg:#000044 #ffffff"),
("input-field", "bg:#000000 #ffffff"),
("line", "#004400"),
])
application = Application(
layout=Layout(container, focused_element=input_field),
key_bindings=kb,
style=style,
mouse_support=True,
full_screen=True,
)
application.run()
from prompt_toolkit.styles import Style, merge_styles
from prompt_toolkit.styles.defaults import (PROMPT_TOOLKIT_STYLE, COLORS_STYLE,
WIDGETS_STYLE)
# from prompt_toolkit.filters import ViInsertMode
# from prompt_toolkit.key_binding.key_processor import KeyPress
# from prompt_toolkit.keys import Keys
from pygments.token import Token
from ptpython.layout import CompletionVisualisation
__all__ = ('configure', )
yo_dogg = merge_styles([
Style(styles)
for styles in (PROMPT_TOOLKIT_STYLE, COLORS_STYLE, WIDGETS_STYLE)
])
def configure(repl):
"""
Configuration method. This is called during the start-up of ptpython.
:param repl: `PythonRepl` instance.
"""
# Show function signature (bool).
repl.show_signature = True
# Show docstring (bool).
repl.show_docstring = True
def start_cli():
"""
Start cli loop and execute command
:return:
"""
CLI.add_command("help", CLI.list_commands, "Show commands")
command_completer = WordCompleter(list(sorted(CLI.prompt_to_execution.keys())), ignore_case=True)
welcome_text = TextArea(text="Type help for command overview. Quit with ctrl-c.", height=1, style='class:output-field')
output_field = TextArea(style='class:output-field')
input_output = TextArea(style='class:output-field', multiline=True, wrap_lines=True)
input_field = TextArea(
height=1,
prompt='> ',
style='class:input-field',
wrap_lines=True,
history=FileHistory('cli_history'),
auto_suggest=AutoSuggestFromHistory(),
completer=command_completer,
complete_while_typing=True)
container = FloatContainer(
content=VSplit([
HSplit([
welcome_text,
input_field,
Window(height=1, char='', style='class:line'),
input_output
]),
Window(width=1, char='|', style='class:line'),
output_field,
]),
floats=[
Float(xcursor=True,
ycursor=True,
content=CompletionsMenu(max_height=16, scroll_offset=1))
]
)
# Style.
style = Style([
('output-field', 'bg:#ecf0f1 #000000'),
('input-field', 'bg:#ecf0f1 #000000'),
('line', 'bg:#ecf0f1 #000000'),
])
kb = KeyBindings()
@kb.add('c-c')
@kb.add('c-q')
def _(event):
" Pressing Ctrl-Q or Ctrl-C will exit the user interface. "
event.app.exit()
os._exit(0)
@kb.add('c-m')
def accept(event=None):
user_input = input_field.text
user_input = user_input.split(" ")
if user_input[0] in CLI.prompt_to_execution:
command = CLI.prompt_to_execution.get(user_input[0], lambda: 'Invalid')[0]
args = CLI.prompt_to_execution.get(user_input[0], lambda: 'Invalid')[1]
if len(user_input) == 2:
command(user_input[1])
elif len(user_input) == 3:
command(user_input[1], user_input[2])
elif len(user_input) == 4:
command(user_input[1], user_input[2], user_input[3])
elif len(user_input) == 5:
command(user_input[1], user_input[2], user_input[3], user_input[4])
elif args is not None:
command(args)
else:
command()
else:
Log.error("Command not found")
input_field.text = ''
#input_field.document = Document(text=new_text, cursor_position=len(new_text))
def log_to_input(**kwargs):
msg = kwargs.get("str")
new_text = input_output.buffer.text + msg + "\n"
input_output.buffer.document = Document(
text=new_text, cursor_position=len(new_text)
)
def clear_input():
new_text = ''
input_output.buffer.document = Document(
text=new_text, cursor_position=len(new_text)
)
def log_to_output(**kwargs):
msg = kwargs.get('str')
new_text = output_field.buffer.text + msg + "\n"
output_field.buffer.document = Document(
text=new_text, cursor_position=len(new_text))
Event.on('log_to_input', log_to_input)
Event.on('log_to_output', log_to_output)
CLI.add_command("clear", clear_input, "Clears cli output")
# Run application.
application = Application(
layout=Layout(container, focused_element=input_field),
key_bindings=kb,
style=style,
mouse_support=True,
full_screen=True)
application.run()
Log.info("Starting cli")
return
loop.create_task(update_leaderboard())
# completions menu
completions_menu = Float(
xcursor=True,
ycursor=True,
content=CompletionsMenu(
max_height=16,
scroll_offset=1))
# Style.
style = Style([
('output-field', 'bg:#000000 #ffffff'),
('input-field', 'bg:#000000 #ffffff'),
('line', '#004400 bg:#000000'),
])
root_container = FloatContainer(
content=HSplit([
output_field,
Window(height=1, char="-", style="class:line"),
input_field,
search_field
]),
floats=[
completions_menu
],
key_bindings=KeyBindings())
event.app.exit()
style = Style([
('output-field', 'bg:#000044 #ffffff'),
('maintitle', '#aaaa00'),
('maintitle.since', 'reverse'),
('exchangetitle', '#aaaa00 bg:black bold'),
('exchangetitle.runtime', 'reverse'),
('exchangetitle.prefix', '#fcba03 bg:black bold'),
('vline', 'reverse'),
('line.light', '#4d4d4d'),
('mbline', "fg:ansiyellow bg:black bold"),
('lastbid', "#34eb37"),
('spacer', "#bfbfbf bold"),
('lastask', "#eb4c34"),
('status', "#aaaa00"),
('status.position', '#aaaa00'),
('status.key', '#c6e334'),
("book.unique", '#666699'),
("book.bq", '#00ff00'),
("book.bb", '#33cc33'),
("book.spacer", '#666699'),
("book.bo", '#cc0000'),
("book.aq", '#ff0000'),
])
def main(self, data):
fr = FileReader(data)
bc = BufferCache()
all_input_processors = [
ConditionalProcessor(HighlightSearchProcessor(), ~is_searching),
HighlightIncrementalSearchProcessor(),
HighlightSelectionProcessor(),
DisplayMultipleCursors(),
]
search_toolbar = SearchToolbar(vi_mode=True)
lst_window = Window(
BufferControl(
Buffer(
name="file_list",
document=Document(fr.get_list_text(), cursor_position=0),
read_only=True,
),
search_buffer_control=search_toolbar.control,
preview_search=True,
include_default_input_processors=False,
input_processors=all_input_processors,
),
cursorline=True,
)
txt_window = Window(
BufferControl(
bc.current_buffer,
search_buffer_control=search_toolbar.control,
preview_search=True,
include_default_input_processors=False,
input_processors=all_input_processors,
),
wrap_lines=False,
)
toolbar = FormattedTextToolbar(text="hello world!",
style="class:buf_name")
body = HSplit([lst_window])
# Key bind
kb = KeyBindings()
kb.add(Keys.ControlD)(scroll_half_page_down)
kb.add(Keys.ControlU)(scroll_half_page_up)
@kb.add(Keys.ControlQ)
def _(event):
event.app.exit()
@kb.add(Keys.Enter, filter=has_focus("file_list"))
def _(event):
idx = event.current_buffer.document.cursor_position_row
path = str(fr.get_path(idx))
origin_data = str(fr.get_relative_path(idx))
origin_data2 = origin_data.split("|")[0]
number = origin_data2.split(":")[-1]
command = "vim " + "+" + number + " " + path
res = subprocess.call(command.split())
@kb.add("k")
def _(event):
event.current_buffer.cursor_up()
idx = event.current_buffer.document.cursor_position_row
path = str(fr.get_relative_path(idx))
try:
set_buffer_txt_window(bc.get_or_append_buffer(path, "AAAAA"))
set_text_toolbar(bc.current_buffer_name)
except:
pass
@kb.add("j")
def _(event):
event.current_buffer.cursor_down()
idx = event.current_buffer.document.cursor_position_row
path = str(fr.get_relative_path(idx))
set_buffer_txt_window(bc.get_or_append_buffer(path, "AAAAA"))
set_text_toolbar(bc.current_buffer_name)
def set_buffer_txt_window(buf):
txt_window.content.buffer = buf
def set_text_toolbar(text):
toolbar.content.text = text
@Condition
def search_buffer_is_empty():
return get_app().current_buffer.text == ""
style = Style([
("buf_name", "fg:#dddddd bg:#8a2be2"),
("incsearch", "fg:ansibrightyellow reverse"),
])
app = Application(layout=Layout(body),
key_bindings=kb,
full_screen=True,
style=style)
app.run()
def for_dialog(self):
return merge_styles(
[default_ui_style(),
Style(list(self._dialog_styles.items()))])
def for_prompt(self):
return merge_styles(
[default_ui_style(),
Style(list(self._prompt_styles.items()))])
root = VSplit([
Box(Frame(buttons, style="class:button_panel"), padding=2),
Box(Frame(text_area, title="Events", style="class:edit_panel"), padding=2),
])
layout = Layout(root)
# napojení na klávesové zkratky
key_bindings = KeyBindings()
key_bindings.add("up")(focus_previous)
key_bindings.add("down")(focus_next)
style = Style([
("button_panel", "bg:#ansiblue #ansiwhite"),
("edit_panel", "bg:#ansigreen #000000"),
("button", "#ansibrightyellow"),
("button focused", "bg:#ff0000"),
("text-area focused", "bg:#ff0000"),
])
@key_bindings.add("escape")
def on_escape_press(event):
"""Callback funkce volaná při stisku klávesy Esc."""
print("\n\n[escape]\n\n")
event.app.exit()
def main():
# vytvoření aplikace s textovým uživatelským rozhraním
application = Application(layout=layout,
NO_OR_YES = "(y/N)"
# Instruction for multiline input
INSTRUCTION_MULTILINE = "(Finish with 'Alt+Enter' or 'Esc, Enter')\n>"
# Selection token used to indicate the selection cursor in a list
SELECTED_POINTER = "»"
# Item prefix to identify selected items in a checkbox list
INDICATOR_SELECTED = "●"
# Item prefix to identify unselected items in a checkbox list
INDICATOR_UNSELECTED = "○"
# Prefix displayed in front of questions
DEFAULT_QUESTION_PREFIX = "?"
# Message shown when a user aborts a question prompt using CTRL-C
DEFAULT_KBI_MESSAGE = "Cancelled by user"
# Default message style
DEFAULT_STYLE = Style([
("qmark", "fg:#5f819d"), # token in front of the question
("question", "bold"), # question text
("answer", "fg:#FF9D00 bold"), # submitted answer text behind the question
("pointer", ""), # pointer used in select and checkbox prompts
("selected", ""), # style for a selected item of a checkbox
("separator", ""), # separator in lists
("instruction", ""), # user instructions for select, rawselect, checkbox
])
def checkbox(
message: str,
choices: Sequence[Union[str, Choice, Dict[str, Any]]],
default: Optional[str] = None,
validate: Callable[[List[str]], Union[bool, str]] = lambda a: True,
qmark: str = DEFAULT_QUESTION_PREFIX,
style: Optional[Style] = None,
use_pointer: bool = True,
initial_choice: Optional[Union[str, Choice, Dict[str, Any]]] = None,
**kwargs: Any,
) -> Question:
"""Ask the user to select from a list of items.
This is a multiselect, the user can choose one, none or many of the
items.
Example:
>>> import questionary
>>> questionary.checkbox(
... 'Select toppings',
... choices=[
... "Cheese",
... "Tomato",
... "Pineapple",
... ]).ask()
? Select toppings done (2 selections)
['Cheese', 'Pineapple']
.. image:: ../images/checkbox.gif
This is just a realy basic example, the prompt can be customised using the
parameters.
Args:
message: Question text
choices: Items shown in the selection, this can contain :class:`Choice` or
or :class:`Separator` objects or simple items as strings. Passing
:class:`Choice` objects, allows you to configure the item more
(e.g. preselecting it or disabling it).
default: Default return value (single value). If you want to preselect
multiple items, use ``Choice("foo", checked=True)`` instead.
validate: Require the entered value to pass a validation. The
value can not be submitted until the validator accepts
it (e.g. to check minimum password length).
This should be a function accepting the input and
returning a boolean. Alternatively, the return value
may be a string (indicating failure), which contains
the error message to be displayed.
qmark: Question prefix displayed in front of the question.
By default this is a ``?``.
style: A custom color and style for the question parts. You can
configure colors as well as font types for different elements.
use_pointer: Flag to enable the pointer in front of the currently
highlighted element.
initial_choice: A value corresponding to a selectable item in the choices,
to initially set the pointer position to.
Returns:
:class:`Question`: Question instance, ready to be prompted (using ``.ask()``).
"""
merged_style = merge_styles([
DEFAULT_STYLE,
# Disable the default inverted colours bottom-toolbar behaviour (for
# the error message). However it can be re-enabled with a custom
# style.
Style([("bottom-toolbar", "noreverse")]),
style,
])
if not callable(validate):
raise ValueError("validate must be callable")
ic = InquirerControl(choices,
default,
use_pointer=use_pointer,
initial_choice=initial_choice)
def get_prompt_tokens() -> List[Tuple[str, str]]:
tokens = []
tokens.append(("class:qmark", qmark))
tokens.append(("class:question", " {} ".format(message)))
if ic.is_answered:
nbr_selected = len(ic.selected_options)
if nbr_selected == 0:
tokens.append(("class:answer", "done"))
elif nbr_selected == 1:
if isinstance(ic.get_selected_values()[0].title, list):
ts = ic.get_selected_values()[0].title
tokens.append((
"class:answer",
"".join([token[1] for token in ts]), # type:ignore
))
else:
tokens.append((
"class:answer",
"[{}]".format(ic.get_selected_values()[0].title),
))
else:
tokens.append(("class:answer",
"done ({} selections)".format(nbr_selected)))
else:
tokens.append((
"class:instruction",
"(Use arrow keys to move, "
"<space> to select, "
"<a> to toggle, "
"<i> to invert)",
))
return tokens
def get_selected_values() -> List[Any]:
return [c.value for c in ic.get_selected_values()]
def perform_validation(selected_values: List[str]) -> bool:
verdict = validate(selected_values)
valid = verdict is True
if not valid:
if verdict is False:
error_text = INVALID_INPUT
else:
error_text = str(verdict)
error_message = FormattedText([("class:validation-toolbar",
error_text)])
ic.error_message = (error_message
if not valid and ic.submission_attempted else None)
return valid
layout = common.create_inquirer_layout(ic, get_prompt_tokens, **kwargs)
bindings = KeyBindings()
@bindings.add(Keys.ControlQ, eager=True)
@bindings.add(Keys.ControlC, eager=True)
def _(event):
event.app.exit(exception=KeyboardInterrupt, style="class:aborting")
@bindings.add(" ", eager=True)
def toggle(_event):
pointed_choice = ic.get_pointed_at().value
if pointed_choice in ic.selected_options:
ic.selected_options.remove(pointed_choice)
else:
ic.selected_options.append(pointed_choice)
perform_validation(get_selected_values())
@bindings.add("i", eager=True)
def invert(_event):
inverted_selection = [
c.value for c in ic.choices if not isinstance(c, Separator)
and c.value not in ic.selected_options and not c.disabled
]
ic.selected_options = inverted_selection
perform_validation(get_selected_values())
@bindings.add("a", eager=True)
def all(_event):
all_selected = True # all choices have been selected
for c in ic.choices:
if (not isinstance(c, Separator)
and c.value not in ic.selected_options and not c.disabled):
# add missing ones
ic.selected_options.append(c.value)
all_selected = False
if all_selected:
ic.selected_options = []
perform_validation(get_selected_values())
@bindings.add(Keys.Down, eager=True)
@bindings.add("j", eager=True)
def move_cursor_down(_event):
ic.select_next()
while not ic.is_selection_valid():
ic.select_next()
@bindings.add(Keys.Up, eager=True)
@bindings.add("k", eager=True)
def move_cursor_up(_event):
ic.select_previous()
while not ic.is_selection_valid():
ic.select_previous()
@bindings.add(Keys.ControlM, eager=True)
def set_answer(event):
selected_values = get_selected_values()
ic.submission_attempted = True
if perform_validation(selected_values):
ic.is_answered = True
event.app.exit(result=selected_values)
@bindings.add(Keys.Any)
def other(_event):
"""Disallow inserting other text. """
pass
return Question(
Application(
layout=layout,
key_bindings=bindings,
style=merged_style,
**utils.used_kwargs(kwargs, Application.__init__),
))
def __init__(self, buffer_queue):
self.buffer = Buffer()
self.modules = {}
self.module_prompt_callback = None
self.prompt_ident = None
self.prompt_ident_skip = []
key_bindings = KeyBindings()
default_text = """
Welcome to VoltronBot!
Type ? for available commands.
Control-C or type 'quit' to exit
"""
lexer = PygmentsLexer(VoltronOutputLexer)
## Main output TextArea
self.scrolling_output = TextArea(focusable=True,
text=default_text,
lexer=lexer)
self.buffer_queue = buffer_queue
self.buffer_thread = UIBufferQueue(self, self.buffer_queue,
self.scrolling_output)
self.buffer_thread.start()
self.prompt_queue = queue.Queue()
## Exit keybinds
@key_bindings.add('c-q')
@key_bindings.add('c-c')
def _exit(event):
self.buffer_queue.put('SHUTDOWN')
self.buffer_thread.join()
event.app.exit()
## TextArea for prompt
self.prompt = TextArea(
height=1,
#prompt=DEFAULT_PROMPT,
multiline=False,
wrap_lines=True)
self.prompt.accept_handler = self.input_recv
## Create status bar
self.status_text = FormattedTextControl(text=DEFAULT_STATUS)
self.scroll_text = FormattedTextControl(text="")
self.status_window = Window(content=self.status_text,
height=1,
style="class:status-bar")
self.scroll_window = Window(content=self.scroll_text,
height=1,
width=6,
style="class:status-bar")
status_split = VSplit([self.status_window, self.scroll_window])
self.prompt_text = FormattedTextControl(text=DEFAULT_PROMPT)
self.prompt_window = Window(content=self.prompt_text,
height=1,
width=len(DEFAULT_PROMPT) + 1)
## Create top bar
self.main_container = HSplit([
Window(content=FormattedTextControl(text=f"VoltronBot v{VERSION}"),
height=1,
style="class:title-bar"),
self.scrolling_output,
status_split,
VSplit([self.prompt_window, self.prompt]),
])
style = Style([
('title-bar', 'bg:ansiblue #000000'),
('status-bar', 'bg:ansicyan #000000'),
('status-bar-important', 'bg:ansired #000000'),
])
self.layout = Layout(self.main_container, focused_element=self.prompt)
## Keybind for page up
@key_bindings.add('pageup')
def _scroll_up(event):
self.layout.focus(self.scrolling_output)
scroll_one_line_up(event)
self.layout.focus(self.prompt)
if not self._scrolled_to_bottom:
self.scroll_text.text = '(more)'
else:
self.scroll_text.text = ''
## Keybind for page down
@key_bindings.add('pagedown')
def _scroll_down(event):
self.layout.focus(self.scrolling_output)
scroll_one_line_down(event)
self.layout.focus(self.prompt)
if not self._scrolled_to_bottom:
self.scroll_text.text = '(more)'
else:
self.scroll_text.text = ''
self._app = Application(layout=self.layout,
full_screen=True,
key_bindings=key_bindings,
style=style)
self.busy = False
time.sleep(self.delay)
if exception is not None:
return False
# custom style for question properties
custom_style = Style([
('qmark', 'fg:#fac731 bold'), # token in front of the question
('question', ''), # question text
# pointer used in select and checkbox prompts
('pointer', 'fg:#673ab7 bold'),
# pointed-at choice in select and checkbox prompts
('highlighted', 'fg:#673ab7 bold'),
('selected', 'fg:#0abf5b'), # style for a selected item of a checkbox
('separator', 'fg:#cc5454'), # separator in lists
# user instructions for select, rawselect, checkbox
('instruction', ''),
('text', 'fg:#4688f1 bold'), # plain text
# disabled choices for select and checkbox prompts
('disabled', 'fg:#858585 italic'),
# submitted answer text behind the question
('answer', 'fg:#f44336 bold'),
])
# api routes/endpoints
routes = {
'auth': {
'route':
'https://api-pa-cliente.equatorialenergia.com.br/auth/connect/token',
'headers': {
def main():
click.secho(" ______ __ __ ______ __ __ ",
fg="red")
click.secho("/\ ___\ /\ \_\ \ /\ ___\ /\ \ /\ \ ",
fg="yellow")
click.secho("\ \ \____ \ \____ \ \ \ \____ \ \ \____ \ \ \ ",
fg="green")
click.secho(" \ \_____\ \/\_____\ \ \_____\ \ \_____\ \ \_\ ",
fg="blue")
click.secho(" \/_____/ \/_____/ \/_____/ \/_____/ \/_/ ",
fg="magenta")
main_prompt = prompt('graphistry>> ', enable_system_prompt=True)
# The layout.
output_field = TextArea(style='class:output-field', text=help_text)
input_field = TextArea(height=2,
prompt='graphistry>> ',
style='class:input-field')
bottom_field = TextArea(height=1,
style='class:bottom-toolbar',
text=revisionist_commit_history())
main_output = VSplit([
output_field,
Window(char='~'),
Window(width=20, style='class:line'),
])
container = HSplit([
main_output,
Window(height=1, char='~', style='class:line'), input_field,
bottom_field
])
# The key bindings.
kb = KeyBindings()
@kb.add('c-c')
@kb.add('c-q')
def _(event):
" Pressing Ctrl-Q or Ctrl-C will exit the user interface. "
event.app.exit()
@kb.add('enter', filter=has_focus(input_field))
def _(event):
try:
output = '\n\nIn: {}\nOut: {}'.format(
input_field.text,
eval(input_field.text)) # Don't do 'eval' in real code!
except BaseException as e:
output = '\n\n{}'.format(e)
new_text = output_field.text + output
output_field.buffer.document = Document(text=new_text,
cursor_position=len(new_text))
input_field.text = ''
# Style.
style = Style([
('output-field', 'bg:#000044 #ffffff'),
('input-field', 'bg:#000000 #ffffff'),
('line', '#004400'),
('bottom-toolbar', '#000000 #ffffff'),
('bottom-toolbar.text', '#ffffff'),
])
# Run application.
application = Application(
layout=Layout(container, focused_element=input_field),
key_bindings=kb,
style=style,
mouse_support=True,
full_screen=True,
)
application.run()
fontsize = default_fontsize
print(fontsize)
directory_list = os.listdir(ztree_path)[::-1] # This reverses the list order
from prompt_toolkit.styles import Style
custom_style_fancy = Style([
# ('qmark', 'fg:#673ab7 bold'), # token in front of the question
('question', 'bold'), # question text
# ('answer', 'fg:#f44336 bold'), # submitted answer text behind the question
('pointer', 'fg:#FFFF00 bold'
), # pointer used in select and checkbox prompts
(
'highlighted', 'fg:#FFFF00 bold'
), # pointed-at choice in select and checkbox prompts if use_pointer=False
('selected', 'fg:#cc5454'), # style for a selected item of a checkbox
# ('separator', 'fg:#cc5454'), # separator in lists
# ('instruction', ''), # user instructions for select, rawselect, checkbox
# ('text', ''), # plain text
# ('disabled', 'fg:#858585 italic') # disabled choices for select and checkbox prompts
])
version = questionary.select(
"Please select z-Tree version.",
choices=directory_list,
style=custom_style_fancy).ask() # returns value of selection
with open(os.path.join(settings_path, fontsize_filename),
"w+") as fontsize_file:
# Styling.
from prompt_toolkit.styles import Style
style = Style(
[
("left-pane", "bg:#888800 #000000"),
("right-pane", "bg:#00aa00 #000000"),
("button", "#000000"),
("button-arrow", "#000000"),
("button focused", "bg:#ff0000"),
("text-area focused", "bg:#ff0000"),
("danger", "#ff3300"),
]
)
def start_app(args):
"""Text-based GUI application"""
cmd = Commands()
completer = WordCompleter(cmd.commands(),
meta_dict=cmd.meta_dict(),
ignore_case=True)
history = InMemoryHistory()
# Individual windows
input_field = TextArea(height=1,
prompt='ctmodbus> ',
style='class:input-field',
completer=completer,
history=history)
output_field = TextArea(scrollbar=True,
style='class:output-field',
text='')
statusbar = Window(content=FormattedTextControl(get_statusbar_text),
height=1,
style='class:statusbar')
# Organization of windows
body = FloatContainer(HSplit([
input_field,
Window(height=1, char='-', style='class:line'), output_field, statusbar
]),
floats=[
Float(xcursor=True,
ycursor=True,
content=CompletionsMenu(max_height=16,
scroll_offset=1))
])
# Adding menus
root_container = MenuContainer(
body=body,
menu_items=[],
# menu_items=[
# MenuItem('Project ', children=[
# MenuItem('New'),
# MenuItem('Open'),
# MenuItem('Save'),
# MenuItem('Save as...'),
# MenuItem('-', disabled=True),
# MenuItem('Exit'), ]),
# MenuItem('View ', children=[
# MenuItem('Split'), ]),
# MenuItem('Info ', children=[
# MenuItem('Help'),
# MenuItem('About'), ]), ],
floats=[
Float(xcursor=True,
ycursor=True,
content=CompletionsMenu(max_height=16, scroll_offset=1)),
])
# The key bindings.
kb = KeyBindings()
@kb.add('space')
def _(event):
input_text = input_field.text
cursor = len(input_text)
input_updated = input_text[:cursor] + ' ' + input_text[cursor + 1:]
cursor += 1
input_field.buffer.document = Document(text=input_updated,
cursor_position=cursor)
input_field.buffer.completer = WordCompleter([], ignore_case=True)
@kb.add('enter', filter=has_focus(input_field))
def _(event):
# Process commands on prompt after hitting enter key
# tx_bytes = parse_command(input_field.text, event=event)
input_field.buffer.completer = WordCompleter(cmd.commands(),
meta_dict=cmd.meta_dict(),
ignore_case=True)
if len(input_field.text) == 0:
return
output_text = cmd.execute(input_field.text, output_field.text, event)
input_field.buffer.reset(append_to_history=True)
# For commands that do not send data to modbus device
if output_text == None:
input_field.text = ''
return
# For invalid commands forcing users to correct them
elif output_text == False:
return
# For invalid commands forcing users to correct them
else:
output_field.buffer.document = Document(
text=output_text, cursor_position=len(output_text))
input_field.text = ''
@kb.add('c-c')
def _(event):
"""Pressing Control-C will copy highlighted text to clipboard"""
data = output_field.buffer.copy_selection()
get_app().clipboard.set_data(data)
@kb.add('c-p')
def _(event):
"""Pressing Control-P will paste text from clipboard"""
input_field.buffer.paste_clipboard_data(get_app().clipboard.get_data())
@kb.add('c-q')
def _(event):
" Pressing Ctrl-Q will exit the user interface. "
cmd.do_exit(input_field.text, output_field.text, event)
@kb.add('c-d')
def _(event):
"""Press Ctrl-D to start the python debugger"""
import pdb
pdb.set_trace()
style = Style([
# ('output-field', 'bg:#000000 #ffffff'),
# ('input-field', 'bg:#000000 #ffffff'),
('line', '#004400'),
('statusbar', 'bg:#AAAAAA')
])
# Run application.
application = MyApplication(layout=Layout(root_container,
focused_element=input_field),
key_bindings=kb,
style=style,
mouse_support=True,
full_screen=True)
application.run()
from prompt_toolkit.styles import Style, merge_styles
override_style = Style([("bottom-toolbar", "noreverse")])
style = REDIS_TOKEN = {
"key": "#33aa33",
"important-key": "#058B06",
"pattern": "bold #33aa33",
"string": "#FD971F",
"member": "#FD971F",
"command": "bold #008000",
"integer": "#AE81FF",
"start": "#AE81FF", # TODO auto merge with integer
"end": "#AE81FF",
"const": "bold #AE81FF",
"time": "#aa22ff",
"double": "#bb6688",
"nil": "#808080",
"bit": "#8541FF",
"field": "cyan",
}
GROUP = {
"group.cluster": "#E6DB74",
"group.connection": "#E6DB74",
"group.generic": "#E6DB74",
"group.geo": "#E6DB74",
"group.hash": "#E6DB74",
"group.hyperloglog": "#E6DB74",
"group.list": "#E6DB74",
"group.pubsub": "#E6DB74",
# The name of the directory containing descriptions of each game relative to the root package. Because this is a
# resource string and not a filesystem path, it must use forward slashes.
DESCRIPTIONS_DIR = "descriptions"
# The name of the directory containing template files relative to the root package. Because this is a resource string
# and not a filesystem path, it must use forward slashes.
TEMPLATES_DIR = "templates"
# The path of the template file containing the default difficulty presets. Because this is a resource string and not a
# filesystem path, it must use forward slashes.
DIFFICULTY_TEMPLATE = "/".join([TEMPLATES_DIR, "difficulty.json"])
# The master style sheet for all GUIs.
GUI_STYLE = Style([
("button.focused", "bg:ansired"),
("dialog.body", "fg:ansidefault bg:ansidefault"),
("dialog shadow", "fg:ansibrightblack bg:ansibrightblack"),
("dialog frame.label", "fg:ansigreen"),
("cursor-line", "fg:ansidefault bg:ansidefault reverse nounderline"),
("cursor-column", "fg:ansidefault bg:ansidefault reverse"),
("selectable-label", ""),
("selectable-label.focused", "reverse"),
("column-name", "bold"),
])
# The number of spaces to indent when serializing JSON.
JSON_INDENT = 4
# The name of the default difficulty level.
DEFAULT_DIFFICULTY = "Normal"
Box(body=Frame(text_area), padding=1, style='class:right-pane'),
]),
]), )
layout = Layout(container=root_container, focused_element=button1)
# Key bindings.
kb = KeyBindings()
kb.add('tab')(focus_next)
kb.add('s-tab')(focus_previous)
# Styling.
style = Style([
('left-pane', 'bg:#888800 #000000'),
('right-pane', 'bg:#00aa00 #000000'),
('button', '#000000'),
('button-arrow', '#000000'),
('button focused', 'bg:#ff0000'),
('text-area focused', 'bg:#ff0000'),
])
# Build a main application object.
application = Application(layout=layout,
key_bindings=kb,
style=style,
full_screen=True)
def main():
application.run()
def gatherup(project, no_instruct, lang, debug, setup, demo):
"""GatherUp helps you post essential Python config details to GitHub
or Discourse, all beautifully formatted"""
global config, console, qs, rich_theme, questionary_style, autocomplete_style
config_file = get_config_file()
if config_file != '':
config = set_config()
else:
config = None
rich_theme = Theme({
"h1": "bold grey0 on yellow1",
"h2": "bold hot_pink",
"ul": "bold white",
"t1": "bold yellow1",
"t2": "bold spring_green3",
"bw": "bold white",
"edge": "grey23",
"link": "dodger_blue3",
"markers":"white italic bold on deep_pink1"
})
questionary_style = Style([
('qmark', 'fg:#00d75f bold'), # token in front of the question
('expected', 'bold'), # the expected value we think the user has
('question', 'bold'), # question text
('answer', 'fg:#ffff00 bold'), # submitted answer text behind the question
('pointer', 'fg:#ff5fd7 bold'), # pointer used in select and checkbox prompts
('highlighted', 'fg:#ff5fd7 bold'), # pointed-at choice in select and checkbox prompts
('selected', 'fg:#949494'), # style for a selected item of a checkbox
('instruction', ''), # user instructions for select, rawselect, checkbox
('text', ''), # plain text
('disabled', 'fg:#858585 italic') # disabled choices for select and checkbox prompts
])
autocomplete_style = Style([
('qmark', 'fg:#00d75f bold'), # token in front of the question - CORRECT
#('expected', 'fg:#000000 bg:#ffffff bold'), # the expected value we think the user has NOT USED
('question', 'bold'), # question text - CORRECT, IS FOR QUESTION TEXT
('answer', 'fg:#00d75f bg:#322e2e bold'), # submitted answer text behind the question - ACTUALLY USED FOR PRIMARY DROP-DOWN
#('pointer', 'fg:#ffffff bg:#000000 bold'), # pointer used in select and checkbox prompts NOT USED
#('highlighted', 'fg:#ffffff bg:#000000 bold'), # pointed-at choice in select and checkbox prompts NOT USED
#('selected', 'fg:#000000 bg:#ffffff'), # style for a selected item of a checkbox SELECTED PRIMARY DROP-DOWN, OTHERWISE SEEMS TO INVERT???
('text', 'fg:#322e2e') # plain text - ACTUALLY USED FOR SECONDARY DROP-DOWN
])
console = Console(width=120, theme=rich_theme)
qs = questionary
if debug:
console.print('\nDEBUG IS ON')
console.print(f'Options:\n\t --lang {lang}')
console.print(f'\t --no_instruct {no_instruct}')
console.print(f'\t --project {project}')
if config is None:
console.print('There is no config file')
else:
console.print(f'Config file: {config_file}')
gather_intro(debug=debug)
#TODO: remove this once languages work beyond instructions only
if not no_instruct:
lang = get_language_choice(LANGUAGES, lang, debug=debug)
else:
lang = 'en'
if setup:
do_setup()
if demo:
do_demo()
#TODO proper quit
return
while not QUIT:
if not no_instruct:
offer_instructions(lang, debug=debug)
output_text = gather_input(project, debug=debug)
handle_output(output_text, debug=debug)
check_successful(debug=debug)
finished(debug=debug)
def get_cmd_input():
return questionary.text("",
qmark="Your input ->",
style=Style([('qmark', '#b373d6'),
('', '#b373d6')])).ask().strip()
def __init__(self) -> None:
self.logger = logging.getLogger(self.__class__.__name__)
self.config_file = os.getenv('IG_CLI_CONFIG', 'config.yml')
self.config = {}
self._id = None
self.authd = False
self._stop_update = Event()
self.client = None
self.positions_thread = None
self.activity_thread = None
self.orders_thread = None
self.trackers_thread = None
self.status_thread = RepeatTimer(self.update_status, 1)
self.style = Style([('output-field', 'bg:#5F9EA0 #F0FFFF'),
('input-field', 'bg:#20B2AA #F0FFFF'),
('separator', '#000000'),
('status-bar', 'bg:#D3D3D3 #2F4F4F')])
self.trackers_field = TextArea(style='class:output-field')
self.positions_field = TextArea(style='class:output-field')
self.orders_field = TextArea(style='class:output-field')
self.activity_field = TextArea(height=7, style='class:output-field')
self.msg_field = TextArea(height=7, style='class:output-field')
self.output_container = HSplit([
VSplit([
self.positions_field,
Window(width=1, char='|', style='class:separator'),
HSplit([
self.trackers_field,
Window(height=1, char='-', style='class:separator'),
self.orders_field
])
]),
Window(height=1, char='-', style='class:separator'),
VSplit([
self.msg_field,
Window(width=1, char='|', style='class:separator'),
self.activity_field
])
])
self.search_field = SearchToolbar()
self.input_field = TextArea(height=1,
prompt='>>> ',
style='class:input-field',
multiline=False,
wrap_lines=False,
search_field=self.search_field)
self.input_field.accept_handler = self.parse
self.status_field = TextArea(height=1,
style='class:status-bar',
multiline=False,
wrap_lines=False,
text=self.status)
self.time_field = TextArea(height=1,
style='class:status-bar',
multiline=False,
wrap_lines=False,
text=self.get_time())
self.container = HSplit([
self.output_container,
Window(height=1, char='-', style='class:separator'),
self.input_field, self.search_field, self.status_field
])
self.app = Application(Layout(self.container,
focused_element=self.input_field),
style=self.style,
full_screen=True,
mouse_support=True,
key_bindings=self.kb)
self.autologin()
self.status_thread.start()
def build_application(self, container: Container,
keys: KeyBindings) -> Application:
return Application(layout=Layout(container),
key_bindings=keys,
full_screen=True,
style=Style([("header", "bg:#005fff fg:black")]))
kb = KeyBindings()
@kb.add("c-q")
def _(event):
event.app.exit()
@kb.add("c-c")
def _(event):
q_commands.put('\x03')
style = Style(
[
("input-field", "bg:#000000 #ffffff"),
("line", "#004400"),
]
)
application = Application(
layout=Layout(container, focused_element=input_field),
key_bindings=kb,
style=style,
mouse_support=True,
full_screen=True,
)
def accept(buff):
command = input_field.text
if 255 >= len(command) > 0:
if command == "clear":
