def test_save_text(): console = Console(record=True, width=100) console.print("foo") with tempfile.TemporaryDirectory() as path: export_path = os.path.join(path, "rich.txt") console.save_text(export_path) with open(export_path, "rt") as text_file: assert text_file.read() == "foo\n"
def output_profiles( self, stats: ScaleneStatistics, pid: int, profile_this_code: Callable[[Filename, LineNumber], bool], python_alias_dir_name: Filename, python_alias_dir: Filename, profile_memory: bool = True, reduced_profile: bool = False, ) -> bool: """Write the profile out.""" # Get the children's stats, if any. if not pid: stats.merge_stats(python_alias_dir_name) try: shutil.rmtree(python_alias_dir) except BaseException: pass current_max: float = stats.max_footprint # If we've collected any samples, dump them. if (not stats.total_cpu_samples and not stats.total_memory_malloc_samples and not stats.total_memory_free_samples): # Nothing to output. return False # Collect all instrumented filenames. all_instrumented_files: List[Filename] = list( set( list(stats.cpu_samples_python.keys()) + list(stats.cpu_samples_c.keys()) + list(stats.memory_free_samples.keys()) + list(stats.memory_malloc_samples.keys()))) if not all_instrumented_files: # We didn't collect samples in source files. return False title = Text() mem_usage_line: Union[Text, str] = "" growth_rate = 0.0 if profile_memory: samples = stats.memory_footprint_samples if len(samples.get()) > 0: # Output a sparkline as a summary of memory usage over time. _, _, spark_str = sparkline.generate( samples.get()[0:samples.len()], 0, current_max) # Compute growth rate (slope), between 0 and 1. if stats.allocation_velocity[1] > 0: growth_rate = (100.0 * stats.allocation_velocity[0] / stats.allocation_velocity[1]) # If memory used is > 1GB, use GB as the unit. if current_max > 1024: mem_usage_line = Text.assemble( "Memory usage: ", ((spark_str, "blue")), (" (max: %6.2fGB, growth rate: %3.0f%%)\n" % ((current_max / 1024), growth_rate)), ) else: # Otherwise, use MB. mem_usage_line = Text.assemble( "Memory usage: ", ((spark_str, "blue")), (" (max: %6.2fMB, growth rate: %3.0f%%)\n" % (current_max, growth_rate)), ) null = open("/dev/null", "w") # Get column width of the terminal and adjust to fit. # Note that Scalene works best with at least 132 columns. if self.html: column_width = 132 else: column_width = shutil.get_terminal_size().columns console = Console( width=column_width, record=True, force_terminal=True, file=null, ) # Build a list of files we will actually report on. report_files: List[Filename] = [] # Sort in descending order of CPU cycles, and then ascending order by filename for fname in sorted( all_instrumented_files, key=lambda f: (-(stats.cpu_samples[f]), f), ): fname = Filename(fname) try: percent_cpu_time = (100 * stats.cpu_samples[fname] / stats.total_cpu_samples) except ZeroDivisionError: percent_cpu_time = 0 # Ignore files responsible for less than some percent of execution time and fewer than a threshold # of mallocs. if (stats.malloc_samples[fname] < self.malloc_threshold and percent_cpu_time < self.cpu_percent_threshold): continue report_files.append(fname) # Don't actually output the profile if we are a child process. # Instead, write info to disk for the main process to collect. if pid: stats.output_stats(pid, python_alias_dir_name) return True for fname in report_files: # Print header. percent_cpu_time = (100 * stats.cpu_samples[fname] / stats.total_cpu_samples) new_title = mem_usage_line + ( "%s: %% of time = %6.2f%% out of %6.2fs." % (fname, percent_cpu_time, stats.elapsed_time)) # Only display total memory usage once. mem_usage_line = "" tbl = Table( box=box.MINIMAL_HEAVY_HEAD, title=new_title, collapse_padding=True, width=column_width - 1, ) tbl.add_column("Line", justify="right", no_wrap=True) tbl.add_column("Time %\nPython", no_wrap=True) tbl.add_column("Time %\nnative", no_wrap=True) tbl.add_column("Sys\n%", no_wrap=True) tbl.add_column("GPU\n%", no_wrap=True) other_columns_width = 0 # Size taken up by all columns BUT code if profile_memory: tbl.add_column("Mem %\nPython", no_wrap=True) tbl.add_column("Net\n(MB)", no_wrap=True) tbl.add_column("Memory usage\nover time / %", no_wrap=True) tbl.add_column("Copy\n(MB/s)", no_wrap=True) other_columns_width = 72 + 5 # GPU tbl.add_column( "\n" + fname, width=column_width - other_columns_width, no_wrap=True, ) else: other_columns_width = 36 + 5 # GPU tbl.add_column( "\n" + fname, width=column_width - other_columns_width, no_wrap=True, ) # Print out the the profile for the source, line by line. with open(fname, "r") as source_file: # We track whether we should put in ellipsis (for reduced profiles) # or not. did_print = True # did we print a profile line last time? code_lines = source_file.read() # Generate syntax highlighted version for the whole file, # which we will consume a line at a time. # See https://github.com/willmcgugan/rich/discussions/965#discussioncomment-314233 syntax_highlighted = None if self.html: syntax_highlighted = Syntax( code_lines, "python", theme="default", line_numbers=False, code_width=None, ) else: syntax_highlighted = Syntax( code_lines, "python", theme="vim", line_numbers=False, code_width=None, ) capture_console = Console( width=column_width - other_columns_width, force_terminal=True, ) formatted_lines = [ SyntaxLine(segments) for segments in capture_console.render_lines(syntax_highlighted) ] for line_no, line in enumerate(formatted_lines, start=1): old_did_print = did_print did_print = self.output_profile_line( fname, LineNumber(line_no), line, console, tbl, stats, profile_this_code, profile_memory=profile_memory, force_print=True, suppress_lineno_print=False, is_function_summary=False, reduced_profile=reduced_profile, ) if old_did_print and not did_print: # We are skipping lines, so add an ellipsis. tbl.add_row("...") old_did_print = did_print # Potentially print a function summary. fn_stats = stats.build_function_stats(fname) print_fn_summary = False for fn_name in fn_stats.cpu_samples_python: if fn_name == fname: continue print_fn_summary = True break if print_fn_summary: tbl.add_row(None, end_section=True) txt = Text.assemble("function summary", style="bold italic") if profile_memory: tbl.add_row("", "", "", "", "", "", "", "", "", txt) else: tbl.add_row("", "", "", "", "", txt) for fn_name in sorted( fn_stats.cpu_samples_python, key=lambda k: stats.firstline_map[k], ): if fn_name == fname: continue if self.html: syntax_highlighted = Syntax( fn_name, "python", theme="default", line_numbers=False, code_width=None, ) else: syntax_highlighted = Syntax( fn_name, "python", theme="vim", line_numbers=False, code_width=None, ) # force print, suppress line numbers self.output_profile_line( fn_name, LineNumber(1), syntax_highlighted, # type: ignore console, tbl, fn_stats, profile_this_code, profile_memory=profile_memory, force_print=True, suppress_lineno_print=True, is_function_summary=True, reduced_profile=reduced_profile, ) console.print(tbl) # Report top K lines (currently 5) in terms of net memory consumption. net_mallocs: Dict[LineNumber, float] = defaultdict(float) for line_no in stats.bytei_map[fname]: for bytecode_index in stats.bytei_map[fname][line_no]: net_mallocs[line_no] += (stats.memory_malloc_samples[fname] [line_no][bytecode_index] - stats.memory_free_samples[fname] [line_no][bytecode_index]) net_mallocs = OrderedDict( sorted(net_mallocs.items(), key=itemgetter(1), reverse=True)) if len(net_mallocs) > 0: console.print("Top net memory consumption, by line:") number = 1 for net_malloc_lineno in net_mallocs: if net_mallocs[net_malloc_lineno] <= 1: break if number > 5: break output_str = ("(" + str(number) + ") " + ("%5.0f" % (net_malloc_lineno)) + ": " + ("%5.0f" % (net_mallocs[net_malloc_lineno])) + " MB") console.print(output_str) number += 1 # Only report potential leaks if the allocation velocity (growth rate) is above some threshold # FIXME: fixed at 1% for now. # We only report potential leaks where the confidence interval is quite tight and includes 1. growth_rate_threshold = 0.01 leak_reporting_threshold = 0.05 leaks = [] if growth_rate / 100 > growth_rate_threshold: vec = list(stats.leak_score[fname].values()) keys = list(stats.leak_score[fname].keys()) for index, item in enumerate(stats.leak_score[fname].values()): # See https://en.wikipedia.org/wiki/Rule_of_succession frees = item[1] allocs = item[0] expected_leak = (frees + 1) / (frees + allocs + 2) if expected_leak <= leak_reporting_threshold: leaks.append(( keys[index], 1 - expected_leak, net_mallocs[keys[index]], )) if len(leaks) > 0: # Report in descending order by least likelihood for leak in sorted(leaks, key=itemgetter(1), reverse=True): output_str = ( "Possible memory leak identified at line " + str(leak[0]) + " (estimated likelihood: " + ("%3.0f" % (leak[1] * 100)) + "%" + ", velocity: " + ("%3.0f MB/s" % (leak[2] / stats.elapsed_time)) + ")") console.print(output_str) if self.html: # Write HTML file. md = Markdown( "generated by the [scalene](https://github.com/plasma-umass/scalene) profiler" ) console.print(md) if not self.output_file: self.output_file = "/dev/stdout" console.save_html(self.output_file, clear=False) else: if not self.output_file: # No output file specified: write to stdout. sys.stdout.write(console.export_text(styles=True)) else: # Don't output styles to text file. console.save_text(self.output_file, styles=False, clear=False) return True
def hermes(args: Optional[List[str]] = None) -> None: """HermesPy Command Line Interface. Default entry point to execute hermespy `.yml` files via terminals. Args: args ([List[str], optional): Command line arguments. By default, the system argument vector will be interpreted. """ # Recover command line arguments from system if none are provided if args is None: args = sys.argv[1:] parser = argparse.ArgumentParser( description='HermesPy - The Heterogeneous Mobile Radio Simulator', prog='hermes') parser.add_argument( "-p", help="settings directory from which to read the configuration", type=str) parser.add_argument( "-o", help="output directory to which results will be dumped", type=str) parser.add_argument("-s", help="style of result plots", type=str) parser.add_argument('-t', '--test', action='store_true', help='run in test-mode, does not dump results') parser.add_argument('-l', '--log', action='store_true', help='log the console information to a txt file') arguments = parser.parse_args(args) input_parameters_dir = arguments.p results_dir = arguments.o style = arguments.s # Create console console = Console(record=arguments.log) console.show_cursor(False) # Draw welcome header console.print( "\n[bold green]Welcome to HermesPy - The Heterogeneous Radio Mobile Simulator\n" ) console.print(f"Version: {__version__}") console.print(f"Maintainer: {__maintainer__}") console.print(f"Contact: {__email__}") console.print( "\nFor detailed instructions, refer to the documentation https://barkhausen-institut.github.io/hermespy" ) console.print( "Please report any bugs to https://github.com/Barkhausen-Institut/hermespy/issues\n" ) # Validate command line parameters if not input_parameters_dir: input_parameters_dir = os.path.join(os.getcwd(), '_settings') elif not (os.path.isabs(input_parameters_dir)): input_parameters_dir = os.path.join(os.getcwd(), input_parameters_dir) console.log(f"Configuration will be read from '{input_parameters_dir}'") with console.status("Initializing Environment...", spinner='dots'): ################## # Import executable from YAML config dump factory = Factory() try: # Load serializable objects from configuration files serializables: List[Serializable] = factory.load( input_parameters_dir) # Filter out non-executables from the serialization list executables: List[Executable] = [ s for s in serializables if isinstance(s, Executable) ] # Abort execution if no executable was found if len(executables) < 1: console.log( "No executable routine was detected, aborting execution", style="red") exit(-1) # For now, only single executables are supported executable = executables[0] # Configure executable if results_dir is None: executable.results_dir = Executable.default_results_dir() else: executable.results_dir = results_dir except ConstructorError as error: print( "\nYAML import failed during parsing of line {} in file '{}':\n\t{}" .format(error.problem_mark.line, error.problem_mark.name, error.problem, file=sys.stderr)) exit(-1) # Configure console executable.console = console # Configure style if style is not None: executable.style = style # Inform about the results directory console.log("Results will be saved in '{}'".format( executable.results_dir)) # Dump current configuration to results directory if not arguments.test: shutil.copytree(input_parameters_dir, executable.results_dir, dirs_exist_ok=True) ################## # run simulation executable.execute() ########### # Goodbye :) console.log('Configuration executed. Goodbye.') # Save log if arguments.log: console.save_text(os.path.join(executable.results_dir, 'log.txt'))
print_table() # Get console output as text file1 = "table_export_plaintext.txt" text = console.export_text() with open(file1, "w") as file: file.write(text) print(f"Exported console output as plain text to {file1}") # Calling print_table again because console output buffer # is flushed once export function is called print_table() # Get console output as html # use clear=False so output is not flushed after export file2 = "table_export_html.html" html = console.export_html(clear=False) with open(file2, "w") as file: file.write(html) print(f"Exported console output as html to {file2}") # Export text output to table_export.txt file3 = "table_export_plaintext2.txt" console.save_text(file3, clear=False) print(f"Exported console output as plain text to {file3}") # Export html output to table_export.html file4 = "table_export_html2.html" console.save_html(file4) print(f"Exported console output as html to {file4}")
while tmp_threshold < 1.0: tmp_y_true = np.asarray(tmp_label) tmp_y_pred = np.squeeze((tmp_pred > tmp_threshold).astype(np.int64)) tn, fp, fn, tp = confusion_matrix(tmp_y_true, tmp_y_pred).ravel() precision = tp / (tp + fp) recall = tp / (tp + fn) f1_score = 2 * (precision * recall) / (precision + recall) accuracy = (tp + tn) / (tn + fp + fn + tp) if f1_score > best_f1_score: best_threshold = tmp_threshold best_precision = precision best_recall = recall best_f1_score = f1_score best_accuracy = accuracy tmp_progress_part.update(tmp_task_id, advance=1) tmp_threshold += 0.01 tmp_model_2_metrics['Threshold'] = round(best_threshold, 2) tmp_model_2_metrics['Precision'] = round(best_precision * 100, 2) tmp_model_2_metrics['Recall'] = round(best_recall * 100, 2) tmp_model_2_metrics['F1'] = round(best_f1_score * 100, 2) tmp_model_2_metrics['Accuracy'] = round(best_accuracy * 100, 2) data_2_model[data_type][model_name] = tmp_model_2_metrics console.log(f"[bold]{models_folder}[/bold] 模型集合评测结果") # 构建评测统计表格 # print(data_2_model) for tmp_dataset_name, tmp_data_dict in data_2_model.items(): construct_table(tmp_dataset_name, tmp_data_dict) console.log(f"Evaluating finished.") console.save_text(f'./{models_folder}模型集合评测结果.txt')