def weekly_report(): print("Generate report!") start = input("Enter start date(yyyy-mm-dd): ") end = input("Enter end date(yyyy-mm-dd): ") sql_select_Query = "select b.isbn, ib.issue_date, count(*) as number_of_copies, datediff(ib.book_due_date, ib.issue_date) as no_of_days, b.author, b.title, lm.ssn, lm.name from issue_book as ib, library_member as lm, book as b where ib.issue_date between '{}' and '{}' and b.isbn=ib.isbn and lm.ssn=ib.member_ssn group by b.isbn".format( start, end) cursor = mydb.cursor() cursor.execute(sql_select_Query) records = cursor.fetchall() index = 1 table = Texttable() table.set_max_width(max_width=110) table.add_row([ 'Index', 'Book Title', 'Book Author', 'Book ISBN', 'Member Name', 'Member SSN', 'Issue Date', 'No of Copies', 'Loan Days' ]) for row in records: table.add_row([ index, row[5], row[4], row[0], row[7], row[6], row[1], row[2], row[3] ]) index += 1 print("Report generated to report.txt file!") file = open("report.txt", "w+", encoding='utf-8') file.write("Weekly Report!\n\n") file.write(table.draw()) file.close()
def test_chaining(): table = Texttable() table.reset() table.set_max_width(50) table.set_chars(list('-|+=')) table.set_deco(Texttable.BORDER) table.set_header_align(list('lll')) table.set_cols_align(list('lll')) table.set_cols_valign(list('mmm')) table.set_cols_dtype(list('ttt')) table.set_cols_width([3, 3, 3]) table.set_precision(3) table.header(list('abc')) table.add_row(list('def')) table.add_rows([list('ghi')], False) s1 = table.draw() s2 = (Texttable() .reset() .set_max_width(50) .set_chars(list('-|+=')) .set_deco(Texttable.BORDER) .set_header_align(list('lll')) .set_cols_align(list('lll')) .set_cols_valign(list('mmm')) .set_cols_dtype(list('ttt')) .set_cols_width([3, 3, 3]) .set_precision(3) .header(list('abc')) .add_row(list('def')) .add_rows([list('ghi')], False) .draw()) assert s1 == s2
def print_warehouse_rules(line, user_ns): warehouse = eval(line, user_ns) result = warehouse_rules(warehouse) if not result: return locations = list(result.values())[0].keys() attrs = [] attrs.append([''] + [format_location(location) for location in locations]) for route, locations in result.items(): row = [format_route(route, warehouse)] attrs.append(row) for location, rules in locations.items(): row.append('\n\n'.join(map(format_rule, rules))) table = Texttable() table.set_deco(Texttable.HEADER | Texttable.VLINES | Texttable.HLINES) table.set_max_width(180) table.add_rows(attrs) print(table.draw())
def get_table(self, width: int = 120): table = Texttable() table.set_deco(Texttable.HEADER | Texttable.HLINES) table.set_max_width(width) header = [ 'Property', 'Description', 'Type', 'Dist.', 'Mean', 'Sigma', 'Offset', 'Truth' ] table.set_cols_dtype(['t', 't', 't', 't', 'a', 'a', 'a', 'a']) table.set_header_align(['l', 'l', 'l', 'l', 'l', 'l', 'l', 'l']) rows = [header] for name in self.design_properties: design_property = self.design_properties[name] row = [ design_property.name, design_property.description, design_property.property_type, design_property.distribution, design_property.mean, design_property.sigma, design_property.get_offset(), self.true_properties[design_property.name].get_value() ] rows.append(row) table.add_rows(rows) return table.draw()
def ner_confusion_matrix(golden, pred, suffix=False): labels = [ 'address', 'book', 'company', 'game', 'government', 'movie', 'name', 'organization', 'position', 'scene', 'O' ] true_entities = set(get_entities(golden, suffix)) pred_entities = set(get_entities(pred, suffix)) true_span2type = {(i, j): k for k, i, j in true_entities} pred_span2type = {(i, j): k for k, i, j in pred_entities} add_span = set() pred_label = [] true_label = [] # 根据span判断pred和golden的对应预测标签,如果span在golden中,但是没在pred中,那么认为pred为O for span, label in true_span2type.items(): true_label.append(label) pred_label.append(pred_span2type.get(span, 'O')) add_span.add(span) # span在pred中没在gold中,那么认为gold为O for span, label in pred_span2type.items(): if span in add_span: continue pred_label.append(label) true_label.append(true_span2type.get(span, 'O')) cf_matrix = confusion_matrix(true_label, pred_label, labels=labels) table = Texttable() table.add_row([" "] + [i[:4] for i in labels]) table.set_max_width(2000) for idx, r in enumerate(cf_matrix): table.add_row([labels[idx][:4]] + [str(i) for i in cf_matrix[idx]]) return table.draw()
def __printTable(self, header, rows): table = Texttable() col, line = os.get_terminal_size() table.set_max_width(col) table.header(header) table.add_rows([rows], header = False) return table.draw()
def get_two_column_table_head(): table = Texttable() table.set_cols_align(["l", "l"]) table.set_cols_valign(["t", "t"]) table.set_deco(Texttable.HEADER | Texttable.VLINES | Texttable.BORDER) table.set_max_width(0) return table
def get_text_table(nbColumn): result = Texttable() result.set_max_width(get_console_window_width()) result.set_cols_align(['c'] * nbColumn) result.set_cols_valign(['m'] * nbColumn) result.set_cols_dtype(['t'] * nbColumn) return result
def show_json_table(header, data, att, mul=False): tb = Texttable() list = getJSONArray(data, att) tb.add_rows(list) tb.header(header) tb.set_max_width(220) print(tb.draw())
def _generate_table_report_adv(self, results, show_mem=True, show_inside_server=True): tbl_report = "=" * 52 + "\n" table = Texttable() table.set_deco(Texttable.HEADER) header_names = ["size", "samples", "iters", "min", "avg", "max"] header_types = ["t", "i", "i", "f", "f", "f"] col_allign = ["l", "r", "r", "r", "r", "r"] if show_mem: header_names.extend(["used (MB)", "total (MB)"]) header_types.extend(["f", "f"]) col_allign.extend(["r", "r"]) if show_inside_server: header_names.extend(["prediction"]) header_types.extend(["f"]) col_allign.extend(["r"]) table.set_cols_dtype(header_types) table.set_cols_align(col_allign) try: terminal_size = shutil.get_terminal_size() table.set_max_width(terminal_size.columns) except Exception as e: pass rows = [header_names] for res in results: row = [res.name, res.samples, res.iterations] d = res.stats_obj.dict_report(CMRunTests.REPORT_NAME) row.extend([d["min"], d["avg"], d["max"]]) server_stats = json.loads( res.server_stats) if res.server_stats else None if show_mem: if server_stats and "mem_info" in server_stats: mem_info = server_stats["mem_info"] row.extend([mem_info["predictor_rss"], mem_info["total"]]) else: row.extend([-9999, -9999]) rows.append(row) if show_inside_server and server_stats: time_info = server_stats["time_info"] row.extend([ time_info["run_predictor_total"]["avg"], ]) table.add_rows(rows) tbl_report = table.draw() return tbl_report
def print_db_table(data_frame): tb = Texttable() tb.header(data_frame.columns.array) tb.set_max_width(0) # text * cols tb.set_cols_dtype(['t'] * data_frame.shape[1]) tb.add_rows(data_frame.to_numpy(), header=False) logger.info(tb.draw())
def createTable(headers, rows): table = Texttable() table.set_deco(Texttable.HEADER) table.set_precision(2) table.set_max_width(32) table.header(headers) for row in rows: table.add_row(row) return table
def generate_table(self, border=True, short=True): """Generate a Textable string with the report. Args: border (bool, optional): Border around the table. Defaults to True. short (bool, optional): Return only 10 rows/values. Defaults to False. Only for multi tables. """ table_final = "" table_obj = Texttable() table_obj.set_max_width(80) table_count = 0 for key in self.data.keys(): if table_count > 0 and self.table_type == 'multi': table_final += "\n\n" if self.table_type == 'single': data_value = self.data[key] table_obj.add_row([key, data_value]) else: # Second round, initialize another instance if table_count > 0: table_obj = Texttable() table_obj.set_max_width(80) table_obj.header([key]) value_count = 0 for value in self.data[key]: if short is True and value_count >= 10: table_obj.add_row(['[...]']) break # Print just 80 chars, improve readability short_value = value[0:76] table_obj.add_row([short_value]) value_count += 1 if border is False: table_obj.set_deco(Texttable.HEADER | Texttable.VLINES) else: table_obj.set_deco(Texttable.BORDER | Texttable.HEADER | Texttable.VLINES) # Print many tables for multi type if self.table_type == 'multi': table_final += table_obj.draw() table_count += 1 # Print just one table for single type if self.table_type == 'single': table_final += table_obj.draw() # short=False return table_final
def show_lcs_table(memo_table): table = Texttable() table.set_cols_align(["c", "c"]) table.set_cols_valign(["t", "t"]) table.set_deco(Texttable.VLINES | Texttable.BORDER) table.set_max_width(0) for memo_line in memo_table: table.add_row(memo_line) print(table.draw())
def show_table(header, data, mutiline=False): tb = Texttable() if mutiline: tb.add_rows(data) else: tb.add_row(data) tb.header(header) tb.set_max_width(150) print(tb.draw())
def printTextTable(alignment, header, data): tt = Texttable(0) tt.set_max_width(0) tt.set_deco(Texttable.HEADER) tt.set_cols_align(alignment) tt.header(header) tt.add_rows(data, header=False) print() print(tt.draw())
def print_model_attrs(attrs): table = Texttable() table.set_deco(Texttable.HEADER | Texttable.VLINES | Texttable.HLINES) table.set_max_width(180) table.add_rows(attrs) print((table.draw()))
def utilization(obj, targets): # This plugin only works for SlurmBackend backend_cls = Backend.from_config(obj) if not issubclass(backend_cls, SlurmBackend): raise GWFError('Utilization plugin only works for Slurm backend!') graph = Graph.from_config(obj) # If user specified list of targets, only report utilization for these. # Otherwise, report utilization for all targets. matches = graph.targets.values() if targets: matches = filter_names(matches, targets) with backend_cls() as backend: job_ids = [] for target in matches: try: job_ids.append(backend.get_job_id(target)) except KeyError: pass rows = [[ 'Target', 'Cores', 'Walltime Alloc', 'Walltime Used', 'Memory Alloc', 'Memory Used', 'CPU Time Alloc', 'CPU Time Used', 'Walltime %', 'Memory %', 'CPU %' ]] for job in get_jobs(job_ids): rows.append([ job.name, job.allocated_cores, pretty_time(job.allocated_time_per_core), pretty_time(job.used_walltime), pretty_size(job.allocated_memory), pretty_size(job.used_memory), pretty_time(job.allocated_cpu_time), pretty_time(job.used_cpu_time), str(format(job.walltime_utilization, '.1f')), format(job.memory_utilization, '.1f'), format(job.cpu_utilization, '.1f') ]) table = Texttable() table.set_deco(Texttable.BORDER | Texttable.HEADER | Texttable.VLINES) ncols = len(rows[0]) table.set_max_width(0) table.set_header_align('l' * ncols) table.set_cols_align(['l'] + (ncols - 1) * ['r']) table.set_cols_dtype(['t'] * ncols) table.add_rows(rows) print(table.draw())
def table_setup(model, width): if not isinstance(model, Model): raise TypeError('Error in model_table. ' + ': model argument must be a Model object') # show table of modifiers table = Texttable() table.set_deco(Texttable.HEADER | Texttable.HLINES) table.set_max_width(width) return table
def create_table(streams): '''Creates a terminal-friendly table from streams.''' table = Texttable() table.set_deco(Texttable.HEADER | Texttable.VLINES) table.set_header_align(['l', 'l', 'l']) table.set_max_width(0) data = [['Streamer', 'Title', 'Viewers']] data.extend( list( map( lambda stream: [stream.streamer, stream.name, stream.viewers], streams))) table.add_rows(data) return table.draw()
def short(args) -> None: table = Texttable() output = main(args) pran = list(output.values())[0]['PRAN Number'] date = list(output.values())[0]['Date'] header = [f"NPS {pran} ({date})", "Percentage", "Units", "NAV", "Value"] table.header(header) table.set_cols_dtype(['t', 't', 't', 't', 't']) table.set_max_width(0) for scheme, scheme_data in output.items(): row = [scheme, scheme_data['Percentage'], scheme_data['Total Units'].replace(',', ''), scheme_data['NAV (Rs.)'].replace(',', ''), scheme_data['Amount (Rs.)'].replace(',', '')] table.add_row(row) print(table.draw())
def validation_test(self): # TODO: create infrastructure to easily add more checks cmd_list = sys.argv cmd_list[1] = ArgumentsOptions.SCORE if ArgumentsOptions.OUTPUT not in cmd_list: cmd_list.extend([ ArgumentsOptions.OUTPUT, "placeholder_to_replace_later_during_test_case" ]) test_cases_results = [ self._basic_batch_prediction_check(), self._null_value_imputation_check(), ] table = Texttable() table.set_deco(Texttable.HEADER) try: terminal_size = shutil.get_terminal_size() table.set_max_width(terminal_size.columns) except Exception as e: pass header_names = ["Test case", "Status", "Details"] col_types = ["t", "t", "t"] col_align = ["l", "l", "l"] rows = [] rows.append(header_names) for test_name, test_passed, failure_message in test_cases_results: rows.append([ test_name, "PASSED" if test_passed else "FAILED", "" if test_passed else failure_message, ]) table.set_cols_dtype(col_types) table.set_cols_align(col_align) table.add_rows(rows) tbl_report = table.draw() print("\n\nValidation checks results") print(tbl_report)
def test_exceeding_max_width3(): table = Texttable() table.set_max_width(35) table.set_deco(Texttable.HEADER) table.add_rows([ ["key", "value"], [1, "a"], [2, "b"], [3, "very long, very long, very long"], ]) assert clean(table.draw()) == dedent('''\ key value =================================== 1 a 2 b 3 very long, very long, very long ''')
def get_locks(self): # Setup query api_url = f"https://api.masterlockvault.com/v4/product" query = api_url + '?' + self._get_cred_param() # make query response = self._make_query("GET", query, "") response = re.search('\[.*\]', response).group(0) response = json.loads(response) # print locks info t = Texttable() t.header(["Lock Name", "Product ID"]) t.set_max_width(0) for i in response: t.add_row([i['Name'], i['Id']]) print(t.draw())
def test_exceeding_max_width4(): table = Texttable() table.set_max_width(14) table.add_rows([ ["a", "b"], [1, "+"], [22, "++++++++"], ]) assert clean(table.draw()) == dedent('''\ +----+-------+ | a | b | +====+=======+ | 1 | + | +----+-------+ | 22 | +++++ | | | +++ | +----+-------+ ''')
def display_books_available_in_lib(): sql_select_Query = "select * from books_available_in_lib" cursor = mydb.cursor() cursor.execute(sql_select_Query) records = cursor.fetchall() index = 1 table = Texttable() table.set_max_width(max_width=120) table.add_row([ 'Index', 'ISBN', 'Can be rented flag', 'Total No Copies', 'No of copies lented', 'Book Description', 'Book Type' ]) for row in records: table.add_row([index, row[0], row[1], row[2], row[3], row[4], row[5]]) index += 1 print(table.draw())
def print_paths(self, paths): table = Texttable() table.set_max_width(400) table.set_cols_align(['l' for _ in range(8)]) table.set_cols_valign(['t' for _ in range(8)]) table.header([ 'direction', 'goal', 'point_type', 'point_id', 'distance', 'points', 'scores', 'final_score' ]) for path in paths: table.add_row([ self._point_direction_lookup[path['points'][0]], path['goal_type'], path['point_type'], path['point_id'], path['distance'], '\n'.join(map(str, path['points'])), '\n'.join(map(str, path['scores'])), path['final_score'] ]) print(table.draw())
def display_book(): sql_select_Query = "select * from book" cursor = mydb.cursor() cursor.execute(sql_select_Query) records = cursor.fetchall() index = 1 table = Texttable() table.set_max_width(max_width=150) table.add_row([ 'Index', 'ISBN', 'Title', 'Author', 'Subject Area', 'Language', 'Binding Type', 'Edition' ]) for row in records: table.add_row( [index, row[0], row[1], row[2], row[3], row[4], row[5], row[6]]) index += 1 print(table.draw())
def print(self): height_range = reversed(range(-1, self.get_height() + 1)) width_range = range(-1, self.get_width() + 1) table = Texttable() table.set_max_width(400) table.set_deco(Texttable.BORDER | Texttable.HLINES | Texttable.VLINES) table.set_cols_align(['l' for _ in width_range]) table.set_cols_valign(['t' for _ in width_range]) for y in height_range: row = [] for x in width_range: cell = self._get_cell((x, y)) row.append("'point': (" + str(x) + "," + str(y) + ")\n" + ("\n".join( "{!r}: {!r},".format(k.name, v.to_string()) for k, v in cell.items()))) table.add_row(row) print(table.draw())
def writetab(llargs, fout, kset): t = Texttable() t.set_max_width(500) info = ['dataset', 'al_type', 'knn', 'clustering'] restricted = ['knn', 'clustering'] header = [] format_row = [] # if show_exp_fd: # header = ["exp_fd"] # format_row.append("t") for k in info: if k not in ["exp_fd"]: header.append(k) format_row.append("t") # text header.append('AUC*') format_row.append('f') t.header(header) t.set_cols_dtype(format_row) for item, aucx in llargs: row = [] for k in info: if item['al_type'] == constants.AL_LP: row.append(item[k]) else: if k in restricted: row.append(None) else: row.append(item[k]) row.append(aucx) t.add_row(row) print("Subset: {}".format(kset)) print(t.draw()) # print in std_out ff = open(fout, 'w') print(t.draw(), file=ff) print("Subset: {}".format(kset), file=ff) ff.close()