def rich_report(self):
results = [task.report_table() for task in self.tasks]
successes = [x[0] for x in results]
if not self._is_secret() or any(successes):
table = Table.grid(expand=True, padding=(0, 2))
table.add_column()
table.add_column()
table.add_column(style='red', overflow='fold', ratio=1)
for result, name, msg, print_if_failed in results:
if not print_if_failed and not result:
continue
emoji = ":green_heart:" if result else ":no_entry_sign:"
name = f"[green]{name}" if result else f"[red]{name}"
table.add_row(f"[{emoji}]", name, msg)
if self.name == "":
title = Text(self.__doc__, justify='center')
else:
title = Text(self.name, justify='center')
success_num = successes.count(True)
summary_line = Text(
f"{success_num} Successful out of {len(results)}",
justify='right')
panel_text = RenderGroup(title, table, '', summary_line)
border_style = "green" if all(successes) else "red"
panel = Panel(panel_text,
highlight=True,
border_style=border_style,
width=100)
print(panel)
return successes
def make_sponsor_message() -> Panel:
"""Some example content."""
sponsor_message = Table.grid(padding=1)
sponsor_message.add_column(style="green", justify="right")
sponsor_message.add_column(no_wrap=True)
sponsor_message.add_row(
"✔ GitHub 🤓 ",
"[u blue link=https://github.com/jiaulislam]https://github.com/jiaulislam",
)
intro_message = Text.from_markup(
"""Consider supporting my work via Github 🤘 🤘 🤘. - Jiaul Islam"""
)
message = Table.grid(padding=1)
message.add_column()
message.add_column(no_wrap=True)
message.add_row(intro_message, sponsor_message)
message_panel = Panel(
Align.center(
RenderGroup(intro_message, "\n", Align.center(sponsor_message)),
vertical="middle",
),
box=box.ROUNDED,
padding=(1, 2),
title="[b red]Thanks for using my application!",
border_style="bright_blue",
)
return message_panel
def get_pretty_failure_for_in(self, err: TestFailure) -> RenderableType:
lhs_msg = Text.assemble(
("The ", "default"),
("item ", "pass.textonly"),
*self.of_type(err.lhs),
)
lhs = Panel(
Pretty(err.lhs),
title=lhs_msg,
title_align="left",
border_style="pass.textonly",
padding=1,
)
rhs_msg = Text.assemble(
("was not " if err.operator is Comparison.In else "was ", "bold default"),
("found in the ", "default"),
("container ", "fail.textonly"),
*self.of_type(err.rhs),
)
rhs = Panel(
Pretty(err.rhs),
title=rhs_msg,
title_align="left",
border_style="fail.textonly",
padding=1,
)
return Padding(RenderGroup(lhs, rhs), pad=(0, 0, 1, 2))
def main() -> None:
previous: list[str] = [""] * 20
with Live() as live:
while True:
mvp, non_mvp = get_idols()
above = Table.grid(expand=True)
above.add_column(width=2)
above.add_column(width=3)
above.add_column()
for i, player in enumerate(mvp):
above.add_row(*format_row(i, player, previous))
noodle = r"[yellow]\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/"
below = Table.grid(expand=True)
below.add_column(width=2)
below.add_column(width=3)
below.add_column()
for j, player in enumerate(non_mvp):
below.add_row(*format_row(i + j + 1, player, previous))
live.update(Panel(RenderGroup(above, noodle, below)))
previous = mvp + non_mvp
time.sleep(30)
def generate_renderable() -> RenderGroup:
"""
Function called to update the live display, fetches data from htcondor, does the processing and
returns a RenderGroup with both Panels.
"""
condor_string = query_condor_q()
user_tasks, cluster_info = read_condor_q(condor_string)
owner = user_tasks[0].owner if user_tasks else "User"
tasks_table = make_tasks_table(user_tasks)
cluster_table = make_cluster_table(owner, cluster_info)
return RenderGroup(
Panel(
tasks_table,
title=f"Scheduler: {cluster_info.scheduler_id}.cern.ch",
expand=False,
border_style="scope.border",
),
Panel(
cluster_table,
title=f"{cluster_info.scheduler_id} Statistics",
expand=False,
border_style="scope.border",
),
)
async def plugin_command(ctx):
all = []
doc = self.get_plugin_doc(name)
doc.extract_metadata("examples")
desc_string = f"## Mogrifier: **{name}**\n"
if doc.get_short_help(default=None):
desc_string += doc.get_short_help() + "\n\n"
desc_string += f"\n## Input Arguments\n\nThis is the list of arguments the *{name}* mogrifier accepts as input:\n"
desc = Markdown(
desc_string,
style=bring_style,
code_theme=bring_code_theme,
justify="left",
)
all.append(desc)
plugin = self.get_plugin(name)
if hasattr(plugin, "_requires"):
args = plugin._requires
else:
args = plugin.requires(None)
record_arg = self._arg_hive.create_record_arg(childs=args)
arg_table = to_rich_table(record_arg)
all.append(arg_table)
desc_string = f"\n## Output Arguments\n\nThis is the list of arguments the *{name}* mogrifier provides as output:\n"
desc = Markdown(
desc_string,
style=bring_style,
code_theme=bring_code_theme,
justify="left",
)
all.append(desc)
if hasattr(plugin, "_provides"):
args = plugin._provides
else:
args = plugin.provides(None)
record_arg = self._arg_hive.create_record_arg(childs=args)
arg_table = to_rich_table(record_arg)
all.append(arg_table)
desc_string = await create_pkg_type_markdown_string(
bring=self.bring, plugin_doc=doc)
desc = Markdown(
desc_string,
style=bring_style,
code_theme=bring_code_theme,
justify="left",
)
all.append(desc)
group = RenderGroup(*all)
console.print(Panel(Panel(group, box=box.SIMPLE)))
def display_notebook(notebook):
row = notebook.row
renders = notebook.get_renders_in_range(row,
row + _METADATA["term_height"])
notebook.needs_redraw = False
return Panel(RenderGroup(*renders))
class Content:
"""
This class represents a per CLI invocation "canvas" which will hold the data
that gets displayed on the CLI. All content updates happen by updating the
value of the instance's RenderGroup
"""
rg: RenderGroup = RenderGroup()
def __rich__(self) -> RenderGroup:
return self.rg
def little_game(game: Game) -> Panel:
weather = Weather.load_one(game.weather).name
grid = Table.grid(expand=True)
grid.add_column()
grid.add_column(justify="right")
grid.add_row(inning(game), weather)
grid.add_row(game.away_team_nickname, f"{game.away_score:g}")
grid.add_row(game.home_team_nickname, f"{game.home_score:g}")
style = highlight(game)
return Panel(RenderGroup(grid, update(game)), width=30, border_style=style)
def pad_renderable(renderable, offset):
"""
Pad a renderable, subject to a particular truncation offset.
"""
if offset < 0:
raise Exception("invalid offset!")
if offset == 0:
return RenderGroup(_RULE, Padding(renderable, 1))
if offset == 1:
return Padding(renderable, 1)
else:
return Padding(renderable, (0, 1, 1, 1))
def get_pretty_comparison_failure(
self, err: TestAssertionFailure
) -> RenderableType:
diff = self.get_diff(err)
parts = [
self.get_operands(err) if not diff else None,
diff,
]
return Padding(
RenderGroup(*(part for part in parts if part)),
pad=(0, 0, 1, 2),
)
def print_probe(probe: VideoProbe) -> None:
format_panel = PropertyPanel(probe.format, "Format", expand=True)
if probe.metadata:
format_panel.add_section(
PropertyPanel(probe.metadata, "Metadata", expand=True))
stream_group = RenderGroup()
for i, stream in enumerate(probe.streams, 1):
stream_group.renderables.append(
PropertyPanel(stream, f"Stream {i}", expand=True))
print(Columns([format_panel, stream_group]))
def create_info_table(self, live_infos):
dct = {0: 0, 1: 100, 2: 50, 4: 10}
dct2 = {0: 0, 1: 100, 2: 50, 3: 30}
infos = sorted([
self.generate_info(rid, live_infos[key])
for key, rid in zip(live_infos.keys(), range(len(live_infos)))
],
key=lambda i: dct[i.live_status] * 100 + 100 * dct2[
i.record_status] - i.row_id + i.queue_status,
reverse=True)
table1 = Table("行号",
"房间ID",
"主播",
"直播标题",
"直播状态",
"录制状态",
"开播时间",
"录制时长",
"队列情况",
"完成时间",
title="%s" %
datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
box=box.SIMPLE)
for info in infos:
table1.add_row(str(info.row_id), info.room_id_map, info.anchor_map,
info.title_map, info.live_status_map,
info.record_status_map, info.start_time_map,
info.record_time, info.queue_status_map,
info.finish_time_map)
table2 = Table("CPU", "Memory", "NetSent", "NetRecv", box=box.SIMPLE)
time_now = datetime.datetime.now()
now_recv = psutil.net_io_counters().bytes_recv
now_sent = psutil.net_io_counters().bytes_sent
table2.add_row(
str(psutil.cpu_percent(None)) + '%' + ' %.2fGHz' %
(psutil.cpu_freq().current / 1000.0),
str(psutil.virtual_memory().percent) + '%' + ' %s/%s' %
(bytes2human(psutil.virtual_memory().used),
bytes2human(psutil.virtual_memory().total)),
bytes2human((now_sent - self.last_net_sent) /
(time_now - self.last_time).total_seconds()) + '/s',
bytes2human((now_recv - self.last_net_recv) /
(time_now - self.last_time).total_seconds()) + '/s')
self.last_time = time_now
self.last_net_sent = now_sent
self.last_net_recv = now_recv
return RenderGroup(table1, table2)
def __init__(
self,
data: Optional[Dict[str, Any]] = None,
title: Optional[str] = None,
title_align: AlignValues = "center",
expand: bool = False,
) -> None:
self.table = PropertyTable(data)
self.group = RenderGroup(self.table)
super().__init__(self.group,
title=title,
title_align=title_align,
expand=expand)
def render_pr(pr):
labels = ", ".join([label.name for label in pr.get_labels()])
body = Markdown(pr.body)
pr_panel = Panel(
RenderGroup(
Panel(f"Title: {pr.title}"),
Panel(f"Labels: {labels}"),
Panel(body, title="Body"),
),
title=f"PR #{pr.number}",
)
console.print(pr_panel)
def createInfoTable(self, liveInfos):
infos = sorted([
self.generateInfo(rid, liveInfos[key])
for key, rid in zip(liveInfos.keys(), range(len(liveInfos)))
],
key=lambda i: i.state * 10 - i.rowID,
reverse=True)
table1 = Table("行号",
"房间ID",
"主播",
"分区",
"直播标题",
"直播状态",
"开播时间",
"录制时间",
"转码用时",
"上传用时",
"当前状态",
title="%s" %
datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
box=box.SIMPLE)
for info in infos:
table1.add_row(str(info.rowID), info.roomID,
info.uname, info.areaName, info.title,
str(info.liveStatus), info.liveStartTimeMap,
info.recordTimeMap, info.decodeTimeMap,
info.uploadTimeMap, info.stateMap)
table2 = Table("CPU", "Memory", "NetSent", "NetRecv", box=box.SIMPLE)
time_now = datetime.datetime.now()
now_recv = psutil.net_io_counters().bytes_recv
now_sent = psutil.net_io_counters().bytes_sent
table2.add_row(
str(psutil.cpu_percent(None)) + '%',
str(psutil.virtual_memory().percent) + '%' + ' %s/%s' %
(bytes2human(psutil.virtual_memory().used),
bytes2human(psutil.virtual_memory().total)),
bytes2human((now_sent - self.last_net_sent) /
(time_now - self.last_time).total_seconds()) + '/s',
bytes2human((now_recv - self.last_net_recv) /
(time_now - self.last_time).total_seconds()) + '/s')
self.last_time = time_now
self.last_net_sent = now_sent
self.last_net_recv = now_recv
return RenderGroup(table1, table2)
def timing_stats_expected_panel(expected_table=timing_stats_expected_table):
return Panel(
RenderGroup(
Padding(
"Median: [b]4000.00[/b]ms"
" [muted]|[/muted] "
"99th Percentile: [b]5000.00[/b]ms",
pad=(0, 0, 1, 0),
),
expected_table,
),
title="[b white]3 Slowest Tests[/b white]",
style="none",
border_style="rule.line",
)
def get_detail_renderable(self, item_id):
# ┌────────────────────────────────────────────────────────────────────────────┐
# │ GET ITEM │
# └────────────────────────────────────────────────────────────────────────────┘
# Get item by ID
item = self.get(id=int(item_id))
# Define panel kwargs
panel_kwargs = {"title_align": "right"}
# Get display detail by
display_detail_by = self.display_detail_by
# Initialize columns
columns = []
# Iterate over rows in display detail by
for row in display_detail_by:
# Initialize columns
cols = []
# Iterate over columns in row
for field, display in row.items():
# Get value
value = getattr(item, field, "N/A")
# Stringify value
value = str(value)
# Add Panel to columns
cols.append(Panel(value, title=display, **panel_kwargs))
# Append row of columns
columns.append(Columns(cols, expand=True))
# Create renderable
renderable = RenderGroup(*columns)
# Pad renderable
renderable = Padding(renderable, (1, 1))
# Return renderable
return renderable
def print_grade_table(self):
table = self.generate_assignment_table()
p_table = self.generate_overall_grade_table()
console.print(
Panel(
RenderGroup(
Columns(
(table, ),
align="center",
expand=True,
), Columns(
(p_table, ),
align="center",
expand=True,
)),
title=f"[white bold]{self.title}",
))
async def run(self):
"""Create and refresh the dashboard every n seconds"""
while not self.tasks_running():
await trio.sleep(0.5)
with Live(transient=True, refresh_per_second=1
) as live, self.create_progress_bar() as progress:
task = progress.add_task("resolving")
while self.tasks_running():
table = await self.generate_tasks_table()
pbar = self.generate_progress(progress, task)
statistics = self.generate_statistics()
panel_group = RenderGroup(
Panel(table, title="Tasks"), Panel(pbar, title="Progress"),
Panel(statistics, title="Query statistics"))
live.update(panel_group)
await trio.sleep(1)
def get_pretty_failure_for_equals(self, err: TestFailure) -> RenderableType:
diff_msg = Text.assemble(
("LHS ", "pass.textonly"),
("vs ", "default"),
("RHS ", "fail.textonly"),
("shown below", "default"),
)
diff = Diff(
err.lhs,
err.rhs,
width=self.terminal_size.width - 24,
show_symbols=self.show_diff_symbols,
)
return RenderGroup(
Padding(diff_msg, pad=(0, 0, 1, 2)),
Padding(diff, pad=(0, 0, 1, 4)),
)
def __rich_console__(self, c: Console, co: ConsoleOptions) -> RenderResult:
def sort_key(r: TestResult) -> float:
assert r.test.timer, "test must've been run already"
return r.test.timer.duration
test_results = sorted(self.all_tests_in_session, key=sort_key, reverse=True)
grid = Table.grid(padding=(0, 2, 0, 0))
grid.add_column(justify="right") # Time taken
grid.add_column() # Test ID
grid.add_column() # Test description
for result in test_results[: self.num_tests_to_show]:
assert result.test.timer, "test must've been run already"
time_taken_secs = result.test.timer.duration
time_taken_millis = time_taken_secs * 1000
test_id = format_test_id(result)
description = result.test.description
grid.add_row(
f"[b]{time_taken_millis:.0f}[/b]ms",
Text(test_id, style="muted"),
description,
)
num_slowest_displayed = min(
len(self.all_tests_in_session), self.num_tests_to_show
)
panel = Panel(
RenderGroup(
Padding(
f"Median: [b]{self._median_secs * 1000:.2f}[/b]ms"
f" [muted]|[/muted] "
f"99th Percentile: [b]{self._percentile99_secs * 1000:.2f}[/b]ms",
pad=(0, 0, 1, 0),
),
grid,
),
title=f"[b white]{num_slowest_displayed} Slowest Tests[/b white]",
style="none",
border_style="rule.line",
)
yield panel
def update(self, current_model=None):
"""
Make a new table, and return it
along with text to display under the table.
Args:
current_model (sklearn.estinator, optional): Estimator. Defaults to None.
Returns:
console.RenderGroup: Rendergroup to print to terminal.
"""
if current_model is None:
return Text("Training ...", justify="center")
table = self.make_performance_table()
last_ = Text("*** = Best Model ", style="bold green", justify="right") \
if current_model == list(self.trainer.grid.keys())[-1] \
else Text("Training ...", justify="center")
return RenderGroup( table, last_ )
def _render_job_attributes(data):
style = "[bold #31DDCF]"
tags = get_tags_str(data["tags"])
name = data["observable_name"] if data["observable_name"] else data["file_name"]
clsfn = (
data["observable_classification"]
if data["observable_classification"]
else data["file_mimetype"]
)
status: str = get_status_text(data["status"], as_text=False)
r = RenderGroup(
f"{style}Job ID:[/] {str(data['id'])}",
f"{style}User:[/] {data['source']}",
f"{style}MD5:[/] {data['md5']}",
f"{style}Name:[/] {name}",
f"{style}Classification:[/] {clsfn}",
f"{style}Tags:[/] {tags}",
f"{style}Status:[/] {status}",
)
return Panel(r, title="Job attributes")
def make_sponsor_message() -> Panel:
"""Some example content."""
sponsor_message = Table.grid(padding=1)
sponsor_message.add_column(style="green", justify="right")
sponsor_message.add_column(no_wrap=True)
sponsor_message.add_row(
"Sponsor me",
"[u blue link=https://github.com/sponsors/willmcgugan]https://github.com/sponsors/willmcgugan",
)
sponsor_message.add_row(
"Buy me a :coffee:",
"[u blue link=https://ko-fi.com/willmcgugan]https://ko-fi.com/willmcgugan",
)
sponsor_message.add_row(
"Twitter",
"[u blue link=https://twitter.com/willmcgugan]https://twitter.com/willmcgugan",
)
sponsor_message.add_row(
"Blog", "[u blue link=https://www.willmcgugan.com]https://www.willmcgugan.com"
)
intro_message = Text.from_markup(
"""Consider supporting my work via Github Sponsors (ask your company / organization), or buy me a coffee to say thanks. - Will McGugan"""
)
message = Table.grid(padding=1)
message.add_column()
message.add_column(no_wrap=True)
message.add_row(intro_message, sponsor_message)
message_panel = Panel(
Align.center(
RenderGroup(intro_message, "\n", Align.center(sponsor_message)),
vertical="middle",
),
box=box.ROUNDED,
padding=(1, 2),
title="[b red]Thanks for trying out Rich!",
border_style="bright_blue",
)
return message_panel
def make_memory_panel(debugger) -> Panel:
addr = 0
mem_bytes = debugger.executor.vm_context.memory_read_bytes(0, 16 * 8)
byte = ''.join(['%02X' % b for b in mem_bytes])
res = hexdump(byte, start=int(addr), to_list=True)
mem_table = Table.grid(padding=0)
for i in res:
mem_table.add_row(i)
memory_panel = Panel(
Align.center(
RenderGroup('', "\n", Align.center(mem_table)),
vertical="top",
),
box=box.ROUNDED,
padding=(0, 1),
title="[b red]Memory",
border_style="bright_blue",
)
return memory_panel
def make_message():
message = Table.grid(padding=1)
message.add_column(style="green", justify="right")
message.add_column(no_wrap=True)
intro_message = Text.from_markup("""Thanks for trying out!""")
message.add_row("Check the Repository on GitHub",
("[u blue link=https://github.com/samborba/rich-terminal]"
"https://github.com/samborba/rich-terminal"))
message_panel = Panel(
Align.center(
RenderGroup(intro_message, "\n", Align.center(message)),
vertical="middle",
),
box=box.ROUNDED,
title="[b white]RICH TERMINAL",
border_style="bright_blue",
)
return message_panel
async def plugin_command(ctx):
all = []
doc = self.get_plugin_doc(name)
doc.extract_metadata("examples")
desc_string = f"## Package type: **{name}**\n"
if doc.get_short_help(default=None):
desc_string += doc.get_short_help() + "\n\n"
desc_string += f"\n## Arguments\n\nThis is the list of arguments that can be used to describe a package of the *{name}* type:\n"
desc = Markdown(
desc_string,
style=bring_style,
code_theme=bring_code_theme,
justify="left",
)
all.append(desc)
plugin = self.get_plugin(name)
args = plugin.get_args()
record_arg = self._arg_hive.create_record_arg(childs=args)
arg_table = to_rich_table(record_arg)
all.append(arg_table)
desc_string = await create_pkg_type_markdown_string(
bring=self.bring, plugin_doc=doc)
desc = Markdown(
desc_string,
style=bring_style,
code_theme=bring_code_theme,
justify="left",
)
all.append(desc)
group = RenderGroup(*all)
console.print(Panel(Panel(group, box=box.SIMPLE)))
def messages(cli_args):
r = requests.get(
"https://passio3.com/www/goServices.php?getAlertMessages=1&json=%7B%22systemSelected0%22%3A%2276%22%2C%22amount%22%3A1%2C%22routesAmount%22%3A0%7D"
)
messages_data = r.json()
messages_data = messages_data["msgs"]
messages_data_new = [{
"title": m["name"],
"html": m["html"],
"date_from": m["from"],
"date_to": m["to"]
} for m in messages_data]
console = Console()
console.print(Panel(Text("Messages", justify="center", style="bold")))
for m in messages_data_new:
group = RenderGroup(
Text(m["title"], justify="center", style="bold"),
Text(m["date_from"] + " to " + m["date_to"], justify="center"),
Padding(Text(m["html"]), (1, 0, 0, 0)))
console.print(Panel(group, expand=True))
def generate_panel(notes, note_choice, note_played, color, score):
if note_choice not in notes:
# it means note_choice is 'Good job!' when the player hits the note
play_note_row = note_choice
else:
play_note_row = f'Play this note: [blue bold]{note_choice}[/]'
note_played_row = f'You played: [{color} bold]{note_played}[/]'
all_notes_row = Text.assemble(('\nAll available notes: ', 'grey53 bold'),
((', ').join(notes), 'grey53'))
current_score_text = Text(f'\nCurrent score: {score}\n')
current_score_text.stylize('yellow bold', 16)
quit_text = Text('\n\n(press ctrl+C to quit at any time)')
quit_text.stylize('grey37')
panel_group = RenderGroup(current_score_text, Panel(play_note_row),
Panel(note_played_row), all_notes_row, quit_text)
return Panel(panel_group, title='FRETBOARD LEARNER', box=box.ASCII)
