def calibrateprofile(): pr = profile.Profile() calib = [] crepeat = 10 for i in range(crepeat): calib.append(pr.calibrate(10000)) final = sum(calib) / crepeat profile.Profile.bias = final # Apply computed bias to all Profile instances created hereafter return final
def run(self, func, *args, **params): """Dump profile data into self.path.""" global _count c = _count = _count + 1 path = os.path.join(self.path, "cp_%04d.prof" % c) prof = profile.Profile() result = prof.runcall(func, *args, **params) prof.dump_stats(path) return result
def profile_stream(stream_class, filename, n=20): p = profile.Profile() def many_calls(filename, n): for i in xrange(n): ts = stream_class(open(filename, 'rb')) while ts.get() is not None: pass p.runcall(many_calls, filename, n) p.print_stats()
def read_file(filename, profile_list): # open file containing profiles with open(filename, mode="r") as infile: # set counter index = 0 # loop through file, begin at first line for line in infile: # split first line for first name, family name, email and gender get_word = line.split() # get first object being first name given_name = get_word[0] # get second object being last name family_name = get_word[1] # get third object being email email = get_word[2] # get fourth object being gender gender = get_word[3] # get next line for status line = infile.readline() # strip line break after status status = str(line.strip('\n')) # create new array (using profile class) containing all objects that were set to the variables we needed new_profile = profile.Profile(given_name, family_name, email, gender, status) # build profile list from just created array # I know list function insert val was required, however this works for PART A, but did not work here ;_( #profile_list = list_function.insert_value(profile_list, new_profile, index) profile_list.append(new_profile) # get next line for number of friends line = int(infile.readline()) # for debugging purposes - count of line #print(line) # if line is greater than zero, for each friends in range between zero and the total friends, read each line - # friends email addresses if int(line) > 0: for friends in range(0, int(line)): line = infile.readline() friend = line.strip('\n') new_profile.add_friend(friend) #increment index += 1 # close file infile.close return profile_list
def _(*args, **kwargs): import profile prof = profile.Profile() try: result = prof.runcall(f, *args, **kwargs) prof.dump_stats(outputFile) except SystemExit: pass prof.print_stats() return result
def test_main(): global ticks ticks = 42000 prof = profile.Profile(timer) prof.runctx("testfunc()", globals(), locals()) assert ticks == 43000, ticks st = pstats.Stats(prof) st.strip_dirs().sort_stats('stdname').print_stats() st.print_callees() st.print_callers()
def run(cmd): prof = profile.Profile() try: stats = pstats.Stats(prof.run(cmd)) except SystemExit: pass stats.strip_dirs().sort_stats("time", "module", "name") win = PStatWindow(stats) win.show() mainloop()
def __call__(self, *args): global profiler_stats profiler = profile.Profile() if profiler_stats is None: profiler_stats = pstats.Stats(profiler) ps = profiler_stats # thread-etc safe - even if the global goes away under us, this wont! ret = profiler.runcall(self.callme, *args) if ps is not None: ps.add(profiler) return ret
def test_random_kmers_are_correct_length(self): self.random_profile = profile.Profile('test_data_set_2.txt') times = 1000 while times > 0: random_motifs = self.randomized_motif_search._random_k_mers( self.random_profile.k, self.random_profile.dna) for text in random_motifs: self.assertEqual(len(text), 6, 'Each random kmer is correct length') times -= 1
def run_test(outFile, xmlFile, stylesheets): tempFileName = tempfile.mktemp() p = Processor.Processor() prof = profile.Profile() prof.runctx("profile_test(p,xmlFile,stylesheets)", globals(), locals()) prof.dump_stats(tempFileName) return tempFileName
def func_wrapper(self, module, input): try: event = input['event'] # *** Filter indirect events out (like for groups related to the configured item) if getattr(event, "getItemName", None) is not None and event.getItemName( ) not in self.triggerItems: self.log.debug("Rule skipped. Event is not related" + appendDetailInfo(self, event)) return except KeyError: event = None try: start_time = time.clock() # *** execute if proxy.profile: pr = profile.Profile() #self.log.debug(str(getItem("Lights"))) #pr.enable() pr.runctx( 'func(self, module, input)', { 'self': self, 'module': module, 'input': input, 'func': func }, {}) status = None else: status = func(self, module, input) if proxy.profile: #pr.disable() s = io.BytesIO() #http://www.jython.org/docs/library/profile.html#the-stats-class ps = pstats.Stats(pr, stream=s).sort_stats('cumulative') ps.print_stats() self.log.debug(s.getvalue()) if status is None or status is True: elapsed_time = round((time.clock() - start_time) * 1000, 1) msg = "Rule executed in " + "{:6.1f}".format( elapsed_time) + " ms" + appendDetailInfo(self, event) self.log.debug(msg) except NotInitialisedException as e: self.log.warn("Rule skipped: " + str(e)) except: self.log.error("Rule execution failed:\n" + traceback.format_exc())
def publish_module_profiled(module_name, stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr, environ=os.environ, debug=0, request=None, response=None): import profile, pstats global _pstat _plock.acquire() try: if request is not None: path_info = request.get('PATH_INFO') else: path_info = environ.get('PATH_INFO') if path_info[-14:] == 'manage_profile': return _pfunc(module_name, stdin=stdin, stdout=stdout, stderr=stderr, environ=environ, debug=debug, request=request, response=response) pobj = profile.Profile() pobj.runcall(pm, module_name, stdin, stdout, stderr, environ, debug, request, response) result = sys._pr_ pobj.create_stats() if _pstat is None: _pstat = sys._ps_ = pstats.Stats(pobj) else: _pstat.add(pobj) finally: _plock.release() if result is None: try: error = sys.exc_info() file = open(_pfile, 'w') file.write( "See the url " "http://www.python.org/doc/current/lib/module-profile.html" "\n for information on interpreting profiler statistics.\n\n") sys.stdout = file _pstat.strip_dirs().sort_stats('cumulative').print_stats(250) _pstat.strip_dirs().sort_stats('time').print_stats(250) file.flush() file.close() except: pass raise error[0], error[1], error[2] return result
def main(): parse_cmdline(sys.argv[1:]) if not PROFILE: gamesrv.mainloop() else: import profile prof = profile.Profile() try: prof = prof.run('gamesrv.mainloop()') finally: prof.dump_stats('profbb')
def data_prep(seed): profile = profile.Profile() interest = interest.Interest() preprocess = preprocess.Preprocessor() profile_raw = profile.get_profile() interest_raw, ids = interest.data_merge() data = preprocess.finalize_data(profile_raw, interest_raw) X, y, X_train, y_train, X_test, y_test = preprocess.split_data(data, seed=seed, re=False) return X, y, X_train, y_train, X_test, y_test, ids
def run_it_with_profiling(): import profile p = profile.Profile() p.runcall(app.start) import tempfile ( tmpfile, tmpfname, ) = tempfile.mkstemp(prefix='shtoomphone') p.dump_stats(tmpfname) del p
def getProfileListFromFile(): import profile # get latest profileList = [] with open(profilePath) as data_file: js = json.load(data_file) l = js["profile"] ###### for item in l: p = profile.Profile(item["name"], item["startDateTime"], item["interval"], item["period"]) profileList.append(p) return profileList
def profile(self, filename): p = profile.Profile() com = 'execfile("%s")' % filename p.run(com) p.snapshot_stats() outf = tempfile.mktemp('pida-profile') f = open(outf, 'w') s = pickle.dump(p.stats, f) f.close() self.ipc.write('stats', outf, 8) while gtk.events_pending(): gtk.main_iteration()
def test_profile_module(self): def test(a, b): return a * b a, b = (2, 3) prof = profile.Profile() ret = prof.runcall(test, a, b) prof.print_stats() self.assertIsInstance(ret, int) self.assertEqual(ret, 6) self.assertRegexpMatches(sys.stdout.getvalue(), r'3 function calls in [0-9\.]+ seconds')
def greedy_motif_search(dna, k, t): first_motifs = first_kmers(dna, k) best_profile = profile.Profile(None, k, first_motifs, 1) best_score = [best_profile.motif_score(), first_motifs] for i in range(0,len(dna[0])-k+1): motifs = [dna[0][i:i+k]] motif_profile = profile.Profile(None, k, motifs, 1) for j in range(1,len(dna)): most_probable_kmers = most_probable(motif_profile, [dna[j]]) for motif in most_probable_kmers: if motif is not None: motifs.extend([motif]) else: motifs.extend([first_motifs[j]]) motif_profile = profile.Profile(None, k, motifs, 1) resulting_kmers = [dna[j], most_probable_kmers, motif_profile.motif_score()] motif_profile = profile.Profile(None, k, motifs, 1) current_score = motif_profile.motif_score() if current_score < best_score[0]: best_score = [current_score, motifs] return best_score[1]
def profile(fn, *args): import profile prof = profile.Profile() try: # roll on 1.6 :-) # return prof.runcall(fn, *args) return prof.runcall(*(fn, ) + args) finally: import pstats # Damn - really want to send this to Excel! # width, list = pstats.Stats(prof).strip_dirs().get_print_list([]) pstats.Stats(prof).strip_dirs().sort_stats("time").print_stats()
def calibrateprofile(): ''' Calibrate the profiler (necessary to have non negative and more exact values) ''' pr = profile.Profile() calib = [] crepeat = 10 for i in range(crepeat): calib.append(pr.calibrate(10000)) final = sum(calib) / crepeat profile.Profile.bias = final # Apply computed bias to all Profile instances created hereafter return final
def run(statement, *args): import sys, profile, time prof = profile.Profile(time.time) try: prof = prof.run(statement) except SystemExit: pass if args: prof.dump_stats(args[0]) else: return prof.print_stats()
def doProfile(httpd, howmany): #h = hotshot.Profile("dwikin.prof") #h.runcall(runLimited, (httpd, howmany)) #h.close() #stats = hotshot.stats.load("dwikin.prof") p = profile.Profile() p.runcall(runLimited, httpd, howmany) stats = pstats.Stats(p) stats.strip_dirs() stats.sort_stats("time", "calls") stats.print_stats(40)
def wrapper(*args, **kwargs): import profile res = ObjectStateHolderVector() prof = profile.Profile() try: res = prof.runcall(main_fn, *args, **kwargs) except SystemExit: pass if filename is not None: prof.dump_stats(filename) else: prof.print_stats(sort) return res
def profile_main(n=18): import profile, pstats print "Running under profiler...." profiler = profile.Profile() try: profiler.runctx('main()', globals(), locals()) finally: sys.stdout = logfile profiler.dump_stats('@html2ps.prof') p = pstats.Stats('@html2ps.prof') p.strip_dirs().sort_stats('time').print_stats(n) p.print_callers(n) p.sort_stats('cum').print_stats(n)
def test_bioinformatics_book_p92(self): alt_file = 'fixtures/bioinformatics_book_p92.txt' self.alt_profile = profile.Profile(alt_file) dna_strings = [ "TTACCTTAAC", "GATGTCTGTC", "ACGGCGTTAG", 'CCCTAACGAG', "CGTCAGAGGT" ] self.assertEqual( ' '.join( self.randomized_motif_search.most_probable( self.alt_profile, dna_strings)), "ACCT ATGT GCGT ACGA AGGT", 'Computes most probable k-mer pattern in dna')
def add_profile(profile_list): email = input('Please enter email address: ') if find_profile(profile_list, email) > -1: print(f'<{email}> already exists in profiles.') else: g_name = input('Please enter given name: ') f_name = input('Please enter family name: ') gender = input('Please enter gender: ') status = input('Please enter current status: ') profile_ = profile.Profile(g_name, f_name, email, gender, status) profile_list.append(profile_) print(f'Successfully added <{email}> to profiles.') return profile_list
def read_file(filename, profile_list): with open(filename) as f: for line in f: friends = [] # friends list of each profile read from a file person = line.split() status = f.readline().strip('\n') friend_num = int(f.readline()) for _ in range(friend_num): friends.append(f.readline().strip('\n')) profile_ = profile.Profile(person[0], person[1], person[2], person[3], status) profile_.set_friends_list(friends) profile_list.append(profile_) return profile_list
def setUp(self): super(QueryWithStatsTest, self).setUp() self.useFixture(fixtures.FakeLogger()) self.db = db.DB(':memory:') self.db.start_run( '12345', '/no/such/dir', ['command', 'line', 'would', 'go', 'here'], 1370436103.65, ) self.local_values = {'name': ['value', 'pairs']} self.trace_arg = [{'complex': 'value'}] self.db.trace( run_id='12345', thread_id='t1', call_id='abcd', event='test', func_name='test_trace', line_no=99, filename='test_db.py', trace_arg=self.trace_arg, local_vars=self.local_values, timestamp=1370436104.65, ) self.db.trace( run_id='12345', thread_id='t1', call_id='abcd', event='test', func_name='test_trace', line_no=100, filename='test_db.py', trace_arg=self.trace_arg, local_vars=self.local_values, timestamp=1370436104.65, ) self.db.start_run( '6789', '/no/such/dir', ['command', 'line', 'would', 'go', 'here'], 1370436104.65, ) stats_data = stats.stats_to_blob(pstats.Stats(profile.Profile())) self.db.end_run( '6789', 1370436105.65, 'error message', None, stats=stats_data, )
def make_hole(diameter, length): pos = [0.0] diam = [diameter] radius = diameter * 0.5 n = 4 for i in range(0, n): x = math.pi / 2 * float(i) / n pos.append(length + radius * (math.sin(x) - 1)) diam.append(diameter * math.cos(x)) prof = profile.Profile(pos, diam, diam) hole = shape.extrude_profile(prof) return hole