def getContacts(client): data = client.listFriends() table = Table(show_footer=False) table.add_column("Name", no_wrap=True) table.add_column("JID", no_wrap=True) table.add_column("Subscription", no_wrap=True) table.add_column("Status", no_wrap=True) table.add_column("Extra", no_wrap=True) table.title = ( "[not italic]:girl_light_skin_tone: Users In Rooster [not italic]:boy_light_skin_tone:" ) for row in data: table.add_row(*row) table.columns[4].header_style = "bold red" table.columns[3].header_style = "bold green" table.columns[2].header_style = "bold blue" table.columns[1].header_style = "red" table.columns[0].header_style = "cyan" table.row_styles = ["none", "dim"] table.border_style = "bright_yellow" for x in [ box.SQUARE, box.MINIMAL, box.SIMPLE, box.SIMPLE_HEAD, ]: table.box = x console.print(table, justify="left")
def search(query: str, amount: int, ignore_errors: bool, min_views, max_views, game) -> None: channels = API.search(query, live=True, amount=amount) table = Table() table_centerd = Align.center(table) table.add_column("channel") table.add_column("views") table.add_column("game") table.add_column("title") table.title = f"search results for [bold]{query}[/bold]" with Live(table_centerd, console=Console, refresh_per_second=20): for channel in channels: try: stream = API.get_stream_info(channel) except Exception as e: if not ignore_errors: table.add_row(f"www.twitch.tv/{channel}", "[bold red]E[/bold red]", "[bold red]Error[/bold red]", f"[bold red]{e}[/bold red]") else: if max_views is not None and stream.views > max_views: continue if min_views is not None and stream.views < min_views: continue if game is not None and stream.game != game: continue table.add_row(f"www.twitch.tv/{stream.channel}", str(stream.views), str(stream.game), str(stream.title))
def getInfoUser(client): questions = [{ 'type': 'input', 'message': 'Enter username to get info', 'name': 'username' }] answers = prompt(questions, style=custom_style_2) data = client.getUserInfo(answers['username']) table = Table(show_footer=False) table.add_column("Email", no_wrap=True) table.add_column("JID", no_wrap=True) table.add_column("Username", no_wrap=True) table.add_column("Name", no_wrap=True) table.title = ( "[not italic]:girl_light_skin_tone: Username Information [not italic]:boy_light_skin_tone:" ) for row in data: table.add_row(*row) table.columns[3].header_style = "bold red" table.columns[2].header_style = "bold green" table.columns[1].header_style = "bold blue" table.columns[0].header_style = "cyan" table.row_styles = ["none", "dim"] table.border_style = "bright_yellow" for x in [ box.SQUARE, box.MINIMAL, box.SIMPLE, box.SIMPLE_HEAD, ]: table.box = x console.print(table, justify="left")
def generate_table_stats(stats) -> "Table": """Make a table for the global stats.""" # print(stats) values = ["request_count", "average_size", "x200", "x300", "x400"] table = Table(show_header=True, header_style="bold magenta") table.title = ("[b] global statistics on request status : [/b]") table.add_column("status code") table.add_column("count") # table.add_column("Status") for index, row in enumerate(values): table.add_row(f"{row}", f"{stats[index]}") return table
def generate_table_last10(last10) -> "Table": """Make a table for the last 10sec or just render a message no input""" # print(stats) if not last10: return Panel("No hits on the last 10s", style="on blue") values = ["Section", "hits count", "average byte sent"] table = Table(show_header=True, header_style="bold magenta") table.title = ( "[b] Statistics on sections for the last 10 secondes : [/b]") for element in values: table.add_column(element) for row in last10: table.add_row(f"{row[0]}", f"{row[1]:d}", f"{row[2]:.2f}") return table
def create_table(blocks, tps, max_tps) -> Table: table = Table() table.add_column(" Height", justify="right") table.add_column("Transactions", justify="right") table.title = 'TPS: {}(MAX) / {}(1m AVG)'.format(int(max_tps), int(tps)) n = min(5, len(blocks)) for i in range(n): block = blocks[len(blocks) - i - 1] txs = block['transactions'] num_txs = 0 if txs is not None: num_txs = len(txs) table.add_row(str(block['height']), str(num_txs)) return table
def output_entry(entry): properties = {} properties["Username"] = entry.username properties["Url"] = entry.url for key, value in entry.custom_properties.items(): properties[key] = value properties["Notes"] = entry.notes table = Table() table.title = entry.title table.add_column("Field") table.add_column("Value") for key, value in properties.items(): if value: table.add_row(key, value) CONSOLE.print(table) if entry.password: pyperclip.copy(entry.password) CONSOLE.print("Password copied to clipboard")
def to_build_tree(ydoc, variants, config, selected_features): for k in variants: table = Table(show_header=True, header_style="bold") table.title = f"Output: [bold white]{k}[/bold white]" table.add_column("Package") table.add_column("Variant versions") for pkg, var in variants[k].items(): table.add_row(pkg, "\n".join(var)) console.print(table) # first we need to perform a topological sort taking into account all the outputs if ydoc.get("outputs"): outputs = [ Output(o, config, parent=ydoc, selected_features=selected_features) for o in ydoc["outputs"] ] outputs = {o.name: o for o in outputs} else: outputs = [Output(ydoc, config, selected_features=selected_features)] outputs = {o.name: o for o in outputs} if len(outputs) > 1: sort_dict = { k: [x.name for x in o.all_requirements()] for k, o in outputs.items() } tsorted = toposort.toposort(sort_dict) tsorted = [o for o in tsorted if o in sort_dict.keys()] else: tsorted = [o for o in outputs.keys()] final_outputs = [] for name in tsorted: output = outputs[name] if variants.get(output.name): v = variants[output.name] combos = [] differentiating_keys = [] for k in v: if len(v[k]) > 1: differentiating_keys.append(k) combos.append([(k, x) for x in v[k]]) all_combinations = tuple(itertools.product(*combos)) all_combinations = [dict(x) for x in all_combinations] for c in all_combinations: x = output.apply_variant(c, differentiating_keys) final_outputs.append(x) else: x = output.apply_variant({}) final_outputs.append(x) temp = final_outputs final_outputs = [] has_intermediate = False for o in temp: if o.sections["build"].get("intermediate"): if has_intermediate: raise RuntimeError( "Already found an intermediate build. There can be only one!" ) final_outputs.insert(0, o) has_intermediate = True else: final_outputs.append(o) # Note: maybe this should happen _before_ apply variant?! if has_intermediate: # inherit dependencies def merge_requirements(a, b): b_names = [x.name for x in b] for r in a: if r.name in b_names: continue else: b.append(r) intermediate = final_outputs[0] for o in final_outputs[1:]: merge_requirements( intermediate.requirements["host"], o.requirements["host"] ) merge_requirements( intermediate.requirements["build"], o.requirements["build"] ) merged_variant = {} merged_variant.update(intermediate.config.variant) merged_variant.update(o.config.variant) o.config.variant = merged_variant return final_outputs
def output( self, outdata: Union[List[str], Dict[str, Any]], tablefmt: str = "rich", title: str = None, caption: str = None, account: str = None, config=None, ok_status: Union[int, List[int], Tuple[int, str], List[Tuple[int, str]]] = None, ) -> str: # log.debugv(f"data passed to output():\n{pprint(outdata, indent=4)}") def _do_subtables(data: list, tablefmt: str = "rich"): out = [] for inner_dict in data: # the object: switch/vlan etc dict for key, val in inner_dict.items(): if not isinstance(val, (list, dict, tuple)): if val is None: inner_dict[key] = '' elif isinstance(val, str) and val.lower() in ['up', 'down']: color = 'red' if val.lower() == 'down' else 'green' if tablefmt == 'rich': inner_dict[ key] = f'[b {color}]{val.title()}[/b {color}]' else: inner_dict[key] = typer.style(val.title(), fg=color) else: if tablefmt == 'rich': inner_dict[key] = Text(str(val), style=None) else: inner_dict[key] = str(val) else: val = self.listify(val) if val and tablefmt == "rich" and hasattr( val[0], 'keys'): inner_table = Table( *(k for k in val[0].keys()), show_header=True, # padding=(0, 0), pad_edge=False, collapse_padding=True, show_edge=False, header_style="bold cyan", box=SIMPLE) _ = [ inner_table.add_row(*[ self.do_pretty(kk, str(vv)) for kk, vv in v.items() ]) for v in val ] with console.capture(): console.print(inner_table) inner_dict[key] = console.export_text() elif val and tablefmt == "tabulate" and hasattr( val[0], 'keys'): inner_table = tabulate(val, headers="keys", tablefmt=tablefmt) inner_dict[key] = inner_table else: if all(isinstance(v, str) for v in val): inner_dict[key] = ", ".join(val) out.append(inner_dict) return out raw_data = outdata _lexer = table_data = None if config and config.sanitize and raw_data and all( isinstance(x, dict) for x in raw_data): redact = [ "mac", "serial", "neighborMac", "neighborSerial", "neighborPortMac", "longitude", "latitude" ] outdata = [{ k: d[k] if k not in redact else "--redacted--" for k in d } for d in raw_data] # -- // List[str, ...] \\ -- Bypass all formatters, (config file output, etc...) if outdata and all(isinstance(x, str) for x in outdata): tablefmt = "strings" # -- convert List[dict] --> Dict[dev_name: dict] for yaml/json outputs if tablefmt in ['json', 'yaml', 'yml']: outdata = self.listify(outdata) if outdata and 'name' in outdata[0]: outdata: Dict[str, Dict[str, Any]] = { item['name']: {k: v for k, v in item.items() if k != 'name'} for item in outdata } if tablefmt == "json": raw_data = json.dumps(outdata, indent=4) _lexer = lexers.JsonLexer elif tablefmt in ["yml", "yaml"]: raw_data = yaml.dump(outdata, sort_keys=False) _lexer = lexers.YamlLexer elif tablefmt == "csv": raw_data = table_data = "\n".join([ ",".join([ k if outdata.index(d) == 0 else str(v) for k, v in d.items() if k not in CUST_KEYS ]) for d in outdata ]) elif tablefmt == "rich": from rich.console import Console from rich.table import Table from rich.box import HORIZONTALS, SIMPLE from rich.text import Text from centralcli import constants console = Console(record=True) customer_id, customer_name = "", "" # outdata = self.listify(outdata) # -- // List[dict, ...] \\ -- if outdata and all(isinstance(x, dict) for x in outdata): customer_id = outdata[0].get("customer_id", "") customer_name = outdata[0].get("customer_name", "") outdata = [{k: v for k, v in d.items() if k not in CUST_KEYS} for d in outdata] table = Table( # show_edge=False, show_header=True, title=title, header_style='magenta', show_lines=False, box=HORIZONTALS, row_styles=['none', 'dark_sea_green']) fold_cols = ['description'] _min_max = {'min': 10, 'max': 30} set_width_cols = {'name': _min_max, 'model': _min_max} full_cols = [ 'mac', 'serial', 'ip', 'public ip', 'version', 'radio', 'id' ] for k in outdata[0].keys(): if k in fold_cols: table.add_column(k, overflow='fold', max_width=115, justify='left') elif k in set_width_cols: table.add_column(k, min_width=set_width_cols[k]['min'], max_width=set_width_cols[k]['max'], justify='left') elif k in full_cols: table.add_column(k, no_wrap=True, justify='left') else: table.add_column(k, justify='left') formatted = _do_subtables(outdata) [ table.add_row(*list(in_dict.values())) for in_dict in formatted ] if title: table.title = f'[italic cornflower_blue]{constants.what_to_pretty(title)}' if account or caption: table.caption_justify = 'left' table.caption = '' if not account else f'[italic dark_olive_green2] Account: {account}' if caption: table.caption = f"[italic dark_olive_green2]{table.caption} {caption}" data_header = f"--\n{'Customer ID:':15}{customer_id}\n{'Customer Name:':15} {customer_name}\n--\n" with console.capture(): console.print(table) raw_data = console.export_text(clear=False) table_data = console.export_text(styles=True) raw_data = f"{data_header}{raw_data}" if customer_id else f"{raw_data}" table_data = f"{data_header}{table_data}" if customer_id else f"{table_data}" elif tablefmt == "tabulate": customer_id = customer_name = "" outdata = self.listify(outdata) # -- // List[dict, ...] \\ -- if outdata and all(isinstance(x, dict) for x in outdata): customer_id = outdata[0].get("customer_id", "") customer_name = outdata[0].get("customer_name", "") outdata = [{k: v for k, v in d.items() if k not in CUST_KEYS} for d in outdata] raw_data = outdata outdata = _do_subtables(outdata, tablefmt=tablefmt) # outdata = [dict((k, v) for k, v in zip(outdata[0].keys(), val)) for val in outdata] table_data = tabulate(outdata, headers="keys", tablefmt=tablefmt) td = table_data.splitlines(keepends=True) table_data = f"{typer.style(td[0], fg='cyan')}{''.join(td[1:])}" data_header = f"--\n{'Customer ID:':15}{customer_id}\n" \ f"{'Customer Name:':15} {customer_name}\n--\n" table_data = f"{data_header}{table_data}" if customer_id else f"{table_data}" raw_data = f"{data_header}{raw_data}" if customer_id else f"{raw_data}" else: # strings output No formatting # -- // List[str, ...] \\ -- if len(outdata) == 1: if "\n" not in outdata[0]: # we can format green as only success output is sent through formatter. table_data = typer.style(f" {outdata[0]}", fg="green") raw_data = outdata[0] else: # template / config file output # get rid of double nl @ EoF (configs) raw_data = table_data = "{}\n".format( '\n'.join(outdata).rstrip('\n')) else: raw_data = table_data = '\n'.join(outdata) # Not sure what hit's this, but it was created so something must log.debug("List[str] else hit") if _lexer and raw_data: table_data = highlight( bytes(raw_data, 'UTF-8'), _lexer(), formatters.Terminal256Formatter(style='solarized-dark')) return self.Output(rawdata=raw_data, prettydata=table_data, config=config)
def to_build_tree(ydoc, variants, config, cbc, selected_features): for k in variants: table = Table(show_header=True, header_style="bold") table.title = f"Output: [bold white]{k}[/bold white]" table.add_column("Package") table.add_column("Variant versions") for pkg, var in variants[k].items(): table.add_row(pkg, "\n".join(var)) console.print(table) # first we need to perform a topological sort taking into account all the outputs if ydoc.get("outputs"): outputs = [ Output( o, config, parent=ydoc, conda_build_config=cbc, selected_features=selected_features, ) for o in ydoc["outputs"] ] outputs = {o.name: o for o in outputs} else: outputs = [ Output( ydoc, config, conda_build_config=cbc, selected_features=selected_features, ) ] outputs = {o.name: o for o in outputs} if len(outputs) > 1: sort_dict = { k: [x.name for x in o.all_requirements()] for k, o in outputs.items() } tsorted = toposort.toposort(sort_dict) tsorted = [o for o in tsorted if o in sort_dict.keys()] else: tsorted = [o for o in outputs.keys()] final_outputs = [] # need to strip static away from output name... :/ static_feature = selected_features.get("static", False) for name in tsorted: output = outputs[name] # this is all a bit hacky ... will have to clean that up eventually variant_name = name if static_feature and name.endswith("-static"): variant_name = name[: -len("-static")] # zip keys need to be contracted zipped_keys = cbc.get("zip_keys", []) if variants.get(variant_name): v = variants[variant_name] import copy vzipped = copy.copy(v) zippers = {} for zkeys in zipped_keys: # we check if our variant contains keys that need to be zipped if sum(k in v for k in zkeys) > 1: filtered_zip_keys = [k for k in v if k in zkeys] print("Filtered zip keys: ", filtered_zip_keys) zkname = "__zip_" + "_".join(filtered_zip_keys) zklen = None for zk in filtered_zip_keys: if zk not in cbc: raise RuntimeError( f"Trying to zip keys, but not all zip keys found on conda-build-config {zk}" ) zkl = len(cbc[zk]) if not zklen: zklen = zkl if zklen and zkl != zklen: raise RuntimeError( f"Trying to zip keys, but not all zip keys have the same length {zkeys}" ) vzipped[zkname] = [str(i) for i in range(zklen)] zippers[zkname] = {zk: cbc[zk] for zk in filtered_zip_keys} for zk in filtered_zip_keys: del vzipped[zk] combos = [] differentiating_keys = [] for k, vz in vzipped.items(): if len(vz) > 1: differentiating_keys.append(k) combos.append([(k, x) for x in vz]) all_combinations = tuple(itertools.product(*combos)) all_combinations = [dict(x) for x in all_combinations] # unzip the zipped keys unzipped_combinations = [] for c in all_combinations: unz_combo = {} for vc in c: if vc.startswith("__zip_"): ziptask = zippers[vc] zipindex = int(c[vc]) for zippkg in ziptask: unz_combo[zippkg] = ziptask[zippkg][zipindex] if vc in differentiating_keys: differentiating_keys.remove(vc) differentiating_keys.extend(zippers[vc].keys()) else: unz_combo[vc] = c[vc] unzipped_combinations.append(unz_combo) for c in unzipped_combinations: x = output.apply_variant(c, differentiating_keys) final_outputs.append(x) else: x = output.apply_variant({}) final_outputs.append(x) temp = final_outputs final_outputs = [] has_intermediate = False for o in temp: if o.sections["build"].get("intermediate"): if has_intermediate: raise RuntimeError( "Already found an intermediate build. There can be only one!" ) final_outputs.insert(0, o) has_intermediate = True else: final_outputs.append(o) # Note: maybe this should happen _before_ apply variant?! if has_intermediate: # inherit dependencies def merge_requirements(a, b): b_names = [x.name for x in b] for r in a: if r.name in b_names: continue else: b.append(r) intermediate = final_outputs[0] for o in final_outputs[1:]: merge_requirements( intermediate.requirements["host"], o.requirements["host"] ) merge_requirements( intermediate.requirements["build"], o.requirements["build"] ) merged_variant = {} merged_variant.update(intermediate.config.variant) merged_variant.update(o.config.variant) o.config.variant = merged_variant return final_outputs
with beat(10): console.print(table, justify="center") table.add_column("Budget", "[u]$412,000,000", no_wrap=True) with beat(10): console.print(table, justify="center") table.add_column("Opening Weekend", "[u]$577,703,455", no_wrap=True) with beat(10): console.print(table, justify="center") table.add_column("Box Office", "[u]$4,331,212,357", no_wrap=True) with beat(10): console.print(table, justify="center") table.title = "Star Wars Box Office" with beat(10): console.print(table, justify="center") table.title = ( "[not italic]:popcorn:[/] Star Wars Box Office [not italic]:popcorn:[/]" ) with beat(10): console.print(table, justify="center") table.caption = "Made with Rich" with beat(10): console.print(table, justify="center") table.caption = "Made with [b]Rich[/b]" with beat(10):
def __rich__(self): from rich import box table = Table(box=box.MINIMAL_DOUBLE_HEAD) s = f"Output: {self.name} {self.version} BN: {self.build_number}\n" if hasattr(self, "differentiating_variant"): short_v = " ".join([val for val in self.differentiating_variant]) s += f"Variant: {short_v}\n" s += "Build:\n" table.title = s table.add_column("Dependency") table.add_column("Version requirement") table.add_column("Selected") table.add_column("Build") table.add_column("Channel") def spec_format(x): version, fv = " ", " " channel = CondaChannel.from_url(x.channel).name if (x.channel.startswith("file://") and context.local_build_root in x.channel): channel = "local" if len(x.final.split(" ")) > 1: version = " ".join(r.final.split(" ")[1:]) if hasattr(x, "final_version"): fv = x.final_version color = "white" if x.from_run_export: color = "blue" if x.from_pinnings: color = "green" if x.is_transitive_dependency: table.add_row(f"{r.final_name}", "", f"{fv[0]}", f"{fv[1]}", f"{channel}") return if x.is_pin: if x.is_pin_compatible: version = "PC " + version else: version = "PS " + version color = "cyan" if len(fv) >= 2: table.add_row( f"[bold white]{r.final_name}[/bold white]", f"[{color}]{version}[/{color}]", f"{fv[0]}", f"{fv[1]}", f"{channel}", ) else: table.add_row( f"[bold white]{r.final_name}[/bold white]", f"[{color}]{version}[/{color}]", f"{fv[0]}", "", f"{channel}", ) def add_header(header, head=False): p = Padding("", (0, 0), style="black") if head: pns = Padding("", (0, 0), style="black") table.add_row(pns, pns, pns, pns, pns) table.add_row(Padding(header, (0, 0), style="bold yellow"), p, p, p, p) if self.requirements["build"]: add_header("Build") for r in self.requirements["build"]: spec_format(r) if self.requirements["host"]: add_header("Host", True) for r in self.requirements["host"]: spec_format(r) if self.requirements["run"]: add_header("Run", True) for r in self.requirements["run"]: spec_format(r) return table
def __init__(self, d, config, parent=None, selected_features=None): if parent is None: parent = {} if selected_features is None: selected_features = {} self.data = d self.data["source"] = d.get("source", parent.get("source", {})) self.config = config self.name = d["package"]["name"] self.version = d["package"]["version"] self.build_string = d["package"].get("build_string") self.build_number = d["build"].get("number", 0) self.is_first = False self.sections = {} def set_section(sname): self.sections[sname] = {} self.sections[sname].update(parent.get(sname, {})) self.sections[sname].update(d.get(sname, {})) set_section("build") set_section("package") set_section("app") set_section("extra") self.sections["files"] = d.get("files") self.sections["source"] = self.data.get("source", {}) if hasattr(self.sections["source"], "keys"): self.sections["source"] = [self.sections["source"]] self.sections["features"] = parent.get("features", []) self.feature_map = { f["name"]: f for f in self.sections.get("features", []) } for fname, feat in self.feature_map.items(): activated = feat.get("default", False) if fname in selected_features: activated = selected_features[fname] feat["activated"] = activated if self.feature_map.get( "static") and self.feature_map["static"]["activated"]: self.name += "-static" if len(self.feature_map): table = Table() table.title = "Activated Features" table.add_column("Feature") table.add_column("State") for feature in self.feature_map: if self.feature_map[feature]["activated"]: table.add_row(feature, "[green]ON[/green]") else: table.add_row(feature, "[red]OFF[/red]") console.print(table) self.requirements = copy.copy(d.get("requirements", {})) for f in self.feature_map.values(): if f["activated"]: if not f.get("requirements"): continue for i in ["build", "host", "run", "run_constrained"]: base_req = self.requirements.get(i, []) feat_req = f["requirements"].get(i, []) base_req += feat_req if len(base_req): self.requirements[i] = base_req self.transactions = {} self.parent = parent for section in ("build", "host", "run", "run_constrained"): self.requirements[section] = [ CondaBuildSpec(r) for r in (self.requirements.get(section) or []) ] # handle strong and weak run exports run_exports = [] for el in self.sections["build"].get("run_exports", []): if type(el) is str: run_exports.append(CondaBuildSpec(el)) else: raise RuntimeError( "no strong run exports supported as of now.") # sub_run_exports = [] # for key, val in el: # for x in val: # sub_run_exports.append(CondaBuildSpec(x)) # run_exports.append({}) if run_exports: self.sections["build"]["run_exports"] = run_exports
def generate_table(): nonlocal config nonlocal manager nonlocal subtensor nonlocal dendrite nonlocal meta total_stake = 0.0 total_incentive = 0.0 total_rank = 0.0 total_success = 0 total_time = 0.0 # Fill row. def get_row(droplet): nonlocal total_stake nonlocal total_incentive nonlocal total_rank nonlocal total_time nonlocal total_success nonlocal config if droplet.name not in config.names: return # Setup asyncio loop. connection = connection_for_droplet(droplet) # Get connection string can_connect_bool = can_connect(connection) connect_str = '[bold green] YES' if can_connect( connection) else '[bold red] NO' # get hotkey if can_connect_bool: try: hotkey = get_hotkey(connection) hotkey_str = hotkey if hotkey != None else '[yellow] None' except Exception as e: hotkey_str = '[yellow] None' logger.error('{}: Failed to pull hotkey error = {}', droplet.name, e) else: hotkey_str = '[yellow] None' # get coldkey if can_connect_bool: try: coldkeypub = get_coldkeypub(connection) coldkeypub_str = coldkeypub if coldkeypub != None else '[yellow] None' except Exception as e: coldkeypub_str = '[yellow] None' logger.error('{}: Failed to pull coldkey error = {}', droplet.name, e) else: coldkeypub_str = '[yellow] None' # get branch if can_connect_bool: try: branch = get_branch(connection) branch_str = branch if branch != None else '[yellow] None' except Exception as e: branch_str = '[yellow] None' logger.error('{}: Failed to pull branch error = {}', droplet.name, e) else: branch_str = '[yellow] None' # get install status if can_connect_bool and branch != None: try: installed = is_installed(connection) is_installed_str = '[bold green] Yes' if installed else '[bold red] No' except Exception as e: installed = False is_installed_str = '[bold red] No' logger.error( '{}: Failed to pull install status error = {}', droplet.name, e) else: installed = False is_installed_str = '[bold red] No' # get miner status if can_connect_bool and installed: try: is_running = is_miner_running(connection) is_running_str = '[bold green] Yes' if is_running else '[bold red] No' except Exception as e: is_running = False is_running_str = '[bold red] No' logger.error( '{}: Failed to pull running status: error = {}', droplet.name, e) else: is_running = False is_running_str = '[bold red] No' # get is_subscribed try: uid = meta.hotkeys.index(hotkey) is_subscribed = True is_subscribed_str = '[bold green] Yes' except: is_subscribed = False is_subscribed_str = '[bold red] No' # get subscription status. if is_subscribed: stake = meta.S[uid].item() rank = meta.R[uid].item() incentive = meta.I[uid].item() lastemit = int(meta.block - meta.lastemit[uid]) lastemit = "[bold green]" + str( lastemit) if lastemit < 3000 else "[bold red]" + str( lastemit) address = str(meta.addresses[uid]) neuron = meta.neuron_endpoints[uid] total_stake += stake total_rank += rank total_incentive += incentive * 14400 uid_str = str(uid) stake_str = '[green]\u03C4{:.5}'.format(stake) rank_str = '[green]\u03C4{:.5}'.format(rank) incentive_str = '[green]\u03C4{:.5}'.format(incentive * 14400) lastemit_str = str(lastemit) address_str = str(address) else: uid_str = '[dim yellow] None' stake_str = '[dim yellow] None' rank_str = '[dim yellow] None' incentive_str = '[dim yellow] None' lastemit_str = '[dim yellow] None' address_str = '[dim yellow] None' # Make query and get response. if installed and is_running and is_subscribed and wallet.has_hotkey and neuron != None: start_time = time.time() result, code = dendrite.forward_text( neurons=[neuron], x=[torch.zeros((1, 1), dtype=torch.int64)]) end_time = time.time() code_to_string = bittensor.utils.codes.code_to_string( code.item()) code_color = bittensor.utils.codes.code_to_color(code.item()) code_str = '[' + str(code_color) + ']' + code_to_string query_time_str = '[' + str( code_color) + ']' + "" + '{:.3}'.format(end_time - start_time) + "s" if code.item() == 0: total_success += 1 total_time += end_time - start_time else: code_str = '[dim yellow] N/A' query_time_str = '[dim yellow] N/A' row = [ str(droplet.name), str(droplet.ip_address), str(droplet.region['name']), str(droplet.size_slug), str(connect_str), branch_str, is_installed_str, is_running_str, is_subscribed_str, address_str, uid_str, stake_str, rank_str, incentive_str, lastemit_str, query_time_str, code_str, hotkey_str, coldkeypub_str ] return row # Get latest droplets. droplets = manager.get_all_droplets(tag_name=[TAG]) if config.names == None: config.names = [droplet.name for droplet in droplets] subtensor.connect() meta.load() meta.sync(subtensor=subtensor, force=config.force) meta.save() TABLE_DATA = [] with ThreadPoolExecutor(max_workers=MAX_THREADS) as executor: if config.live: TABLE_DATA = list(executor.map(get_row, droplets)) else: TABLE_DATA = list( tqdm(executor.map(get_row, droplets), total=len(droplets))) TABLE_DATA = [row for row in TABLE_DATA if row != None] TABLE_DATA.sort(key=lambda TABLE_DATA: TABLE_DATA[0]) total_stake_str = '\u03C4{:.7}'.format(total_stake) total_rank_str = '\u03C4{:.7}'.format(total_rank) total_incentive_str = '\u03C4{:.7}'.format(total_incentive) total_time_str = '{:.3}s'.format( total_time / len(config.names)) if total_time != 0 else '0.0s' total_success_str = '[bold green]' + str( total_success) + '/[bold red]' + str( len(config.names) - total_success) console = Console() table = Table(show_footer=False) table.title = ("[bold white]Miners") table.add_column("[overline white]NAME", str(len(config.names)), footer_style="overline white", style='white') table.add_column("[overline white]IP", style='blue') table.add_column("[overline white]LOC", style='yellow') table.add_column("[overline white]SIZE", style='green') table.add_column("[overline white]CONN", style='green') table.add_column("[overline white]BRNCH", style='bold purple') table.add_column("[overline white]INSTL") table.add_column("[overline white]RNG") table.add_column("[overline white]SUBD") table.add_column("[overline white]ADDR", style='blue') table.add_column("[overline white]UID", style='yellow') table.add_column("[overline white]STAKE(\u03C4)", total_stake_str, footer_style="overline white", justify='right', style='green', no_wrap=True) table.add_column("[overline white]RANK(\u03C4)", total_rank_str, footer_style="overline white", justify='right', style='green', no_wrap=True) table.add_column("[overline white]INCN(\u03C4/d)", total_incentive_str, footer_style="overline white", justify='right', style='green', no_wrap=True) table.add_column("[overline white]LEmit", justify='right', no_wrap=True) table.add_column("[overline white]Qry(sec)", total_time_str, footer_style="overline white", justify='right', no_wrap=True) table.add_column("[overline white]Qry(code)", total_success_str, footer_style="overline white", justify='right', no_wrap=True) table.add_column("[overline white]HOT", style='bold blue', no_wrap=False) table.add_column("[overline white]COLD", style='blue', no_wrap=False) table.show_footer = True console.clear() for row in TABLE_DATA: table.add_row(*row) table.box = None table.pad_edge = False table.width = None table = Align.center(table) return table
def overview(self): r""" Prints an overview for the wallet's colkey. """ console = bittensor.__console__ wallet = bittensor.wallet( config = self.config ) subtensor = bittensor.subtensor( config = self.config ) all_hotkeys = CLI._get_hotkey_wallets_for_wallet( wallet ) neurons = [] block = subtensor.block with console.status(":satellite: Syncing with chain: [white]{}[/white] ...".format(self.config.subtensor.network)): for wallet in tqdm(all_hotkeys): nn = subtensor.neuron_for_pubkey( wallet.hotkey.ss58_address ) if not nn.is_null: neurons.append( nn ) balance = subtensor.get_balance( wallet.coldkeypub.ss58_address ) TABLE_DATA = [] total_stake = 0.0 total_rank = 0.0 total_trust = 0.0 total_consensus = 0.0 total_incentive = 0.0 total_dividends = 0.0 total_emission = 0 for nn, hotwallet in tqdm(list(zip(neurons,all_hotkeys))): uid = nn.uid active = nn.active stake = nn.stake rank = nn.rank trust = nn.trust consensus = nn.consensus incentive = nn.incentive dividends = nn.dividends emission = int(nn.emission * 1000000000) last_update = int(block - nn.last_update) row = [ hotwallet.hotkey_str, str(uid), str(active), '{:.5f}'.format(stake), '{:.5f}'.format(rank), '{:.5f}'.format(trust), '{:.5f}'.format(consensus), '{:.5f}'.format(incentive), '{:.5f}'.format(dividends), '{}'.format(emission), str(last_update), bittensor.utils.networking.int_to_ip( nn.ip) + ':' + str(nn.port) if nn.port != 0 else '[yellow]none[/yellow]', nn.hotkey ] total_stake += stake total_rank += rank total_trust += trust total_consensus += consensus total_incentive += incentive total_dividends += dividends total_emission += emission TABLE_DATA.append(row) total_neurons = len(neurons) table = Table(show_footer=False) table.title = ( "[white]Wallet - {}:{}".format(self.config.wallet.name, wallet.coldkeypub.ss58_address) ) table.add_column("[overline white]HOTKEY", str(total_neurons), footer_style = "overline white", style='bold white') table.add_column("[overline white]UID", str(total_neurons), footer_style = "overline white", style='yellow') table.add_column("[overline white]ACTIVE", justify='right', style='green', no_wrap=True) table.add_column("[overline white]STAKE(\u03C4)", '\u03C4{:.5f}'.format(total_stake), footer_style = "overline white", justify='right', style='green', no_wrap=True) table.add_column("[overline white]RANK", '{:.5f}'.format(total_rank), footer_style = "overline white", justify='right', style='green', no_wrap=True) table.add_column("[overline white]TRUST", '{:.5f}'.format(total_trust), footer_style = "overline white", justify='right', style='green', no_wrap=True) table.add_column("[overline white]CONSENSUS", '{:.5f}'.format(total_consensus), footer_style = "overline white", justify='right', style='green', no_wrap=True) table.add_column("[overline white]INCENTIVE", '{:.5f}'.format(total_incentive), footer_style = "overline white", justify='right', style='green', no_wrap=True) table.add_column("[overline white]DIVIDENDS", '{:.5f}'.format(total_dividends), footer_style = "overline white", justify='right', style='green', no_wrap=True) table.add_column("[overline white]EMISSION(\u03C1)", '\u03C1{}'.format(int(total_emission)), footer_style = "overline white", justify='right', style='green', no_wrap=True) table.add_column("[overline white]UPDATED", justify='right', no_wrap=True) table.add_column("[overline white]AXON", justify='left', style='dim blue', no_wrap=True) table.add_column("[overline white]HOTKEY", style='dim blue', no_wrap=False) table.show_footer = True table.caption = "[white]Wallet balance: [green]\u03C4" + str(balance.tao) console.clear() for row in TABLE_DATA: table.add_row(*row) table.box = None table.pad_edge = False table.width = None console.print(table)
def metagraph(self): r""" Prints an entire metagraph. """ console = bittensor.__console__ subtensor = bittensor.subtensor( config = self.config ) metagraph = bittensor.metagraph( subtensor = subtensor ) console.print(":satellite: Syncing with chain: [white]{}[/white] ...".format(self.config.subtensor.network)) metagraph.sync() metagraph.save() issuance = subtensor.total_issuance difficulty = subtensor.difficulty TABLE_DATA = [] total_stake = 0.0 total_rank = 0.0 total_trust = 0.0 total_consensus = 0.0 total_incentive = 0.0 total_dividends = 0.0 total_emission = 0 for uid in metagraph.uids: ep = metagraph.endpoint_objs[uid] row = [ str(ep.uid), '{:.5f}'.format( metagraph.stake[uid]), '{:.5f}'.format( metagraph.ranks[uid]), '{:.5f}'.format( metagraph.trust[uid]), '{:.5f}'.format( metagraph.consensus[uid]), '{:.5f}'.format( metagraph.incentive[uid]), '{:.5f}'.format( metagraph.dividends[uid]), '{}'.format( int(metagraph.emission[uid] * 1000000000)), str((metagraph.block.item() - metagraph.last_update[uid].item())), str( metagraph.active[uid].item() ), ep.ip + ':' + str(ep.port) if ep.is_serving else '[yellow]none[/yellow]', ep.hotkey[:10], ep.coldkey[:10] ] total_stake += metagraph.stake[uid] total_rank += metagraph.ranks[uid] total_trust += metagraph.trust[uid] total_consensus += metagraph.consensus[uid] total_incentive += metagraph.incentive[uid] total_dividends += metagraph.dividends[uid] total_emission += int(metagraph.emission[uid] * 1000000000) TABLE_DATA.append(row) total_neurons = len(metagraph.uids) table = Table(show_footer=False) table.title = ( "[white]Metagraph: name: {}, block: {}, N: {}/{}, tau: {}/block, stake: {}, issuance: {}, difficulty: {}".format(subtensor.network, metagraph.block.item(), sum(metagraph.active.tolist()), metagraph.n.item(), bittensor.Balance.from_tao(metagraph.tau.item()), bittensor.Balance.from_tao(total_stake), issuance, difficulty ) ) table.add_column("[overline white]UID", str(total_neurons), footer_style = "overline white", style='yellow') table.add_column("[overline white]STAKE(\u03C4)", '\u03C4{:.5f}'.format(total_stake), footer_style = "overline white", justify='right', style='green', no_wrap=True) table.add_column("[overline white]RANK", '{:.5f}'.format(total_rank), footer_style = "overline white", justify='right', style='green', no_wrap=True) table.add_column("[overline white]TRUST", '{:.5f}'.format(total_trust), footer_style = "overline white", justify='right', style='green', no_wrap=True) table.add_column("[overline white]CONSENSUS", '{:.5f}'.format(total_consensus), footer_style = "overline white", justify='right', style='green', no_wrap=True) table.add_column("[overline white]INCENTIVE", '{:.5f}'.format(total_incentive), footer_style = "overline white", justify='right', style='green', no_wrap=True) table.add_column("[overline white]DIVIDENDS", '{:.5f}'.format(total_dividends), footer_style = "overline white", justify='right', style='green', no_wrap=True) table.add_column("[overline white]EMISSION(\u03C1)", '\u03C1{}'.format(int(total_emission)), footer_style = "overline white", justify='right', style='green', no_wrap=True) table.add_column("[overline white]UPDATED", justify='right', no_wrap=True) table.add_column("[overline white]ACTIVE", justify='right', style='green', no_wrap=True) table.add_column("[overline white]AXON", justify='left', style='dim blue', no_wrap=True) table.add_column("[overline white]HOTKEY", style='dim blue', no_wrap=False) table.add_column("[overline white]COLDKEY", style='dim purple', no_wrap=False) table.show_footer = True for row in TABLE_DATA: table.add_row(*row) table.box = None table.pad_edge = False table.width = None console.print(table)