def format_markdown(self, index, cell, config):
"""Format the markdown cell content. Render only input and leave out output."""
panels = []
panels.append(self.format_index(index, source_type="input"))
source = self.get_source_text(cell)
if config.no_cell_border:
panels.append("\n")
panels.append(Markdown(source))
panels.append("\n")
else:
panels.append(Panel(Markdown(source)))
return panels
def format_raw(self, index, cell, config):
"""Format raw code block. Render only input source."""
panels = []
panels.append(self.format_index(index))
text = self.get_source_text(cell)
if config.no_cell_border:
panels.append("\n")
panels.append(text)
panels.append("\n")
else:
panels.append(Panel(text))
return panels
def make_logo():
"""Make logo component."""
logo = Panel("\t \n \t :honeybee: RICH TERMINAL \n \t A proof of concept",
width=42,
height=6,
style=Style(
color='yellow',
bgcolor='black',
),
border_style='white')
return logo
def render_video(self, video: Video):
formatted = video.get_formatted()
title = formatted['title']
title.stylize('bold')
stats = formatted['stats']
stats.stylize('blue')
up = formatted['up']
up.stylize('magenta')
desc = formatted['desc']
desc.truncate(90, overflow='ellipsis')
summary = Text.assemble(title, '\n', stats, '\n', up, '\n', desc)
self.panels.append(Panel(summary, expand=True))
def get_vms():
vcenter_id = config['vcenter']['id']
limit = config['api']['limit']
base_url = config['api']['base_url']
get_vm_api_path = '/datasources/vmware/vcenters/' + vcenter_id + '/vms'
# params = {'limit': '<limit>', 'start': '<start>', 'filter': '<filter>'}
params = {'limit': limit}
headers = headers_func()
data = my_request(base_url, get_vm_api_path, headers, params)
pages = get_pages(data)
alldf = pd.DataFrame([])
vm_table(data)
rprint(
Panel('[cyan]START: Fething and Building VM List via Clumio API',
title="EXECUTION STATUS"))
i = 1
for i in track(range(1, int(pages))):
print(Fore.CYAN + Style.BRIGHT + '...Fetching page ' + str(i) +
' from Clumio API...' + Style.RESET_ALL)
get_vm_api_path = ('/datasources/vmware/vcenters/' + vcenter_id +
'/vms?limit=' + limit + '&start=' + str(i))
log(get_vm_api_path)
data = my_request(base_url, get_vm_api_path, headers, params)
table = vm_table(data)
alldf = my_df(alldf, table, i)
rprint(
Panel('[green]DONE: Fething VM List via Clumio API',
title="EXECUTION STATUS"))
rprint(Panel('[cyan]START: Create DataFrame', title="EXECUTION STATUS"))
print(alldf)
rprint(
Panel('[cyan]START: Writing DataFrame to vms.csv for future use',
title="EXECUTION STATUS"))
alldf.to_csv('vms.csv', index=False)
rprint(
Panel('[green]DONE: Writing DataFrame to vms.csv',
title="EXECUTION STATUS"))
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 print(self):
console = Console()
df = self.df
# print file info
console.print(Panel(self.filename, style="green bold"),
justify="center")
console.print()
console.print('FILE INFO', style="green bold")
console.print(f' File size: {sizeof_fmt(self.bite_size)}',
style="green")
console.print(f' Rows: {self.nrows}, Columns: {self.ncolumns}',
style="green")
# print columns info
console.print()
console.print('COLUMN INFO', style="green bold")
if df is not None:
table = Table()
table.add_column("Name", style="cyan", no_wrap=True)
table.add_column("Data Type", style="magenta")
table.add_column("Is Unique", justify="center", style="green")
table.add_column("Empty Cell Count", style="green")
for col, dtype in df.dtypes.iteritems():
empty_count = df[col].isnull().sum()
table.add_row(
col, # column name
clean_dtypes(
dtype), # data type, turned into human-readable format
ok('✔') if df[col].is_unique else error('✗'),
ok(empty_count)
if empty_count == 0 else warning(empty_count))
console.print(table)
else:
console.print(" Couldn't be parsed by pandas.", style='red')
# go through validation tests
console.print()
console.print('VALIDATION TESTS', style="green bold")
console.print(self.parsable_by_pandas)
console.print(self.column_names_unique)
console.print(self.rows_unique)
console.print(self.column_names_not_null)
console.print(self.rows_have_equal_number_of_columns)
console.print(self.has_utf8_encoding)
# console.print(self.quotes_are_escaped)
# console.print(self.line_endings_are_CRLF)
console.print()
def style(self):
title = 'HELP MESSAGE'
def terminal_width(width: int) -> int:
'''controle the ruler width
max width = 1
minmim width = 0
'''
square_text = 6
terminal_width = terminal().size['width'] - square_text
return int(terminal_width * float(width) / float(1))
# RULER = lambda: '[white]' + '─' * (terminal_width(1))
RULER = lambda: f'[bold][white]{"─" * terminal_width(1)}[/bold][/white]'
if self.title:
title = f"[bold][green]{self.title.upper()}[/green]"
sections = []
temp = 0
for section_title, commands in self.sections.items():
sections.append('')
sections[temp] += f'[white][bold] {section_title.lower()}: [/bold]\n' + RULER() + '\n'
# commands
tempFixwidth = [key[0] for key in commands]
tempFixwidth = Text.full(tempFixwidth)
tempCommands = [key[0] for key in commands]
for command, helpMsg in commands:
command = tempFixwidth[tempCommands.index(command)]
if Config.get('settings', 'ARABIC_RESHAPER'):
helpMsg = Text.arabic(helpMsg)
sections[temp] += f' [yellow]{command}[/yellow] [white]{helpMsg}\n'
# sections[temp] += RULER() + '\n\n'
sections[temp] += '\n\n'
temp += 1
style = ''
for section in sections:
style += section
print(
Panel(
style[:-3],
box=box.ROUNDED,
padding=(1, 2),
title=title,
border_style='bold green',
)
)
def __rich_console__(self, *args):
"""
Yields the panel elements for printing in rich console
"""
yield Panel.fit(
self.tb,
width=self.width,
border_style=self.dim,
padding=(0, 2, 1, 2),
)
if self.show_info:
yield f"[dim {self.color}]{self._info()}"
def generate_log_table(data):
new_data = "\n".join(data)
data = new_data.split("\n")
c = Console()
last_n = c.size.height - 10
log_table = Table(expand=True,
show_header=False,
show_footer=False,
box=box.SIMPLE)
log_table.add_column("Script execution log")
for row in data[-last_n:]:
log_table.add_row(row)
return Panel(log_table, title="Execution log")
async def on_ready():
console.print(
Panel('[bold green]Connected to Discord API ✓\nLoading Complete ✓'),
justify='center')
console.print(Markdown('# Logging Commands:'))
embed = Embed(title="Good Morning",
description="It's a beautiful day for pie",
color=0x00ff00)
embed.set_image(
url=
"https://media1.tenor.com/images/4443069022c0e23622626a46909162ec/tenor.gif?itemid=10618052"
)
await bot.get_channel(830932320771899432).send(embed=embed)
def _generate_power_panel(self) -> Panel:
"""
Generate Power readout
:return: Power readout
"""
text = Text(f"\n{round(self.piloton.bike.power)}\n", justify="center")
text.stylize("bold white")
panel = Panel(text,
title="Power (W)",
box=box.HEAVY,
border_style="#E89005")
return panel
def _generate_resistance_panel(self) -> Panel:
"""
Generate resistance readout
:return: Resistance readout
"""
text = Text(f"\n{self.piloton.bike.resistance}\n", justify="center")
text.stylize("bold white")
panel = Panel(text,
title="Resistance",
box=box.HEAVY,
border_style="#E9CE2C")
return panel
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 _drawComponents(self, aPkgs):
if not aPkgs:
return ''
lString = ''
for pkg in sorted(aPkgs):
lString += '+ %s (%d)\n' % (pkg, len(aPkgs[pkg]))
lSortCmps = sorted(aPkgs[pkg])
for cmp in lSortCmps[:-1]:
lString += u' ├──' + str(cmp) + '\n'
lString += u' └──' + str(lSortCmps[-1]) + '\n'
return Panel.fit(lString[:-1])
def main():
p = 0.125
dim = 5
bfs = np.random.randint(0, 2, dim)
bflpn = HBOracle(bfs, p)
print(Panel(f"[yellow2]Brute Force on HB Protocol\n[cyan3]Error Rate = {p}\nKey Length = {dim}\nSecret Key = {bfs}",
title="[yellow]HB Protocol", expand=False))
print(f"[light_steel_blue]Found key: {BruteForceHB(bflpn)}")
print(f"[light_steel_blue]Actual secret: {bflpn.secret}")
def render_numbers(numbers, name):
grid = Table.grid(padding=1)
for row in range(16):
row = [
Text(
str(numbers[row * 16 + col]),
style=styles[numbers[row * 16 + col] % 16],
)
for col in range(16)
]
grid.add_row(*row)
columns.add_renderable(Panel.fit(grid, title=name))
def test_justify_renderable_right():
console = Console(
file=io.StringIO(),
force_terminal=True,
width=20,
legacy_windows=False,
_environ={},
)
console.print(Panel("FOO", expand=False, padding=0), justify="right")
assert (
console.file.getvalue()
== " ╭───╮\n │FOO│\n ╰───╯\n"
)
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)
def generate_display(display: str) -> Panel:
"""Generate a panel to display using the rich library.
Args:
display (str): The visualized values to display.
Returns:
rich.Panel: The generated panel.
"""
table = Panel(display,
expand=False,
title="[bold blue]Devilizer[/bold blue]")
return Align(table, align="center")
def nowplayingupdate(title: dict):
"""
updates the now playing text
"""
nowplayingstring = updatercore("nowplaying", title)
obsinstance.call(
requests.SetTextGDIPlusProperties("nowplaying", text=nowplayingstring))
return console.log(Panel.fit(nowplayingstring, title="Now Playing"))
pass
def update_audio_idx(brick):
panel = Table.grid()
panel.add_column(ratio=2)
for _ in range(brick.config.settings.notchCount):
panel.add_column(ratio=1)
notches = ["0x%02X " % x for x in brick.config.settings.notchBounds]
n = brick.state.audio_notch
if n < len(brick.config.settings.notchBounds):
notches[n] = "[black on white]0x%02X " % (
brick.config.settings.notchBounds[n])
panel.add_row("Curr Notch ", "%d" % (brick.state.audio_notch + 1))
panel.add_row("Notch", *notches)
return Panel(panel)
def add_failure(self, task, fail_info):
console = Console()
if isinstance(fail_info, TaskError):
console.print(f'[red]Task Error - {task.name}'
f' => {fail_info.message}')
if fail_info.traceback:
console.print(
Panel(
"".join(fail_info.traceback),
title=f"{task.name}",
subtitle=fail_info.message,
border_style="red",
))
def __init__(self, title="Monitor", log=False) -> None:
"""Monitor allows you to monitor the progress of what is happenening inside your application
Args:
title (str, optional): The Title of this Monitor (Is the Panels Title). Defaults to "Monitor".
progress (bool, optional): Do you want to monitor the progress of assignments and reservations? Defaults to False.
"""
self.columns = Table.grid(expand=True)
self.columns.add_column()
self.log = log
self.panel = Panel(self.columns, title=title)
self.live = Live(self.panel, refresh_per_second=4, console=console)
def __rich_console__(self, console: Console,
options: ConsoleOptions) -> RenderResult:
width = options.max_width
height = options.height or options.size.height
layout = self.layout
title = (f"{layout.name!r} ({width} x {height})"
if layout.name else f"({width} x {height})")
yield Panel(
Align.center(Pretty(layout), vertical="middle"),
style=self.style,
title=self.highlighter(title),
border_style="blue",
)
def reset():
"""
Reset the configuration to default.
"""
if Confirm.ask("\n:bomb: Are you sure you want to reset the config file?"):
reset_config()
console.print(
Panel.fit(
f":thumbs_up_dark_skin_tone: Successfully reset the config file: {config_path} :thumbs_up_dark_skin_tone:"
),
style="bold green",
)
def render(self, displays, bootstrap=True):
b = self.board
# Recover state
for display in displays:
self.round += 1
self.count = [display['blackCount'], display['whiteCount']]
if 'x0' not in display: continue
x0 = display['x0']
if x0 == -1: continue
y0 = display['y0']
x1 = display['x1']
y1 = display['y1']
x2 = display['x2']
y2 = display['y2']
color = 2 - self.round % 2
b[x1][y1] = b[x0][y0]
b[x0][y0] = 0
b[x2][y2] = -1
message = 'Round: %d\n%s: %d\n%s: %d\nNext: %s' % (
self.round, self.stones[1], self.count[0], self.stones[2],
self.count[1], self.stones[1 + self.round % 2])
styles = [[
self.stones[b[i][j]]
if b[i][j] >= 0 else Text(self.stones[b[i][j]], style='blue')
for j in range(self.size)
] for i in range(self.size)]
if displays:
d = displays[-1]
if not d: d = {}
x0 = d.get('x0', -1)
y0 = d.get('y0', -1)
if x0 != -1 and isinstance(styles[x0][y0], str):
styles[x0][y0] = Text(styles[x0][y0], 'on red')
x1 = d.get('x1', -1)
y1 = d.get('y1', -1)
if x1 != -1:
styles[x1][y1] = Text(styles[x1][y1], 'on green')
x2 = d.get('x2', -1)
y2 = d.get('y2', -1)
if x2 != -1:
styles[x2][y2].style = 'blue on yellow'
if 'winner' in d:
message += '\n%s wins!' % self.stones[d['winner'] + 1]
t = Table.grid(padding=(0, 1))
t.add_row('', *map(chr, range(65, 65 + self.size)))
for j in range(self.size):
t.add_row(str(1 + j), *[styles[i][j] for i in range(self.size)])
tt = Table.grid(padding=(0, 4))
tt.add_row(t, message)
print(Panel.fit(tt, box=box.SQUARE))
def main(hydra_cfg: DictConfig):
print_title()
logger.setLevel(hydra_cfg.log_level)
if hydra_cfg.log_level.upper() == "DEBUG":
verbose = True
else:
verbose = False
# really unclear why hydra has so many unclear validation issues with structure configs using ConfigStore
# this correctly assigns the correct structured config
# and updates from the passed hydra config
# annoying... but this resolves all these issues
cfg = OmegaConf.structured(Config())
cfg.update(hydra_cfg)
# debug
if verbose:
print_yaml(cfg)
from pytorch_lightning.loggers import WandbLogger
# explicitly convert the DictConfig back to Config object
# has the added benefit of performing validation upfront
# before any expensive training or logging initiates
config = Config.from_dict_config(cfg)
wandb_logger = WandbLogger(project="pytorchlightning", offline=config.offline)
# initialize the training module
training_module = TrainingModule(config)
logger.info("Priming the model with data")
prime_the_model(training_module, config)
logger.debug(Panel("Model", expand=False))
if verbose:
print_model(training_module)
logger.info("Generating data...")
data = DataGenerator(config.data)
data.init()
logger.info("Beginning training...")
trainer = Trainer(gpus=config.gpus, logger=wandb_logger, check_val_every_n_epoch=5)
trainer.fit(
training_module,
train_dataloader=data.train_loader(),
val_dataloaders=data.eval_loader(),
)
def output_test_result_summary(
self, test_results: List[TestResult], time_taken: float, show_slowest: int
):
if show_slowest:
self.console.print(TestTimingStatsPanel(test_results, show_slowest))
result_table = Table.grid()
result_table.add_column(justify="right")
result_table.add_column()
result_table.add_column()
outcome_counts = self._get_outcome_counts(test_results)
test_count = sum(outcome_counts.values())
result_table.add_row(
Padding(str(test_count), pad=HORIZONTAL_PAD, style="bold"),
Padding(
f"{'Test' if test_count==1 else 'Tests' } Encountered",
pad=HORIZONTAL_PAD,
),
style="default",
)
for outcome, count in outcome_counts.items():
if count > 0:
result_table.add_row(
Padding(str(count), pad=HORIZONTAL_PAD, style="bold"),
Padding(outcome.display_name, pad=HORIZONTAL_PAD),
Padding(f"({100 * count / test_count:.1f}%)", pad=HORIZONTAL_PAD),
style=outcome_to_style(outcome),
)
exit_code = get_exit_code(test_results)
if exit_code == ExitCode.SUCCESS:
result_style = "pass.textonly"
else:
result_style = "fail.textonly"
result_summary_panel = Panel(
result_table,
title="[b default]Results[/b default]",
style="none",
expand=False,
border_style=result_style,
)
self.console.print(result_summary_panel)
self.console.print(
Rule(
f"[b]{exit_code.clean_name}[/b] in [b]{time_taken:.2f}[/b] seconds",
style=result_style,
)
)
def cli(info_jsons):
info_re = re.compile('^info_.*\.json$')
if not info_jsons:
info_jsons = tuple(f for f in os.listdir() if info_re.match(f))
info_threads = {j: InfoThread(j, 1) for j in info_jsons}
for a, t in info_threads.items():
t.start()
layout = make_layout()
layout["header"].update(Panel(Text("nano Opmon", justify="center")))
layout["footer"].update(
Panel(Text("extra infos will go here", justify="center")))
layout["side"].update(
Panel(Text("app status will go here", justify="center")))
tables = {}
try:
with Live(layout, refresh_per_second=2, screen=True):
while True:
for app, trd in info_threads.items():
j = None
try:
j = trd.queue.get(block=False)
except:
pass
if j is not None:
t = info_to_table(j, app)
tables[app] = Panel(t, expand=True)
layout["body"].update(Columns(tables.values()))
time.sleep(1)
except KeyboardInterrupt:
for a, t in info_threads.items():
t.running = False
for a, t in info_threads.items():
t.join()
