def main(): infile = raw_input('Input file name: ') if os.path.exists(infile): print '\n[!] Loading PCAP file. Please wait, it might take a while...' ips = sorted(set(p[IP].src for p in PcapReader(infile) if IP in p)) total = len(ips) print '[!] Total number of IP addresses: %d\n' % total bar = Bar('Processing', max=total) for ip in ips: get_data(ip) bar.next() bar.finish() headers = ['IP', 'OWNER','COUNTRY', 'ORGANIZATION','SERVER','DESCRIPTION'] print '\n\n' print tabulate(table,headers,tablefmt='grid') if exceptions: print '\nExceptions:' for e in exceptions: print '*\t%s' % e print '\n\n[!] Done.\n\n' else: print '[!] Cannot find file "%s"\n\tExiting...' % infile sys.exit()
def print_domain_templates(self,templates): ''' Print template details List of templates provided in templates argument ''' #Create table and table headers table = [] headers = ["Name","Description","TemplateId"] if type(templates) is list: #Print domain template parameters for template in templates: entry = [] entry.append(template.name) entry.append(template.description) entry.append(template.id) table.append(entry) else: entry = [] entry.append(templates.name) entry.append(templates.description) entry.append(templates.id) table.append(entry) print tabulate(table,headers)
def __str__(self): try: self.check() except ValueError as e: return e.message poolitems = sorted(self.pools.items(), key=lambda pitem: pitem[1].hashrate, reverse=True) totalhashrate = self.calc_totalhashrate() headers = ["Name", "HR (Thps)", "Prop", "MBS", "MFR", "AKN", "BKN", "MFR.mean", "MFR.std", "MFR.bias"] table = [[ name, pool.hashrate*1e-12, pool.hashrate/totalhashrate, pool.maxblocksize, pool.minfeerate, pool.mfrstats['abovekn'], pool.mfrstats['belowkn'], pool.mfrstats['mean'], pool.mfrstats['std'], pool.mfrstats['bias']] for name, pool in poolitems] poolstats = tabulate(table, headers=headers) meanblocksize = sum([row[2]*row[3] for row in table]) maxcap = meanblocksize*self.blockrate table = [ ("Block interval (s)", 1 / self.blockrate), ("Total hashrate (Thps)", totalhashrate*1e-12), ("Max capacity (bytes/s)", maxcap) ] miscstats = tabulate(table) return poolstats + '\n' + miscstats
def dumpProfile(self): """ Print region profiling information in a nice format. """ print "Profiling information for {}".format(type(self).__name__) totalTime = 0.000001 for region in self.network.regions.values(): timer = region.computeTimer totalTime += timer.getElapsed() count = 1 profileInfo = [] for region in self.network.regions.values(): timer = region.computeTimer count = max(timer.getStartCount(), count) profileInfo.append([region.name, timer.getStartCount(), timer.getElapsed(), 100.0*timer.getElapsed()/totalTime, timer.getElapsed()/max(timer.getStartCount(),1)]) profileInfo.append(["Total time", "", totalTime, "100.0", totalTime/count]) print tabulate(profileInfo, headers=["Region", "Count", "Elapsed", "Pct of total", "Secs/iteration"], tablefmt = "grid", floatfmt="6.3f") if self.tmRegion is not None: if self.tmRegion.getSpec().commands.contains("prettyPrintTraces"): self.tmRegion.executeCommand(["prettyPrintTraces"])
def displayGraph(ingredientMap): # Display graph # list of foods foodNodes = ingredientMap.m.values() # table for display numNodeComb = 0 numNodeSep = 0 displayTable = [ [row,"nameFood",[]] for row in range(len(foodNodes)) ] for eachFood in foodNodes: displayTable[eachFood.getIndex()][1] = eachFood.getName() for i,each in enumerate(ingredientMap.adjList): stringChild = [str(eachChild) for eachChild in each ] if (len(stringChild) > 1): numNodeSep +=1 elif (len(stringChild) == 1): numNodeComb += 1 stringChild = ",".join(stringChild) displayTable[i][2] = stringChild # global countComb, countSep # countComb += numNodeComb # countSep += numNodeSep print tabulate(displayTable, headers=["node-id","node-form", "child-id"]) # originalTextsWithEdge = [] # for each in originalTexts: # if each in dictTextEdge.keys(): # originalTextsWithEdge.append("\nEDGE:"+each +'\n'+ str(dictTextEdge[each])+"\n") # else: # originalTextsWithEdge.append(each)
def output(matrix): tmp = [[''] * 4 for _ in range(4)] for i in range(4): for j in range(4): if matrix[i][j] != 0: tmp[i][j] = matrix[i][j] print tabulate.tabulate(tmp, tablefmt = 'grid')
def printTableRowsAvg(sumTuples, countTuples, columns): rows = [] if len(sumTuples) == 1 and countTuples[0][0] == 0: if len(columns) == 2: rows.append(["NULL", "NULL"]) else: rows.append(["NULL"]) print(tabulate(rows, headers = columns)) return else: if len(columns) == 2: counts = dict(countTuples) for row in sumTuples: newRow = list(row) encryptedSalaryHex = newRow[0] encryptedSalary = newRow[0][:-1].decode('hex_codec') encryptLength = len(encryptedSalary) ffiUC_encryptedSalary = ffi.new("unsigned char[%i]" % encryptLength, encryptedSalary) newRow[0] = float(int(cryptoLib.decrypt_num(cryptoLib.toData(ffiUC_encryptedSalary), keys.public, keys.private, encryptLength))) / counts[newRow[1]] rows.append(newRow) print(tabulate(rows, headers = columns)) return else: counts = countTuples[0][0] for row in sumTuples: newRow = list(row) encryptedSalaryHex = newRow[0] encryptedSalary = newRow[0][:-1].decode('hex_codec') encryptLength = len(encryptedSalary) ffiUC_encryptedSalary = ffi.new("unsigned char[%i]" % encryptLength, encryptedSalary) newRow[0] = float(int(cryptoLib.decrypt_num(cryptoLib.toData(ffiUC_encryptedSalary), keys.public, keys.private, encryptLength))) / counts rows.append(newRow) print(tabulate(rows, headers = columns)) return
def construct_SCL_table(pv_methods): table = [] i = 0 #collect domain pairs for method in pv_methods: if i == 0: m_list = collect_accuracy("../work/batchSCL.%s.csv"%method) pairs = [x[0] for x in m_list] i+=1 # use pairs to collect accuracies for pair in sorted(pairs): tmp = [] tmp.append(pair) for method in pv_methods: if "landmark" in method: m_list = construct_best_landmark(collect_params('SCL',method)) tmp.append([x[2] for x in m_list if x[0]==pair][0]) m_list = construct_best_landmark(collect_params_on_server('SCL',method)) tmp.append([x[2] for x in m_list if x[0]==pair][0]) else: m_list = collect_accuracy("../work/batch%s.%s.csv"% ('SCL', method)) tmp.append([x[2] for x in m_list if x[0]==pair][0]) m_list = collect_accuracy("../work/temp/batch%s.%s.csv"% ('SCL', method)) tmp.append([x[2] for x in m_list if x[0]==pair][0]) best = max(tmp[1:]) best_idx = [i for i, j in enumerate(tmp) if j == best] new_tmp = ["\\textbf{%.2f}"%x if x == best else x for x in tmp] # print pair,[convert(pv_methods[i-1]) for i in best_idx],best table.append(new_tmp) headers = ['S-T']+sum([[convert(x)+'(S,T)',convert(x)+'(T)'] for x in pv_methods],[]) print tabulate(table,headers,floatfmt=".2f") pass
def highest_dividend(): nshares = defaultdict(lambda: 1) for order in orders(): nshares[order[1]] = nshares[order[1]] + order[3] sortsec = sorted(securities(), key=(lambda x: x[1] * x[2] / nshares[x[0]]), reverse=True) table = map(lambda sec: [sec[0], sec[1] * sec[2] / nshares[sec[0]], sec[1] * sec[2], nshares[sec[0]]], sortsec) print tabulate(table, headers=["Ticker", "Dividend per Share", "Total Dividend", "Shares being traded"])
def main(): parser = argparse.ArgumentParser(description="List available subtitles for a show") parser.add_argument("show", help="Show you want to list the subtitles for") parser.add_argument("-s", "--season", help="Season you want to list", type=int, default=1) parser.add_argument("-l", "--language", help="Language you want to list subtitles in", default='en') args = parser.parse_args() os = OpenSubtitles() os.login(username=None, password=None) show_name = args.show sub_language = args.language season = str(args.season) results = os.search_subtitles([{'sublanguageid': sub_language, 'query': show_name, 'season': season}]) sorted_results = sorted(results, key=lambda x: int(x['SeriesEpisode'])) table = [] for result in sorted_results: name = result['MovieName'].strip() match_exact_show_name_regex = r'\"{}\"'.format(show_name) if re.search(match_exact_show_name_regex, name): username_raw = result['UserNickName'] username = username_raw if username_raw else 'nobody' size = result['SubSize'] date_raw = result['SubAddDate'] date = datetime.strptime(date_raw, '%Y-%m-%d %H:%M:%S') filename = result['SubFileName'] table.append(['-r--r--r--', '1', username, username, size, date.strftime('%b %d %H:%M'), filename]) print "total {}".format(len(table)) print tabulate(table, tablefmt="plain")
def load_lots_of_items(): char = poe_lib.Character() js = open("items.json").read().strip().decode('ascii', 'ignore') items = json.loads(js) weapon_types = {} words = {} for _, item, _ in items: if isinstance(item, dict): typ = item['typeLine'].lower() for word in typ.split(" "): words.setdefault(word, 0) words[word] += 1 checks = ['sword', 'mace', 'stave', 'flask', 'shield', 'greaves', 'boots'] for check in checks: if check in typ: weapon_types.setdefault(check, 0) weapon_types[check] += 1 break else: weapon_types.setdefault("unk", 0) weapon_types["unk"] += 1 pprint.pprint(sorted(words.items(), key=lambda a: a[1])) pprint.pprint(sorted(weapon_types.items(), key=lambda a: a[1])) data = [eff.tabulate() for eff in char.effects] print tabulate.tabulate(data, headers=["Effect Magnitude", "Requirement to Effect", "Effects", "Source", "Original Text"])
def sensorInfos(args): requireSensorID(args) params = extractParams(args) if 'tail' not in params: params['tail'] = 1 obj = lib.Sensor(args.directory, args.sensorid, args.type) infos = obj.SensorInfos(**params) if not infos: print "Not enought datas for %s" % args.sensorid sys.exit(1) showresult = [ ['Sensorid', args.sensorid], #['Sensor Type', obj.configs['type']], ['NB lines', str(infos['nblines'])], ['Min date', format_datetime(infos['mindate'])], ['Max date', format_datetime(infos['maxdate'])], ['Min value', '%s (%s)' % (str(infos['minvalue']), format_datetime(infos['minvaluedate']))], ['Max value', '%s (%s)' % (str(infos['maxvalue']), format_datetime(infos['maxvaluedate']))], # ['Avg size', str(infos['avgsize'])], ['Avg value', str(infos['avgvalue'])], ['Avg delta (round ratio)', str(infos['avgdelta'])], # ['Total size', '%s Mo' % str(infos['avgsize'] * infos['nblines'] / 1024 / 1024.0)], ] header = ['Title', 'Value'] print tabulate(showresult, headers=header)
def bridgemem_details(self): """ :return: list vlans or bridge names of various stp states MODIFY """ if not self.iface.is_bridgemem(): return None # check if port is in STP _str = '' _stpstate = self.iface.stp.state # get the list of states by grabbing all the keys if self.iface.vlan_filtering: _vlanlist = self.iface.vlan_list _header = [_("all vlans on l2 port")] _table = [[', '.join(linux_common.create_range('', _vlanlist))]] _str += tabulate(_table, _header, numalign='left') + self.new_line() _header = [_("untagged vlans")] _table = [[', '.join(self.iface.native_vlan)]] _str += tabulate(_table, _header, numalign='left') + self.new_line() for _state, _bridgelist in _stpstate.items(): if _bridgelist: _header = [_("vlans in %s state") % (inflection.titleize(_state))] # if vlan aware and bridgelist is not empty, then assume # all vlans have that stp state if self.iface.vlan_filtering: _table = [[', '.join(linux_common.create_range( '', _vlanlist))]] else: _table = [self._pretty_vlanlist(_bridgelist)] _str += tabulate(_table, _header, numalign='left') + self.new_line() return _str
def print_events(conn, stack_name, follow, lines=100, from_dt=datetime.fromtimestamp(0, tz=pytz.UTC)): """Prints tabulated list of events""" events_display = [] seen_ids = set() next_token = None while True: events, next_token = get_events(conn, stack_name, next_token) status = get_stack_status(conn, stack_name) normalize_events_timestamps(events) if follow: events_display = [(ev.timestamp.astimezone(tzlocal.get_localzone()), ev.resource_status, ev.resource_type, ev.logical_resource_id, ev.resource_status_reason) for ev in events if ev.event_id not in seen_ids and ev.timestamp >= from_dt] if len(events_display) > 0: print(tabulate(events_display, tablefmt='plain'), flush=True) seen_ids |= set([event.event_id for event in events]) if status not in IN_PROGRESS_STACK_STATES and next_token is None: break if next_token is None: time.sleep(5) else: events_display.extend([(event.timestamp.astimezone(tzlocal.get_localzone()), event.resource_status, event.resource_type, event.logical_resource_id, event.resource_status_reason) for event in events]) if len(events_display) >= lines or next_token is None: break if not follow: print(tabulate(events_display[:lines], tablefmt='plain'), flush=True) return status
def show(self, header=True): print if header: print self.table_header + ":" print table = copy.deepcopy(self.cell_values) print tabulate.tabulate(table, headers=self.col_header, numalign="left", stralign="left") print
def handle_party_list(data): wanted = "name series_id acc atk def eva matk mdef mnd series_acc series_atk series_def series_eva series_matk series_mdef series_mnd" topn = OrderedDict() topn["atk"] = 5 topn["matk"] = 2 topn["mnd"] = 2 topn["def"] = 5 find_series = [101001, 102001, 104001, 105001, 106001, 107001, 108001, 110001] equips = defaultdict(list) for item in data["equipments"]: kind = item.get("equipment_type", 1) heapq.heappush(equips[kind], Equipment(slicedict(item, wanted))) for series in find_series: print "Best equipment for FF{0}:".format((series - 100001) / 1000) # Need to use lists for column ordering tbl = ["stat n weapon stat n armor stat n accessory".split()] tbldata = [[],[],[],[]] for itemtype in range(1, 4): ## 1, 2, 3 for stat, count in topn.iteritems(): for equip in best_equipment(series, equips[itemtype], stat, count): name = equip["name"].replace(u"\uff0b", "+") tbldata[itemtype].append([stat, equip[stat], name]) # Transpose data for idx in range(0, len(tbldata[1])): tbl.append(tbldata[1][idx] + tbldata[2][idx] + tbldata[3][idx]) print tabulate(tbl, headers="firstrow") print ""
def show_summary_all(db_server, db_port, db_name, db_collection): pattern = {} print "-" * 60 print "Summary Data: " print "-" * 60 data = pns_mongo.pns_search_results_from_mongod(db_server, db_port, db_name, db_collection, pattern) for record in data: print_record_header(record) for flow in record['flows']: print_flow_header(flow) # Display the results for each flow. cols = ['throughput_kbps', 'protocol', 'tool', 'rtt_ms', 'loss_rate', 'pkt_size', 'rtt_avg_ms'] result_list = get_results_info(flow['results'], cols) print tabulate.tabulate(result_list, headers="keys", tablefmt="grid") print "\n"
def main(): print''' Welcome to La-Z-Boy For the love of good content ''' print("If you want to check movies movies on a channel select 1") print("To get movies of a specific Genre select 2") choice=raw_input("Enter choice: ") if(str(choice)=='1'): #channel = raw_input("Enter name of the TV Channel: ") channel2 = raw_input("Enter name of the TV Channel: ") #channel = "-".join([item.strip() for item in channel.split(" ")]) if(len(channel2.split())>1): channel2 = "-".join([item.strip() for item in channel2.split(" ")]) channel2 = channel2.title() else: channel2 = channel2.strip() channel2 = channel2.upper() movie_rating = search_channel(channel2) else: genre = raw_input("Enter Genre: (like comedy, action ....) ") no_of_channel = raw_input("Enter No of channels to check (e.g, 1-44)") genre_recommend(genre, no_of_channel) print '\nNumber of movies of genre ' + genre.upper()+' found : ' + str(len(movies_of_my_genre)) get_ratings(movies_of_my_genre) sorted_list = sorted(movies_of_my_genre, key=lambda movie: movie.movie_rating, reverse=True) headers = ['Movies','Channel','Time', 'Rating'] data_movies2 = [] for movie in islice(sorted_list, 5): data_movies2.append([movie.movie_name.replace('\t', ''), movie.movie_channel.replace('\t', ''), movie.movie_start+"-"+movie.movie_end, movie.movie_rating]) print tabulate(data_movies2, headers=headers)
def tabulate(cls, data, fields, headers={}): """ Prints a tabulate version of data Args: data: something to disply """ if isinstance(data, str): print(tabulate([[data]], tablefmt=Printer.TABULATE_FORMAT)) elif isinstance(data, dict): print(tabulate([data], headers=headers, tablefmt=Printer.TABULATE_FORMAT)) elif isinstance(data, list): results = [] for obj in data: if isinstance(obj, NURESTObject): results.append(cls._object_to_dict(obj, fields)) else: results.append([obj]) print(tabulate(results, headers=headers, tablefmt=Printer.TABULATE_FORMAT)) else: dictionary = cls._object_to_dict(data, fields) result = [(key, value) for key, value in dictionary.items()] print(tabulate(result, headers=headers, tablefmt=Printer.TABULATE_FORMAT))
def after(self): def fmt_date(dt): if not dt: return '' return dt.strftime('%Y-%m-%d %H:%M') def fmt_dur(d): if not d: return '' return '%0.1f' % (d / 60.0) s=Storage(self.config['storage_root']) stats=s.get_status() tab=[] for vm in self.result: stat=stats.get(vm) row=self.result[vm] if stat: row.append(fmt_date(stat['last_backup'])) row.append(fmt_dur(stat['duration'])) else: row.extend(['', '']) tab.append(row) for vm in stats: if not self.result.has_key(vm): tab.append(['', vm, '', '', '', fmt_date(stats[vm]['last_backup']), fmt_dur(stats[vm]['duration'])]) print tabulate(tab, ['Host', 'VM', 'State', 'AutoBck', 'AutoBck Batch', 'Last Backup', 'Dur. (m)'])
def parse(self, response): htmlresponseinit = HtmlXPathSelector(text=response.body).select('//div[@id="browseJobs"]') i_range = range(13) for sel in htmlresponseinit: items = [] for i in i_range: item = FreelancerscraperItem() id_a_link = "jobCat" + str(i) + "_heading" id_ul_link = "jobCat" + str(i) parent_categ_name = sel.select('p/strong/a[@id="' + id_a_link + '"]/text()').extract() item['parent_categ_name'] = parent_categ_name categ_and_count_string = (sel.select('ul[@id="' + id_ul_link + '"]/li/a/text()').extract()) result = {} for categ_and_count in categ_and_count_string: # Electronics (1234) categ = categ_and_count.split("(")[0].strip() count = re.findall(r'\d+', categ_and_count)[0] result[categ] = int(count) sorted_result = sorted(result.items(), key=operator.itemgetter(1), reverse = True) item['categ_name_count'] = sorted_result items.append(item) for item in items: print "--------------*******------------------------------*******----------------" print tabulate(item['categ_name_count'], ["CATEGORY: " + "".join(item['parent_categ_name']), "Count"], tablefmt="grid") yield None
def tail(self, rows=10, cols=200, **kwargs): """ Analgous to R's `tail` call on a data.frame. Display a digestible chunk of the H2OFrame starting from the end. :param rows: Number of rows to display. :param cols: Number of columns to display. :param kwargs: Extra arguments passed from other methods. :return: None """ if self._vecs is None or self._vecs == []: raise ValueError("Frame Removed") nrows = min(self.nrow(), rows) ncols = min(self.ncol(), cols) colnames = self.names()[0:ncols] exprs = [self[c][(self.nrow()-nrows):(self.nrow())] for c in range(ncols)] print "Last", str(nrows), "rows and first", str(ncols), "columns: " if nrows != 1: fr = H2OFrame.py_tmp_key() cbind = "(= !" + fr + " (cbind %" cbind += " %".join([expr.eager() for expr in exprs]) + "))" res = h2o.rapids(cbind) h2o.remove(fr) tail_rows = [range(self.nrow()-nrows+1, self.nrow() + 1, 1)] tail_rows += [rows[0:nrows] for rows in res["head"][0:ncols]] tail = zip(*tail_rows) print tabulate.tabulate(tail, headers=["Row ID"] + colnames) else: print tabulate.tabulate([[self.nrow()] + [expr.eager() for expr in exprs]], headers=["Row ID"] + colnames) print
def main(): parser = argparse.ArgumentParser( description='Finds spare change using CSV exported from Mint!') parser.add_argument('filename', type=str, help='Filename to read for csv.') parser.add_argument('-y', '--years', type=int, default=5, help='The number of previous years (including current) to print.') args = parser.parse_args() # Ensure that the file exists that user provides. if not os.path.isfile(args.filename): print "ERROR: {0} does not exist! Please specify a valid file!".format( args.filename) sys.exit(1) # Determine the start date for grabbing the values. TODAY = datetime.datetime.now() start_date = datetime.datetime( TODAY.year - args.years + 1, 1, 1) spare_change = collections.OrderedDict( {"Month" : calendar.month_abbr[1:13] + ["Total"]}) # Open the CSV file and parse each row. with open(args.filename, 'rb') as csvfile: dictreader = csv.DictReader(csvfile) for row in dictreader: date = datetime.datetime.strptime(row['Date'], '%m/%d/%Y') # If the date is greater than the start date, accumlate values. if date > start_date: # See if the year exist in the dictionary yet and create # the list if not. We use None here instead of 0 so the table # does not print values that are zero. if date.year not in spare_change: spare_change[date.year] = [None] * (MONTHS_IN_YEAR + 1) # Calculate the change and then add the amount to the list # in the dictionary. Index is the month offset by 1 since # the list starts with 0. dollars = float(row['Amount']) change = dollars - math.floor(dollars) if spare_change[date.year][date.month - 1] is None: spare_change[date.year][date.month - 1] = change else: spare_change[date.year][date.month - 1] += change if spare_change[date.year][12] is None: spare_change[date.year][12] = change else: spare_change[date.year][12] += change # Print the results. print tabulate(spare_change, headers="keys", floatfmt=".2f")
def processDatabase(dbfile,free_params): con = sqlite3.connect(dbfile) cur = con.cursor() cur.execute('SELECT ParamName,Value,GaussianPrior,Scale,Max,Min,Fixed from SystematicParams ORDER BY ParamName') data = cur.fetchall() try: print tabulate(data,headers=["Name","Value","GaussianPrior","Scale","Max","Min","Fixed"],tablefmt="grid") except: print "PARAMETER TABLE: \n" col_names = [col[0] for col in cur.description] print " %s %s %s %s %s %s %s" % tuple(col_names) for row in data: print " %s %s %s %s %s %s %s" % row # Convert all row's angles from degrees to rad: for irow,row in enumerate(data): if 'theta' in row[0]: row = list(row) row[1] = np.deg2rad(row[1]) if row[2] is not None: row[2] = np.deg2rad(row[2]) row[4] = np.deg2rad(row[4]) row[5] = np.deg2rad(row[5]) data[irow] = row params = {} for row in data: prior_dict = {'kind': 'uniform'} if row[2] is None else {'fiducial': row[1], 'kind': 'gaussian', 'sigma': row[2]} params[row[0]] = {'value': row[1], 'range': [row[5],row[4]], 'fixed': bool(row[6]),'scale': row[3], 'prior': prior_dict} # now make fixed/free: if free_params is not None: # modify the free params to include the '_ih'/'_nh' tags: mod_free_params = [] for p in free_params: if ('theta23' in p) or ('deltam31' in p): mod_free_params.append(p+'_ih') mod_free_params.append(p+'_nh') else: mod_free_params.append(p) print "\nmod free params: ",mod_free_params #Loop over the free params and set to fixed/free for key in params.keys(): if key in mod_free_params: params[key]['fixed'] = False else: params[key]['fixed'] = True if not params[key]['fixed']: print " Leaving parameter free: ",key print " ...all others fixed!" return params
def __mk_volume_table(table, ty, headers=(), **kwargs): if ty == 'global': return tabulate(table, headers=headers, tablefmt=global_tablefmt, **kwargs) elif ty == 'byweek': return tabulate(table, headers=headers, tablefmt=byweek_tablefmt, **kwargs) elif ty == 'rank': return tabulate(table, headers=headers, tablefmt=rank_tablefmt, **kwargs)
def pprint(cls, struct, data=None, format='pprint'): # TODO: maybe refactor to struct._pprint_ name = struct._name_() payload = struct._dump_() payload_hex = hexlify(payload) if data: payload_data = list(data.items()) else: payload_data = list(cls.to_dict(struct).items()) if format == 'pprint': print 'name:', name print 'hex: ', payload_hex pprint(payload_data, indent=4, width=42) elif format == 'tabulate-plain': separator = ('----', '') output = [ separator, ('name', name), separator, ] output += StructAdapter.binary_reprs(payload) output += [separator] output += payload_data print tabulate(output, tablefmt='plain') #print tabulate(list(meta.items()), tablefmt='plain') #print tabulate(payload_data, missingval='n/a', tablefmt='simple') else: raise ValueError('Unknown format "{}" for pretty printer'.format(format))
def print_tabulate(res, noheader=False, short=False): config = read_config() c = conn(config) tbl = [] for i in res: if not i.__dict__.has_key('passwordenabled'): i.__setattr__('passwordenabled', 0) if not i.__dict__.has_key('created'): i.__setattr__('created', '') if i.passwordenabled == 1: passw = "Yes" else: passw = "No" if short: tbl.append(["%s/%s" % (i.account, i.name)]) else: tbl.append([ "%s/%s" % (i.account, i.name), i.zonename, i.ostypename, i.created, passw, ]) tbl = sorted(tbl, key=operator.itemgetter(0)) if (noheader or short): print tabulate(tbl, tablefmt="plain") else: tbl.insert(0, ['name', 'zone', 'ostype', 'created', 'passwordenabled']) print tabulate(tbl, headers="firstrow")
def head(self, rows=10, cols=200, **kwargs): """ Analgous to R's `head` call on a data.frame. Display a digestible chunk of the H2OFrame starting from the beginning. :param rows: Number of rows to display. :param cols: Number of columns to display. :param kwargs: Extra arguments passed from other methods. :return: None """ if self._vecs is None or self._vecs == []: raise ValueError("Frame Removed") nrows = min(self.nrow(), rows) ncols = min(self.ncol(), cols) colnames = self.names()[0:ncols] fr = H2OFrame.py_tmp_key() cbind = "(= !" + fr + " (cbind %" cbind += " %".join([vec._expr.eager() for vec in self]) + "))" res = h2o.rapids(cbind) h2o.remove(fr) head_rows = [range(1, nrows + 1, 1)] head_rows += [rows[0:nrows] for rows in res["head"][0:ncols]] head = zip(*head_rows) print "First", str(nrows), "rows and first", str(ncols), "columns: " print tabulate.tabulate(head, headers=["Row ID"] + colnames) print
def showPfcAsym(interface): """ PFC handler to display asymmetric PFC information. """ i = {} table = [] key = [] header = ('Interface', 'Asymmetric') configdb = swsssdk.ConfigDBConnector() configdb.connect() if interface: db_keys = configdb.keys(configdb.CONFIG_DB, 'PORT|{0}'.format(interface)) else: db_keys = configdb.keys(configdb.CONFIG_DB, 'PORT|*') for i in db_keys or [None]: if i: key = i.split('|')[-1] if key and key.startswith('Ethernet'): entry = configdb.get_entry('PORT', key) table.append([key, entry.get('pfc_asym', 'N/A')]) sorted_table = natsorted(table) print '\n' print tabulate(sorted_table, headers=header, tablefmt="simple", missingval="") print '\n'
def describe(self): """ Generate an in-depth description of this H2OFrame. The description is a tabular print of the type, min, max, sigma, number of zeros, and number of missing elements for each H2OVec in this H2OFrame. :return: None (print to stdout) """ if self._vecs is None or self._vecs == []: raise ValueError("Frame Removed") print "Rows:", len(self._vecs[0]), "Cols:", len(self) headers = [vec._name for vec in self._vecs] table = [ self._row('type', None), self._row('mins', 0), self._row('mean', None), self._row('maxs', 0), self._row('sigma', None), self._row('zero_count', None), self._row('missing_count', None) ] chunk_summary_tmp_key = H2OFrame.send_frame(self) chunk_summary = h2o.frame(chunk_summary_tmp_key)["frames"][0]["chunk_summary"] h2o.remove(chunk_summary_tmp_key) print tabulate.tabulate(table, headers) print print chunk_summary print
async def statusset_list(self, ctx: commands.Context, service: Optional[ServiceConverter]): """ List that available services and ones are used in this server. Optionally add a service at the end of the command to view detailed settings for that service. """ # this needs refactoring # i basically copied and pasted in rewrite # maybe stick the two sections in .utils if TYPE_CHECKING: guild = Guild() else: guild = ctx.guild unused_feeds = list(FEEDS.keys()) if service: data = [] for channel in guild.channels: feeds = await self.config.channel(channel).feeds() restrictions = await self.config.guild( guild).service_restrictions() for name, settings in feeds.items(): if name != service.name: continue mode = settings["mode"] webhook = settings["webhook"] if channel.id in restrictions.get(service, []): restrict = True else: restrict = False data.append([f"#{channel.name}", mode, webhook, restrict]) table = box( tabulate(data, headers=[ "Channel", "Send mode", "Use webhooks", "Restrict" ])) await ctx.send( f"**Settings for {service.name}**: {table}\n`Restrict` is whether or not to " f"restrict access for {service.name} server-wide in the `status` command. Members " "are redirected to an appropriate channel.") else: guild_feeds: Dict[str, List[str]] = {} for channel in guild.channels: feeds = await self.config.channel(channel).feeds() for feed in feeds.keys(): try: guild_feeds[feed].append(f"#{channel.name}") except KeyError: guild_feeds[feed] = [f"#{channel.name}"] if not guild_feeds: msg = "There are no status updates set up in this server.\n" else: msg = "" data = [] for name, settings in guild_feeds.items(): if not settings: continue data.append([name, humanize_list(settings)]) try: unused_feeds.remove(name) except Exception: pass if data: msg += "**Services used in this server:**" msg += box(tabulate(data, tablefmt="plain"), lang="arduino") # cspell:disable-line if unused_feeds: msg += "**Other available services:** " msg += inline_hum_list(unused_feeds) msg += ( f"\nTo see settings for a specific service, run `{ctx.clean_prefix}statusset " "list <service>`") await ctx.send(msg)
def analyze_all_continuous(self): list_tables = Database.get_table_names(Database.database_name) iter = 0 func_names = {} for table in list_tables: if (table.split('_')[0] != 'Comp'): func_name = table.split('_')[3] if (func_names.get(func_name, -1) == -1): func_names[str(func_name)] = iter iter += 1 acc_matrix = [['' for x in range(7)] for x in range(iter)] rec_matrix = [['' for x in range(7)] for x in range(iter)] prec_matrix = [['' for x in range(7)] for x in range(iter)] iter = -1 x = 0 for table in list_tables: print(table) if (table.split('_')[0] != 'Comp'): func_name = table.split('_')[3] result = ClassifyMusic.run(table, 5, [1, 2, 3, 4, 5, 6], False) string = acc_matrix[func_names.get(func_name)] array = [func_name, result[0][2], result[1][2], result[2][2], result[3][2], result[4][2], result[5][2]] if (string[0] == ''): acc_matrix[func_names.get(func_name)] = array else: arr = [a + '-' + b for a, b in zip(string, array)] acc_matrix[func_names.get(func_name)] = arr array = [func_name, result[0][3], result[1][3], result[2][3], result[3][3], result[4][3], result[5][3]] if (string[0] == ''): prec_matrix[func_names.get(func_name)] = array else: arr = [a + '-' + b for a, b in zip(string, array)] prec_matrix[func_names.get(func_name)] = arr array = [func_name, result[0][4], result[1][4], result[2][4], result[3][4], result[4][4], result[5][4]] if (string[0] == ''): rec_matrix[func_names.get(func_name)] = array else: arr = [a + '-' + b for a, b in zip(string, array)] rec_matrix[func_names.get(func_name)] = arr avg_acc_matrix = cont_create_tables(acc_matrix) avg_rec_matrix = cont_create_tables(rec_matrix) avg_prec_matrix = cont_create_tables(prec_matrix) print('-------------------------------------------------------------------') print('------------------------------------acc matrix---------------------') print(tabulate(avg_acc_matrix, tablefmt="latex_raw", headers=['Type', 'Random Forest', 'KNN', 'SVC Poly', 'GaussianNB', 'SVC Linear', 'SVC RBF'])) print( '----------------------------------------------------------------------------') print( '-----------------------------------acc matrix--------------------------------') print( '-------------------------------------------------------------------------------') print( '----------------------------------------rec matrix-----------------------------') print(tabulate(avg_rec_matrix, tablefmt="latex_raw", headers=['Type', 'Random Forest', 'KNN', 'SVC Poly', 'GaussianNB', 'SVC Linear', 'SVC RBF'])) print( '-----------------------------------------------------------------------------------') print( '-----------------------------rec matrix--------------------------------------------') print( '----------------------------------------------------------------') print( '-------------------------prec matrix-----------------------------') print(tabulate(avg_prec_matrix, tablefmt="latex_raw", headers=['Type', 'Random Forest', 'KNN', 'SVC Poly', 'GaussianNB', 'SVC Linear', 'SVC RBF'])) print( '-------------------------------------------------------------------------------') print( '-----------------------------------------prec matrix---------------------------')
def print_matrix(input_matrix): cprint(tabulate(input_matrix, tablefmt="fancy_grid", floatfmt="2.5f"), 'cyan')
def print_ip_table(avlist, navlist): res = {'Reachable': avlist, 'Unreachable': navlist} return print(tabulate(res, headers="keys"))
return 0 elif re.search('Self', x): return 1 elif re.search('gov', x): return 2 else: return 3 df['WorfClass_cat'] = df.workclass.apply(lambda x: x.strip()).apply( lambda x: workclas(x)) df['WorfClass_cat'] = df.workclass.apply(lambda x: x.strip()).apply( lambda x: workclas(x)) df['WorfClass_cat'].value_counts() print(tabulate(df.head(15), tablefmt='psql', headers='keys')) #......................................test data........................................................ data_test = pd.read_csv( r"C:\Users\nikita\Desktop\data_analytics_material\AIT590\python presentation\ML_test_data_without_output.csv" ) df_test = pd.DataFrame(data_test) # print(df) df_test.replace(' ?', numpy.nan, regex=False, inplace=True) print(df_test.columns[df_test.isna().any()]) #print(tabulate(df, tablefmt='psql'))
cmd = input() ctrlc_cnt = 0 if cmd[0:2] == 'cd': try: os.chdir(os.path.join(os.getcwd(), cmd.split(' ')[1])) except: print("Cannot cd.") elif cmd == 'ls': print(subprocess.getoutput("ls")) elif len(cmd) > 0 and cmd[0] == '!': cmds = cmd.split(" ") if cmd == '!ls': print( tabulate([(k, *jobs[k].shortsummary()) for k in jobs], tablefmt="grid", headers=[ "ID", "status", "pwd", "command", "create", "run", "finished" ])) elif cmds[0] == '!k': if len(cmds) == 2 and cmds[1].isdigit(): jobs[int(cmds[1])].kill() elif cmds[0] == '!s': if len(cmds) == 2 and cmds[1].isdigit(): jobs[int(cmds[1])].showstdout() elif cmds[0] == '!j': if len(cmds) == 2 and cmds[1].isdigit(): threadpoolmax = int(cmds[1]) else: print("Thread pool size:", threadpoolmax) # elif cmds[0]=='!showstderr': # if len(cmds)==2 and cmds[1].isdigit():
def run_all(self): self.pulse_logger.info('Checking instance pulse') self.pulse_logger.info('Checking Connections') result = self.check_connections() print(result) self.pulse_logger.info('Complete: Checking Connections') self.pulse_logger.info('Analyzing Query Stats') r1, r2, r3 = self.check_query_stats() print(r1) print(r2) print(r3) self.pulse_logger.info('Complete: Analyzing Query Stats') # check scheduled plans self.pulse_logger.info('Analyzing Query Stats') with trange(1, desc='(3/5) Analyzing Scheduled Plans', bar_format=self.bar, postfix=self.postfix_default, ncols=100, miniters=0) as t: for i in t: result = self.check_scheduled_plans() fail_flag = 0 if type(result) == list and len(result) > 0: if result[0]['failure'] > 0: fail_flag = 1 result = tabulate(result, headers="keys", tablefmt='psql', numalign='center') t.postfix[0]["value"] = 'DONE' t.update() print(result) if fail_flag == 1: print('Navigate to /admin/scheduled_jobs on your instance for ' 'more details') self.pulse_logger.info('Complete: Analyzing Scheduled Plans') # check enabled legacy features self.pulse_logger.info('Checking Legacy Features') with trange(1, desc='(4/5) Legacy Features', bar_format=self.bar, postfix=self.postfix_default, ncols=100, miniters=0) as t: for i in t: result = self.check_legacy_features() t.postfix[0]["value"] = 'DONE' t.update() print(result) self.pulse_logger.info('Complete: Checking Legacy Features') # check looker version self.pulse_logger.info('Checking Version') t = trange(1, desc='(5/5) Version', bar_format=self.bar, postfix=self.postfix_default, ncols=100) for i in t: result = self.check_version() t.postfix[0]["value"] = "DONE" t.update() print(result) self.pulse_logger.info('Complete: Checking Version') self.pulse_logger.info('Complete: Checking instance pulse') return
def print_latex(T: list, num_table: int) -> None: """ Print iteration data as LaTeX tabular. Parameters ---------- T : list List of iteration data. num_table : int Split iteration data into columns to display side by side. """ if num_table != 1: if num_table <= 0: logging.warning( f'Non-positive number of side by side tables {num_table}, now print normally' ) elif num_table > len(T): logging.warning( f'Number of side by side tables {num_table} exceeds number of data rows {len(T)}, now print normally' ) else: num_row = len(T) num_col = len(T[0]) row_per_side_table = int(ceil(num_row / num_table)) table = T T = ( ( table[i + j * row_per_side_table][k] for i in [i] # I lol'd so hardddddd for j in range(num_table) for k in range(num_col) if i + j * row_per_side_table < num_row) for i in range(row_per_side_table)) latex = str( tabulate(T, tablefmt='latex', floatfmt=f".{config['decimal_places']}f")) # Filter content line only (avoid tabular,...) latex = '\n'.join( filter(lambda line: line.endswith('\\'), latex.splitlines())) # Remove trailing zeros trailing_zero_matcher = re.compile( r''' (?<= # Positive (=) look behind (<), i.e. must be (positive) preceded by (look behind) \.\d* # Decimal dot, followed by zero or more digit ) 0 # Match a SINGLE trailing zero (?= # Positive (=) look ahead (no <), i.e. must be (positive) succeeded by (look ahead) 0*\b # Zero or more 0, followed by word boundary \b ) ''', re.VERBOSE # Allow free-spacing and comment ) latex = re.sub(trailing_zero_matcher, ' ', latex) # Remove trailing decimal dot latex = re.sub(r'\.(?=\s)', ' ', latex) # Remove redundant minus sign latex = re.sub(r'-(?=0\s)', ' ', latex) # Add spacing between columns and newline latex = re.sub('&', ' & ', latex) latex = re.sub(r'\\\\', r' \\\\', latex) # Remove excessive whitespaces # e.g. from # 8 \\ # 9.2 \\ # to # 8 \\ # 9.2 \\ # Split row into cells split_cells: Callable[[str], List[str]] = lambda row: \ row[: len(row) - 2].split('&') # Merge cells into row merge_cells: Callable[[Iterable[str]], str] = lambda cells: \ '&'.join(cells) + r'\\' # Split data into columns split_columns: Callable[[str], Iterable[str]] = lambda latex: \ zip(*map(split_cells, latex.splitlines())) # Merge rows into string, reversing split_columns merge_columns: Callable[[Iterable[str]], str] = lambda columns: \ '\n'.join(map(merge_cells, zip(*columns))) # Find the number of trailing spaces num_of_trailing_spaces: Callable[[str], int] = lambda cell: \ len(cell) - len(cell.rstrip()) # Find the number of excess spaces in each row find_excess_spaces: Callable[[Iterable[str]], int] = lambda column: \ min((num_of_trailing_spaces(cell) for cell in column)) - 2 # Mandatory 2 trailing spaces def strip_excess_spaces(column): num_of_excess_spaces = find_excess_spaces(column) return map(lambda cell: cell[:len(cell) - num_of_excess_spaces], column) latex = merge_columns(map(strip_excess_spaces, split_columns(latex))) print(latex)
def main(): results = Manager().list() uniqueSymbols = Manager().list() filesProcessed = Manager().Value('i', 0) symbolsProcessed = Manager().Value('i', 0) out(''' :: findSymbols.py - Finds PE Import/Exports based on supplied filters. Mariusz Banach / mgeeky, '21 <mb [at] binary-offensive.com> ''') args, regexes = opts(sys.argv) is_wow64 = (platform.architecture()[0] == '32bit' and 'ProgramFiles(x86)' in os.environ) start_time = datetime.now() try: if '\\system32\\' in args.path.lower() and is_wow64: verbose( args, 'Redirecting input path from System32 to SysNative as we run from 32bit Python.' ) args.path = args.path.lower().replace('\\system32\\', '\\SysNative\\') if os.path.isdir(args.path): processDir(args, regexes, args.path, results, uniqueSymbols, filesProcessed, symbolsProcessed) else: if not os.path.isfile(args.path): out(f'[!] Input file does not exist! Path: {args.path}') sys.exit(1) processFile(args, regexes, args.path, results, uniqueSymbols, filesProcessed, symbolsProcessed) except KeyboardInterrupt: out(f'[-] User interrupted the scan.') time_elapsed = datetime.now() - start_time if args.format == 'json': resultsList = list(results) dumped = str(json.dumps(resultsList, indent=4)) if args.output: with open(args.output, 'w') as f: f.write(dumped) else: print('\n' + dumped) else: resultsList = list(results) if len(resultsList) > 0: idx = headers.index(args.column) resultsList.sort(key=lambda x: x[idx], reverse=args.descending) headers[idx] = '▼ ' + headers[ idx] if args.descending else '▲ ' + headers[idx] if args.first > 0: for i in range(len(resultsList) - args.first): resultsList.pop() table = tabulate.tabulate(resultsList, headers=[ '#', ] + headers, showindex='always', tablefmt='pretty') if args.output: with open(args.output, 'w', encoding='utf-8') as f: f.write(str(table)) else: print('\n' + table) if args.first > 0: out(f'\n[+] Found {Logger.colored(args, len(resultsList), "green")} symbols meeting all the criterias (but shown only first {Logger.colored(args, args.first, "magenta")} ones).\n' ) else: out(f'\n[+] Found {Logger.colored(args, len(resultsList), "green")} symbols meeting all the criterias.\n' ) else: out(f'[-] Did not find symbols meeting specified criterias.') out(f'[.] Processed {Logger.colored(args, filesProcessed.value, "green")} files and {Logger.colored(args, symbolsProcessed.value, "green")} symbols.' ) out('[.] Time elapsed: {}'.format( Logger.colored(args, time_elapsed, "magenta")))
column_marker = 0 columns = row.find_all('td') for column in columns: df.iat[row_marker, column_marker] = column.get_text() column_marker += 1 if len(columns) > 0: row_marker += 1 for col in df: try: df[col] = df[col].astype(float) except ValueError: pass return df time = datetime.datetime.now( datetime.timezone.utc).strftime("%Y-%m-%d %H:%M%Z") time1 = datetime.datetime.now(datetime.timezone.utc).strftime("%m-%d %H") print("\n" + "Date/Time >: " + time) print("Counters are reset at 23:59UTC" + "\n") hp = HTMLTableParser() table = hp.parse_url(url)[0][1] print(tabulate(table, headers=["#","Country","Cases","+","Deaths","+",\ "Recovered","Active","Critical","CPM", "Deaths PM"], tablefmt='psql')) table.to_csv("/root/coronavirus/kungflu.csv") exit()
def print_table(dataframe): print(tabulate(dataframe, headers="keys", tablefmt="psql"))
import pandas as pd import matplotlib.pyplot as plt from pydataset import data df = data('mtcars') df.head() df.columns df.dtypes df.shape pd.options.display.max_columns = None pd.options.display.width = 1000 #%%% df from tabulate import tabulate print(tabulate(df, headers='firstrow')) #%%% from tabulate import tabulate pdtabulate = lambda df: tabulate(df, headers='keys') print(pdtabulate(df)) data.head() print(pdtabulate(df.head())) #%%% from tabulate import tabulate pdtabulate = lambda df: tabulate(df, headers='keys', tablefmt='psql') print(pdtabulate(df)) #%%%html from tabulate import tabulate pdtabulate = lambda df: tabulate(df, headers='keys', tablefmt='html')
#!/usr/bin/python3 """ Prints out a prompted IP address in decimal, binary, and hex formatted in a table. """ from tabulate import tabulate from__future__ import print_function, unicode_literals ip_address = input("Please Enter Your IP Address Separated With a Decimal(.):") #Prompts a user to input an IP address decimal_address=ip_address.split(".") #Breaks the IP address into octets results = [] for number in decimal_address: decimal_number=results.append(number) binary_number=results.append(bin(int(number))) hexadecimal_number=results.append(hex(int(number))) #Puts the IP address into decimal, binary and hexadecimal table = [["Octet1",results[0],results[1],results[2]], ["Octet2",results[3],results[4],results[5]], ["Octet3",results[6],results[7],results[8]], ["Octet4",results[9],results[10],results[11]]] #Inputs the values into a table print(tabulate(table, headers=["Octet","Decimal", "Binary", "Hexadecimal"], tablefmt="pretty"))
def tabulate_results(results): """ Formats the results of a validation run into a table :param results: dictionary containing the results of a validation run. Key is the annotated filename, which maps to an inner dictionary where the key is the model name, and the value is the validation metric score of that model on the annotated filename Will take the form {"filename": {"model_name": metric_score, "model_name2": metric_score}, "filename2": ...} :return: the table (also prints to stdout) """ # takes the form [<filename>, model1score, model2score,...] rows = [] # list of model names headers = ["test filename"] flag = 0 # dict that for each model, tracks the scores in a list per_model = defaultdict(list) # iterate over each file for fname, file_dict in results.items(): model_scores = [] # creates a list of model scores in alphabetical order based on model name for model_name in sorted(file_dict): model_scores.append(file_dict[model_name]) per_model[model_name].append(file_dict[model_name]) if not flag: headers.append(model_name) ## find the model name with the highest score for that file max_model_name = sorted(file_dict)[model_scores.index( max(model_scores))] model_scores.insert(0, fname) model_scores.append(max_model_name) rows.append(model_scores) flag = 1 ## create the mean, median, stdev rows that tally the columns means = ["mean"] medians = ["median"] stdevs = ["stdev"] for model_name in sorted(per_model): means.append(mean(per_model[model_name])) medians.append(median(per_model[model_name])) stdevs.append(stdev(per_model[model_name])) ## get the model with the highest mean and median model_means = means[1:] # doesn't include the "mean" header model_medians = medians[1:] max_mean_model_name = sorted(file_dict)[model_means.index( max(model_means))] max_median_model_name = sorted(file_dict)[model_medians.index( max(model_medians))] means.append(max_mean_model_name) medians.append(max_median_model_name) # spacing between data table and summary statistics rows.append(["- " for i in range(len(means))]) # spacing rows.append(means) rows.append(medians) rows.append(stdevs) headers.append("file's best model") table = tabulate(rows, headers) print(table) return table
def compare_results(): print('Comparing results') import pandas as pd from tabulate import tabulate # Read in output of demo script measure_fpath = 'measurements_haul83.csv' py_df = pd.DataFrame.from_csv(measure_fpath, index_col=None) # Convert python length output from mm into cm for consistency py_df['fishlen'] = py_df['fishlen'] / 10 py_df['current_frame'] = py_df['current_frame'].astype(np.int) # janky CSV parsing py_df['box_pts1'] = py_df['box_pts1'].map( lambda p: eval(p.replace(';', ','), np.__dict__)) py_df['box_pts2'] = py_df['box_pts2'].map( lambda p: eval(p.replace(';', ','), np.__dict__)) py_df['obox1'] = [ ctalgo.OrientedBBox(*cv2.minAreaRect(pts[:, None, :].astype(np.int))) for pts in py_df['box_pts1'] ] py_df['obox2'] = [ ctalgo.OrientedBBox(*cv2.minAreaRect(pts[:, None, :].astype(np.int))) for pts in py_df['box_pts2'] ] py_df.drop(['box_pts1', 'box_pts2'], axis=1, inplace=True) # Remap to matlab names py_df = py_df.rename(columns={ 'error': 'Err', 'fishlen': 'fishLength', 'range': 'fishRange', }) # Load matlab results mat_df = _read_kresimir_results() FORCE_COMPARABLE_RANGE = True # FORCE_COMPARABLE_RANGE = False if FORCE_COMPARABLE_RANGE: # Be absolutely certain we are in comparable regions (may slightly bias # results, against python and in favor of matlab) min_frame = max(mat_df.current_frame.min(), py_df.current_frame.min()) max_frame = min(mat_df.current_frame.max(), py_df.current_frame.max()) print('min_frame = {!r}'.format(min_frame)) print('max_frame = {!r}'.format(max_frame)) mat_df = mat_df[(mat_df.current_frame >= min_frame) & (mat_df.current_frame <= max_frame)] py_df = py_df[(py_df.current_frame >= min_frame) & (py_df.current_frame <= max_frame)] intersect_frames = np.intersect1d(mat_df.current_frame, py_df.current_frame) print('intersecting frames = {} / {} (matlab)'.format( len(intersect_frames), len(set(mat_df.current_frame)))) print('intersecting frames = {} / {} (python)'.format( len(intersect_frames), len(set(py_df.current_frame)))) # Reuse the hungarian algorithm implementation from ctalgo min_assign = ctalgo.FishStereoMeasurments.minimum_weight_assignment correspond = [] for f in intersect_frames: pidxs = np.where(py_df.current_frame == f)[0] midxs = np.where(mat_df.current_frame == f)[0] pdf = py_df.iloc[pidxs] mdf = mat_df.iloc[midxs] ppts1 = np.array([o.center for o in pdf['obox1']]) mpts1 = np.array([o.center for o in mdf['obox1']]) ppts2 = np.array([o.center for o in pdf['obox2']]) mpts2 = np.array([o.center for o in mdf['obox2']]) dists1 = sklearn.metrics.pairwise.pairwise_distances(ppts1, mpts1) dists2 = sklearn.metrics.pairwise.pairwise_distances(ppts2, mpts2) # arbitrarilly chosen threshold thresh = 100 for i, j in min_assign(dists1): d1 = dists1[i, j] d2 = dists2[i, j] if d1 < thresh and d2 < thresh and abs(d1 - d2) < thresh / 4: correspond.append((pidxs[i], midxs[j])) correspond = np.array(correspond) # pflags = np.array(ub.boolmask(correspond.T[0], len(py_df))) mflags = np.array(ub.boolmask(correspond.T[1], len(mat_df))) # print('there are {} detections that seem to be in common'.format(len(correspond))) # print('The QC flags of the common detections are: {}'.format( # ub.dict_hist(mat_df[mflags]['QC'].values))) # print('The QC flags of the other matlab detections are: {}'.format( # ub.dict_hist(mat_df[~mflags]['QC'].values))) print('\n\n----\n## All stats\n') print( ub.codeblock(''' Overall, the matlab script made {nmat} length measurements and the python script made {npy} length measurements. Here is a table summarizing the average lengths / ranges / errors of each script: ''').format(npy=len(py_df), nmat=len(mat_df))) stats = pd.DataFrame(columns=['python', 'matlab']) for key in ['fishLength', 'fishRange', 'Err']: stats.loc[key, 'python'] = '{:6.2f} ± {:6.2f}'.format( py_df[key].mean(), py_df[key].std()) stats.loc[key, 'matlab'] = '{:6.2f} ± {:6.2f}'.format( mat_df[key].mean(), mat_df[key].std()) stats.loc['nTotal', 'python'] = '{}'.format(len(py_df)) stats.loc['nTotal', 'matlab'] = '{}'.format(len(mat_df)) print(tabulate(stats, headers='keys', tablefmt='psql', stralign='right')) print('\n\n----\n## Only COMMON detections\n') py_df_c = py_df.iloc[correspond.T[0]] mat_df_c = mat_df.iloc[correspond.T[1]] stats = pd.DataFrame(columns=['python', 'matlab']) for key in ['fishLength', 'fishRange', 'Err']: stats.loc[key, 'python'] = '{:6.2f} ± {:6.2f}'.format( py_df_c[key].mean(), py_df_c[key].std()) stats.loc[key, 'matlab'] = '{:6.2f} ± {:6.2f}'.format( mat_df_c[key].mean(), mat_df_c[key].std()) stats.loc['nTotal', 'python'] = '{}'.format(len(py_df_c)) stats.loc['nTotal', 'matlab'] = '{}'.format(len(mat_df_c)) print( ub.codeblock(''' Now, we investigate how many dections matlab and python made in common. (Note, choosing which dections in one version correspond to which in another is done using a heuristic based on distances between bbox centers and a thresholded minimum assignment problem). Python made {npy_c}/{nmat} = {percent:.2f}% of the detections matlab made ''').format(npy_c=len(py_df_c), nmat=len(mat_df), percent=100 * len(py_df_c) / len(mat_df))) print(tabulate(stats, headers='keys', tablefmt='psql', stralign='right')) print('\n\n----\n## Evaulation using the QC code\n') hist_hit = ub.dict_hist(mat_df[mflags]['QC'].values) hist_miss = ub.dict_hist(mat_df[~mflags]['QC'].values) print( ub.codeblock(''' However, not all of those matlab detections were good. Because we have detections in corrsepondences with each other we can assign the python detections QC codes. Here is a histogram of the QC codes for these python detections: {} (Note: read histogram as <QC-code>: <frequency>) Here is a histogram of the other matlab detections that python did not find: {} To summarize: python correctly rejected {:.2f}% of the matlab QC=0 detections python correctly accepted {:.2f}% of the matlab QC=1 detections python correctly accepted {:.2f}% of the matlab QC=2 detections Note, that because python made detections that matlab did not make, the remaining {} detections may be right or wrong, but there is no way to tell from this analysis. Lastly, here are the statistics for the common detections that had a non-zero QC code. ''').format(ub.repr2(hist_hit, nl=1), ub.repr2(hist_miss, nl=1), 100 * hist_miss[0] / (hist_hit[0] + hist_miss[0]), 100 * hist_hit[1] / (hist_hit[1] + hist_miss[1]), 100 * hist_hit[2] / (hist_hit[2] + hist_miss[2]), len(py_df) - len(py_df_c))) is_qc = (mat_df_c['QC'] > 0).values mat_df_c = mat_df_c[is_qc] py_df_c = py_df_c[is_qc] stats = pd.DataFrame(columns=['python', 'matlab']) for key in ['fishLength', 'fishRange', 'Err']: stats.loc[key, 'python'] = '{:6.2f} ± {:6.2f}'.format( py_df_c[key].mean(), py_df_c[key].std()) stats.loc[key, 'matlab'] = '{:6.2f} ± {:6.2f}'.format( mat_df_c[key].mean(), mat_df_c[key].std()) stats.loc['nTotal', 'python'] = '{}'.format(len(py_df_c)) stats.loc['nTotal', 'matlab'] = '{}'.format(len(mat_df_c)) print(tabulate(stats, headers='keys', tablefmt='psql', stralign='right'))
print j.nodeid, for i in all_nodes: fname = "chain" + str(i.nodeid) fcreate = open(fname, "w+") for txt in i.my_chain.flist: fcreate.write(txt + "\n") fcreate.close() print "Total trans happened: ", len(all_nodes[0].ledger) '''for i in all_nodes: temp = i.my_chain.find_longest_chain() print i.nodeid, ": ", i.my_chain.print_blockchain(temp)''' #printing entire blockchain of the node for i in all_nodes: print "My blockchain", i.nodeid, ": ", i.my_chain.print_longest() check_list = verify_btc() nodeids = [] for j in all_nodes: nodeids.append([ j.nodeid, j.nature, j.num_peers, j.btc, check_list[j.nodeid - 1001], j.my_chain.print_blockchain(j.my_chain.find_longest_chain()) ]) print tabulate(nodeids, headers=[ 'Node ID', 'Nature', 'No. of peers', "BTC", "Cal BTC", "Chain length" ])
desk_filter([1],[3]) #print(df2) index = 0 coloringtester = tk.Tk() #for index, row in df2.iterrows(): #print(index) #print(row) #tk.Label(coloringtester, text=row,font=("Helvetica", 16)).grid(row=0, column=0) #for i in range(len(df2)): # print(df2.iloc[i]) #emplist = [] #emplist.append() #tk.Label(coloringtester, text=df2.iloc[i],font=("Helvetica", 16)).pack() layout = tabulate(df2) #print(layout) #alist = [[1,2,3],[4],[5,6]] #for i in alist: # print(i) # tk.Label(coloringtester, text=i,font=("Helvetica", 16)).pack() #coloringtester.mainloop() #print(df2.to_csv(header=None, index=False)) headers = [] for col in df2.columns: #print(col) headers.append(col) headers[0] = 'Desk#' headerindex = 0 for i in headers: tk.Label(coloringtester, text=i,font=("Helvetica", 16),bg = 'cyan',anchor= 'e',relief = 'solid').grid(row = 0, column = headerindex, sticky = 'w'+'e')
def _tabulate(self, table, **args): if tabulate: tabular = tabulate(table, args) self._print(tabular) else: self._print("\n".join("\t|".join(line) for line in table))
def create_numerical_table(self): """ Prints a summary table for t-test comparisons of numerical values at the patient level """ numerical_table_data = [self._calc_t_test(column_label) for column_label in self._numerical_columns] print(tabulate(numerical_table_data, headers=['Feature', 'Mean (SD)', 'Mean (SD)', "Student's T", 'P-Value']))
from sklearn.model_selection import cross_val_score from sklearn.model_selection import GridSearchCV from sklearn.model_selection import RandomizedSearchCV from sklearn.model_selection import KFold from sklearn.model_selection import StratifiedKFold from sklearn.metrics import classification_report, roc_auc_score, \ precision_recall_curve, auc, roc_curve titanic = sns.load_dataset("titanic") # こんなデータです。先頭5行を表示します。 headers = [c for c in titanic.columns] headers.insert(0,"ID") print(tabulate(titanic[0:5], headers, tablefmt="pipe")) # 確認 print(titanic.head()) # カテゴリ変数をダミー変数化 def convert_dummies(df, key): dum = pd.get_dummies(df[key]) ks = dum.keys() print("Removing {} from {}...".format(ks[0], key)) dum.columns = [key + "_" + str(k) for k in ks] df = pd.concat((df, dum.iloc[:,1:]), axis=1) df = df.drop(key, axis=1) return df titanic = convert_dummies(titanic, "who") titanic = convert_dummies(titanic, "class")
new_column_order.extend(current_columns) output_data_frame = output_data_frame[new_column_order] output_data_frame.drop(columns=old_col_name, inplace=True) elif (is_target and old_col_suffix != '(t)') or (not is_target and re.search( 't-1', old_col_suffix) is not None): output_data_frame[new_col_name] = output_data_frame[ old_col_name] output_data_frame.drop(columns=old_col_name, inplace=True) else: output_data_frame.drop(columns=old_col_name, inplace=True) ts_data_frame = output_data_frame.copy() ts_data_frame.set_index('Date', inplace=True) print(tabulate(ts_data_frame.tail(), ts_data_frame.columns.values)) history = pd.DataFrame(index=ts_data_frame.index.values) history['Interval_Date'] = history.index.values history['Interval_Date'] = history['Interval_Date'].shift(+INTERVAL_IN_DAYS) history = pd.merge(history, mv_time_series, how='left', left_on='Interval_Date', right_on='Date') history.index = ts_data_frame.index.values history = history[[TARGET_COL]] groups = [3, 4, 5] # if 1 in graphs: # i = 1
if r.status_code != 200: logger.critical("Failed to contact {}: {} | time={}s size={}B".format(mpd.get_url(), r.status_code, round(t.elapsed_secs, 2), r.headers['content-length'])) else: logger.info("MPD OK | time={}s size={}B".format(t.elapsed_secs, r.headers['content-length'])) else: logger.info("MPD status.") table = [["Descriptions", "Values"], ["http code", r.status_code], ["time spend (sec)", round(t.elapsed_secs, 2)], ["content-length", r.headers['content-length']], ["url", str(r.url)], ["content-type", r.headers['content-type']]] # Output table print tabulate(table, headers="firstrow") # Get Lexer base on content-type if r.headers['content-type'].startswith('application/xml'): lexer = lexers.XmlLexer() elif r.headers['content-type'].startswith('application/json'): lexer = lexers.JsonLexer() else: lexer = lexers.HtmlLexer() # Try to print JSON content try: # Format Json with indentation formatted_http_response = json.dumps(json.loads(r.text), sort_keys=True, indent=2) except Exception: formatted_http_response = r.text
elif angka == 12: return "C" elif angka == 13: return "D" elif angka == 14: return "E" elif angka == 15: return "F" elif angka == 16: return "G" print("Program Sederhana untuk Konversi Bilangan Desimal-Biner-Octal-Hexa") angka = int( input("Masukkan bilangan untuk dikonversi dalam bentuk Desimal ? ")) print("==============================================================") biner, hasilBiner = konversi(angka, 2) octal, hasilOctal = konversi(angka, 8) hexa, hasilHexa = konversi(angka, 16) combine = list(it.zip_longest(biner, octal, hexa)) header = ("Binner", "Octal", "Hexadecimal") print(tabulate(combine, header, tablefmt="plain")) print("") print("==============================================================") print("Binner =", hasilBiner, end=" ") print("Octal =", hasilOctal, end=" ") print("Hexa =", hasilHexa, end=" ")
# Таким образом, Вы определите как взаимосвязаны пол и класс кабины с выживаемостью. import csv import pandas as pd import pprint as pp from tabulate import tabulate def get_data_from_csv(filename): f = open(filename, "r") list_dicts = [row for row in csv.DictReader(f, delimiter=',')] list_inner_dicts = [dict(row) for row in list_dicts] f.close() return list_inner_dicts data_lst = get_data_from_csv(r'C:\Users\lisam\Downloads\titanic.csv') dt = pd.DataFrame.from_dict(data_lst) dt['Qty'] = 1 wanted_keys = ['Sex', 'Pclass', 'Survived', 'Qty'] dt_new = dt[wanted_keys] wanted_keys[:] = ['Sex', 'Pclass', 'Survived'] #dt_new['Qty'] = 1 grouped = dt_new.groupby(wanted_keys).sum() # print(grouped) pp.pprint(grouped) print(tabulate(grouped, headers='keys', tablefmt='psql'))
def showData(tab): cursorA.execute("SELECT * FROM {name}".format(name=tab)) data_tmp = cursorA.fetchall() print(tabulate(data_tmp, headers=cursorA.column_names), '\n')
img.append(img_train[rn]) label.append(label_train[rn]) n.train(img, label) t2 = time.time() u = n.losses(img_test, label_test) losses[i] = u t3 = time.time() print( f"Batch : {i + 1}/{BATCH} en {round(t2 - t1, 4)} s avec {round(t3 - t2, 4)} en loss ({EPOCH} {BATCH_SIZE})" ) ftime = time.time() ## NN representation evaluation, accuracy, precision, recall, f1_score = n.confusion( img_test, label_test) peval = tabulate(evaluation, tablefmt="fancy_grid") pscore = tabulate([["accuracy", accuracy], ["precision", precision], ["recall", recall], ["f1_score", f1_score]], tablefmt="fancy_grid") str_result = f"Evaluation :\n{peval}\nScore :\n{pscore}\nTime to train : {round(ftime - stime, 4)}" print(str_result) plt.figure() plt.plot(losses.get()) plt.xlabel("BATCH") plt.ylabel("Loss") plt.title(f"Covid Loss with {BATCH} batchs of {BATCH_SIZE} retropopagation") filename = "naif_s90_b300_e1_bs10" plt.savefig(f'plot/{filename}.png') with open(f"{filename}.txt", "w") as f:
def print_merged_table_per_algorithm(self, results): for det in self.detectors: table = tabulate(results[results['algorithm'] == det.name], headers='keys', tablefmt='psql') self.logger.info(f'Detector: {det.name}\n{table}')
def ValueCounts(f, data, target, columns): # To view summary aggregates f.writelines("\n\nVALUE COUNTS:\n\n") dataf= pd.DataFrame(list(zip(data[target].value_counts().index,data[target].value_counts())), columns=['Column','counts']) f.write(tabulate(dataf, tablefmt="grid", headers="keys", showindex=False)) f.writelines("\n---------------------------------------------------------------------------------------------------------------------------------------")
def print_merged_table_per_dataset(self, results): for ds in self.datasets: table = tabulate(results[results['dataset'] == ds.name], headers='keys', tablefmt='psql') self.logger.info(f'Dataset: {ds.name}\n{table}')
def print_list(datasets): """Print dataset list in a mono-replica context.""" li = [[d['status'], d['dataset_functional_id']] for d in datasets] print tabulate(li, tablefmt="plain")