def run_profile():
import profile
profile.run('for i in range(1): demo()', '/tmp/profile.out')
import pstats
p = pstats.Stats('/tmp/profile.out')
p.strip_dirs().sort_stats('time', 'cum').print_stats(60)
p.strip_dirs().sort_stats('cum', 'time').print_stats(60)
def sortedProfiling(code, maxfunctions=50):
f = "temp/profilingInfo.tmp"
if os.path.split(os.path.abspath(""))[1] != "tests":
f = "../" + f
profile.run(code, f)
p = pstats.Stats(f)
p.sort_stats("time").print_stats(maxfunctions)
def _main():
"""Run from command line."""
usage = "usage: %prog [options] cmd [arg] ..."
optprs = OptionParser(usage=usage, version=version)
optprs.add_option("--debug", dest="debug", default=False,
action="store_true",
help="Enter the pdb debugger on main()")
optprs.add_option("--host", dest="host", metavar="HOST",
default="localhost", help="Connect to server at HOST")
optprs.add_option("--port", dest="port", type="int",
default=9000, metavar="PORT",
help="Connect to server at PORT")
optprs.add_option("--profile", dest="profile", action="store_true",
default=False,
help="Run the profiler on main()")
(options, args) = optprs.parse_args(sys.argv[1:])
# Are we debugging this?
if options.debug:
import pdb
pdb.run('main(options, args)')
# Are we profiling this?
elif options.profile:
import profile
print("%s profile:" % sys.argv[0])
profile.run('main(options, args)')
else:
main(options, args)
def test():
import profile, pstats
# profile.run("simple_test()")
profile.run("stacked_test()", "barchart.prof")
p = pstats.Stats("barchart.prof")
p.sort_stats("cumulative").print_stats(20)
def opt_profile(option, opt, value, parser):
global profiling
if not profiling:
profiling = 1
import profile
profile.run('SCons.Script.main()', value)
sys.exit(exit_status)
def sortedProfiling(code, maxfunctions=50):
f = 'temp/profilingInfo.tmp'
if os.path.split(os.path.abspath(''))[1] != 'tests':
f = '../' + f
profile.run(code, f)
p = pstats.Stats(f)
p.sort_stats('time').print_stats(maxfunctions)
def reference_viewer(sys_argv):
"""Create reference viewer from command line."""
viewer = ReferenceViewer(layout=default_layout)
viewer.add_default_plugins()
viewer.add_separately_distributed_plugins()
# Parse command line options with optparse module
from optparse import OptionParser
usage = "usage: %prog [options] cmd [args]"
optprs = OptionParser(usage=usage,
version=('%%prog %s' % version.version))
viewer.add_default_options(optprs)
(options, args) = optprs.parse_args(sys_argv[1:])
if options.display:
os.environ['DISPLAY'] = options.display
# Are we debugging this?
if options.debug:
import pdb
pdb.run('viewer.main(options, args)')
# Are we profiling this?
elif options.profile:
import profile
print(("%s profile:" % sys_argv[0]))
profile.run('viewer.main(options, args)')
else:
viewer.main(options, args)
def main():
import profile
import pstats
if len(sys.argv[1:]):
profile_it = 0
reps_flag = 0
profile_reps = 100
for arg in sys.argv[1:]:
if reps_flag:
profile_reps = int(arg)
reps_flag = 0
elif arg == "-p" or arg == "--profile":
profile_it = 1
elif arg == "-r" or arg == "--reps":
reps_flag = 1
elif profile_it > 0:
print "Profiling, " + str(profile_reps) + " repetitions..."
page = page_factory.page(arg)
profile.run('benchmark("' + arg + '", ' + str(profile_reps) + ")", "profile_stats")
p = pstats.Stats("profile_stats")
p.sort_stats("time").print_stats()
else:
print page_factory.page(URI(arg))
else:
profile()
def prof_run(fun,file,n):
'''Run function fun, put the stats into file and print
out the stats for the n most time consuming operations.'''
profile.run(fun,file)
prof_dat = pstats.Stats(file)
prof_dat.strip_dirs().sort_stats('time').print_stats(n)
return
def runtests(xmlrunner=False):
''' Run unit tests '''
import sys
if '--profile' in sys.argv:
import profile
import pstats
sys.argv = [x for x in sys.argv if x != '--profile']
if xmlrunner:
import xmlrunner as xr
profile.run("unittest.main(testRunner=xr.XMLTestRunner(output='test-reports', verbosity=2))", '_stats.txt')
else:
profile.run('unittest.main()', '_stats.txt')
stats = pstats.Stats('_stats.txt')
#stats.strip_dirs()
stats.sort_stats('cumulative', 'calls')
stats.print_stats(25)
stats.sort_stats('time', 'calls')
stats.print_stats(25)
elif xmlrunner:
import xmlrunner as xr
unittest.main(testRunner=xr.XMLTestRunner(output='test-reports', verbosity=2))
else:
unittest.main()
def run_profile(self):
using_hotshot = False
if using_hotshot:
import hotshot
import hotshot.stats
else:
import profile
import pstats
profile_name = 'NormalFormTest.prof'
proportion_worst_results = 0.125
create_empty_file(profile_name)
if using_hotshot:
profiler = hotshot.Profile(profile_name)
benchtime = profiler.runcall(run_nf) #main call
profiler.close()
stats = hotshot.stats.load(profile_name)
else:
profile.run('run_nf()', profile_name) #main call
stats = pstats.Stats(profile_name)
#output profile
stats.strip_dirs()
stats.sort_stats('time', 'cum', 'calls')
print '[1] Statistics:'
stats.print_stats(proportion_worst_results)
print '[2] Callers for the above:'
stats.print_callers(proportion_worst_results)
def beltway_profiling(algorithm, input_size_step=5, max_input_size=50):
""" Perform a profiling session on a solution algorithm for the beltway problem.
:param algorithm: The candidate algorithm to solve beltway problem:
A function that takes a list of distances and return a list of points.
The algorithm will be first profiled on a input set of 10 points,
successive profiling will involve input set with size that will be incremented
by 'input_size_step' points at each step, until the max_input_size is reached.
:type algorithm: function
:param input_size_step: how many points are added in each profiling step
:type input_size_step: int
:invariant: input_size_step > 0
:param max_input_size: Maximum number of points in any problem instance
:type max_input_size: int
:invariant: max_input_size > 10
:return: None
"""
if input_size_step <= 0 or max_input_size < 10:
logging.warn("[beltway_profiling] Illegal parameters input_size_step: %s, max_input_size: %s" % (str(input_size_step), str(max_input_size)))
import profile #import profile only if this method is called
pr = profile.Profile()
for _ in range(5):
print pr.calibrate(10000)
for n_points in xrange(10, max_input_size, input_size_step):
profile.run('beltway_random_testing(algorithm, 1000, %d, %d)' % (n_points, n_points), 'beltway_profile_%d.txt' % n_points)
def main(self, *arguments):
import getopt
options, arguments = getopt.getopt(arguments, 'bipqv')
for option, value in options:
if option == '-b':
self.bigger = True
elif option == '-i':
self.immediate = True
elif option == '-p':
self.profile = True
elif option == '-q':
self.verbosity = 0
elif option == '-v':
self.verbosity = 2
self.print_warning()
# Save remaining arguments for `unittest' to consider.
sys.argv[1:] = list(arguments)
self.prepare_suite()
if self.profile:
import profile, pstats
global run_suite
run_suite = self.run_suite
profile.run('run_suite()', 'profile-data')
stats = pstats.Stats('profile-data')
stats.strip_dirs().sort_stats('time', 'cumulative').print_stats(10)
else:
self.run_suite()
def planner(sys_argv):
viewer = QueuePlanner(layout=default_layout)
viewer.add_plugins(plugins)
# Parse command line options with optparse module
from optparse import OptionParser
usage = "usage: %prog [options] cmd [args]"
optprs = OptionParser(usage=usage,
version=('%%prog %s' % version.version))
viewer.add_default_options(optprs)
(options, args) = optprs.parse_args(sys_argv[1:])
if options.display:
os.environ['DISPLAY'] = options.display
# Are we debugging this?
if options.debug:
import pdb
pdb.run('viewer.main(options, args)')
# Are we profiling this?
elif options.profile:
import profile
print(("%s profile:" % sys_argv[0]))
profile.run('viewer.main(options, args)')
else:
viewer.main(options, args)
def __call__(self, **kwargs):
#profile.run('ap_rigging.%s(%s)' % (self.f, kwargs), 'C:/temp/profile.txt')
profile.run('%s(%s)' % (self.f, kwargs), 'C:/temp/profile.txt')
import pstats
p = pstats.Stats('C:/temp/profile.txt')
p.sort_stats('cumulative').print_stats(10)
def profile():
import profile, testing
profile.run('testing.compile()', 'profile.txt')
import pstats
p = pstats.Stats('profile.txt')
#p.strip_dirs().sort_stats('cumulative').print_stats(20)
p.strip_dirs().sort_stats('time').print_stats(20)
def profile():
import profile, pstats
path = "/tmp/profile"
profile.run( "profile_execute()", path)
p = pstats.Stats(path)
p.sort_stats('cumulative').print_stats(30)
print "*"*30
p.sort_stats('time').print_stats(30)
def test_speed(rsa, dgst):
print ' measuring speed...'
if showprofile:
import profile
profile.run('speed()')
else:
speed()
print
def mainprofile():
import profile
pf = 'profile_results'
profile.run('main()', pf)
import pstats
p = pstats.Stats(pf)
p.sort_stats('cumulative').print_stats(50)
os.unlink(pf)
def StartPIS():
""" Prepare and enter project insight studio.
1) First thing is to process the command line as following.
Usage: PIS.py [options]
Options:
--version show program's version number and exit
-h, --help show this help message and exit
-p PROFILE_NAME, --profile=PROFILE_NAME
Specific profile file name for getting profiling
information
-d VERBOSE, --debug=VERBOSE
Turn on debug message and specific debug level:
[DEBUG|INFO|WARNING|ERROR|CRITICAL]
-l LOGFILE, --logfile=LOGFILE
Specific log file or server address to hold log
information under specific debug level.
-s LOGSERVER, --logserver=LOGSERVER
Specific log server address to hold log information
under specific debug level.
2) Initialize logging system as early as possible.
3) Launch the PIS's core.
"""
#
# Process command line firstly.
#
parser = OptionParser(version="%s - Version %s" % (PROJECT_NAME, VERSION))
parser.add_option('-p', '--profile', action='store', dest='profile_name',
help='Specific profile file name for getting profiling information')
parser.add_option('-d', '--debug', action='store', dest='verbose', default='DEBUG',
help='Turn on debug message and specific debug level: [DEBUG|INFO|WARNING|ERROR|CRITICAL]')
parser.add_option('-l', '--logfile', action='store', dest='logfile',
help='Specific log file or server address to hold log information under specific debug level.')
parser.add_option('-s', '--logserver', action='store', dest='logserver',
help='Specific log server address to hold log information under specific debug level.')
(options, args) = parser.parse_args()
if options.verbose not in ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']:
parser.error("invalid value for -d options")
sys.exist(0)
#
# Enable the logging system.
#
core.debug.IniLogging(options.verbose, options.logfile, options.logserver)
#
# Start main entry, if want profiling, then profile the main entry.
#
if options.profile_name != None and gFlagProfileEnable:
# profiling PIS and display the result after finishing run()
profile.run('core.appmain.main()', options.profile_name)
stats = pstats.Stats(options.profile_name)
stats.strip_dirs().sort_stats("time").print_stats(10)
else:
core.appmain.main()
def profile(num):
## import cProfile
## profiler = cProfile
profiler.run("[run(root) for x in range(0,100)]", 'logfile.dat')
stats = pstats.Stats('logfile.dat')
stats.strip_dirs()
stats.sort_stats('cumulative', 'calls')
#stats.sort_stats('calls')
stats.print_stats(num)
def profile(statement):
import profile, pstats
datafile = 'meta/profile.data'
statfile = 'meta/profile.output'
profile.run('main()', datafile)
with open(statfile, 'w') as stream:
p = pstats.Stats(datafile, stream=stream)
p.strip_dirs().sort_stats('cumulative')
p.print_stats()
def run_profile():
import profile
profile.run("for i in range(10): demo()", "/tmp/profile.out")
import pstats
p = pstats.Stats("/tmp/profile.out")
p.strip_dirs().sort_stats("time", "cum").print_stats(60)
p.strip_dirs().sort_stats("cum", "time").print_stats(60)
def speedTest():
global x
import profile
M.compilestring(factorial)
M.compilestring("START " +
20 * "50 FACTORIAL DROP " +
"STOP")
x = M.Thread()
profile.run('for i in range(1000): x.run()')
def runProfile(command):
import random
random.seed(23)
import profile, pstats
datFile = '%s.prof.dat' % (command)
profile.run('%s()' % command, datFile)
stats = pstats.Stats(datFile)
stats.strip_dirs()
stats.sort_stats('time').print_stats()
def profiler():
import profile,pstats
def benchmark(): #todo
pass
filename = 'benchmark.prof'
profile.run("benchmark()",filename)
s = pstats.Stats(filename)
s.sort_stats("cumulative")
s.print_stats("getitem|setitem|append|pop|insert")
def prof_test():
sys.stdout.write("\n$PY_DEBUG_OBJECT is: ")
if os.environ.has_key("PY_DEBUG_OBJECT"):
sys.stdout.write(os.environ["PY_DEBUG_OBJECT"])
else:
sys.stdout.write("not defined")
sys.stdout.write("\n\n")
sys.stdout.write("Profiling speed of Object constructor/get/set.\n\n")
profile.run("profObject(1000)")
def prof(dfile): global f import profile f=open(dfile) #profile.run( "do_it()", 'profile.out' ) do_it(); return profile.run( "do_it()" ) #stats = profile.Stats( 'profile.out' ) #stats.print_stats() tr.free()
def startProfile(filename=PyUtilProfileDefaultFilename,
lines=PyUtilProfileDefaultLines,
sorts=PyUtilProfileDefaultSorts,
silent=0,
callInfo=1,
cmd='run()'):
import profile
profile.run(cmd, filename)
if not silent:
printProfile(filename, lines, sorts, callInfo)
def test2(self):
"This is a profiled version of test1()."
try:
import profile
except ImportError:
return
fileName = outputfile('test_graphics_speed_profile.log')
# This runs ok, when only this test script is executed,
# but fails, when imported from runAll.py...
profile.run("t = GraphicsSpeedTestCase('test2')", fileName)
#sys.path.append(os.path.abspath('..'))#this is a hack because Eclipse has bug
from vimm.Frame import Frame
def Main():
app = wx.PySimpleApp()
frame = Frame(None, -1, 'vimm')
frame.Show()
if len(sys.argv) > 1:
fname = sys.argv[1]
frame.load_file_nodialog(fname)
else:
#frame.load_file_nodialog("../testfiles/CSF_SPECT_aluminum.nc")
#frame.load_file_nodialog("../testfiles/o2.molf")
frame.create_xyz_file()
#frame.dotest()
app.MainLoop()
if __name__ == '__main__':
do_profile = 0
if do_profile:
import profile, pstats
profile.run('Main()', 'vimm_prof')
vimm_prof = pstats.Stats('vimm_prof')
vimm_prof.strip_dirs().sort_stats('time').print_stats(20)
else:
Main()
#end
return T.weight + min([min_length(s) for s in T.sons] or [0])
if __name__ == "__main__":
example_1 = Tree(0, [
Tree(5, [Tree(-4, [Tree(11), Tree(2)]),
Tree(2)]),
Tree(2, [Tree(5, [Tree(-2), Tree(4), Tree(7)])]),
Tree(1, [Tree(10)])
])
example_2 = Tree(5, [
Tree(1, [
Tree(-5, [Tree(7, []), Tree(3, [])]),
Tree(2, []),
Tree(11, [Tree(-5, [])])
]),
Tree(2, [Tree(0, [Tree(12, [])])]),
Tree(3, [Tree(7, [Tree(2, [])]), Tree(2, [])])
])
print("## Example 1:")
print("Min length: %d" % min_length(example_1))
print("Size: %d" % example_1.size())
profile.run("min_length(example_1)")
print("\n## Example 2:")
print("Min length: %d" % min_length(example_2))
print("Size: %d" % example_2.size())
profile.run("min_length(example_2)")
def main():
profile.run('IsPrimeNumberRangeChecker(3, 10000000)')
#self.putchar('\n')
def deroff_files(files):
for arg in files:
sys.stderr.write(arg + '\n')
if arg.endswith('.gz'):
f = gzip.open(arg, 'r')
str = f.read()
if IS_PY3: str = str.decode('latin-1')
else:
f = open(arg, 'r')
str = f.read()
d = Deroffer()
d.deroff(str)
d.flush_output(sys.stdout)
f.close()
if __name__ == "__main__":
import gzip
paths = sys.argv[1:]
if True:
deroff_files(paths)
else:
import cProfile, profile, pstats
profile.run('deroff_files(paths)', 'fooprof')
p = pstats.Stats('fooprof')
p.sort_stats('time').print_stats(100)
#p.sort_stats('calls').print_callers(.5, 'startswith')
def profileb3(): profile.run(mainfunction, output)
import ftp_server
import chat_server
import resolver
import logger
rs = resolver.caching_resolver ('127.0.0.1')
lg = logger.file_logger (sys.stdout)
ms = monitor.secure_monitor_server ('fnord', '127.0.0.1', 9999)
fs = filesys.os_filesystem (sys.argv[1])
dh = default_handler.default_handler (fs)
hs = http_server ('', string.atoi (sys.argv[2]), rs, lg)
hs.install_handler (dh)
ftp = ftp_server.ftp_server (
ftp_server.dummy_authorizer(sys.argv[1]),
port=8021,
resolver=rs,
logger_object=lg
)
cs = chat_server.chat_server ('', 7777)
sh = status_handler.status_extension([hs,ms,ftp,cs,rs])
hs.install_handler (sh)
if ('-p' in sys.argv):
def profile_loop ():
try:
asyncore.loop()
except KeyboardInterrupt:
pass
import profile
profile.run ('profile_loop()', 'profile.out')
else:
asyncore.loop()
else:
print "Incorrect status_code {} for url {}".format(r.status_code,url)
except Exception as inst:
if verbose:
print "Download failed from url {}.".format(url)
print inst
return None
def get_SHA1_b64_from_URL(url,verbose=False):
if verbose:
print "Downloading image from {}.".format(url)
try:
r = requests.get(url, stream=True, timeout=imagedltimeout)
if r.status_code == 200:
sha1hash = get_SHA1_from_data(r.raw.data)
b64_from_data = get_b64_from_data(r.raw.data)
return sha1hash,b64_from_data
except Exception as inst:
if verbose:
print "Download failed from url {}.".format(url)
print inst
return None,None
if __name__ == "__main__":
import profile
profile.run('sha1 = get_SHA1_from_URL("https://s3.amazonaws.com/memex-images/full/581ed33d3e12498f12c86b44010306b172f4ad6a.jpg")')
print sha1
profile.run('sha1_sio = get_SHA1_from_URL_StringIO("https://s3.amazonaws.com/memex-images/full/581ed33d3e12498f12c86b44010306b172f4ad6a.jpg")')
print sha1_sio
sha1_sio = get_SHA1_from_URL_StringIO("https://s3.amazonaws.com/memex-images/full/581ed33d3e12498f12c86b44010306b172f4ad6a.jpg")
print sha1_sio
## sys.argv = ["macgrins", fss.as_pathname()]
## else:
## import EasyDialogs
## url = EasyDialogs.AskString("CMIF/SMIL URL")
## if url is None:
## sys.exit(0)
## sys.argv = ["maccmifed", url]
no_exception=0
try:
try:
if profile:
import profile
fss, ok = macfs.StandardPutFile("Profile output:")
if not ok: sys.exit(1)
profile.run("import cmifed", fss.as_pathname())
else:
import cmifed
no_exception=1
except SystemExit:
no_exception=1
finally:
if not no_exception:
if quietconsole:
quietconsole.revert()
## if DEBUG:
## import pdb
## pdb.post_mortem(sys.exc_info()[2])
## elif quietconsole:
## quietconsole.revert()
## print 'Type return to exit-',
nsv2 = _hyperplane(hyp_x_max, self._w, self._b, -1)
self._ax.plot([hyp_x_min, hyp_x_max], [nsv1, nsv2], 'k')
db1 = _hyperplane(hyp_x_min, self._w, self._b, 0)
db2 = _hyperplane(hyp_x_max, self._w, self._b, 0)
self._ax.plot([hyp_x_min, hyp_x_max], [db1, db2], 'y--')
plt.show()
data_dict = {
-1: np.array([
[1, 7],
[2, 8],
[3, 8],
]),
1: np.array([
[5, 1],
[6, -1],
[7, 3],
])
}
if __name__ == '__main__':
svm = SupportVectorMachine()
profile.run('svm.fit(data_dict)')
predict_us = [[0, 10], [1, 3], [3, 4], [3, 5], [5, 5], [5, 6], [6, -5],
[5, 8]]
for p in predict_us:
svm.predict(p)
svm.visualize()
def profileProfile():
print "using standard profiler"
import profile
profile.run('bomberman.main()', PROFILEFILE)
#
# Copyright 2001 - 2016 Ludek Smid [http://www.ospace.net/]
#
# This file is part of Pygame.UI.
#
# Pygame.UI is free software; you can redistribute it and/or modify
# it under the terms of the Lesser GNU General Public License as published by
# the Free Software Foundation; either version 2.1 of the License, or
# (at your option) any later version.
#
# Pygame.UI is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# Lesser GNU General Public License for more details.
#
# You should have received a copy of the Lesser GNU General Public License
# along with Pygame.UI; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
# profiling
import profile
profile.run('import demo', 'profile.txt')
self.HDICT[key] = [item]
pass
def testit(self):
while 1:
a = util.getinput("Enter a word:")
if a=='.': break
if a=='': continue
self.search_prn(a)
if __name__ == "__main__":
if os.getenv("SHELL") != None:
hdic = hanengdict("/data1/AD/data/engdic/")
else:
hdic = hanengdict("C:/Works/ad_svc_backup/ad_svc_data/engdic/")
profile.run ("hdic.prepare('a', 'a')")
hdic.info()
#hdic.prn_hdict()
#hdic.prn_edict()
hdic.testit()
book.set_price(9999)
book = inven.find("mybook0123")
if book:
book.show()
else:
print "Not in the inventory"
print
print "# Test 3"
inven.remove("mybook0123") # implement BookInventory.remove()
book = inven.find("mybook0123")
if book:
book.show()
else:
print "Not in the inventory"
print
print "# Test 4"
pf.run('find_book_ntimes(inven, "mybook0000", 10000)'
) # performance evaluation of sequential search
pf.run('find_book_ntimes(inven, "mybook0123", 10000)'
) # *this book is not in the inventory
pf.run('find_book_ntimes(inven, "mybook9999", 10000)')
print "# Test 4 - bsearch"
pf.run('find_bsearch_book_ntimes(inven, "mybook0000", 10000)'
) # implement BookInventory.find_bsearch()
pf.run('find_bsearch_book_ntimes(inven, "mybook0123", 10000)')
pf.run('find_bsearch_book_ntimes(inven, "mybook9999", 10000)')
default=False,
help="Run as a server")
parser.add_option("--svcname",
dest="svcname",
default='ro_example',
help="Register using service NAME",
metavar="NAME")
(options, args) = parser.parse_args(sys.argv[1:])
if len(args) != 0:
parser.error("incorrect number of arguments")
# Are we debugging this?
if options.debug:
import pdb
pdb.run('main(options, args)')
# Are we profiling this?
elif options.profile:
import profile
print "%s profile:" % sys.argv[0]
profile.run('main(options, args)')
else:
main(options, args)
#END
NETGEN_3D_Parameters.SetOptimize( 1 )
NETGEN_3D_Parameters.SetFineness( 2 )
NETGEN_3D_Parameters.SetMinSize( 1 )
fluid_1 = Mesh_1.GroupOnGeom(fluid,'fluid',SMESH.VOLUME)
solid_1 = Mesh_1.GroupOnGeom(solid,'solid',SMESH.VOLUME)
wall_1 = Mesh_1.GroupOnGeom(wall,'wall',SMESH.FACE)
inlet_1 = Mesh_1.GroupOnGeom(inlet,'inlet',SMESH.FACE)
outlet_1 = Mesh_1.GroupOnGeom(outlet,'outlet',SMESH.FACE)
isDone = Mesh_1.Compute()
## set object names
smesh.SetName(Mesh_1.GetMesh(), 'Mesh_1')
smesh.SetName(NETGEN_2D3D.GetAlgorithm(), 'NETGEN_2D3D')
smesh.SetName(NETGEN_3D_Parameters, 'NETGEN 3D Parameters')
smesh.SetName(fluid_1, 'fluid')
smesh.SetName(solid_1, 'solid')
smesh.SetName(wall_1, 'wall')
smesh.SetName(inlet_1, 'inlet')
smesh.SetName(outlet_1, 'outlet')
if salome.sg.hasDesktop():
salome.sg.updateObjBrowser(1)
import salomeToOpenFOAM
import profile
profile.run("salomeToOpenFOAM.exportToFoam(Mesh_1,'./sampleMultiRegionPipe/constant/polyMesh')")
#salomeToOpenFOAM.exportToFoam(Mesh_1,'./sampleMultiRegionPipe/constant/polyMesh')
#Note that no internal BC has ben set up. splitMeshRegions -cellZones will create regeionX_to_regionY
#Boundaries.
#Testing script to run a bunch of different command line cases to ensure motionmeerkat functionality.
import os
import numpy as np
import profile
#cd into direction holding main.py - for users this would be the directory holding main.exe
### Profile Code
profile.run("os.system('main.py --minSIZE 0.3')")
# Run from command line, using default video to test state
testing_mainpy = False
if testing_mainpy:
os.chdir('C:/Users/Ben/Documents/OpenCV_HummingbirdsMotion/MotionMeerkat/')
#Minsize
os.system('main.py --minSIZE 0.3')
#Threshold
os.system('main.py --thresh 10')
#Cropping
os.system('main.py --set_ROI --ROI_include include')
#Change frame rate
os.system('main.py --frameSET --frame_rate 1')
#Windy conditions
os.system('main.py --windy --windy_min 1')
#Burnin by 0.1 minute
#os.system('main.py --burnin 1')
]
if len(strings) == 1:
return columns
# we eliminate all columns that aren't blank for every string
for s in strings:
for c in columns[0:]: # we'll be modifying columns
if c < len(s) and s[c] != char:
columns.remove(c)
columns.sort()
testtimer.end()
return columns
if __name__ == '__main__':
import gourmet.recipeManager as recipeManager
import tempfile, sys, profile, os.path
from gourmet.OptionParser import *
print 'Testing MealMaster import'
tmpfile = tempfile.mktemp()
import backends.rmetakit
rd = backends.rmetakit.RecipeManager(tmpfile)
if not args: args = ['/home/tom/Projects/recipe/Data/200_Recipes.mmf']
for a in args:
profi = os.path.join(tempfile.tempdir, 'MMI_PROFILE')
profile.run(
"mmf_importer(rd,a,prog=lambda *args: sys.stdout.write('|'),threaded=False)",
profi)
import pstats
p = pstats.Stats(profi)
p.strip_dirs().sort_stats('cumulative').print_stats()
import profile
def fib(n):
if n == 0: return 0
if n == 1: return 1
return fib(n - 1) + fib(n - 2)
def fibonacci_seq(n):
seq = []
if n > 0:
seq.extend(fibonacci_seq(n - 1))
seq.append(fib(n))
return seq
profile.run('print(fibonacci_seq(20)); print()')
1
def fib_seq(n):
seq = []
if n > 0:
seq.extend(fib_seq(n - 1))
seq.append(fib(n))
return seq
@functools.lru_cache(maxsize=None)
def fib1(n):
if n == 0:
return 0
if n == 1:
return 1
return fib1(n - 1) + fib1(n - 2)
def fib_seq1(n):
seq = []
if n > 0:
seq.extend(fib_seq1(n - 1))
seq.append(fib1(n))
return seq
if __name__ == "__main__":
profile.run("print(fib_seq(20))")
profile.run("print(fib_seq1(20))")
profile.runctx("print(fib_seq1(n))", globals(), {"n": 20})
for query in queries:
print()
print(query)
package = db.get_package(query)
if not package:
print("--- unknown ---")
continue
props = package.get_properties()
print("Homepages:", props.get_homepages())
print("Description:", props.description)
print("License:", props.license)
print("Slot:", props.get_slot())
print("Keywords:", props.get_keywords())
print("USE flags:", props.get_use_flags())
print("Installed:", package.get_installed())
print("Latest:", get_version(package.get_latest_ebuild()))
print(("Latest unmasked:",
get_version(package.get_latest_ebuild(0))))
## main()
import profile, pstats
profile.run("main()", "stats.txt")
stats = pstats.Stats("stats.txt")
stats.strip_dirs()
stats.sort_stats('cumulative')
#stats.sort_stats('time')
#stats.sort_stats('calls')
stats.print_stats(0.2)
def __profile__():
import profile
profile.run('__fulltest__()')
import sys, profile
sys.path.append('D:/MyCodes/Python')
from my_math import product
profile.run('product(1,2)')
def test():
import profile, pstats
#profile.run("simple_test()")
profile.run('stacked_test()', 'barchart.prof')
p = pstats.Stats('barchart.prof')
p.sort_stats('cumulative').print_stats(20)
def oai_profile():
"""
Runs a benchmark
"""
from six import StringIO
oai_list_records_or_identifiers(StringIO(),
argd={
"metadataPrefix": "oai_dc",
"verb": "ListRecords"
})
oai_list_records_or_identifiers(StringIO(),
argd={
"metadataPrefix": "marcxml",
"verb": "ListRecords"
})
oai_list_records_or_identifiers(StringIO(),
argd={
"metadataPrefix": "oai_dc",
"verb": "ListIdentifiers"
})
return
if __name__ == "__main__":
import profile
import pstats
profile.run('oai_profile()', "oai_profile")
p = pstats.Stats("oai_profile")
p.strip_dirs().sort_stats("cumulative").print_stats()
"""
Run count_occurrences_in_text on a few examples
"""
i = 0
for x in range(400):
i += count_occurrences_in_text("word", SAMPLE_TEXT_FOR_BENCH)
i += count_occurrences_in_text("sugar", SAMPLE_TEXT_FOR_BENCH)
i += count_occurrences_in_text("help", SAMPLE_TEXT_FOR_BENCH)
i += count_occurrences_in_text("heavily", SAMPLE_TEXT_FOR_BENCH)
i += count_occurrences_in_text("witfull", SAMPLE_TEXT_FOR_BENCH)
i += count_occurrences_in_text("dog", SAMPLE_TEXT_FOR_BENCH)
i += count_occurrences_in_text("almost", SAMPLE_TEXT_FOR_BENCH)
i += count_occurrences_in_text("insulin", SAMPLE_TEXT_FOR_BENCH)
i += count_occurrences_in_text("attaching", SAMPLE_TEXT_FOR_BENCH)
i += count_occurrences_in_text("asma", SAMPLE_TEXT_FOR_BENCH)
i += count_occurrences_in_text("neither", SAMPLE_TEXT_FOR_BENCH)
i += count_occurrences_in_text("won't", SAMPLE_TEXT_FOR_BENCH)
i += count_occurrences_in_text("green", SAMPLE_TEXT_FOR_BENCH)
i += count_occurrences_in_text("parabole", SAMPLE_TEXT_FOR_BENCH)
print(i)
# Start the tests
if __name__ == '__main__':
# I need to be fast as well:
import profile
profile.run('doit()')
# I need to pass the test:
unittest.main()
def __init__(self, sink, baseURI):
self._sink = sink
self._baseURI = baseURI
def feed(self, text):
p = rdfn3_yapps.Parser(rdfn3_yapps.scanner(text),
self._sink, self._baseURI)
f = getattr(p, 'document')
f() #raises SyntaxError, etc.
def test(text):
gen = notation3.ToN3(sys.stdout.write)
p = Parser(gen, 'http://example.org/2001/stuff/doc23')
gen.startDoc()
p.feed(text)
gen.endDoc()
def testKIF(text, addr):
import KIFSink
gen = KIFSink.Sink(sys.stdout.write)
p = Parser(gen, addr)
gen.startDoc()
p.feed(text)
gen.endDoc()
if __name__ == '__main__':
import os
import profile
profile.run("testKIF(sys.stdin.read(), 'file:%s/STDIN' % (os.getcwd(),))")
tishu = 10 #一共十道题
fenshu = 0
shurucishu = 1
while (shurucishu <= 3 and nianji < 1 or nianji > 6): #小学生是1~6年级
nianji = int(
input("您是小学生,请注意,如果输入错误年级次数大于三次你的成绩将为0，你所在的年级是：(n>=1 and n<=6)"))
shurucishu = shurucishu + 1
for i in range(1, tishu + 1):
if (shurucishu > 3):
break
if nianji > 3: #三年级以下题目长度较短
n = random.randint(3, 10)
else:
n = random.randint(2, 4)
daan = -1
while (daan < 0):
daan, ti = timu(nianji, n)
jieguo = jieguozhuanhuan(input(ti + ""))
if (jieguo == Fraction(
'{}'.format(daan)).limit_denominator()): #判断是否正确
print("正确")
fenshu = fenshu + 10
else:
print("错误,答案为：", end='')
print(Fraction('{}'.format(daan)).limit_denominator())
print("答题结束，总分为" + str(fenshu)) #给出总分
if __name__ == "__main__":
profile.run('main()')
for i in xrange(num_fetch_threads):
procs.append(Process(name = str(i), target=main2, args=(i, enclosure_queue,)))
#procs[-1].daemon = True
procs[-1].start()
for pth in pth_list:
enqp(pth)
print '*** Main thread waiting ***'
enclosure_queue.join()
print '*** Done ***'
for p in procs:
enqp( None )
enclosure_queue.join()
for p in procs:
p.join()
print "Finished everything...."
print "num active children:", multiprocessing.active_children()
if __name__=="__main__":
profile.run("main()")
+sub[9]+'</div></td><td><div class="bsig">'+str(sub[10])+'</div></td></tr>')
'''
dlist = sub[15].split('_')
summary.append('<td>'+time.strftime("%Y/%m/%d %H:%M:%S",time.localtime(sub[16]))+':'+str(int(str(sub[16]).split('.')[1]))+'</td><td>'+sub[0]+'</td><td>'+sub[1]+'</td><td>'+str(sub[2])+'</td><td>'+str(sub[3])+'</td><td>'+str(sub[4])+'</td><td>'\
+(dlist[1]+'-'+dlist[3])+'</td><td>'+(dlist[2]+'-'+dlist[4])+'</td><td>'+SC\
+'</td><td>'+sub[18]+'</td><td><div class="csig" onmouseover=$(this).children("span.unshow").show() onmouseout=$(this).children("span.unshow").hide()>'\
+sub[9]+'</div></td><td><div class="bsig">'+str(sub[10])+'</div></td></tr>')
summary.append("</tbody>")
summary.append(
"</table><script language='JavaScript'>$('#filterName').keyup()</script>"
)
#print time.time()
#print summary
#pdb.set_trace()
return ''.join(summary)
if __name__ == '__main__':
#pdb.set_trace()
usetime = 100
pcapNum = 100
#log=open('log.txt','w')
files = [
r'D:\all.pcap',
]
#node,totalflow,valid,invalid,error,L5node=finalNode(files,{},{})
profile.run("finalNode(files,{},{})")
#showNode(node,totalflow,valid,invalid,usetime,pcapNum,error,'fp','r')
#log.close()
print "please email the output to the author."
print "Verbose output automatically enabled"
options.verbose = 1
if options.verbose:
print "Verbose execution enabled"
if options.stats:
import pstats
p = pstats.Stats(options.stats)
p.sort_stats('cumulative').print_stats(10)
p.sort_stats('time').print_stats(10)
sys.exit()
try:
import psyco
psyco.full()
except ImportError:
if options.verbose:
print "Could not import psyco, ignoring..."
sf = Soulforge(0)
if options.profile:
print "Program execution will be profiled."
print "Expect it to run a lot slower."
import profile
profile.run('sf.MainLoop()', options.profile)
else:
sf.MainLoop()
