def list_all(): print '\n{}ENCODERS{}'.format(logs.bold(logs.purple('>>')),logs.bold(logs.purple('<<'))) table_data = [['--NAME--', '--ARCH--', '--DESCRIPTION--', '--RANK--']] encoders = [] for enc in os.walk(PATH+'encoders'): encoders.append(enc) encoders = encoders[0][2] cdrs = [] for enc in encoders: if ('init' in enc or '.pyc' in enc): pass else: cdrs.append(enc.replace('.py', '')) for encoder in cdrs: try: encoder = importlib.import_module('encoders.'+encoder).Encoder() if encoder.rank == 'unstable': rank = logs.red('UNSTABLE') if encoder.rank == 'manual': rank = logs.yellow('MANUAL') elif encoder.rank == 'good': rank = logs.green('GOOD') elif encoder.rank == 'excellent': rank = logs.blue('EXCELLENT') except: rank = 'N/A' table_data.append([encoder.name, encoder.arch, encoder.description, rank]) table_instance = SingleTable(table_data) table_instance.inner_heading_row_border = True table_instance.inner_row_border = False table_instance.justify_columns = {0: 'left', 1: 'left', 2: 'left'} print table_instance.table print '\n{}EGGHUNTERS{}'.format(logs.bold(logs.purple('>>')),logs.bold(logs.purple('<<'))) table_data = [['--NAME--', '--PLATFORM--', '--SIZE--', '--EGG SIZE--']] for egg in eggs: table_data.append([egg, eggs[egg][1],'{} bytes'.format(eggs[egg][2]),'{} bytes'.format(eggs[egg][3])]) table_instance = SingleTable(table_data) table_instance.inner_heading_row_border = True table_instance.inner_row_border = False table_instance.justify_columns = {0: 'left', 1: 'left', 2: 'left'} print table_instance.table print '\n{}FORMATS{}'.format(logs.bold(logs.purple('>>')),logs.bold(logs.purple('<<'))) table_data = [['--FORMAT--', '--DESCRIPTION--']] for func in dir(wrappers): if "format_" in func: table_data.append([func.replace("format_", ''), eval("wrappers.{}".format(func)).__doc__]) table_instance = SingleTable(table_data) table_instance.inner_heading_row_border = True table_instance.inner_row_border = False table_instance.justify_columns = {0: 'left', 1: 'left', 2: 'left'} print table_instance.table
def _repr_tty_(self) -> str: """Return a summary of this sample sheet in a TTY compatible codec.""" header_description = ['Sample_ID', 'Description'] header_samples = [ 'Sample_ID', 'Sample_Name', 'Library_ID', 'index', 'index2', ] header = SingleTable([], 'Header') setting = SingleTable([], 'Settings') sample_main = SingleTable([header_samples], 'Identifiers') sample_desc = SingleTable([header_description], 'Descriptions') # All key:value pairs found in the [Header] section. max_header_width = max(MIN_WIDTH, sample_desc.column_max_width(-1)) for key in self.Header.keys(): if 'Description' in key: value = '\n'.join( wrap(getattr(self.Header, key), max_header_width)) else: value = getattr(self.Header, key) header.table_data.append([key, value]) # All key:value pairs found in the [Settings] and [Reads] sections. for key in self.Settings.keys(): setting.table_data.append((key, getattr(self.Settings, key) or '')) setting.table_data.append(('Reads', ', '.join(map(str, self.Reads)))) # Descriptions are wrapped to the allowable space remaining. description_width = max(MIN_WIDTH, sample_desc.column_max_width(-1)) for sample in self.samples: # Add all key:value pairs for this sample sample_main.table_data.append( [getattr(sample, title) or '' for title in header_samples]) # Wrap and add the sample descrption sample_desc.table_data.append(( sample.Sample_ID, '\n'.join(wrap(sample.Description or '', description_width)), )) # These tables do not have horizontal headers so remove the frame. header.inner_heading_row_border = False setting.inner_heading_row_border = False table = '\n'.join([ header.table, setting.table, sample_main.table, sample_desc.table ]) return table
def print_secrets(secrets): data = [ ["id", "name", "website", "user", "password", "notes" ] ] for s in secrets: data = Secret.todict(s).items() table = SingleTable(data) table.inner_heading_row_border = False print(table.table)
def validate_args(self): parser = argparse.ArgumentParser(description="") parser.add_argument("-A", "--option", metavar="<option>", dest="algorithm", default=None, help="Choose hash' option between %s" % ALGORITHMS) parser.add_argument("-H", "--hash", metavar="<hash>", dest="hash", default=None, help="Specify a hash to crack") args = parser.parse_args() if not args.hash: print_error("Missing --hash option!") sys.exit(-1) if not args.algorithm: print_error("Missing --option option!") sys.exit(-1) if args.algorithm not in ALGORITHMS: print_error("Wrong --option option!") data = [] for x in ALGORITHMS: data.append([x]) t = SingleTable(data, 'Available option') #AsciiTable() t.inner_heading_row_border = False t.justify_columns[0] = 'center' print "Available option:" print t.table sys.exit(-1) return args
def stat_bar(cur): """ one-liner stat bar """ # Block : All=X Ours=Y Oth=Z | Allow : All=X Ours=Y Oth=Z data = [] data.append("Blocks Enabled: All=" + str(get(cur, "total_adlist_enabled"))) data.append("│") data.append("Ours=" + str(get(cur, "our_adlist_enabled"))) # data.append("│") # data.append("Other=" + str(get(cur, "other_adlist_enabled"))) data.append("│") data.append("Allows Enabled: All=" + str(get(cur, "total_allow_enabled"))) data.append("│") data.append("Ours=" + str(get(cur, "our_allow_enabled"))) # data.append("│") # data.append("Other=" + str(get(cur, "other_allow_enabled"))) table = SingleTable([data]) table.inner_heading_row_border = False table.outer_border = False table.inner_row_border = False table.inner_column_border = False table.padding_left = 2 print() print(color(table.table, bg="#505050", fg="white")) print()
def summary_arp_mon(pkts, res): table_data = [[]] def arp_mon_display(pkt): if pkt[ARP].op == 1: return f"{green('>')} Request: {pkt[ARP].psrc} is asking about {pkt[ARP].pdst}" if pkt[ARP].op == 2: return f"{red('<')} Response: {pkt[ARP].hwsrc} has address {pkt[ARP].hwdst}" if pkt[ARP].op == 2 and pkt[ARP].psrc == pkt[ARP].pdst: return f"{blue('*')} Cache exchange: {pkt[ARP].psrc}" for pkt in pkts: if pkt.haslayer(ARP): table_data.append([arp_mon_display(pkt)]) print(f"{s} ARP monitor {s}") #if any(pkt.haslayer(ARP) for pkt in pkts): if len(table_data) != 0: table = SingleTable(table_data[1:]) else: table = SingleTable([[red("No packets with ARP layer")]]) table.inner_heading_row_border = False print(table.table) if res.OUTPUT: with open(res.OUTPUT, "a") as out_file: out_file.write(f"\n{table.table}\n") print("")
def handleDiscovery(self, dev, isNewDev, isNewData): if not isNewDev: return elif self.opts.mac is not None and dev.addr != self.opts.mac: return elif dev.rssi < self.opts.sensitivity: return vendor = vendors.find(dev.addr) vlabel = yellow(vendor + ' ') if vendor is not None else '?' clabel = green(u'\u2713') if dev.connectable else red(u'\u2715') dlabel = "(no data) " if not dev.scanData else "" title = " %s (%s dBm) %s" % (bold(dev.addr), dev.rssi, dlabel) tdata = [['Vendor', vlabel], ['Allows Connections', clabel], ['Address Type', dev.addrType]] for (tag, desc, val) in dev.getScanData(): if desc == 'Flags': tdata.append(['Flags', self._parseFlags(val)]) # short local name or complete local name elif tag in [8, 9]: try: tdata.append([desc, yellow(val.decode('utf-8'))]) except UnicodeEncodeError: tdata.append([desc, yellow(repr(val))]) else: tdata.append([desc, repr(val)]) table = SingleTable(tdata, title) table.inner_heading_row_border = False print table.table + "\n"
def archs(self): filtered = [] table = [] archs = sorted(list(self.executor.get_archs())) cur = [archs[0]] loc_max = MN_INF for pos in range(1, len(archs)): if self.__is_similar(archs[pos], archs[pos - 1]): cur.append(archs[pos]) else: loc_max = max(loc_max, len(cur)) filtered.append(['<cyan>{}</>'.format(x) for x in cur]) cur = [archs[pos]] filtered.append(['<cyan>{}</>'.format(x) for x in cur]) loc_max = max(loc_max, len(cur)) table.append(['\r'] * len(filtered)) for i in range(loc_max): cur_row = [] for j in range(len(filtered)): cur_row.append('' if i >= len(filtered[j]) else make_colors( filtered[j][i])) table.append(cur_row) rtable = SingleTable(table) rtable.inner_heading_row_border = False return rtable.table
def print_inventory(emoji, emoji_you_have, title="Your Inventory"): newlist = [emoji[1:], emoji_you_have[1:]] table = SingleTable(newlist) table.inner_row_border = True table.inner_heading_row_border = False table.title = title print(table.table)
def viewSentiments(number): twits = getFile() table_data = [[ Color('{cyan}TWEET{/cyan}'), Color('{autored}SENTIMENTS{/autored}') ]] for twit in tqdm(twits.items(), total=number, desc="Analysing sentiments..."): sentiment = twit[1]['sentiments'] sentString = '' for item in sentiment: sentString += item + '\n' sentString = sentString.strip() text = '\n'.join(wrap(twit[1]['tweet'], 80)) table_data.append([ Color('{cyan}' + text + '{/cyan}'), Color('{red}' + sentString + '{/red}') ]) table_instance = SingleTable(table_data, Color('{green}Sentiment Analysis{/green}')) table_instance.inner_heading_row_border = True table_instance.inner_row_border = True table_instance.justify_columns = {0: 'left', 1: 'left'} return table_instance.table
def viewRanks(number): twits = getFile() stopWords = getStopwords() words = [] for twit in tqdm(twits.items(), total=number, desc="Ranking words..."): words.extend(word_tokenize(twit[1]['tweet'])) words = [ word for word in words if word.lower() not in stopWords and re.match(r'\w', word) ] wordsDict = Counter(words) sortedList = sorted(wordsDict.items(), key=lambda x: x[1], reverse=True) table_data = [[ Color('{cyan}WORDS{/cyan}'), Color('{autored}RANKS{/autored}') ]] for word in sortedList: table_data.append( [Color(word[0]), Color('{autored}' + str(word[1]) + '{/autored}')]) table_instance = SingleTable(table_data, Color('{green}Word Frequency{/green}')) table_instance.inner_heading_row_border = True table_instance.inner_row_border = True table_instance.justify_columns = {0: 'center', 1: 'center'} return table_instance.table
def __str__(self): title = 'Prediction for ' + str(self.input) data = [[p[1], '{:6.2f}%'.format(100 * p[0])] for p in self.probabilities] table = SingleTable(data) table.inner_heading_row_border = False return title + '\n' + table.table
def get_description(self): root, _, scripts = self.walking_in_directory() scripts.sort() full_description = {} for s in scripts: with open(root + s) as text: head = [next(text) for l in range(2)] technique_name = head[0].replace('#TechniqueName: ', '').strip('\n') atomic_name = head[1].replace('#AtomicTestName:', '').strip('\n') if technique_name not in full_description: full_description[technique_name] = [(atomic_name, s)] else: full_description[technique_name].append((atomic_name, s)) description_display = '' table_data = [] for key, values in full_description.items(): table_data.append([f'\n#{key}', '']) for ttp_variant in values: table_data.append([f' {ttp_variant[0]}', ttp_variant[1]]) self.ttp_list.append(ttp_variant[1]) table = SingleTable(table_data, title='Atomics') table.inner_column_border = False table.inner_heading_row_border = False table.inner_row_border = False table.outer_border = False description_display += table.table return description_display
def printShortTable(self, addr): """ Print the short overview table for the given device @addr: mac addr of the device to print """ vendor = self.devdata[addr]["vendor"] vlabel = yellow( vendor + ' ' ) if vendor is not None else '?' clabel = green( u'\u2713' ) if self.devdata[addr]["connectable"] else red( u'\u2715' ) dlabel = "(no data) " if not self.devdata[addr]["scanData"] else "" title = " %s (%s dBm) %s" % ( bold(addr), self.devdata[addr]["rssi"], dlabel ) tdata = [ [ 'Vendor', vlabel ], [ 'Allows Connections', clabel ], [ 'Address Type', self.devdata[addr]["addrType"]] ] for desc in self.devdata[addr]["descs"]: tdata.append([ desc, self.devdata[addr][desc] ]) if "Short Local Name" in self.devdata[addr].keys(): tdata.append([ "Short Local Name", yellow( self.devdata[addr]["Short Local Name"] ) ]) if "Complete Local Name" in self.devdata[addr].keys(): tdata.append([ "Complete Local Name", yellow( self.devdata[addr]["Complete Local Name"] ) ]) tdata.append([ 'Flags', ', '.join(self.devdata[addr].get("flags",[])) ]) table = SingleTable(tdata, title) table.inner_heading_row_border = False print(table.table + "\n")
def info(ctx): redact = ctx.obj["redact"] card = get_reader(ctx.obj["reader"]) apps = card.list_applications() click.secho("\n1PAY.SYS.DDF01 (Index of apps for chip payments)", bold=True) render_app(card, "1PAY.SYS.DDF01", redact) click.secho("\n2PAY.SYS.DDF01 (Index of apps for contactless payments)", bold=True) try: render_app(card, "2PAY.SYS.DDF01", redact) except MissingAppException: click.secho( "2PAY.SYS.DDF01 not available (this is normal on some cards)", fg="yellow") for app in apps: click.secho( "\nApplication %s, DF Name: %s" % ( render_element(Tag.APP_LABEL, app[Tag.APP_LABEL]), render_element(Tag.DF, app[Tag.ADF_NAME]), ), bold=True, ) render_app(card, app[Tag.ADF_NAME], redact) click.echo("\nFetching card metadata...") try: tab = SingleTable(card.get_metadata().items()) tab.inner_heading_row_border = False click.echo(tab.table) except ErrorResponse as e: click.secho("Unable to fetch card data: %s" % e, fg="yellow")
def print_vending_machine(): line1 = ' 1 2 3 ' line2 = ' ' line3 = ' ^_^ | T-T | @_@ ' line4 = ' 20 | 60 | 100 ' line5 = ' 4 5 6 ' line6 = ' ' line7 = ' @.@ | *-* | :P ' line8 = ' 150 | 200 | 250 ' line9 = ' ' line10 = ' OUTPUT ' line11 = ' ' line12 = ' _______________ ' newlist = [] newlist.append([line1 + "\n" + line2 + "\n" + line3 + "\n" + line4]) newlist.append([line5 + "\n" + line6 + "\n" + line7 + "\n" + line8]) newlist.append([line9 + "\n" + line10 + "\n" + line11 + "\n" + line12]) #print(newlist) table = SingleTable(newlist) table.inner_row_border = True table.inner_heading_row_border = False table.title = "Emoji Vending Machine" sp.call("clear", shell=True) print(table.table)
def print_compare(self, src, dst, a, b, sym): from colorclass import Color, Windows from terminaltables import SingleTable Windows.enable(auto_colors=True, reset_atexit=True) # Does nothing if not on Windows. max_width = 50 l = [Color('{autocyan}' + self.wrap_text(src, max_width) + '{/autocyan}'), sym[0], Color('{autocyan}' + self.wrap_text(dst, max_width) + '{/autocyan}')] table_data = [] table_data.append(l) for key, value in a.items(): l = [self.wrap_text(key, max_width), sym[1], ""] table_data.append(l) for key, value in b.items(): l = ["", sym[2], self.wrap_text(key, max_width)] table_data.append(l) table = SingleTable(table_data) table.inner_heading_row_border = True table.inner_row_border = True print(table.table)
def reevaluate(): path = '*.lp' if DIRECTORY: path = os.path.join(DIRECTORY, path) files = glob.glob(path) if not files: print('No .lp files found') return # in case solving takes a while print('Solving...', end=' ', flush=True) res = solve_interruptible(files=files) if res.raw and 'UNSATISFIABLE' in res.raw: print(res.raw) return r, c = term_dimensions() facts = res.facts facts = sorted(facts) # before we destroy the structure for rendering facts = [wrap(f) for f in facts] facts = split_columns(facts, r - 3) table = SingleTable(facts) table.inner_heading_row_border = False clear() print(table.table)
def trace_table(exc, logger='default', note=True, column=5, mode='ascii', level='error', width=40): if isinstance(logger, str): logger = logging.getLogger(logger) tb = traceback.extract_tb(exc.__traceback__, limit=None) len_tb = len(tb) group_size = len_tb // column if len_tb % column != 0: group_size += 1 if note: column -= 1 if column <= 0: column = 1 for index, tb_chunked in enumerate(grouper_it(tb, column)): if note: data = [ ['file'], ['func'], ['desc'] ] else: data = [[], [], []] for i, frame in enumerate(tb_chunked): current_filename = frame.filename if i == 0: last_filename = frame.filename else: if current_filename == last_filename: current_filename = '' else: last_filename = current_filename # + ':' + frame.lineno if len(current_filename) == 0: data[0].append(str(frame.lineno)) else: data[0].append('\n'.join(wrap(current_filename + ':' + str(frame.lineno), width))) data[1].append(frame.name) data[2].append('\n'.join(wrap(frame.line, width))) if mode == 'single': table = SingleTable(data, str(group_size) + '-' + str(index + 1)) else: table = AsciiTable(data, str(group_size) + '-' + str(index + 1)) table.outer_border = True table.inner_heading_row_border = True table.inner_column_border = True table.inner_row_border = True # max_width = table.column_max_width(1) # wrapped_string = '\n'.join(wrap(LONG_STRING, max_width)) # table.table_data[0][1] = wrapped_string if level == 'critical': logger.critical('\n' + table.table) elif level == 'warning': logger.warning('\n' + table.table) elif level == 'info': logger.info('\n' + table.table) elif level == 'debug': logger.debug('\n' + table.table) else: logger.error('\n' + table.table)
def tokenizer_stats(self, tokenizer): def chunk(iterable, n): for i in range(0, len(iterable), n): yield iterable[i:i + n] document_ids = [ hit.meta.id for hit in tokenizer.documents.search()[:100] ] sentence_counts = [ tokenizer.sentences.search().filter('term', document_id=doc).count() for doc in document_ids ] data = [[ '%s | %s' % pair for pair in zip(l, r) ] for l, r in zip(chunk(document_ids, 5), chunk(sentence_counts, 5))] table = SingleTable(data, title=' Documents: %d | Sentences: %d ' % ( tokenizer.documents.search().count(), tokenizer.sentences.search().count(), )) table.inner_heading_row_border = False self.stdout.write(table.table)
def summary_host_write(pkts, res): found_hosts = [] for pkt in pkts: if pkt.haslayer(IP): found_hosts.append(pkt[IP].src) found_hosts.append(pkt[IP].dst) found_hosts = set(found_hosts) for h in found_hosts: table_data.append(host_formatter(h, pkts)) print(f"{s} Hosts {s}") #if any(pkt.haslayer(ARP) for pkt in pkts): if len(table_data) == 0: table = SingleTable(table_data[1:]) else: table = SingleTable([[red("No hosts found")]]) table.inner_heading_row_border = False print(table.table) with open(res.HOST_WRITE, "w+") as host_write_file: host_write_file.write("\n".join(found_hosts)) host_write_file.close() print_info( f"Saved addresses of {len(found_hosts)} found hosts in {res.HOST_WRITE}" ) if res.OUTPUT: with open(res.OUTPUT, "a") as out_file: out_file.write(f"\n{table.table}\n") print("")
def view(server: GroupsServer, group_id: Union[str, int]): group = server.view(group_id) data = [['Id', group['id']], ['Name', group['name']]] if 'environment' in group and len(group['environment']) > 0: e = SingleTable([[key, value] for key, value in group['environment'].items()]) e.inner_heading_row_border = False e.outer_border = False e.inner_column_border = False data.append(['Environment', e.table]) table = SingleTable(data) table.inner_heading_row_border = False click.echo(table.table)
def print_table(data: List[List[str]] = None, title: str = '', colored_header: bool = True, no_borders: bool = False): if data is None: return # Make header blue if colored_header: for x in range(len(data[0])): data[0][x] = print_utils.color(data[0][x], 'blue') table = SingleTable(data) table.title = title table.inner_row_border = True if no_borders: table.inner_row_border = False table.inner_column_border = False table.outer_border = False table.inner_footing_row_border = False table.inner_heading_row_border = False print('') print(table.table) print('')
def box(cls, width, height, title=''): table_structure = [[' ' * (width - 2)] for x in range(height - 2)] table = SingleTable(table_structure, ' {} '.format(title)) table.inner_row_border = False table.inner_heading_row_border = False return table.table
def print_table(guessed_result): newlist = [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], guessed_result] table = SingleTable(newlist) table.inner_row_border = True table.inner_heading_row_border = False table.title = "Number List" # sp.call("clear",shell=True) print(table.table)
def pprint(self): """ Pretty prints the contents of the box """ table = SingleTable(self.boxes) table.inner_heading_row_border = False table.inner_row_border = True print(table.table)
def table_metrics(self): # Returns a printable table of metrics data = [[m, self.metrics[m][-1]] for m in self.metrics.keys()] table = SingleTable(data, self.experiment.name) table.inner_heading_row_border = True table.inner_row_border = True table.inner_column_border = True return table.table
def print_table(table_data,title=None): """Return table string to be printed.""" table_instance = SingleTable(table_data.tolist(), title) table_instance.inner_heading_row_border = False table_instance.inner_row_border = True # table_instance.justify_columns = {0: 'center', 1: 'center', 2: 'center'} print (table_instance.table)
def list_files(folder_path): ipa_files = [f for f in os.listdir(folder_path) if str(f).endswith(".ipa")] table_data = [[' * ', Color('{autoblue}%-40s{/autoblue}' % f)] for f in ipa_files] table = SingleTable(table_data) table.title = "All ipa files:" table.inner_column_border = False table.inner_heading_row_border = False print(table.table)
def show_sorted_gold(self): table = SingleTable(self.mat) table.title = Color('{blue}Sorted gold{/blue}') table.inner_row_border = True table.inner_heading_row_border = False for i in range(5): table.justify_columns[i] = 'center' print(table.table) print()
def gettable(headers, data): from terminaltables import SingleTable table = SingleTable([headers] + data) table.inner_heading_row_border = False table.inner_column_border = False table.outer_border = False return table
def display_latest_rankings(date=None, json_output=False, data_dir=None, esi_filename=None, esi_sheet_name=None): """Display ESI rankings in the console or output as JSON.""" BOLD = '\033[1m' ENDC = '\033[0m' GREEN = '\033[92m' RED = '\033[91m' indicators = [ 'esi', 'industrial_confidence', 'services_confidence', 'consumer_confidence', 'retail_confidence', 'construction_confidence' ] esi = ESIDataWrapper() if data_dir: esi.data_dir = data_dir if esi_filename: esi.esi_filename = esi_filename if esi_sheet_name: esi.esi_sheet_name = esi_sheet_name num_entries = len(esi.ESI_ENTITIES) rankings = esi.get_latest_rankings(date=date) if json_output: print(json.dumps(rankings)) else: table_data = [ # Headers. [ BOLD + 'ESI' + ENDC, 'Industrial Confidence (40%)', 'Services Confidence (30%)', 'Consumer Confidence (20%)', 'Retail Trade Confidence (5%)', 'Construction Confidence (5%)' ] ] for i in range(num_entries): if i == 0: tmpl = GREEN + '{} ({})' + ENDC elif i == 15: tmpl = RED + '{} ({})' + ENDC else: tmpl = '{} ({})' row = [ tmpl.format(rankings[indicator][i][0], rankings[indicator][i][1]) for indicator in indicators ] table_data.append(row) rankings_table = SingleTable(table_data) rankings_table.inner_heading_row_border = False rankings_table.inner_heading_row_border = True if date: rankings_table.title = 'Rankings for {}'.format(date) print(rankings_table.table)
def view(server: JobServer, job_id: Union[int, str]): current_job = server.view(job_id) data = [['Id', current_job['id']], ['Name/Description', current_job['name']], [ 'Alias', util.format_none(current_job['alias'] if 'alias' in current_job else '') ], ['Image:tag', f'{current_job["image"]}:{current_job["tag"]}'], ['Schedule', current_job['scheduleText']], ['Time Zone', current_job['timeZone']], ['Paused', current_job['paused']], ['Cron entry', current_job['schedule']], ['Cron Type', current_job['cronType']], ['EntryPoint', util.format_none(current_job['entryPoint'])], ['Groups', ','.join(current_job['groups'])], ['Created on', f"{current_job['createdOn']} (UTC)"], ['Last status', util.format_status(current_job['lastStatus'])], ['Updated on', f"{current_job['statusUpdateOn']} (UTC)"], [ 'Last run on', f"{current_job['lastRun']} ({current_job['timeZone']})" ], [ 'Next run on', f"{current_job['nextRun']} ({current_job['timeZone']})" ]] if 'environment' in current_job and len(current_job['environment']) > 0: e = SingleTable( [[key, value[:9] + ' ...' if len(value) > 14 else value] for key, value in current_job['environment'].items()]) e.inner_heading_row_border = False e.outer_border = False e.inner_column_border = False data.append(['Environment', e.table]) table = SingleTable(data) table.inner_heading_row_border = False click.echo(table.table)
def table_server_timings(): """Return table string to be printed.""" table_data = [ [Color('{autogreen}<10ms{/autogreen}'), '192.168.0.100, 192.168.0.101'], [Color('{autoyellow}10ms <= 100ms{/autoyellow}'), '192.168.0.102, 192.168.0.103'], [Color('{autored}>100ms{/autored}'), '192.168.0.105'], ] table_instance = SingleTable(table_data) table_instance.inner_heading_row_border = False return table_instance.table
def test(): #Windows.enable(auto_colors=True, reset_atexit=True) table_data = [ [Color('{autogreen}TITLE{/autogreen}'), '192.168.0.100, 192.168.0.101'], [Color('{autocyan}10ms <= 100ms{/autocyan}'), '192.168.0.102, 192.168.0.103'], [Color('{autored}>100ms{/autored}'), '192.168.0.105'], ] table = SingleTable(table_data) table.inner_heading_row_border = False print(table.table)
def table_server_status(): """Return table string to be printed.""" table_data = [ [Color('Low Space'), Color('{autocyan}Nominal Space{/autocyan}'), Color('Excessive Space')], [Color('Low Load'), Color('Nominal Load'), Color('{autored}High Load{/autored}')], [Color('{autocyan}Low Free RAM{/autocyan}'), Color('Nominal Free RAM'), Color('High Free RAM')], ] table_instance = SingleTable(table_data, '192.168.0.105') table_instance.inner_heading_row_border = False table_instance.inner_row_border = True table_instance.justify_columns = {0: 'center', 1: 'center', 2: 'center'} return table_instance.table
def hinton_diagram(arr, max_arr=None): max_arr = arr if max_arr is None else max_arr max_val = max(abs(np.max(max_arr)), abs(np.min(max_arr))) diagram = [list([hinton_diagram_value(x, max_val) for x in _arr]) for _arr in arr] table = SingleTable(diagram) table.inner_heading_row_border = False table.inner_footing_row_border = False table.inner_column_border = False table.inner_row_border = False table.column_max_width = 1 return table.table
def _print_deployment_summary(env): table_data = [ ["Project name:", env.project_name], ["Target:", env.target_name], ["User:"******"Host(s):", "; ".join(env.hosts)], ] table = SingleTable(table_data) table.title = Color('{autoyellow}Deployment configuration{/autoyellow}') table.justify_columns = {0: 'left', 1: 'left'} table.inner_row_border = False table.inner_heading_row_border = False _print_table(table)
def print_run_table(table_data): table = SingleTable(table_data) table.justify_columns = {0: 'left', 1: 'center', 2: 'left'} table.inner_heading_row_border = False table.inner_column_border = False table.outer_border = False max_width = table.column_max_width(2) for index, row in enumerate(table_data): table.table_data[index][2] = str(row[2][0:max_width].splitlines()[0]) if row[1] == 0: table.table_data[index][1] = colored(str(row[1]), 'green') elif row[1] == 1: table.table_data[index][2] = colored(str(row[1]), 'yellow') elif row[1] == 3: table.table_data[index][2] = colored(str(row[1]), 'grey') else: table.table_data[index][2] = colored(str(row[1]), 'red') print table.table
def fill_tabel(app): table_data = [ ['{0: <20}'.format('Title'),Color('{autoblue}%-50s{/autoblue}' % app.title)], ['{0: <20}'.format('URL'), Color('{autocyan}%s{/autocyan}' % app.url)], ['{0: <20}'.format('Price'), Color('{autogreen}%s{/autogreen}' % app.price)], ['{0: <20}'.format('Category'),Color('{autogreen}%s{/autogreen}' % app.category)], ['{0: <20}'.format('Release'),Color('{autogreen}%s{/autogreen}' % app.release)], ['{0: <20}'.format('Version') ,Color('{autogreen}%s{/autogreen}' % app.version)], ['{0: <20}'.format('Size'),Color('{autogreen}%s{/autogreen}' % app.size)], ['{0: <20}'.format('Language(s)'),Color('{autogreen}%s{/autogreen}' % app.language)], ['{0: <20}'.format('Developer'),Color('{autogreen}%s{/autogreen}' % app.developer)], ['{0: <20}'.format('Compatibility'),Color('{autogreen}%s...{/autogreen}' % ".".join(app.compatibility.split('.')[:2]))], ['{0: <20}'.format('Description:'),Color('{autocyan}%-50s{/autocyan}' % app.description)], ] table = SingleTable(table_data) table.inner_column_border = False table.inner_heading_row_border = False return table
def show_app_item(a): x = lambda s: Color('{autogreen}%s{/autogreen}' % s) y = lambda s: '{0: <20}'.format(s) table_data = [ [y('Title'), x(a.title)], [y('URL'), x(a.url)], [y('Price'), x(a.price)], [y('Category'), x(a.category)], [y('Release'), x(a.release)], [y('Version'), x(a.version)], [y('Size'), x(a.size)], [y('Language(s)'), x(a.language)], [y('Developer'), x(a.developer)], [y('Compatibility'), x(a.compatibility)], [y('Description:'), x(a.description)], ] table = SingleTable(table_data) table.inner_column_border = False table.inner_heading_row_border = False print(table.table)
def table_abcd(): """Return table string to be printed. Two tables on one line.""" table_instance = SingleTable([['A', 'B'], ['C', 'D']]) # Get first table lines. table_instance.outer_border = False table_inner_borders = table_instance.table.splitlines() # Get second table lines. table_instance.outer_border = True table_instance.inner_heading_row_border = False table_instance.inner_column_border = False table_outer_borders = table_instance.table.splitlines() # Combine. smallest, largest = sorted([table_inner_borders, table_outer_borders], key=len) smallest += [''] * (len(largest) - len(smallest)) # Make both same size. combined = list() for i, row in enumerate(largest): combined.append(row.ljust(10) + ' ' + smallest[i]) return '\n'.join(combined)
def handleDiscovery(self, dev, isNewDev, isNewData): if not isNewDev: return elif self.opts.mac is not None and dev.addr != self.opts.mac: return elif dev.rssi < self.opts.sensitivity: return vendor = vendors.find(dev.addr) vlabel = yellow( vendor + ' ' ) if vendor is not None else '?' clabel = green( u'\u2713' ) if dev.connectable else red( u'\u2715' ) dlabel = "(no data) " if not dev.scanData else "" title = " %s (%s dBm) %s" % ( bold(dev.addr), dev.rssi, dlabel ) tdata = [ [ 'Vendor', vlabel ], [ 'Allows Connections', clabel ], [ 'Address Type', dev.addrType] ] for ( tag, desc, val ) in dev.getScanData(): if desc == 'Flags': tdata.append([ 'Flags', self._parseFlags(val) ]) # short local name or complete local name elif tag in [8, 9]: try: tdata.append([ desc, yellow( val.decode('utf-8') ) ]) except UnicodeEncodeError: tdata.append([ desc, yellow( repr(val) ) ]) else: tdata.append([ desc, repr(val) ]) table = SingleTable(tdata, title) table.inner_heading_row_border = False print table.table + "\n"
from __future__ import print_function from colorclass import Color, Windows from terminaltables import SingleTable Windows.enable(auto_colors=True, reset_atexit=True) # Does nothing if not on Windows. table_data = [ [Color('{autobgred}{autogreen}<10ms{/autogreen}{/bgred}'), '192.168.0.100, 192.168.0.101'], [Color('{autoyellow}10ms <= 100ms{/autoyellow}'), '192.168.0.102, 192.168.0.103'], [Color('{autored}>100ms{/autored}'), '192.168.0.105'], ] table = SingleTable(table_data) table.inner_heading_row_border = False print() print(table.table) table.title = '192.168.0.105' table.justify_columns = {0: 'center', 1: 'center', 2: 'center'} table.inner_row_border = True table.table_data = [ [Color('Low Space'), Color('{autocyan}Nominal Space{/autocyan}'), Color('Excessive Space')], [Color('Low Load'), Color('Nominal Load'), Color('{autored}High Load{/autored}')], [Color('{autocyan}Low Free RAM{/autocyan}'), Color('Nominal Free RAM'), Color('High Free RAM')], ] print() print(table.table) table.title = None
def print_pokemon(self): sorted_mons = sorted(self.pokemon, key=lambda k: (k['pokedex_number'], -k['iv_percent'])) groups = groupby(sorted_mons, key=lambda k: k['pokedex_number']) table_data = [ [u'Pokémon', 'Level', 'CP', 'IV %', 'ATK', 'DEF', 'STA', 'Candy', 'Recommendation'] ] total_evolutions = 0 total_transfers = 0 print u'%d Pokémon found.' % len(sorted_mons) for key, group in groups: group = list(group) pokemon_name = self.pokemon_list[str(key)] best_iv_pokemon = max(group, key=lambda k: k['iv_percent']) best_iv_pokemon['best_iv'] = True candy_count=self.candy[key] result = pogotransfercalc.calculate( pokemon_count=len(group), candy_count=candy_count, pokedex_number=key) evolutions = result['evolutions'] total_evolutions += evolutions if evolutions: for pokemon in group[:evolutions]: pokemon['message'] = 'evolve' transfers = result['transfers'] transfer_count = 0 if transfers: for pokemon in reversed(group[evolutions:]): if pokemon['is_favorite']: pokemon['message'] = u'keep (★)' continue if pokemon['has_costume']: pokemon['message'] = u'keep (costume)' continue if pokemon['is_shiny']: pokemon['message'] = u'keep (shiny)' continue if pokemon['iv_percent'] < self.config.iv: pokemon['message'] = 'transfer' pokemon['transfer'] = True transfer_count += 1 total_transfers += 1 if transfer_count == transfers: break continue for pokemon in group: if pokemon['iv_percent'] >= self.config.iv: iv_msg = u'(IV ≥ %d%%)' % self.config.iv if 'message' in pokemon: pokemon['message'] += ' %s' % iv_msg else: pokemon['message'] = 'keep %s' % iv_msg row_data = [ pokemon_name + pokemon['gender'] + (u'✨' if pokemon['is_shiny'] else '') + (u'☃' if pokemon['has_costume'] else '') + (u'★' if pokemon['is_favorite'] else ''), pokemon['level'], pokemon['cp'], '{0:.0f}%'.format(pokemon['iv_percent']), pokemon['attack'], pokemon['defense'], pokemon['stamina'], candy_count, pokemon.get('message', '') ] table_data.append(row_data) table = SingleTable(table_data) table.justify_columns = { 0: 'left', 1: 'right', 2: 'right', 3: 'right', 4: 'right', 5: 'right', 6: 'right', 7: 'right' } print table.table table = SingleTable([ ['Total suggested transfers', format_number(total_transfers)], ['Total evolutions', format_number(total_evolutions)], ['Total XP from evolutions', format_number(total_evolutions * 500)], ['Total XP from evolutions with lucky egg', format_number(total_evolutions * 1000)], ]) table.inner_heading_row_border = False table.justify_columns = { 0: 'left', 1: 'right' } print table.table