def __init__(self):
self._body = WidgetPlaceholder(
Pile([
Filler(
Text(
'Coral Dashboard Initialized\n'
'Waiting for agent ...',
align='center',
), ),
]))
self._wrapper = LineBox(
self._body,
title=self.DEFAULT_TITLE.format(version=__version__),
)
self.palette = ()
self.topmost = MessageShower(
self._wrapper,
width=self.DEFAULT_MESSAGE_WIDTH,
height=self.DEFAULT_MESSAGE_HEIGHT,
)
self.tree = OrderedDict()
def __init__(self, app, parent):
rows = []
for key, text in GLOBAL_KEYS:
rows.append(TableRow([Text(_(key)), Text(_(text))]))
if app.opts.dry_run:
for key, text in DRY_RUN_KEYS:
rows.append(TableRow([Text(_(key)), Text(_(text))]))
table = TablePile(rows,
spacing=2,
colspecs={1: ColSpec(can_shrink=True)})
widgets = [
Pile([
('pack', Text(rewrap(GLOBAL_KEY_HELP))),
('pack', Text("")),
('pack', table),
]),
Text(""),
button_pile([close_btn(parent)]),
]
super().__init__(_("Shortcut Keys"), widgets, 0, 2)
def __init__(self, controller, setup):
self.controller = controller
self.initial_setting = setup.setting
self.layouts = setup.layouts
self.form = KeyboardForm()
opts = []
for layout in self.layouts:
opts.append(Option((layout.name, True, layout)))
opts.sort(key=lambda o: locale.strxfrm(o.label.text))
connect_signal(self.form, 'submit', self.done)
connect_signal(self.form, 'cancel', self.cancel)
connect_signal(self.form.layout.widget, "select", self.select_layout)
self.form.layout.widget.options = opts
layout, variant = self.lookup(
setup.setting.layout, setup.setting.variant)
self.set_values(layout, variant)
if self.controller.opts.run_on_serial:
excerpt = _('Please select the layout of the keyboard directly '
'attached to the system, if any.')
else:
excerpt = _('Please select your keyboard layout below, or select '
'"Identify keyboard" to detect your layout '
'automatically.')
lb_contents = self.form.as_rows()
if not self.controller.opts.run_on_serial:
lb_contents.extend([
Text(""),
button_pile([
other_btn(label=_("Identify keyboard"),
on_press=self.detect)]),
])
super().__init__(screen(
lb_contents,
self.form.buttons,
excerpt=excerpt,
narrow_rows=True))
def render(self, size, focus=False):
"""
Render the graph
:param focus: ignored
:type size: tuple
:return:
"""
del focus
self.last_size = size
matrix = self.__get_matrix(size[0], size[1])
rows = []
for row in range(0, size[1]):
line = []
groups = ["".join(grp) for _, grp in groupby(matrix[row])]
for chunk in groups:
color = self.colors[int(chunk[0])]
char = self.chars[int(chunk[0])]
line.append((color, len(chunk) * char))
rows.append((Text(line).render((size[0], )), None, False))
return CanvasCombine(rows)
def create_interface():
m_map = Padding(LineBox(minimap,
tlcorner='',
tline='',
lline='',
trcorner='',
blcorner='',
rline='│',
bline='',
brcorner=''),
align="center",
width=35)
_help = Text(("help", "Карта - m, тетрадь - c,\nНачать зарисовку - q\n" +
"сделать отметку - CTRL+arrow_key"),
align="center")
#column = Columns([description, Pile([m_map, _help]), BoxAdapter(
column = Columns([
description, m_map,
BoxAdapter(Filler(location_text, valign=("relative", 20)), 20)
])
return Filler(Padding(column, align="center", width=120), valign="middle")
def __init__(self, controller, selection):
self.controller = controller
buttons = [
danger_btn("CONFIRM", on_press=self.confirm),
back_btn("BACK", on_press=self.back),
]
fmt = self.canned_summary.get(selection.action.mode,
self.default_summary)
summary = fmt.format(action=selection.action.title,
action_lower=selection.action.title.lower(),
model=selection.system.model.display_name,
publisher=selection.system.brand.display_name,
version=selection.system.label)
rows = [
Text(summary),
]
super().__init__(
controller.model.current,
screen(rows=rows,
buttons=button_pile(buttons),
focus_buttons=False))
def _build_widget(self, **kwargs):
total_items = []
for _item in self.radio_items.keys():
desc = AttrWrap(Text(" {}".format(self.radio_items[_item][1])),
'input', 'input focus')
total_items.append(
AttrWrap(self.radio_items[_item][0], 'input', 'input focus'))
total_items.append(AttrWrap(desc, 'input'))
total_items.append(Divider('-'))
self.input_lbox = ListBox(SimpleListWalker(total_items[:-1]))
self.add_buttons()
self.container_box_adapter = BoxAdapter(self.input_lbox,
len(total_items))
self.container_lbox = ListBox(
[self.container_box_adapter,
Divider(), self.btn_pile])
return LineBox(BoxAdapter(self.container_lbox,
height=len(total_items) + 3),
title=self.title)
def __init__(self, model, signal, opts):
self.model = model
self.signal = signal
self.opts = opts
self.items = []
self.realname = RealnameEditor(caption="")
self.hostname = UsernameEditor(caption="")
self.username = UsernameEditor(caption="")
self.password = PasswordEditor(caption="")
self.ssh_import_id = StringEditor(caption="")
self.ssh_import_confirmed = True
self.error = Text("", align="center")
self.confirm_password = PasswordEditor(caption="")
body = [
Padding.center_90(self._build_model_inputs()),
Padding.line_break(""),
Padding.center_90(Color.info_error(self.error)),
Padding.line_break(""),
Padding.fixed_10(self._build_buttons()),
]
super().__init__(ListBox(body))
def __init__(self, app):
self.app = app
rows = [
TableRow([
Text(""),
Text(_("DATE")),
Text(_("KIND")),
Text(_("STATUS")),
Text(""),
])]
self.report_to_row = {}
for report in self.app.controllers.Error.reports:
connect_signal(report, "changed", self._report_changed, report)
r = self.report_to_row[report] = self.row_for_report(report)
rows.append(r)
self.table = TablePile(rows, colspecs={1: ColSpec(can_shrink=True)})
widgets = [
Text(_("Select an error report to view:")),
Text(""),
self.table,
Text(""),
button_pile([close_btn(self)]),
]
super().__init__("", widgets, 2, 2)
def _single_response(self, s, f, date, schedule, constant_name,
display_range):
start_time = local_date_to_time(schedule.start_of_frame(date))
finish_time = local_date_to_time(schedule.next_frame(date))
response = Response(
**loads(Constant.get(s, constant_name).at(s, start_time).value))
start = self._read(s, response.dest_name, start_time, finish_time, asc)
finish = self._read(s, response.dest_name, start_time, finish_time,
desc)
if start and finish and start.value != finish.value:
lo, hi = self._range(s, response.dest_name, start, finish_time,
dt.timedelta(days=90))
if lo is not None and hi is not None:
if display_range:
style = 'quintile-%d' % min(
5, 1 + int(5 * (finish.value - lo.value) /
(hi.value - lo.value)))
else:
style = 'em'
yield [
Text(response.dest_name),
Text([label('Frm: '), (style, '%d' % int(start.value))]),
Text([label('To: '), (style, '%d' % int(finish.value))]),
Text(
em('increase')
if start.value < finish.value else error('decrease'))
]
if display_range:
yield [
Text([label('Over 90 days')]),
Text([label('Lo: '),
'%d' % int(lo.value)]),
Text([label('Hi: '),
'%d' % int(hi.value)]),
Text('')
]
def __init__(self, model, controller):
self.model = model
self.controller = controller
self.dev_to_row = {}
self.cur_netdevs = []
self.error = Text("", align='center')
self.device_table = TablePile(
self._build_model_inputs(),
spacing=2, colspecs={
0: ColSpec(rpad=1),
4: ColSpec(can_shrink=True, rpad=1),
})
self._create_bond_btn = menu_btn(
_("Create bond"), on_press=self._create_bond)
bp = button_pile([self._create_bond_btn])
bp.align = 'left'
rows = [
self.device_table,
bp,
]
buttons = button_pile([
done_btn(_("Done"), on_press=self.done),
back_btn(_("Back"), on_press=self.cancel),
])
self.bottom = Pile([
('pack', buttons),
])
self.error_showing = False
super().__init__(screen(
rows=rows,
buttons=self.bottom,
focus_buttons=True,
excerpt=self.excerpt))
def render_Code(self, code):
# entries/out/ce_status
def insert_prompt(entries):
yield Link(
"verbatim",
">>>",
lambda: self.cb("likely copy content to clipboard"),
)
yield (None, " ")
for txt, ref, css in entries:
if txt == "\n":
yield (None, "\n")
yield ("verbatim", "... ")
else:
yield ("pyg-" + str(css), f"{txt}")
return urwid.Padding(
urwid.Pile(
[TextWithLink([x for x in insert_prompt(code.entries)])] +
([Text(code.out)] if code.out else []), ),
left=2,
)
def show_network_error(self, action, info=None):
self.error_showing = True
self.bottom.contents[0:0] = [
(Text(""), self.bottom.options()),
(Color.info_error(self.error), self.bottom.options()),
]
if action == 'stop-networkd':
exc = info[0]
self.error.set_text("Stopping systemd-networkd-failed: %r" %
(exc.stderr, ))
elif action == 'apply':
self.error.set_text("Network configuration could not be applied; "
"please verify your settings.")
elif action == 'timeout':
self.error.set_text("Network configuration timed out; "
"please verify your settings.")
elif action == 'down':
self.error.set_text("Downing network interfaces failed.")
elif action == 'canceled':
self.error.set_text("Network configuration canceled.")
else:
self.error.set_text("An unexpected error has occurred; "
"please verify your settings.")
def __init__(self, user, last_statuses):
"""
Receive a ``user`` and its ``last_statuses`` to render the widget.
"""
whitespace = Divider(' ')
widgets = []
# name
name = Text('%s' % user.name)
widgets.extend([name, whitespace])
# bio
if user.description:
description = Text(parse_attributes(user.description))
widgets.extend([description, whitespace])
# URL
if user.url:
url_text_with_attr = ('url', user.url)
url = Text(url_text_with_attr)
widgets.extend([url, whitespace])
# statistics: following, followers and favorites
# TODO: tweet count
following = Text(_('following:\n%s' % user.friends_count))
followers = Text(_('followers:\n%s' % user.followers_count))
favorites = Text(_('favorites:\n%s' % user.favorites_count))
stats = Columns([following, followers, favorites])
widgets.extend([stats, whitespace])
# Last n statuses
# TODO: make it configurable
statuses_to_show = configuration.styles['statuses_in_user_info']
status_widgets = [
StatusWidget(status) for status in last_statuses[:statuses_to_show]
]
widgets.extend(status_widgets)
pile = Pile(widgets)
WidgetWrap.__init__(
self, LineBox(title='@%s' % user.screen_name,
original_widget=pile))
def __init__(self, controller, current, has_more=False):
self.controller = controller
log.debug('more systems available: %s', has_more)
log.debug('current system: %s', current)
actions = []
for action in sorted(current.actions, key=by_preferred_action_type):
actions.append(
forward_btn(label=action.title.capitalize(),
on_press=self._current_system_action,
user_arg=(current, action)))
if has_more:
# add a button to show the other systems
actions.append(Text(""))
actions.append(
forward_btn(label="Show all available systems",
on_press=self._more_options))
lb = ListBox(actions)
super().__init__(current,
screen(lb, narrow_rows=True, excerpt=self.excerpt))
def _refresh_nodes_on_main_thread(self):
status = model_status()
for name, service in sorted(status['applications'].items()):
service_w = ServiceWidget(name, service)
for unit in service_w.Units:
try:
unit_w = self.deployed[unit._name]
except:
self.deployed[unit._name] = unit
unit_w = self.deployed[unit._name]
self.table.addColumns(
unit._name,
[('fixed', 3, getattr(unit_w, 'Icon')),
('fixed', 50, getattr(unit_w, 'Name')),
('fixed', 20, getattr(unit_w, 'AgentStatus'))])
if not hasattr(unit_w, 'WorkloadInfo'):
continue
self.table.addColumns(
unit._name, [('fixed', 5, Text("")),
Color.info_context(unit_w.WorkloadInfo)],
force=True)
self.update_ui_state(unit_w, unit._unit)
def build_widget(self):
self.step_pile = pile = Pile([
self.description,
Padding.line_break(""),
Padding.push_4(self.output),
])
if utils.is_linux() and self.model.needs_sudo:
pile.contents.append((Padding.line_break(""), pile.options()))
label = 'This step requires sudo.'
if not self.app.sudo_pass:
label += ' Enter sudo password, if needed:'
self.sudo_input = PasswordEditor()
columns = [
('weight', 0.5, Padding.left(Text(('body', label)), left=5)),
]
if self.sudo_input:
columns.append(
('weight', 1,
Color.string_input(self.sudo_input,
focus_map='string_input focus')))
pile.contents.append((Columns(columns,
dividechars=3), pile.options()))
def __init__(self, model, controller, name):
self.model = model
self.controller = controller
self.dev = self.model.get_netdev_by_name(name)
self.is_gateway = False
self.form = NetworkConfigForm(self.ip_version)
connect_signal(self.form, 'submit', self.done)
connect_signal(self.form, 'cancel', self.cancel)
self.form.subnet.help = _("Example: %s"%(self.example_address,))
configured_addresses = self.dev.configured_ip_addresses_for_version(self.ip_version)
if configured_addresses:
addr = ipaddress.ip_interface(configured_addresses[0])
self.form.subnet.value = str(addr.network)
self.form.address.value = str(addr.ip)
configured_gateway = self.dev.configured_gateway_for_version(self.ip_version)
if configured_gateway:
self.form.gateway.value = configured_gateway
self.form.nameservers.value = ', '.join(self.dev.configured_nameservers)
self.form.searchdomains.value = ', '.join(self.dev.configured_searchdomains)
self.error = Text("", align='center')
super().__init__(self.form.as_screen(focus_buttons=False))
def __init__(self, app, step_model, cb):
"""
Arguments:
step_model: step model
step_model_widget: step model widget
cb: callback
"""
self.app = app
self.model = step_model
self.title = Text(('info_minor', step_model.title))
self.description = Text(('info_minor', step_model.description))
self.result = Text(step_model.result)
self.output = Text(('info_minor', ''))
self.icon = Text(("info_minor", "\N{BALLOT BOX}"))
self.additional_input = []
if len(step_model.additional_input) > 0:
for i in step_model.additional_input:
widget = {
"label": Text(('body', i['label'])),
"key": i['key'],
"input": self.INPUT_TYPES.get(i['type'])
}
if 'default' in i:
widget['input'] = StringEditor(default=i['default'])
self.additional_input.append(widget)
else:
widget = {
"label": Text(""),
"key": "submit",
"input": None
}
self.additional_input.append(widget)
self.cb = cb
self.step_pile = self.build_widget()
self.show_output = True
super().__init__(self.step_pile)
def add(self, message, packet):
"""
Args:
message (str): Text message that will appear
packet (Scapy packet): Packet that corresponds to this entry.
"""
txt = AttrMap(Text(message), 'frame', 'selected')
self.walker.append(txt)
self.packets.append(packet)
if self.rolling_packet_buffer is not None and len(
self.walker) > self.rolling_packet_buffer:
self.packets.pop(0)
self.walker.pop(0)
currently_selected = self.get_focus()
if isinstance(currently_selected, (list, tuple)):
currently_selected = currently_selected[0]
# This ensures auto scrolling only engages if our selected item is the bottom one
if len(self.walker) <= 1 or currently_selected is self.walker[-2]:
self.set_focus(len(self.walker) - 1)
def render_BlockDirective(self, directive):
if directive.directive_name == "note":
return urwid.Padding(
urwid.LineBox(self.render(directive.inner),
title="Note",
title_align="left"),
left=2,
right=2,
)
elif directive.directive_name == "math":
assert False
args0 = [a for a in directive.args0 if a]
inner = directive.inner
content = " ".join(directive.args0)
if content:
if inner:
assert len(inner.children) == 1
content = content + inner.children[0].value
else:
assert len(inner.children) == 1
content = inner.children[0].value
from flatlatex import converter
c = converter()
return urwid.Padding(urwid.Text(("math", c.convert(content))),
left=2)
inn = [
blank,
Text([("param", ".. " + directive.directive_name + "::")] +
directive.args0),
]
if directive.inner:
inn.append(urwid.Padding(self.render(directive.inner), left=4)),
return urwid.Pile(inn)
def __init__(self, app):
ClipLauncherUI.__init__(self, app)
# set colors
self.app.main_loop.screen.register_palette(self.palette)
# create widgets
tracks = enumerate(self.app.tracks)
self.cols = Columns(
SimpleFocusListWalker(
[TrackWidget(self, t, n + 1) for n, t in tracks]),
self.track_spacing)
self.editor = Panel()
self.header = TransportWidget(app.transport)
self.footer = AttrMap(Text('foo'), 'footer')
# listen to events
INFO.append(self.on_info)
# init as pile of widgets
WidgetWrap.__init__(
self,
Pile([('pack', self.header), self.cols, (10, self.editor),
('pack', self.footer)]))
def build_menuable_items(self):
""" Builds a list of bundles available to install
"""
cols = []
for bundle in app.bundles:
bundle_metadata = bundle['Meta']['bundle-metadata']
try:
conjure_data = bundle['Meta']['extra-info/conjure-up']
name = conjure_data.get('friendly-name',
bundle['Meta']['id']['Name'])
except KeyError:
name = bundle['Meta']['id']['Name']
self.fname_id_map[name] = bundle
cols.append(
Columns([("weight", 0.2,
Color.body(menu_btn(label=name, on_press=self.done),
focus_map="menu_button focus")),
("weight", 0.3,
Text(bundle_metadata.get('Description',
'Needs a description'),
align="left"))],
dividechars=1))
cols.append(Padding.line_break(""))
return Pile(cols)
def __init__(self):
self.keybind = {}
self.main_helper_text = self.generate_helper_text([
("F10", "Quit", "helper_text_red"),
])
self.subview_helper_text = self.generate_helper_text([
("F1", "Confirm", "helper_text_green"),
("F5", "Abort", "helper_text_brown"),
("F10", "Quit", "helper_text_red"),
("TAB", "Next", "helper_text_light"),
("S-TAB", "Previous", "helper_text_light")
])
self.root = Frame(self.generate_main_view(),
Text(("header", ""), "center"),
self.main_helper_text)
self.loop = MainLoop(self.root,
palette,
unhandled_input=self.unhandled_input)
self.bind_global("f10", self.quit)
self.handle_os_signals()
def _journal_date(self, s, f, ajournal, date):
zones = build_zones(s, ajournal, HRZ_WIDTH)
active_date = self.__active_date(s, ajournal, date)
climbs = self.__climbs(s, ajournal, date)
details = Pile(([] if climbs else [Divider()]) + active_date + climbs)
yield Pile([
Text(f'{ajournal.name} ({ajournal.activity_group.name})'),
Indent(Columns([details, (HRZ_WIDTH + 2, zones)])),
Divider(),
Indent(
Columns([
Pile(
self.__template(s, ajournal, MIN_KM_TIME_ANY,
'Min Time', r'(\d+km)', date) +
self.__template(s, ajournal, MED_KM_TIME_ANY,
'Med Time', r'(\d+km)', date)),
Pile(
self.__template(s, ajournal, MAX_MED_HR_M_ANY,
'Max Med Heart Rate', r'(\d+m)', date)
+ self.__template(s, ajournal, MAX_MEAN_PE_M_ANY,
'Max Mean Power Estimate', r'(\d+m)',
date))
]))
])
def _build_filesystem_list(self):
log.debug('FileSystemView: building part list')
cols = []
mount_point_text = _("MOUNT POINT")
longest_path = len(mount_point_text)
for m in sorted(self.model._mounts, key=lambda m: m.path):
path = m.path
longest_path = max(longest_path, len(path))
for p, *dummy in reversed(cols):
if path.startswith(p):
path = [('info_minor', p), path[len(p):]]
break
cols.append((m.path, path, humanize_size(m.device.volume.size),
m.device.fstype, m.device.volume.desc()))
for fs in self.model._filesystems:
if fs.fstype == 'swap':
cols.append(
(None, _('SWAP'), humanize_size(fs.volume.size), fs.fstype,
fs.volume.desc()))
if len(cols) == 0:
return Pile(
[Color.info_minor(Text(_("No disks or partitions mounted.")))])
size_text = _("SIZE")
type_text = _("TYPE")
size_width = max(len(size_text), 9)
type_width = max(len(type_text), self.model.longest_fs_name)
cols.insert(
0,
(None, mount_point_text, size_text, type_text, _("DEVICE TYPE")))
pl = []
for dummy, a, b, c, d in cols:
if b == "SIZE":
b = Text(b, align='center')
else:
b = Text(b, align='right')
pl.append(
Columns([(longest_path, Text(a)), (size_width, b),
(type_width, Text(c)),
Text(d)], 4))
return Pile(pl)
def __init__(self, user):
"""
"""
whitespace = Divider(' ')
widgets = []
# name
name = Text('%s' % user.name)
widgets.extend([name, whitespace])
# bio
if user.description:
description = Text(parse_attributes(user.description))
widgets.extend([description, whitespace])
# URL
if user.url:
url_text_with_attr = ('url', user.url)
url = Text(url_text_with_attr)
widgets.extend([url, whitespace])
# statistics: following, followers and favorites
following = Text(_('following:\n%s' % user.friends_count))
followers = Text(_('followers:\n%s' % user.followers_count))
favorites = Text(_('favorites:\n%s' % user.favorites_count))
stats = Columns([following, followers, favorites])
widgets.extend([stats, whitespace])
# last status
if user.status:
status = StatusWidget(user.status)
widgets.append(status)
pile = Pile(widgets)
WidgetWrap.__init__(self, LineBox(title='@%s' % user.screen_name,
original_widget=pile))
def _build_iface_inputs(self):
col1 = [
Columns([("weight", 0.2, Text("Subnet")),
("weight", 0.3,
Color.string_input(self.subnet_input,
focus_map="string_input focus")),
("weight", 0.5, Text("CIDR e.g. 192.168.9.0/24"))],
dividechars=2),
Columns([("weight", 0.2, Text("Address")),
("weight", 0.3,
Color.string_input(self.address_input,
focus_map="string_input focus")),
("weight", 0.5, Text(""))],
dividechars=2),
Columns([("weight", 0.2, Text("Gateway")),
("weight", 0.3,
Color.string_input(self.gateway_input,
focus_map="string_input focus")),
("weight", 0.5, Text(""))],
dividechars=2)
]
return Pile(col1)
def __init__(self, model, controller):
self.model = model
self.controller = controller
self.items = []
self.error = Text("", align='center')
self.additional_options = Pile(self._build_additional_options())
self.listbox = ListBox(self._build_model_inputs() + [
Padding.center_79(self.additional_options),
Padding.line_break(""),
])
self.bottom = Pile([
Text(""),
self._build_buttons(),
Text(""),
])
self.error_showing = False
self.frame = Pile([('pack', Text("")),
('pack', Padding.center_79(Text(_(self.excerpt)))),
('pack', Text("")),
Padding.center_90(self.listbox),
('pack', self.bottom)])
self.frame.focus_position = 4
super().__init__(self.frame)
def __init__(self, app, message):
self.message = Text(message, align="center")
self.output = Text("", align="left")
self.loading_boxes = [Text(x) for x in self.load_attributes]
super().__init__(self._build_node_waiting())