def interactive_config_bootstrap(self,
path,
config_title,
source_config="",
edit_message="",
post_message=""):
# Initialize the config system (copy any example configs to their final directories)
self.init_config_system(path, source_config)
# Strip the original title and replace it with the one we're being fed
self.add_title_to_file(path, config_title)
# Ask the user to configure the program
if len(edit_message) > 0:
print(edit_message)
# Wait for them to press a key
blessed.Terminal().inkey()
# Drop them into editing
self.edit_file(path, False)
if len(post_message) > 0:
print(post_message)
blessed.Terminal().inkey()
print(blessed.Terminal().clear_eos() + "")
exit(self.EXIT_CODE_CONFIG)
def __init__(
self,
loop: AbstractEventLoop,
protocol: Protocol,
input_handler,
output_handler,
) -> None:
super().__init__()
self._loop = loop
self._protocol = protocol
import sys
self._input = _File(sys.__stdin__, mode='r', non_blocking=True)
self._output = _File(sys.__stdout__, mode='w')
self._input_decoder = codecs.getincrementaldecoder(
self._input.encoding)(errors='ignore')
self._input_buf = []
self._output_encoder = codecs.getincrementalencoder(
self._output.encoding)(errors='ignore')
self._output_buf = deque()
self._saved_attr = None
self._terminal = None
self._shared = False
self._echo = None
if self._input.isatty:
self._saved_attr = termios.tcgetattr(self._input.fd)
attr = termios.tcgetattr(self._input.fd)
attr[3] &= ~termios.ICANON
attr[6][termios.VMIN] = 1
attr[6][termios.VTIME] = 0
termios.tcsetattr(self._input.fd, termios.TCSADRAIN, attr)
if self._input == self._output:
self._terminal = blessed.Terminal()
self._shared = True
else:
self._terminal = blessed.Terminal(
stream=self._input.tty_file(mode='w'), )
self._echo = _File(self._terminal.stream, mode='w')
self._loop.call_soon(self._protocol.connection_made, self)
self._loop.call_soon(self._add_reader)
def main(transport_logical_preset, application_preset):
"""Run echo test."""
connection = connect_serial_retry(baudrate=115200, timeout=None)
if connection is None:
logger.fatal('Failed to establish serial connection!')
return
handlers = {
'echo': LoggingHandler(b'echo', name='Echo'),
'copy': LoggingHandler(b'copy', name='Copy'),
'reply': LoggingHandler(b'reply', name='Reply'),
'prefix': LoggingHandler(b'prefix', name='Prefix'),
'blink': LoggingHandler(b'blink', name='Blink'),
'ping-pong': PingPongHandler()
}
term = blessed.Terminal()
protocol = AutomaticStack(
make_preset_stack(transport_logical=transport_logical_preset,
application=application_preset),
list(handlers.values()), ReceiveLoggerLink())
stack = ThreadedSerialAdapter(
connection, make_threading_stack(protocol_stack=protocol))
logger.info(stack)
time.sleep(1.0)
run_once(run_console, stack, handlers, term)
logger.info('Quitting!')
def __init__(self, _address=None, cols=20, rows=2, backlight_enabled=True):
import blessed
self.term = blessed.Terminal()
self.backlt = backlight_enabled
super(_TerminalLCD, self).__init__(cols=cols, rows=rows)
def dprint(text):
""" Function for printing debug information """
if (not SHOW_DEBUG):
return
t = blessed.Terminal()
print(t.red_bold("@DEBUG: {t}".format(t=text)))
def __init__(self):
# Parse command line arguments
# (also loads the configuration file)
self.parse_args()
self.connector = JiraConnector(self.config)
self.issues = self.get_responses()
self.sorted_issues = self.issues.copy()
result_tuple = Selector.select_item(self.sorted_issues,
self.NUM_RESULTS, self.QUERY_TEXT)
term = blessed.Terminal()
# User cancelled the select
if result_tuple is None:
print(term.clear_eos() + "")
exit(self.EXIT_CODE_CANCEL)
selected_issue = result_tuple[0]
self.sorted_issues = result_tuple[1]
if selected_issue is not None:
self.save_issue(selected_issue)
self.write_to_cache(self.cache_file_path)
self.selected_issue = selected_issue
print(term.clear_eos() + "")
exit(self.normal_exit_code)
def __init__(self):
self.cursed = Cursed()
self.t = blessed.Terminal()
prefixes = ['', 'Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei']
self.sizes = list(
reversed([(1024**i, name) for i, name in enumerate(prefixes)]))
def main():
term = blessed.Terminal()
with term.cbreak(), term.hidden_cursor(), term.fullscreen():
idx = len(HSV_SORTED_COLORS) // 2
dirty = True
while True:
if dirty:
outp = render(term, idx)
print(outp, end='', flush=True)
with term.hidden_cursor():
inp = term.inkey()
dirty = True
if inp.code == term.KEY_LEFT or inp == 'h':
idx -= 1
elif inp.code == term.KEY_DOWN or inp == 'j':
idx += term.width
elif inp.code == term.KEY_UP or inp == 'k':
idx -= term.width
elif inp.code == term.KEY_RIGHT or inp == 'l':
idx += 1
elif inp.code in (term.KEY_TAB, term.KEY_BTAB):
term.number_of_colors = next_color(
term.number_of_colors, inp.code == term.KEY_TAB)
elif inp in ('[', ']'):
term.color_distance_algorithm = next_algo(
term.color_distance_algorithm, inp == '[')
elif inp == '\x0c':
pass
else:
dirty = False
while idx < 0:
idx += len(HSV_SORTED_COLORS)
while idx >= len(HSV_SORTED_COLORS):
idx -= len(HSV_SORTED_COLORS)
def main():
# Initalize blessed - the curses wrapper.
t = blessed.Terminal()
globals()["t"] = t
# Print the introduction method and alike things.
print(t.bold_red(Client.conf.intro_banner))
print("Welcome to Latharia.")
print("This is the main console, where you can do various things!")
print(options_menu)
# Interpret and execute options
while True:
command = input("Option: ")
if (command == "0"):
func.client_menu()
break
elif (command == "1"):
func.server_menu()
break
else:
print("Invalid option")
continue
def __init__(self, script, shell):
self.script = Script(script)
self.shell = shell
self.STDINFD = sys.stdin.fileno()
self.exit_flag = False
self.statusline_flag = False
self.terminal = TerminalSession(self.shell)
self.terminal.add_output_callback( lambda c: self.update_statusline() )
self.saved_terminal_settings = None
self.command_parser = CommandParser()
self.command_parser.add_command("passthrough", ['pass-through','pass'])
self.command_parser.add_command("temporary passthrough",['temporary pass-through', 'temp pass'])
self.command_parser.add_command("line")
self.command_parser.add_command("mode")
self.command_parser.add_command("statusline")
self.command_parser.add_command("stdout")
self.command_parser.add_command("pause")
self.command_parser.add_command("comment")
self.command_parser.add_command("display")
if have_blessed:
self.bterm = blessed.Terminal()
self.detected_term_escape_sequences = list(blessed.keyboard.get_keyboard_sequences(self.bterm).keys())
else:
self.detected_term_escape_sequences = []
if have_blessings:
self.bterm = blessings.Terminal()
else:
self.bterm = None
try:
self.saved_terminal_settings = termios.tcgetattr(self.STDINFD)
tty.setraw(self.STDINFD)
except:
logging.warning("Could not save terminal state for stdin. This likely means that no terminal is in control.")
self.input_handler = UserInputHandler(self.STDINFD)
self.mode = self.Modes.Insert
self.mode_handlers = {self.Modes.Insert:self.InsertMode(self),
self.Modes.Line:self.LineMode(self),
self.Modes.Command:self.CommandMode(self),
self.Modes.Passthrough:self.PassthroughMode(self),
self.Modes.TemporaryPassthrough:self.TemporaryPassthroughMode(self),
}
self.mode_status_abbrvs = {self.Modes.Insert:"I",
self.Modes.Command:"C",
self.Modes.Passthrough:"P",
self.Modes.TemporaryPassthrough:"T",
self.Modes.Line:"L"}
self.monitor_server = None
self.monitor_server_flag = False
self.monitor_server_hostname = "localhost"
self.monitor_server_port = 3000
self.message_display = None
def disable_styling(self):
# The `does_styling` attr is read-only, so in order to actually change
# it we do a small hack: create a new Terminal object which has styling
# disabled, and then replace the "guts" of the current object with those
# of the newly created object.
tt = blessed.Terminal(force_styling=None)
tt.override_width = self.override_width
self.__dict__, tt.__dict__ = tt.__dict__, self.__dict__
def __lldb_init_module(debugger, env_dict):
"""
Called by LLDB when the module is loaded
"""
if not 'cmd' in env_dict:
log.debug("Initialising LLDB command")
env_dict['cmd'] = VoltronLLDBCommand(debugger, env_dict)
print(blessed.Terminal().bold_red("Voltron loaded."))
print("Run `voltron init` after you load a target.")
def invoke(self, *args):
regs = voltron.debugger.registers()
reg_list = [
'rax', 'rbx', 'rcx', 'rdx', 'rbp', 'rsp', 'rdi', 'rsi', 'rip',
'r8', 'r9', 'r10', 'r11', 'r12', 'r13', 'r14', 'r15'
]
for name in reg_list:
print("{t.bold}{:3} {t.normal}{:0=16X}".format(
name, regs[name], t=blessed.Terminal()))
def _main():
s.log.setup()
assert s.net.port_free(
_port), 'something already running on port: {}'.format(_port)
s.thread.new(_server)
terminal = blessed.Terminal()
with terminal.fullscreen():
with terminal.hidden_cursor():
_app(terminal)
def convert(ctx):
"""Convert video file(s)"""
containers = build_containers(ctx.obj['FILES'])
running = main_menu(containers)
terminal = blessed.Terminal()
err = ErrorWriter(terminal)
padding = max([len(container.file_name) for container in running])
for line_number, container in enumerate(running):
container.add_progress(terminal, line_number + 2, padding)
writer = Writer(0, terminal, 'bold_blue_on_black')
total_ms = sum([container.microseconds for container in running])
widgets = [
progressbar.Percentage(), ' ',
progressbar.Bar(), ' ',
progressbar.Timer(), ' | ',
progressbar.ETA()
]
pr_bar = progressbar.ProgressBar(max_value=total_ms,
widgets=widgets,
fd=writer)
with terminal.fullscreen():
while running:
total_progress = 0
for container in running:
try:
progress = container.progress
container.pr_bar.update(progress)
except (ProgressFinishedError) as _e:
if container.process.returncode:
err.write('Warning: ffmpeg error while converting '
'{}'.format(container.file_name))
err.write(container.process.communicate()[1].strip(
os.linesep))
running.remove(container)
progress = container.microseconds
container.pr_bar.finish()
total_progress += progress
pr_bar.update(total_progress)
time.sleep(0.2)
pr_bar.finish()
click.clear()
for message in err.messages:
click.secho(
message,
fg='red',
bg='black',
)
def __lldb_init_module(debugger, env_dict):
"""
Called by LLDB when the module is loaded
"""
if 'cmd' not in env_dict:
log.debug("Initialising LLDB command")
env_dict['cmd'] = VoltronLLDBCommand(debugger, env_dict)
voltron.cmd = env_dict['cmd']
print(blessed.Terminal().bold_red("Voltron loaded."))
print("Run `voltron init` after you load a target.")
env_dict['cmd'].adaptor.host.HandleCommand("script import voltron")
def main():
term = blessed.Terminal()
print(term.clear)
start_ts = time.time()
try:
command_line(term)
except Exception:
log.exception("Exception")
return 1
finally:
print(f"Total processing time: {format_sec_to_hms(time.time() - start_ts)}")
return 0
def start_config_copy(self):
print("Starting interactive copy dialogue for local configuration...")
try:
git_root = self.get_git_root_dir()
git_branch = self.get_git_branch()
current_local_config_path = self.local_configuration_path(
git_root, git_branch)
except git.exc.InvalidGitRepositoryError:
# If we have no git repo, we have no local config, which means what the hell are we doing in this function
print(
"[WARNING] No GIT repo detected, can't edit local configurations."
)
exit(1)
local_configs_root = self.local_configs_dir()
paths = [
path for path in self.get_directory_contents(local_configs_root)
if path != current_local_config_path
]
items = [path.relative_to(local_configs_root) for path in paths]
selected_item_tuple = Selector.select_item(
items, 15, "Search for local config: ")
if selected_item_tuple is not None:
selected_item = selected_item_tuple[0]
print(
"Replace current local config for {1}{2} with config from: {0}? (y/n) "
.format(selected_item, git_root, git_branch),
end="",
flush=True)
term = blessed.Terminal()
key = term.inkey()
if key == "y":
match = [
path for path in paths if path.match(str(selected_item))
]
selected_path = match[0]
print("Replacing {0} with {1}...".format(
current_local_config_path, selected_path))
if not self.dry_run:
shutil.copyfile(str(selected_path),
str(current_local_config_path))
exit(self.normal_exit_code)
def test_init_with_parameters(self):
"""Start.__init__() should set the given parameters, as
the initial attribute values.
"""
exp = {
'data': grid.Grid(3, 3),
'term': blessed.Terminal(),
}
state = sui.Start(**exp)
act = {
'data': state.data,
'term': state.term,
}
self._dicteq(exp, act)
def test__init__with_parameters(self):
"""Save.__init__() should accept given parameters and use them
as the initial values for the relevant attributes.
"""
exp = {
'data': grid.Grid(3, 3),
'term': blessed.Terminal(),
}
state = sui.Save(**exp)
act = {
'data': state.data,
'term': state.term,
}
self.assertDictEqual(exp, act)
def test_init_with_parameters(self):
"""Given grid and term, Load.__init__() will set the Load
objects attributes with the given values.
"""
exp = {
'data': grid.Grid(3, 3),
'term': blessed.Terminal(),
}
state = sui.Load(**exp)
act = {
'data': state.data,
'term': state.term,
}
self.assertDictEqual(exp, act)
def _print_lines_not_matching_pattern(errors, pattern, decorate=True):
term = blessed.Terminal()
msg_start = ''
msg_prepend_lines = ''
msg_end = ''
if decorate:
msg_start = term.darkorange(f'WARNING: following lines do not match '
f'the pattern "{pattern}" and have been '
f'ignored:\n')
msg_prepend_lines = term.darkorange('✘ ')
msg_end = term.darkorange('End of ignored lines list\n')
msg_content = '\n'.join(msg_prepend_lines + line for line in errors)
message = f'{msg_start}{msg_content}\n{msg_end}'
sys.stderr.write(message)
def main():
"""Program entry point."""
term = blessed.Terminal(stream=sys.__stderr__)
# This table was generated with the aide of bin/new-wide-by-version.py in
# the wcwidth repository, note that 4.1.0 and 5.0.0 have identical wide
# characters.
previous_version = '4.1.0'
wide_by_version = [
('5.1.0', '龼'),
('5.2.0', '🈯'),
('6.0.0', '🈁'),
('8.0.0', '🉐'),
('9.0.0', '🐹'),
('10.0.0', '🦖'),
('11.0.0', '🧪'),
('12.0.0', '🪐'),
('12.1.0', '㋿'),
('13.0.0', '🫕'),
]
try:
echo = functools.partial(print, end='', flush=True, file=sys.stderr)
echo()
except TypeError:
def echo(string):
print(string, end='', file=sys.stderr)
sys.stderr.flush()
def get_xpos():
ypos, xpos = term.get_location(timeout=3.0)
if -1 in (ypos, xpos):
echo(term.normal + term.move_x(0) + term.clear_eol)
echo('ucs-detect: Unicode Version could not be determined!\n')
sys.exit(1)
return xpos
with term.hidden_cursor():
for version, wchar in wide_by_version:
start_x = get_xpos()
echo(wchar)
end_x = get_xpos()
echo(term.move_x(0) + term.clear_eol)
if end_x - start_x != 2:
break
previous_version = version
echo(term.normal)
print('UNICODE_VERSION={0}; export UNICODE_VERSION'
.format(previous_version))
return 0
def __init__(self, args):
self.args = args
self.imgterm = None
if self.args['--sixel']:
self.imgterm = 'sixel'
elif 'TERM_PROGRAM' in os.environ:
if os.environ['TERM_PROGRAM'] == 'WezTerm':
self.imgterm = 'WezTerm'
elif os.environ['TERM_PROGRAM'] == 'iTerm.app':
self.imgterm = 'iTerm2'
elif os.environ['TERM'] == 'xterm-kitty':
self.imgterm = 'kitty'
if self.imgterm is None:
print("Error: Unable to detect your terminal program.")
sys.exit(1)
self.args = args
self.term = blessed.Terminal()
if self.term.number_of_colors < 256:
print("Got just %d colors" % self.term.number_of_colors)
sys.exit(1)
self.starty = None
self.startx = None
osver, _, arch =platform.mac_ver()
self.is_macos = osver is not None and osver != ''
if self.args['-g'] is not None:
if 'x' not in self.args['-g']:
print("[Error] The geometry must be specified in the form wxh - example: 640x480")
sys.exit(1)
self.scwid, self.scht = [ int(sci, 10) for sci in self.args['-g'].lower().split('x') ]
elif self.is_macos:
self.scwid, self.scht = self.macos_get_pixwidth()
self.scht -= 35
else:
print("[Error] The window geometry must be specified in order to display a cover.")
sys.exit(1)
print(self.term.clear)
ts = get_terminal_size()
# Get how many pixels per character
self.ppc_w = self.scwid / ts.columns
self.ppc_h = self.scht / (ts.lines + 1)
print(f'scwid: {self.scwid} pixels/w: {self.ppc_w} scht: {self.scht} pixels/h: {self.ppc_h}')
print(self.term.move_yx(ts.lines-1, 0))
def __init__(self,
data=None,
options=None,
prefix=__file__,
name=None,
version=None):
if options is not None:
self.options = options
if version is not None:
self.version = version
if data is not None:
self.data = data
self.name = name
self.prefix = prefix
self.init()
self.term = blessed.Terminal()
def parse(filename, pattern, errors_only=False):
"""
Parse file using provided pattern and output the result. Do not store
anything.
"""
_, titles = parser.parse_pattern(pattern)
parsed, errors = parser.parse_file(filename, pattern)
if not errors_only:
print(terminal.tabulate([titles] + parsed))
if errors:
_print_lines_not_matching_pattern(errors,
pattern,
decorate=not errors_only)
elif errors_only:
term = blessed.Terminal()
sys.stderr.write(term.chartreuse3('No parsing errors ☺\n'))
def test_update_ui(self, mock_print):
"""Start.update_ui() should draw the initial UI."""
data = grid.Grid(3, 3)
term = blessed.Terminal()
state = sui.Start(data, term)
exp = [
call(loc.format(1, 1) + ' '),
call(loc.format(2, 1) + ' '),
call(loc.format(3, 1) + '\u2500' * data.width),
call(loc.format(4, 1) + state.menu + clr_eol, end='', flush=True),
]
state.update_ui()
act = mock_print.mock_calls
self._listeq(exp, act)
def test_input(self, mock_print, _, __):
"""Start.input() should return the run command if any key is
pressed."""
term = blessed.Terminal()
exp = ('run', )
exp_calls = [
call(loc.format(term.height, 1) + 'Press any key to continue.' +
clr_eol,
end='',
flush=True),
]
state = sui.Start()
act = state.input()
act_calls = mock_print.mock_calls
self.assertTupleEqual(exp, act)
self.assertListEqual(exp_calls, act_calls)
def __init__(self):
self.jupyter = False
self.ipython = False
if sys.__stdin__ and sys.__stdout__:
import blessed
import _locale
# Save current locale settings
try:
_lls = []
for i in range(100):
ll = _locale.setlocale(i)
_lls.append(ll)
except _locale.Error:
pass
self._blessed_term = blessed.Terminal()
# Restore previous locale settings
for i, ll in enumerate(_lls):
_locale.setlocale(i, ll)
self._allow_unicode = False
self._enable_keyboard = True
self._enable_colors = True
self._enable_terminal_codes = True
self._encoding = self._blessed_term._encoding
enc = self._encoding.upper()
if enc == "UTF8" or enc == "UTF-8":
self._allow_unicode = True
self.is_a_tty = sys.__stdin__.isatty() and sys.__stdout__.isatty()
self._width = 0
self._height = 0
self._check_ipython()
else:
self._enable_keyboard = False
self._enable_colors = False
self._enable_terminal_codes = False
self._encoding = "UTF8"
self._allow_unicode = True
self.is_a_tty = False
self._width = 80
self._height = 25
async def gui_main(gh: GitHub, cmd_options: CommandOptions):
try:
term = blessed.Terminal()
def get_key():
with term.raw():
return term.inkey()
with term.fullscreen(), term.hidden_cursor():
main = MainWindow(term, gh, cmd_options)
await main.init()
while True:
main.on_paint()
with concurrent.futures.ThreadPoolExecutor() as pool:
key = await asyncio.get_event_loop().run_in_executor(pool, get_key)
await main.on_input(key)
except ExitApp:
pass
