def wrapper(self, f, *args, **kwargs): # memory_profiler with StringIO() as s: rtn = profile(f, stream=s, precision=2)(*args, **kwargs) memory_value = self._memory_profiler_parse(s.getvalue()) # line_profiler prof = LineProfiler() prof.add_function(f) rtn = prof.runcall(f, *args, **kwargs) with StringIO() as s: prof.print_stats(stream=s) mix, line_tmp = self._line_profiler_parse(s.getvalue()) # memory line mix output template = self.L_M_TEMPLATE for l, m in zip(line_tmp, memory_value): l_m_mix = l[:5] + m mix.append(template.format(*l_m_mix)) mix[self.L_M_HEADER_INDEX] = template.format(*self.L_M_HEADER) mix[self.L_M_SEPARATOR_INDEX] += "=" * 27 self.logger.debug("line, memory profiler result\n" + "\n".join(mix)) return rtn
def newfunc(*args, **kwargs): if line_profile and getattr(sys, 'gettrace')() is None: from line_profiler import LineProfiler lp = LineProfiler() lp.timer_unit = 1e-6 for f in profile_funcs: lp.add_function(f) lp_wrapper = lp(func) t = time.time() res = lp_wrapper(*args, **kwargs) t = time.time() - t if verbose: lp.print_stats() return res, [t] else: t_lst = [] for i in range(100000): startTime = time.time() res = func(*args, **kwargs) t_lst.append(time.time() - startTime) if sum(t_lst) > min_time and len(t_lst) >= min_runs: if hasattr(func, '__name__'): fn = func.__name__ else: fn = "Function" if verbose: print('%s: %f +/-%f (%d runs)' % (fn, np.mean(t_lst), np.std(t_lst), i + 1)) return res, t_lst
def test_staircase_stats_profile(self): """ How to use line profiler in a script? https://stackoverflow.com/a/43377717/6610243 Returns ------- """ return sequence = [0, 0, 1, 1, 1, 0, 0, 0, 1, 0] force_terminate = [0, 1, 0, 0, 0, 0, 1, 0, 0, 0] try: from line_profiler import LineProfiler except ImportError: return # Baseline: Total time: 2.07796 s s for N = 10000 # Numpy: Total time: 2.11567 s # Combined 2 x n array: Total time: 1.5246 s # Total time: 1.19332 s # Remove creating temporary termination array for terminate == None: Total time: 1.19105 s # Switching 0 and 1 cases: Total time: 1.14139 s # Switching to: >2, 1, 0: Total time: 1.10141 s lp = LineProfiler() lp.add_function(strategy.DoubleStaircaseStrategy.get_staircase_stats) lp_wrapper = lp(lambda *args, **kwargs: [ strategy.DoubleStaircaseStrategy.get_staircase_stats( *args, **kwargs) for _ in range(10000) ]) lp_wrapper(sequence, step=(4, 2), force_terminate=force_terminate) with open("test_staircase_stats_profile.py", "w") as f: lp.print_stats(stream=f, output_unit=1e-3)
def profiled_func(*args, **kwargs): profiler = LineProfiler() profiler.add_function(func) for f in follow: profiler.add_function(f) profiler.enable_by_count() return func(*args, **kwargs)
def line_profile(items): """A context manager which prints a line-by-line profile for the given functions, modules, or module names while execution is in its context. Example: with line_profile(__name__, Class.some_function, some_module): do_something() """ from line_profiler import LineProfiler prof = LineProfiler() for item in items: if inspect.isfunction(item): prof.add_function(item) elif inspect.ismodule(item): prof.add_module(item) elif isinstance(item, str): prof.add_module(sys.modules[str]) else: raise TypeError( 'Inputs must be functions, modules, or module names') prof.enable() yield prof.disable() prof.print_stats()
def getNextDay(): try: year = int(entryYear.get()) month = int(entryMonth.get()) day = int(entryDay.get()) except ValueError as error: eLinter.set("时间格式不合法:") else: time_start = time.time() lp = LineProfiler() lp.add_function(main.isRunNian) lp_wrapper = lp(checkTime) lp_wrapper(year, month, day) lp.print_stats() str1 = checkTime(year, month, day) if '' != str1: eLinter.set(str1) eYear.set('') eMonth.set('') eDay.set('') eLunar.set('') return newYear, newMonth, newDay = main.getNextday(year, month, day) #在界面显示结果 eYear.set(str(newYear)) eMonth.set(str(newMonth)) eDay.set(str(newDay)) eLinter.set("") days = int(nextday.Lunar(newYear, newMonth, newDay).getDays()) week = ["星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"] #print(week[(days+1)%7]) eLunar.set( nextday.test(newYear, newMonth, newDay) + " " + week[(days + 1) % 7])
def benchmark(cls, func, *args): from line_profiler import LineProfiler prf = LineProfiler() prf.add_function(func) ret = prf.runcall(func, *args) prf.print_stats() return ret
def jungleprofiler_wrapped_f(*args, **kwargs): ''' Wrapper that collects time and system usage data on wrapped function f''' # Set up LineProfiler lp = LineProfiler() lp.add_function(f) # Set up MemoryProfiler pass # todo add Memory Profiler # Start Counters if self.t_prof: lp.enable_by_count() if self.m_prof: pass try: t0 = time.time() sio = io.StringIO() # Collects redirected stdout with redirect_stdout(sio): preturn = f(*args, **kwargs) self.stdout = sio.getvalue() t1 = time.time() finally: # Stop Counters if self.m_prof: lp.disable_by_count() if self.m_prof: pass # todo add Memory Profiler # Collect Stats # print('Get Stats: %s' % lp.print_stats()) self.walltime = t1 - t0 return preturn, copy.deepcopy(self)
def profiled_func(*args, **kwargs): try: profiler = LineProfiler() profiler.add_function(func) profiler.enable_by_count() return func(*args, **kwargs) finally: profiler.print_stats()
def profiled_func(*args, **kwargs): try: profiler = LineProfiler() profiler.add_function(func) profiler.enable_by_count() return func(*args, **kwargs) finally: profiler.print_stats()
def wrap(*args, **kwargs): profile = LineProfiler() profile.add_function(f) profile.enable_by_count() result = f(*args, **kwargs) profile.disable_by_count() profile.print_stats(sys.stdout) return result
def DataReader_bin_test2(self): self.select_file(num=1) prf = LineProfiler() prf.add_function(self.read_bin_file_to_tx2) prf.runcall(self.read_bin_file_to_tx2, start=3 * 10**7, datapoints=10**6) prf.print_stats() print(len(self.x), math.log10((len(self.x)))) self.plot_timecorse_of_move(show_it=1)
def profiled_func(*args, **kwargs): try: lp = LineProfiler() lp.add_function(f) lp.enable_by_count() return f(*args, **kwargs) finally: lp.print_stats()
def profiled_func(*args, **kwargs): line_profiler = LineProfiler() line_profiler.add_function(func) map(lambda x: line_profiler.add_function(x), self.follow) line_profiler.enable_by_count() result = func(*args, **kwargs) line_profiler.disable_by_count() line_profiler.print_stats(stripzeros=True) return result
def decorator(*args, **kwargs): # line-profiler==3.0.2 profiler = LineProfiler() try: profiler.add_function(func) profiler.enable_by_count() return func(*args, **kwargs) finally: profiler.dump_stats('/var/log/{}.lprof'.format(time.time()))
def wrapper(*args, **kwargs): try: profiler = LineProfiler() profiler.add_function(func) for f in follow: profiler.add_function(f) profiler.enable_by_count() return func(*args, **kwargs) finally: profiler.print_stats()
def DataReader_bin_test2(self): self.select_file(num=1) prf = LineProfiler() prf.add_function(self.read_bin_file_to_tx2) prf.runcall(self.read_bin_file_to_tx2, start=3 * 10**7, datapoints=10**6) prf.print_stats() print(len(self.x), math.log10((len(self.x)))) self.plot_timecorse_of_move(show_it=1)
def wrapped_fn(*args, **kwargs): try: profiler = LineProfiler() profiler.add_function(fn) for f in follow: profiler.add_function(f) profiler.enable_by_count() return fn(*args, **kwargs) finally: profiler.print_stats()
def profiled_func(*args, **kwargs): try: profiler = LineProfiler() profiler.add_function(func) for f in follow: profiler.add_function(getattr(args[0], f)) profiler.enable_by_count() return func(*args, **kwargs) finally: profiler.print_stats()
def profiled_func(*args, **kwargs): try: pf = LineProfiler() pf.add_function(func) for f in follow: pf.add_function(f) pf.enable_by_count() return func(*args, **kwargs) finally: pf.print_stats()
def timetest(func, *para): p = LineProfiler() p.add_function(func) p.enable_by_count() p_wrapper = p(func) p_wrapper(*para) # Printing print(func(*para)) p.print_stats()
def wrapper(self, f, *args, **kwargs): prof = LineProfiler() prof.add_function(f) rtn = prof.runcall(f, *args, **kwargs) with StringIO() as f: prof.print_stats(stream=f) msg = "line_profiler result\n{}".format(f.getvalue()) self.logger.debug(msg) return rtn
def profile_on(fcn_names=None): if fcn_names and HAS_LINE_PROFILER: pr = LineProfiler() for fcn_name in fcn_names: pr.add_function(fcn_name) pr.enable() return pr pr = cProfile.Profile() pr.enable() return pr
def profile_on(fcn_names=None): if fcn_names and HAS_LINE_PROFILER: pr = LineProfiler() for fcn_name in fcn_names: pr.add_function(fcn_name) pr.enable() return pr pr = cProfile.Profile() pr.enable() return pr
def wrapper(*args, **kwargs): profiler = LineProfiler() profiler.add_function(fn) try: for f in follow: profiler.add_function(f) profiler.enable_by_count() return fn(*args, **kwargs) finally: profiler.print_stats(output_unit=1) profiler.dump_stats(report)
def run_profiling_by_line(func, kwargs): line_profiler = LineProfiler() functions = inspect.getmembers(inspect.getmodule(func), inspect.isfunction) function_instances = dict(functions).values() for function_instance in function_instances: if function_instance is not func: line_profiler.add_function(function_instance) line_profiler_wrapper = line_profiler(func) line_profiler_wrapper(**kwargs) line_profiler.print_stats()
def profiled_func(*args, **kwargs): try: profiler = LineProfiler() profiler.add_function(func) for f in follow: if isinstance(f, basestring): f = to_function(f) profiler.add_function(f) profiler.enable_by_count() return func(*args, **kwargs) finally: profiler.print_stats()
def profiled_func(*args, **kwargs): try: profiler = LineProfiler() profiler.add_function(func) for f in follow: if isinstance(f, six.string_types): f = to_function(f) profiler.add_function(f) profiler.enable_by_count() return func(*args, **kwargs) finally: profiler.print_stats()
def profiled_func(*args, **kwargs): try: profiler = LineProfiler() profiler.add_function(func) if follow_all_methods: cls = args[0] # class instance _add_all_class_methods(profiler, cls, except_=func.__name__) for f in follow: _add_function_or_classmethod(profiler, f, args) profiler.enable_by_count() return func(*args, **kwargs) finally: profiler.print_stats()
def create_line_profile(*args): line_profiler = LineProfiler() line_profiler.enable_by_count() for klass in args: for attr in dir(klass): func = getattr(klass, attr) condition = (not inspect.isfunction(func), not inspect.ismethod(func)) if all(condition): continue line_profiler.add_function(func) return line_profiler
def __call__(self, *args, **kwargs): result = None if logger.getEffectiveLevel() == logging.MPROFILE: import sys result = self.function(*args, **kwargs) logger.debug(">>Tracing memory size : return object is %s bytes", sys.getsizeof(result)) elif logger.getEffectiveLevel() == logging.CPROFILE: import cProfile profile = cProfile.Profile() try: profile.enable() result = self.function(*args, **kwargs) profile.disable() finally: profile.print_stats() elif logger.getEffectiveLevel() == logging.LPROFILE: try: from line_profiler import LineProfiler try: profiler = LineProfiler() profiler.add_function(self.function) profiler.enable_by_count() result = self.function(*args, **kwargs) finally: profiler.print_stats() except ImportError: logger.debug("Error importing line_profiler.") return self.function(*args, **kwargs) elif logger.getEffectiveLevel() == logging.MEMPROFILE: try: from memory_profiler import LineProfiler, show_results try: profiler = LineProfiler() profiler.add_function(self.function) profiler.enable_by_count() result = self.function(*args, **kwargs) finally: show_results(profiler) except ImportError: logger.debug("Error importing memory_profiler.") result = self.function(*args, **kwargs) else: result = self.function(*args, **kwargs) return result
def process(cell_id): if strtobool(get_param(DbName.COMMON, 'profile')[0]): print('cell id : {}'.format(cell_id)) pr = LineProfiler() rtg = RdfToGcnf(cell_id) pr.add_function(rtg.create_gcn_file) pr.enable() rtg.create_gcn_file() pr.disable() pr.print_stats() del rtg else: rtg = RdfToGcnf(cell_id) rtg.create_gcn_file() del rtg
def line( cls_runner: tp.Type[Perf], pattern_func: str, ) -> None: runner = cls_runner() for name in runner.iter_function_names(pattern_func): f = getattr(runner, name) profiler = LineProfiler() if not runner.meta: raise NotImplementedError('must define runner.meta') profiler.add_function(runner.meta[name].line_target) profiler.enable() f() profiler.disable() profiler.print_stats()
def speedtest_validate_transaction(): # create a transaction b = bigchaindb.Bigchain() tx = b.create_transaction(b.me, b.me, None, 'CREATE') tx_signed = b.sign_transaction(tx, b.me_private) # setup the profiler profiler = LineProfiler() profiler.enable_by_count() profiler.add_function(bigchaindb.Bigchain.validate_transaction) # validate_transaction 1000 times for i in range(1000): b.validate_transaction(tx_signed) profiler.print_stats()
def _conduct_test_and_write_stats(cipher_obj: Cipher) -> bool: """ The cipher object to run encryption and then decryption. Write to a file detailing the statistics of encryption and decryption. :param cipher_obj: (_cipher.Cipher) The cipher object to encrypt and decrypt with :return: (bool) THe success or failure of the encryption and decryption """ # Setup for encrypting/decrypting with profiling lp = LineProfiler() # Set up the line-profiler object module_name = str(type(cipher_obj)).split(".")[ -2] # Get the name of the module that cipher_obj uses class_name = str(type(cipher_obj)).split(".")[-1][ 0:-2] # Get the class that cipher_obj is functions = eval("inspect.getmembers({}.{}, " "predicate=inspect.isfunction)".format( module_name, class_name)) functions = [item[0] for item in functions ][1:] # Only want names. Also, ignore first element (init) functions.remove("encrypt_plaintext") functions.remove("decrypt_ciphertext") functions.remove("write_statistics") # Add all function/method to profile lp.add_function(undecorated.undecorated(cipher_obj.encrypt_plaintext)) lp.add_function(undecorated.undecorated(cipher_obj.decrypt_ciphertext)) for function in functions: exec("lp.add_function(undecorated.undecorated({}.{}.{}))".format( module_name, class_name, function)) # Encrypt and decrypt. Also, profile TODO lp_wrapped = lp(cipher_obj.encrypt_plaintext) # Wrap encrypt_plaintext() lp_wrapped() lp_wrapped = lp(cipher_obj.decrypt_ciphertext) # Wrap decrypt_ciphertext() lp_wrapped() lp.print_stats() # Generate file name and write to that file containing the statistics of the encryption and decryption cipher_name = str(type(cipher_obj)) cipher_name = cipher_name[cipher_name.rfind(".") + 1:-2] stats_file_path = "Resources/Files_Logs/{}__{}"\ .format(cipher_name, datetime.datetime.now().strftime("%Y-%m-%d_%Hh%Mm%Ss")) cipher_obj.write_statistics(stats_file_path) # Return the correctness of the encryption and decryption return cipher_obj.original_plaintext == cipher_obj.plaintext
def run_profiling(args): lprofiler = LineProfiler() monitor_fuctions = [ api.problem.submit_key, api.problem.get_unlocked_pids, api.problem.get_solved_pids, api.problem.get_all_problems, api.problem.get_solved_problems, api.stats.get_score, api.cache.memoize, api.autogen.grade_problem_instance, api.autogen.get_problem_instance, api.autogen.get_number_of_instances ] for func in monitor_fuctions: lprofiler.add_function(func) lprofiler.enable() if args.stack: profiler = Profiler(use_signal=False) profiler.start() for func, a, kw in operations: func(*a, **kw) if args.stack: profiler.stop() lprofiler.disable() if args.print: print(profiler.output_text(unicode=True, color=True)) lprofiler.print_stats() output = open(args.output, "w") if args.stack: output.write(profiler.output_text(unicode=True)) if args.output_html is not None: output_html = open(args.output_html, "w") output_html.write(profiler.output_html()) output_html.close() print("Wrote test info to " + args.output_html) lprofiler.print_stats(output) output.close() print("Wrote test info to " + args.output)
def run_and_profile(self): if len(self._funcs_to_profile) > 0: profiler = LineProfiler() for func in self._funcs_to_profile: profiler.add_function(func) profiler.enable_by_count() try: yield finally: with io.StringIO() as str_stream: profiler.print_stats(str_stream) string = str_stream.getvalue() print(f'Writing profile data to "{self._output_filenmae}"') with open(self._output_filenmae, 'w') as fid: fid.write(string) else: yield
def profile(): import termcolor import time from line_profiler import LineProfiler epoch = int(time.time()) outfile = f"compare50_profile_{epoch}.txt" profiler = LineProfiler() for f in PROFILE: profiler.add_function(f) profiler.enable_by_count() try: yield finally: with open(outfile, "w") as f: profiler.print_stats(stream=f) termcolor.cprint(f"Profiling data written to {outfile}", "yellow")
class Profiler(object): def __init__(self, *args): self.profile = LineProfiler() if len(args) > 0: for func in args: if callable(func): self.add_function(func) def add_function(self, func): self.profile.add_function(func) def __enter__(self): self.profile.enable_by_count() def __exit__(self, type, value, traceback): self.profile.disable_by_count() self.profile.print_stats()
def run_profiling(args): lprofiler = LineProfiler() monitor_fuctions = [api.problem.submit_key, api.problem.get_unlocked_pids, api.problem.get_solved_pids, api.problem.get_all_problems, api.problem.get_solved_problems, api.stats.get_score, api.cache.memoize, api.autogen.grade_problem_instance, api.autogen.get_problem_instance, api.autogen.get_number_of_instances] for func in monitor_fuctions: lprofiler.add_function(func) lprofiler.enable() if args.stack: profiler = Profiler(use_signal=False) profiler.start() for func, a, kw in operations: func(*a, **kw) if args.stack: profiler.stop() lprofiler.disable() if args.print: print(profiler.output_text(unicode=True, color=True)) lprofiler.print_stats() output = open(args.output, "w") if args.stack: output.write(profiler.output_text(unicode=True)) if args.output_html is not None: output_html = open(args.output_html, "w") output_html.write(profiler.output_html()) output_html.close() print("Wrote test info to " + args.output_html) lprofiler.print_stats(output) output.close() print("Wrote test info to " + args.output)
ret = [name for name in availableAI] return GetResp((200, {"aiList": ret})) @app.route('/') @app.route('/index.html') def Index(): if request.url.startswith('https://'): url = request.url.replace('https://', "http://", 1) return redirect(url, 301) i = InfoDb.query.get(0) if i != None: aiOnly = i.ai_only else: aiOnly = False return render_template('index.html', aiOnly=aiOnly) @app.route('/admin.html') def Admin(): if request.url.startswith('https://'): url = request.url.replace('https://', "http://", 1) return redirect(url, 301) return render_template('admin.html') if pr: pr.add_function(GetGameInfo) pr.add_function(CellDb.Attack) pr.add_function(UpdateGame)
m = DFMessage(fmt, elements, False) except ValueError: return self._parse_next() self._add_msg(m) return m if __name__ == "__main__": import sys use_profiler = False if use_profiler: from line_profiler import LineProfiler profiler = LineProfiler() profiler.add_function(DFReader_binary._parse_next) profiler.add_function(DFReader_binary._add_msg) profiler.add_function(DFReader._set_time) profiler.enable_by_count() filename = sys.argv[1] if filename.endswith('.log'): log = DFReader_text(filename) else: log = DFReader_binary(filename) while True: m = log.recv_msg() if m is None: break #print(m) if use_profiler:
def _transform_STRIKED(self, match: Match) -> str: if not match['STRIKED_TEXT']: return '' return f"<s>{self._parse(match['STRIKED_TEXT'], 'STRIKED')}</s>" def _transform_SUPERSCRIPT(self, match: Match) -> str: if not match['SUPERSCRIPT_TEXT']: return '' return f"<sup>{self._parse(match['SUPERSCRIPT_TEXT'], 'SUPERSCRIPT')}</sup>" def _transform_SUBSCRIPT(self, match: Match) -> str: if not match['SUBSCRIPT_TEXT']: return '' return f"<sub>{self._parse(match['SUBSCRIPT_TEXT'], 'SUBSCRIPT')}</sub>" def _transform_HORIZ_RULE(self, match: Match) -> str: return f'<hr />' def _post_BACKSLASH_UNESCAPE(self, text: str) -> str: return self._backslash_escape_re.sub(r'\1', text) d = DefaultRenderer() if __name__ == '__main__': from line_profiler import LineProfiler lp = LineProfiler() lp.add_function(d._parse) lp.runcall(d.parse, '*****' * 2000) lp.print_stats() print(d.parse('**__hi__**'))
# Test and profile TimeHistogram # # Copyright (C) 2010-2012 Huang Xin # # See LICENSE.TXT that came with this file. #import cProfile,pstats from line_profiler import LineProfiler import TimeHistogram def run(): psth = TimeHistogram.PSTHAverage('/home/chrox/dev/plexon_data/c04-stim-timing-8ms-rand-1.plx') psth.get_data() if __name__ == '__main__': #cProfile.run('psth.get_data()','hist_profile') #p = pstats.Stats('hist_profile') #p.sort_stats('cumulative') #p.print_stats() profile = LineProfiler() profile.add_function(run) profile.add_function(TimeHistogram.PSTHAverage._process_unit) profile.run('run()') profile.print_stats() profile.dump_stats("hist_profile.lprof")
for timestamp in bit_2_events[-5:]: print "unstrobed bit 2 t=%f" % timestamp print "found %d bit 3 events. Last 5 events are:" %(len(bit_3_events)) for timestamp in bit_3_events[-5:]: print "unstrobed bit 3 t=%f" % timestamp unstrobed_word = pu.GetExtEvents(data, event='unstrobed_word', online=False) print "found %d unstrobed word events in which 10 events are:" %(len(unstrobed_word['value'])) indices = np.arange(0,len(unstrobed_word['value']),len(unstrobed_word['value'])/10) for value,timestamp in zip(unstrobed_word['value'][indices],unstrobed_word['timestamp'][indices]) : binary_value = bin(value) print "unstrobed word:%s t=%f" % (binary_value,timestamp) if __name__ == "__main__": #run() profile = LineProfiler() profile.add_function(run) profile.add_function(PlexUtil.GetExtEvents) profile.add_function(reconstruct_word) profile.run('run()') profile.print_stats() profile.dump_stats("testPlexFile_profile.lprof") #cProfile.run('run()','PlexFile_profile') #p = pstats.Stats('testPlexFile_profile.lprof') #p.sort_stats('cumulative') #p.print_stats() #print h.heap()
class SpecialTestRunner(SpecialTest): """ Test runner, calls the specified test under specified profiler Mode = None - no profiler, "c" - cProfile, "l" - LineProfiler, "h" - hotshot """ def __init__(self, test, mode=None): super(SpecialTestRunner, self).__init__() self.mode = mode self.test = test self.profiler = None def setup(self): if self.mode == 'c': import cProfile self.profiler = cProfile.Profile() elif self.mode == 'l': from line_profiler import LineProfiler self.profiler = LineProfiler() elif self.mode == 'h': import hotshot self.info['name'] = 'special.prof' self.profiler = hotshot.Profile(self.info['name']) self.test.setup() def run(self): if self.mode == 'c': self.profiler.enable() elif self.mode == 'l': self.profiler.enable_by_count() self.profiler.add_function(Handler.handle) self.profiler.add_function(Condition.check_string_match) self.profiler.add_function(Condition.check_function) self.profiler.add_function(Condition.check_list) t = Timer() # Run itself if self.mode == 'h': self.profiler.runcall(self.test.run) else: self.test.run() print('Test time: %s' % t.delta()) if self.mode == 'c': import pstats import StringIO self.profiler.disable() sio = StringIO.StringIO() ps = pstats.Stats(self.profiler, stream=sio).sort_stats('time') ps.print_stats() print(sio.getvalue()) elif self.mode == 'h': import hotshot.stats print('Processing results...') self.profiler.close() name = self.info['name'] stats = hotshot.stats.load(name) stats.strip_dirs() stats.sort_stats('time', 'calls') stats.print_stats(50) print('Run "hotshot2calltree -o %s.out %s" to generate the cachegrind file' % (name, name)) elif self.mode == 'l': self.profiler.disable() self.profiler.print_stats()
properties[i].append(objects[j].moments_hu()) properties[i].append(objects[j].image()) properties[i].append(objects[j].label) properties[i].append(objects[j].major_axis_length()) properties[i].append(objects[j].max_intensity()) properties[i].append(objects[j].mean_intensity()) properties[i].append(objects[j].min_intensity()) properties[i].append(objects[j].minor_axis_length()) properties[i].append(objects[j].moments()) properties[i].append(objects[j].moments_normalized()) properties[i].append(objects[j].orientation()) properties[i].append(objects[j].perimeter()) properties[i].append(objects[j].solidity()) properties[i].append(objects[j].weighted_moments_central()) properties[i].append(objects[j].weighted_centroid()) properties[i].append(objects[j].weighted_moments_hu()) properties[i].append(objects[j].weighted_moments()) properties[i].append(objects[j].weighted_moments_normalized()) return properties, prop_names if __name__ == '__main__': image = io.imread('test-image.png') green = image[..., 1].copy() lp = LineProfiler() lp.add_function(object_features) lp.run('intensity_object_features(green, 100)') lp.print_stats() lp.dump_stats('profile.lprof') print(__file__)