def create_ui(timestamp: datetime):
""" Create our user interface within the console. Returns the rich Layout."""
# https://rich.readthedocs.io/en/latest/index.html
ui = Layout()
ui.split_row(
Layout(name='left'),
Layout(name='right'),)
panel_now = weather_now.create_weather_panel()
panel_3h = weather_03h.create_weather_panel()
panel_6h = weather_06h.create_weather_panel()
panel_9h = weather_09h.create_weather_panel()
panel_info = Panel(f"[i]{get_next_update_time(timestamp, api_delay_in_sec)}[/]")
panel_info.box = box.ASCII
panel_info.renderable += f"\n[i]Press [red]CTRL-C[/red] for different location at any time.[/]"
# Future forecast panels.
ui['right'].split_column(
Layout(panel_3h, name='3h'),
Layout(panel_6h, name='6h'),
Layout(panel_9h, name='9h'),
)
# "now" and "info" panels.
ui['left'].split_column(
Layout(panel_now, name='now', ratio=3),
Layout(panel_info, name='info'),
)
return ui
def get_renderable(self):
tasks_panel_rendered = self.tasks_panel.get_renderable()
metrics_panel_rendered = self.metrics_panel.get_renderable()
if tasks_panel_rendered is None and metrics_panel_rendered is None:
return Align(
Text(f"Waiting for test to start... ({self.test_name})"),
align="center")
layout = Layout()
layout.split_row(
Layout(name="running", visible=False),
Layout(name="metrics", ratio=2, visible=False),
)
if metrics_panel_rendered is not None:
layout["metrics"].visible = True
layout["metrics"].update(metrics_panel_rendered)
if tasks_panel_rendered is not None:
layout["running"].visible = True
layout["running"].update(tasks_panel_rendered)
return Panel(layout, title=self.test_name)
def make_info_panel(debugger) -> Layout:
info_layout = Layout(name='Info')
info_layout.split_row(Layout(name='runtime_state'),
Layout(name='world_state'))
pc = debugger.executor.vm_context.code.pc + 1
insn = debugger.executor.disasm_dict[pc]
opcode = insn.byte
mnemonic = insn.mnemonic
msg = debugger.executor.vm_context.msg
info_table = Table(box=box.SIMPLE)
info_table.grid(padding=1)
info_table.add_column('Key', justify="middle", style="cyan", no_wrap=True)
info_table.add_column("Value", justify="middle", style="magenta")
info_table.add_row('PC', f'{str(pc)} ({hex(pc)})')
info_table.add_row('Opcode', f'{int(opcode[2:], 16)} ({opcode})')
info_table.add_row('Mnemonic', f'{mnemonic}')
info_table.add_row('', '')
info_table.add_row('Sender', f'0x{msg.sender.hex()}')
if msg.to:
info_table.add_row('To', f'0x{msg.to.hex()}')
elif msg.storage_address:
info_table.add_row('To', f'0x{msg.storage_address.hex()}')
elif msg.code_address:
info_table.add_row('To', f'0x{msg.code_address.hex()}')
info_table.add_row('Gas Price', str(msg.gas_price))
info_table.add_row('Nonce', str(debugger.executor.vm_context.msg.depth))
info_panel = Panel(
info_table,
box=box.ROUNDED,
title="[b red]Runtime State",
border_style="bright_blue",
)
state = debugger.executor.vm_context.state
world_state_table = Table(box=box.SIMPLE)
world_state_table.grid(padding=1)
world_state_table.add_column('Key',
justify="middle",
style="cyan",
no_wrap=True)
world_state_table.add_column("Value", justify="middle", style="magenta")
world_state_table.add_row('coinbase', f'{state.coinbase.hex()}')
world_state_table.add_row('timestamp', f'{state.timestamp}')
world_state_table.add_row('block_number', f'{state.block_number}')
world_state_table.add_row('difficulty', f'{state.difficulty}')
world_state_table.add_row('gas_limit', f'{state.gas_limit}')
world_state_panel = Panel(
world_state_table,
box=box.ROUNDED,
title="[b red]World State",
border_style="bright_blue",
)
info_layout["runtime_state"].update(info_panel)
info_layout["world_state"].update(world_state_panel)
return info_layout
def main() -> None:
layout = Layout()
layout.split_row(
Layout(name="all"),
Layout(name="bats"),
Layout(name="run"),
Layout(name="def"),
Layout(name="pitch"),
)
layout["all"].update(Panel(
sort_players("hitting", "defense", "baserunning", "pitching"),
title="Overall",
))
layout["bats"].update(Panel(
sort_players("hitting"),
title="Batting",
))
layout["def"].update(Panel(
sort_players("defense"),
title="defense",
))
layout["run"].update(Panel(
sort_players("baserunning"),
title="Baserunning",
))
layout["pitch"].update(Panel(
sort_players("pitching"),
title="Pitching",
))
console.print(layout)
def _get_binance_layout(
bin_status: BinanceStatus,
profit_today: Dict[str, ExchangeRate],
profit_yesterday: Dict[str, ExchangeRate],
) -> Layout:
"""
Binance info Layout.
:param bin_status: current binance status.
:param profit_today: today's calculated profit.
:param profit_yesterday: yesterday's calcualted profit.
:return: binance renderable layout.
"""
layout = Layout(name="binance_status")
layout.split_row(
Layout(
_get_binance_status(
bin_status,
),
),
Layout(
_get_profit_table(bin_status, profit_today, profit_yesterday),
ratio=2,
),
)
return layout
def make_layout():
log_table = Table()
log_table.add_column("")
layout = Layout(name="root")
layout.split_row(
Layout(name="log", ratio=2),
Layout(name="tree"),
)
layout["tree"].update(generate_tree_from_schema({}))
layout["log"].update(generate_log_table([]))
return layout
def test_refresh_screen():
layout = Layout()
layout.split_row(Layout(name="foo"), Layout(name="bar"))
console = Console(force_terminal=True, width=20, height=5)
console.print(layout)
with console.screen():
with console.capture() as capture:
layout.refresh_screen(console, "foo")
result = capture.get()
print(repr(result))
expected = "\x1b[1;1H\x1b[34m╭─\x1b[0m\x1b[34m \x1b[0m\x1b[32m'foo'\x1b[0m\x1b[34m─╮\x1b[0m\x1b[2;1H\x1b[34m│\x1b[0m Layout \x1b[34m│\x1b[0m\x1b[3;1H\x1b[34m│\x1b[0m \x1b[1m(\x1b[0m \x1b[34m│\x1b[0m\x1b[4;1H\x1b[34m│\x1b[0m \x1b[33mna\x1b[0m \x1b[34m│\x1b[0m\x1b[5;1H\x1b[34m╰────────╯\x1b[0m"
assert result == expected
def _get_nb_layout(nb_status: NBMinerStatus) -> Layout:
"""
Get NBMiner layout.
:param nb_status: current NBMiner status.
:return: renderable layout.
"""
layout = Layout(name="miner_status", ratio=2)
layout.split_row(
Layout(_get_nb_stratum_table(nb_status)),
Layout(_get_nb_devices_table(nb_status.miner.devices), ratio=2),
)
return layout
def create_layout():
# determining the total number of rows
total_width = 0
row_layouts = []
row_layout = []
for sub_layout in sub_layouts:
if total_width + sub_layout.minimum_size >= console.size[0]:
row_layouts.append(row_layout)
row_layout = [sub_layout]
total_width = 0
else:
row_layout.append(sub_layout)
total_width += sub_layout.minimum_size
row_layouts.append(row_layout)
to_split_col = []
for row in row_layouts:
tmp_layout = Layout()
tmp_layout.split_row(*row)
to_split_col.append(tmp_layout)
layout.split_column(
*to_split_col
)
],
expand=True,
column_first=True,
),
title=name,
)
for name, y in mail.items()
],
column_first=True,
)
# Partition the screen into manageable chunks
layout = Layout()
layout.split_column(
Layout(Padding(""), name="padding", size=1),
Layout(Rule(platform.node()), name="title", size=1),
Layout(name="content"),
)
timed_layout = Layout()
timed_layout.split_row(
Layout(Panel(events, title="Calendar"), name="calendar"),
Layout(Panel(mails, title="Emails"), name="email"),
)
layout["content"].split_row(
Layout(Panel(fetch), name="fetch"),
Layout(Panel(timed_layout, title=str(datetime.date.today())), name="timed", ratio=4),
)
# Do it
console.print(layout)
class TUI:
def __init__(self, node_id, resources_by_endpoint) -> None:
self.node_id = node_id
self.resources_by_endpoint = resources_by_endpoint
self.start_time = datetime.datetime.now()
self.layout = Layout(name="root")
self.layout.split(
Layout(name="header", size=6),
Layout(name="gpu", size=15),
Layout(name="cpu", size=15),
Layout(name="endpoints", size=19),
Layout(name="console", ratio=1),
)
self.layout["header"].split_row(
Layout(name="logo", size=70),
Layout(name="info", ratio=1),
)
self.gpu_layout = Layout(name="gpu")
self.gpu_layout.split_row(
Layout(name="utilization", ratio=1),
Layout(name="memory", ratio=1),
)
self.cpu_layout = Layout(name="cpu")
self.cpu_layout.split_row(
Layout(name="utilization", ratio=1),
Layout(name="memory", ratio=1),
)
self.endpoints_layout = Layout(name="cpu")
self.endpoints_layout.split_row(
Layout(name="data", ratio=1),
Layout(name="graph", ratio=1),
)
py3nvml.nvmlInit()
self.gpu_mem_usage = [
collections.deque(maxlen=150),
collections.deque(maxlen=150),
]
self.gpu_usage = [
collections.deque(maxlen=150),
collections.deque(maxlen=150)
]
self.cpu_usage = [collections.deque(maxlen=150)]
self.ram_usage = [collections.deque(maxlen=150)]
self.layout["header"]["logo"].update(
Text(figlet_format("PurpleSmart", font="slant"), style="magenta"))
width, _ = shutil.get_terminal_size()
self.console = Console(
file=io.StringIO(),
force_terminal=True,
color_system="truecolor",
width=width - 4,
)
logging.basicConfig(
level="INFO",
format="%(message)s",
datefmt="[%X]",
handlers=[RichHandler(rich_tracebacks=True, console=self.console)],
)
self.tail = LogTail(self.console)
self.gpu_usage_graph = AsciiGraph(self.gpu_usage, 100)
max_mem = []
for i in range(py3nvml.nvmlDeviceGetCount()):
handle = py3nvml.nvmlDeviceGetHandleByIndex(i)
meminfo = py3nvml.nvmlDeviceGetMemoryInfo(handle)
max_mem.append(meminfo.total)
max_mem = int(round(max(max_mem) / 1024**2))
self.gpu_mem_usage_graph = AsciiGraph(self.gpu_mem_usage, max_mem)
self.cpu_usage_graph = AsciiGraph(self.cpu_usage, 100)
self.ram_usage_graph = AsciiGraph(
self.ram_usage,
int(round(psutil.virtual_memory().total / 1024**2)))
self.endpoints_past_values = {}
self.stop_flag = False
def live(self, callback):
try:
with Live(
self.layout,
refresh_per_second=2,
screen=False,
redirect_stderr=False,
redirect_stdout=False,
) as live:
while True:
if self.stop_flag:
break
if callback:
callback(self)
if not self.resources_by_endpoint:
self.layout["endpoints"].update(
Panel(
Align.center(
Text(
"Waiting for endpoints to come alive"),
vertical="middle",
)))
else:
self.endpoints_layout["data"].update(
EndpointMonitor(self.resources_by_endpoint))
self.endpoints_values = []
updated_keys = set()
max_value = 0
for (
endpoint_name,
endpoint_data,
) in self.resources_by_endpoint.items():
updated_keys.add(endpoint_name) # todo: finish
total_used = 0
total_max = 0
for entry in endpoint_data.values():
total_used += entry.used
total_max += entry.available
max_value = max(max_value, total_max)
# self.endpoints_values.append(data)
past_entries = self.endpoints_past_values.setdefault(
endpoint_name, [])
past_entries.append(total_used)
self.endpoints_values.append(past_entries)
self.endpoints_graph = AsciiGraph(
self.endpoints_values, max_value, BACKEND_COLORS)
self.endpoints_layout["graph"].update(
self.endpoints_graph)
self.layout["endpoints"].update(
Panel(self.endpoints_layout, title="Endpoints"))
uptime = datetime.datetime.now() - self.start_time
self.layout["header"]["info"].update(
Align.right(
Text(f"""Node ID: {self.node_id}
Uptime: {humanize.naturaldelta(uptime)}
https://discord.gg/94KqBcE"""),
vertical="middle",
))
titles = []
table = Table.grid()
table.add_column(style="green")
table.add_column(no_wrap=True)
self.cpu_usage[0].append(psutil.cpu_percent(interval=None))
self.ram_usage[0].append(
int(round(psutil.virtual_memory().used / 1024**2)))
total_gpus_actual = py3nvml.nvmlDeviceGetCount()
for i in range(total_gpus_actual):
handle = py3nvml.nvmlDeviceGetHandleByIndex(i)
meminfo = py3nvml.nvmlDeviceGetMemoryInfo(handle)
utilization_info = py3nvml.nvmlDeviceGetUtilizationRates(
handle)
table.add_row(
py3nvml.nvmlDeviceGetName(handle),
str(round(meminfo.used / 1024**2)),
)
self.gpu_mem_usage[i].append(
round(meminfo.used / 1024**2))
self.gpu_usage[i].append(utilization_info.gpu)
color = RICH_COLORS[i]
titles.append(
f"[{color}]" + py3nvml.nvmlDeviceGetName(handle) +
f" {utilization_info.gpu}%, {humanize.naturalsize(meminfo.used)}/{humanize.naturalsize(meminfo.total)}"
+ "[/]")
self.gpu_layout["utilization"].update(
self.gpu_usage_graph, )
self.gpu_layout["memory"].update(self.gpu_mem_usage_graph)
self.layout["gpu"].update(
Panel(self.gpu_layout, title=" ".join(titles)))
self.cpu_layout["utilization"].update(
Panel(self.cpu_usage_graph))
self.cpu_layout["memory"].update(
Panel(self.ram_usage_graph))
self.cpu_layout["utilization"].update(
self.cpu_usage_graph, )
self.cpu_layout["memory"].update(self.ram_usage_graph)
self.layout["cpu"].update(
Panel(self.cpu_layout, title=CPU_NAME))
self.layout["console"].update(self.tail)
sleep(1.0)
except KeyboardInterrupt as e:
py3nvml.nvmlShutdown()
raise e
def stop(self) -> None:
self.stop_flag = True