def main(): usage = "mactrace.py [-o output_file_path] scriptfile [arg] ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option('-o', '--outfile', dest="outfile", help="Save trace to <outfile>", default=None) if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() sys.argv[:] = args if options.outfile: twriter = TraceWriter(open(options.outfile, "w")) else: twriter = TraceWriter() sys.settrace(twriter.trace) if len(args) > 0: progname = args[0] sys.path.insert(0, os.path.dirname(progname)) with open(progname, 'rb') as fp: code = compile(fp.read(), progname, 'exec') globs = { '__file__': progname, '__name__': '__main__', '__package__': None, } eval(code, globs) else: parser.print_usage() return parser
def main(): from optparse import OptionParser parser = OptionParser() parser.allow_interspersed_args = False parser.add_option('-o', '--outfile', dest="outfile", help="Save stats to <outfile>", default='/tmp/profile.tmp') if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() #viz = kcachegrind viz = profile_viz sys.path = [os.getcwd()] + sys.path if len(args) > 0: sys.argv[:] = args sys.path.insert(0, os.path.dirname(sys.argv[0])) viz('execfile(%r)' % sys.argv[0], out=options.outfile) else: parser.print_usage() return parser
def main(): usage = "profile.py [-o output_file_path] [-s sort] scriptfile [arg] ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option('-o', '--outfile', dest="outfile", help="Save stats to <outfile>", default=None) parser.add_option('-s', '--sort', dest="sort", help="Sort order when printing to stdout, based on pstats.Stats class", default=-1) if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() sys.argv[:] = args if len(args) > 0: progname = args[0] sys.path.insert(0, os.path.dirname(progname)) with open(progname, 'rb') as fp: code = compile(fp.read(), progname, 'exec') globs = { '__file__': progname, '__name__': '__main__', '__package__': None, } runctx(code, globs, None, options.outfile, options.sort) else: parser.print_usage() return parser
def main(): usage = "profile.py [-o output_file_path] [-s sort] scriptfile [arg] ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option('-o', '--outfile', dest="outfile", help="Save stats to <outfile>", default=None) parser.add_option( '-s', '--sort', dest="sort", help="Sort order when printing to stdout, based on pstats.Stats class", default=-1) if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() sys.argv[:] = args if (len(sys.argv) > 0): sys.path.insert(0, os.path.dirname(sys.argv[0])) run('execfile(%r)' % (sys.argv[0], ), options.outfile, options.sort) else: parser.print_usage() return parser
def main(): usage = "profile.py [-o output_file_path] [-s sort] scriptfile [arg] ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option("-o", "--outfile", dest="outfile", help="Save stats to <outfile>", default=None) parser.add_option( "-s", "--sort", dest="sort", help="Sort order when printing to stdout, based on pstats.Stats class", default=-1 ) if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() if len(args) > 0: sys.argv[:] = args sys.path.insert(0, os.path.dirname(sys.argv[0])) fp = open(sys.argv[0]) try: script = fp.read() finally: fp.close() run("exec(%r)" % script, options.outfile, options.sort) else: parser.print_usage() return parser
def main(): usage = """%prog Generates doxygen documentation in build/doxygen. Optionaly makes a tarball of the documentation to dist/. Must be started in the project top directory. """ from optparse import OptionParser parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option('--with-dot', dest="with_dot", action='store_true', default=False, help="""Enable usage of DOT to generate collaboration diagram""") parser.add_option('--dot', dest="dot_path", action='store', default=find_program('dot'), help="""Path to GraphViz dot tool. Must be full qualified path. [Default: %default]""") parser.add_option('--doxygen', dest="doxygen_path", action='store', default=find_program('doxygen'), help="""Path to Doxygen tool. [Default: %default]""") parser.add_option('--with-html-help', dest="with_html_help", action='store_true', default=False, help="""Enable generation of Microsoft HTML HELP""") parser.add_option('--no-uml-look', dest="with_uml_look", action='store_false', default=True, help="""Generates DOT graph without UML look [Default: False]""") parser.add_option('--open', dest="open", action='store_true', default=False, help="""Open the HTML index in the web browser after generation""") parser.add_option('--tarball', dest="make_tarball", action='store_true', default=False, help="""Generates a tarball of the documentation in dist/ directory""") parser.add_option('-s', '--silent', dest="silent", action='store_true', default=False, help="""Hides doxygen output""") parser.enable_interspersed_args() options, args = parser.parse_args() build_doc( options )
def main(): import os, sys from optparse import OptionParser usage = "yappi.py [-b] [scriptfile] args ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option( "-b", "--builtins", action="store_true", dest="profile_builtins", default=False, help="Profiles builtin functions when set. [default: False]") if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() sys.argv[:] = args if (len(sys.argv) > 0): sys.path.insert(0, os.path.dirname(sys.argv[0])) start(options.profile_builtins, options.timing_sample) execfile(sys.argv[0]) stop() print_stats() # we will currently use default params for this. else: parser.print_usage() return parser
def main(): from optparse import OptionParser usage = "yappi.py [-b] [-s] [scriptfile] args ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option("-b", "--builtins", action="store_true", dest="profile_builtins", default=False, help="Profiles builtin functions when set. [default: False]") parser.add_option("-s", "--single_thread", action="store_true", dest="profile_single_thread", default=False, help="Profiles only the thread that calls start(). [default: False]") if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() sys.argv[:] = args if (len(sys.argv) > 0): sys.path.insert(0, os.path.dirname(sys.argv[0])) start(options.profile_builtins, not options.profile_single_thread) if sys.version_info >= (3, 0): exec(compile(open(sys.argv[0]).read(), sys.argv[0], 'exec'), sys._getframe(1).f_globals, sys._getframe(1).f_locals) else: execfile(sys.argv[0], sys._getframe(1).f_globals, sys._getframe(1).f_locals) stop() # we will currently use default params for these get_func_stats().print_all() get_thread_stats().print_all() else: parser.print_usage()
def parse_args(): usage = "measureproc.py scriptfile [arg] ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option("-v", action="store_true", default=False, dest="verbose") (options, args) = parser.parse_args() return (parser, options, args)
def main(): usage = """%prog [options] Generate a single amalgated source and header file from the sources. """ from optparse import OptionParser parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option('-s', '--source', dest="target_source_path", action='store', default='dist/amalgated-src/cppunit_lib.cpp', help="""Output .cpp source path. [Default: %default]""") parser.add_option('-t', '--top-dir', dest="top_dir", action='store', default=os.getcwd(), help="""Source top-directory. [Default: %default]""") parser.enable_interspersed_args() options, args = parser.parse_args() msg = amalgamate_source(source_top_dir=options.top_dir, target_source_path=options.target_source_path) if msg: sys.stderr.write(msg + '\n') sys.exit(1) else: print 'Source succesfully amalagated'
def main(): from optparse import OptionParser parser = OptionParser() parser.allow_interspersed_args = False parser.add_option('-o', '--outfile', dest="outfile", help="Save stats to <outfile>", default='/tmp/profile.tmp') if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() #viz = kcachegrind viz = profile_viz sys.path = [os.getcwd()] + sys.path if len(args) > 0: sys.argv[:] = args sys.path.insert(0, os.path.dirname(sys.argv[0])) viz('execfile(%r)' % sys.argv[0], out=options.outfile) else: parser.print_usage() return parser
def ParseArgs(argv): _CMD_OPTIONS_LIST = [ make_option("-h", "--host", dest="host", default="localhost", help="Host name"), make_option("-u", "--user", dest="user", default="root", help="User name"), make_option("-p", "--pwd", dest="pwd", default="", help="Password"), make_option("-n", "--vmname", dest="vmname", default="QuestionTest", help="Virtual machine name"), make_option("-v", "--verbose", dest="verbose", action="store_true", default=False, help="Enable verbose logging"), make_option("-i", "--iterations", dest="iter", type="int", default=1, help="Number of iterations"), make_option("-?", "--help", action="store_true", help="Help"), ] _STR_USAGE = "%prog [options]" # Get command line options cmdParser = OptionParser(option_list=_CMD_OPTIONS_LIST, usage=_STR_USAGE, add_help_option=False) cmdParser.allow_interspersed_args = False usage = cmdParser.format_help() # Parse arguments (options, remainingOptions) = cmdParser.parse_args(argv) cmdParser.destroy() # Print usage if options.help: print(usage) sys.exit(0) return (options, remainingOptions)
def main(): usage = __import__(__name__).__doc__.strip() usage += "\n\nCommands:\n\n" commands = {} for func in sorted(COMMANDS): name = func.__name__.strip().replace("cmd_", "").replace("_", "-") commands[name] = func head, tail = pydoc.splitdoc(pydoc.getdoc(func)) cmd_help = textwrap.fill(tail, width=70).replace("\n", "\n ").strip() usage += "%s\n %s\n\n" % (head, cmd_help) usage = usage.strip() parser = OptionParser(usage=usage) parser.allow_interspersed_args = False (options, args) = parser.parse_args() if len(args) < 1: parser.error("No command given") cmd_name = args.pop(0) cmd = commands.get(cmd_name) if cmd is None: parser.error("Unknown command %s" % cmd_name) else: cmd(args)
def main(): import os, sys from optparse import OptionParser usage = "yappi.py [-b] [scriptfile] args ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option("-b", "--builtins", action="store_true", dest="profile_builtins", default=False, help="Profiles builtin functions when set. [default: False]") if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() sys.argv[:] = args if (len(sys.argv) > 0): sys.path.insert(0, os.path.dirname(sys.argv[0])) start(options.profile_builtins, options.timing_sample) execfile(sys.argv[0]) stop() print_stats() # we will currently use default params for this. else: parser.print_usage() return parser
def main(): import os, sys from optparse import OptionParser usage = "cProfile.py [-o output_file_path] [-s sort] scriptfile [arg] ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option("-o", "--outfile", dest="outfile", help="Save stats to <outfile>", default=None) parser.add_option( "-s", "--sort", dest="sort", help="Sort order when printing to stdout, based on pstats.Stats class", default=-1 ) if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() sys.argv[:] = args if len(sys.argv) > 0: sys.path.insert(0, os.path.dirname(sys.argv[0])) run("execfile(%r)" % (sys.argv[0],), options.outfile, options.sort) else: parser.print_usage() return parser
def main(): usage = "%s [-o output_file_path] [-s sort] scriptfile [arg] ..." % sys.argv[0] parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option('-o', '--outdir', dest="outdir", help="Save report to <outdir>", default=os.getcwd()) if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() sys.argv[:] = args if len(args) > 0: progname = args[0] sys.path.insert(0, os.path.dirname(progname)) with open(progname, 'rb') as fp: code = compile(fp.read(), progname, 'exec') globs = { '__file__': progname, '__name__': '__main__', '__package__': None, } try: os.makedirs(options.outdir) except OSError, e: if e.errno != errno.EEXIST: raise runctx(code, globs, None, options.outdir)
def main(): import os, sys, pstats from optparse import OptionParser usage = "cProfile.py [-o output_file_path] [-s sort] scriptfile [arg] ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option('-o', '--outfile', dest="outfile", help="Save stats to <outfile>", default=None) parser.add_option('-s', '--sort', dest="sort", help="Sort order when printing to stdout, based on pstats.Stats class", default=-1, choices=sorted(pstats.Stats.sort_arg_dict_default)) if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() sys.argv[:] = args if len(args) > 0: progname = args[0] sys.path.insert(0, os.path.dirname(progname)) with open(progname, 'rb') as fp: code = compile(fp.read(), progname, 'exec') globs = { '__file__': progname, '__name__': '__main__', '__package__': None, } runctx(code, globs, None, options.outfile, options.sort) else: parser.print_usage() return parser
def main(): import os, sys from optparse import OptionParser usage = "cProfile.py [-o output_file_path] [-s sort] scriptfile [arg] ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option("-o", "--outfile", dest="outfile", help="Save stats to <outfile>", default=None) parser.add_option( "-s", "--sort", dest="sort", help="Sort order when printing to stdout, based on pstats.Stats class", default=-1 ) if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() sys.argv[:] = args if len(args) > 0: progname = args[0] sys.path.insert(0, os.path.dirname(progname)) with open(progname, "rb") as fp: code = compile(fp.read(), progname, "exec") globs = {"__file__": progname, "__name__": "__main__", "__package__": None, "__cached__": None} runctx(code, globs, None, options.outfile, options.sort) else: parser.print_usage() return parser
def main(): usage = 'profile.py [-o output_file_path] [-s sort] scriptfile [arg] ...' parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option('-o', '--outfile', dest='outfile', help='Save stats to <outfile>', default=None) parser.add_option( '-s', '--sort', dest='sort', help='Sort order when printing to stdout, based on pstats.Stats class', default=-1) if not sys.argv[1:]: parser.print_usage() sys.exit(2) options, args = parser.parse_args() sys.argv[:] = args if len(args) > 0: progname = args[0] sys.path.insert(0, os.path.dirname(progname)) with open(progname, 'rb') as fp: code = compile(fp.read(), progname, 'exec') globs = { '__file__': progname, '__name__': '__main__', '__package__': None } runctx(code, globs, None, options.outfile, options.sort) else: parser.print_usage() return parser
def parse_args(): usage = "measureproc.py scriptfile [arg] ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option("-v", action="store_true", default=False, dest="verbose") (options, args) = parser.parse_args() return (parser, options, args)
def main(): usage = "mactrace.py [-o output_file_path] scriptfile [arg] ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option('-o', '--outfile', dest="outfile", help="Save trace to <outfile>", default=None) if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() sys.argv[:] = args if options.outfile: twriter = TraceWriter(open(options.outfile, "w")) else: twriter = TraceWriter() sys.settrace(twriter.trace) if len(args) > 0: progname = args[0] sys.path.insert(0, os.path.dirname(progname)) with open(progname, 'rb') as fp: code = compile(fp.read(), progname, 'exec') globs = { '__file__': progname, '__name__': '__main__', '__package__': None, } eval(code, globs) else: parser.print_usage() return parser
def main(): usage = """%prog Generates doxygen documentation in build/doxygen. Optionaly makes a tarball of the documentation to dist/. Must be started in the project top directory. """ from optparse import OptionParser parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option('--with-dot', dest="with_dot", action='store_true', default=False, help="""Enable usage of DOT to generate collaboration diagram""") parser.add_option('--dot', dest="dot_path", action='store', default=find_program('dot'), help="""Path to GraphViz dot tool. Must be full qualified path. [Default: %default]""") parser.add_option('--doxygen', dest="doxygen_path", action='store', default=find_program('doxygen'), help="""Path to Doxygen tool. [Default: %default]""") parser.add_option('--with-html-help', dest="with_html_help", action='store_true', default=False, help="""Enable generation of Microsoft HTML HELP""") parser.add_option('--no-uml-look', dest="with_uml_look", action='store_false', default=True, help="""Generates DOT graph without UML look [Default: False]""") parser.add_option('--open', dest="open", action='store_true', default=False, help="""Open the HTML index in the web browser after generation""") parser.add_option('--tarball', dest="make_tarball", action='store_true', default=False, help="""Generates a tarball of the documentation in dist/ directory""") parser.add_option('-s', '--silent', dest="silent", action='store_true', default=False, help="""Hides doxygen output""") parser.enable_interspersed_args() options, args = parser.parse_args() build_doc( options )
def main(): usage = """%prog DIR [DIR2...] Updates license text in sources of the project in source files found in the directory specified on the command-line. Example of call: python devtools\licenseupdater.py include src -n --diff => Show change that would be made to the sources. python devtools\licenseupdater.py include src => Update license statement on all sources in directories include/ and src/. """ from optparse import OptionParser parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option( '-n', '--dry-run', dest="dry_run", action='store_true', default=False, help="""Only show what files are updated, do not update the files""") parser.add_option('--diff', dest="show_diff", action='store_true', default=False, help="""On update, show change made to the file.""") parser.enable_interspersed_args() options, args = parser.parse_args() update_license_in_source_directories(args, options.dry_run, options.show_diff) print('Done')
def main(): import os import sys import runpy import pstats from optparse import OptionParser usage = "cProfile.py [-o output_file_path] [-s sort] [-m module | scriptfile] [arg] ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option('-o', '--outfile', dest="outfile", help="Save stats to <outfile>", default=None) parser.add_option( '-s', '--sort', dest="sort", help="Sort order when printing to stdout, based on pstats.Stats class", default=-1, choices=sorted(pstats.Stats.sort_arg_dict_default)) parser.add_option('-m', dest="module", action="store_true", help="Profile a library module", default=False) if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() sys.argv[:] = args # The script that we're profiling may chdir, so capture the absolute path # to the output file at startup. if options.outfile is not None: options.outfile = os.path.abspath(options.outfile) if len(args) > 0: if options.module: code = "run_module(modname, run_name='__main__')" globs = {'run_module': runpy.run_module, 'modname': args[0]} else: progname = args[0] sys.path.insert(0, os.path.dirname(progname)) with open(progname, 'rb') as fp: code = compile(fp.read(), progname, 'exec') globs = { '__file__': progname, '__name__': '__main__', '__package__': None, '__cached__': None, } runctx(code, globs, None, options.outfile, options.sort) else: parser.print_usage() return parser
def usage(): """Defines the usage for the setup.py script.""" usage = "usage: %prog [options] argv[program to compile]" parser = OptionParser(usage) parser.allow_interspersed_args = True parser.add_option( "-e", "--exe", dest="CouetteFlw", default=None, help="This option will compile or run utility program for pre and " "post-processing files used by code. You must specify a utility " "type, UTILITY, as well as the name of the utility within that type. " "For more help and a list of options run, ./setup.py -u HELP") parser.add_option( "-u", "--utility", dest="utility", default=None, help="This option will compile or run utility program for pre and " "post-processing files used by code. You must specify a utility " "type, UTILITY, as well as the name of the utility within that type. " "For more help and a list of options run, ./setup.py -u HELP") parser.add_option( "-p", "--postproc", dest="postprocessing", default=None, help="This option will compile or run postprocessing routines" "For more help and a list of options run, ./setup.py -u HELP") (options, args) = parser.parse_args() if options.CouetteFlw != None: action = "CouetteFlw" elif options.utility != None: action = "utility" elif options.postprocessing != None: action = "postprocessing" else: action = None # inputargs is re-defined as a dictonary for the input variables # specified at command line, if not specified defaults are used. inputargs = {} if len(args) == 0: inputargs['name'] = "NO INPUT" else: inputargs['name'] = args[0] # update dictionary values using any additional command-line inputs if len(args) > 1: inputargs.update(ast.literal_eval(sys.argv[len(sys.argv) - 1])) return options, inputargs, action
def setup_parser(self): parser = OptionParser() parser.allow_interspersed_args = False parser.add_option("-H", "--host", dest='host', help='database host', default=None) parser.add_option("-u", "--user", dest='user', help='database user', default=None) parser.add_option("-p", "--password", dest='password', help='database password', default=None) parser.add_option("-d", "--database", dest='db', help='database name', default=None) parser.add_option('-v', '--verbose', action='callback', callback=self.increase_verbose_cb) parser.add_option('-x', '--xception-trace', action='store_true', dest='exception_trace', default=False) return parser
def _init_parser(self): parser = OptionParser(add_help_option=False, usage=self.usage()) parser.allow_interspersed_args = self.interspersed_arguments() for op in self.options(): parser.add_option(copy.deepcopy(op)) for gr in self.groups(): real_group = parser.add_option_group(gr.name()) for op in gr.options(): real_group.add_option(copy.deepcopy(op)) return parser
def _init_parser(self): parser = OptionParser(add_help_option=False, usage=self.usage()) parser.allow_interspersed_args = self.interspersed_arguments() for op in self.options(): parser.add_option(copy.deepcopy(op)) for gr in self.groups(): real_group = parser.add_option_group(gr.name()) for op in gr.options(): real_group.add_option(copy.deepcopy(op)) return parser
def setup_parser(self): parser = OptionParser() parser.allow_interspersed_args = False parser.add_option('-g', '--generate', action='store_true', default=False, help='generate only') parser.add_option('-a', '--activate', action='store_true', default=False, help='activate only') parser.add_option('-v', '--verbose', action='callback', callback=self.increase_verbose_cb) parser.add_option('-d', '--debug', action='store_true', default=False, help='debug output') parser.add_option('-x', '--xception-trace', action='store_true', dest='exception_trace', default=False) return parser
def main(): usage = "usage: %prog [-h] [-o output_file_path] scriptfile [arg] ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option('', '--html', dest="output_html", action='store_true', help="output HTML instead of text", default=False) parser.add_option('-o', '--outfile', dest="outfile", action='store', help="save stats to <outfile>", default=None) if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() sys.argv[:] = args if len(args) > 0: progname = args[0] sys.path.insert(0, os.path.dirname(progname)) with open(progname, 'rb') as fp: code = compile(fp.read(), progname, 'exec') globs = { '__file__': progname, '__name__': '__main__', '__package__': None, } profiler = Profiler() profiler.start() try: exec code in globs, None except SystemExit, KeyboardInterrupt: pass profiler.stop() if options.outfile: f = codecs.open(options.outfile, 'w', 'utf-8') unicode = True color = False else: f = sys.stdout unicode = stdout_supports_unicode() color = stdout_supports_color() if options.output_html: f.write(profiler.output_html()) else: f.write(profiler.output_text(unicode=unicode, color=color)) f.close()
def ParseArguments(argv): """ Parse arguments """ from optparse import OptionParser, make_option testHelp = """ """ # Internal cmds supported by this handler _CMD_OPTIONS_LIST = [ make_option("-h", "--host", dest="host", default="localhost", help="ESX host name"), make_option("-o", "--port", dest="port", default=443, help="Port"), make_option("-u", "--user", dest="user", default="root", help="Host User name"), make_option("-p", "--pwd", dest="pwd", default="", help="Host Password"), make_option("-k", "--key", dest="keyFile", default=None, help="Key file path"), make_option("-c", "--cert", dest="certFile", default=None, help="Cert file path"), make_option("-w", "--workers", dest="workers", type="int", default=8, help="Num of workers"), make_option("-s", "--waitSec", dest="waitSec", type="int", default=8, help="Num of sec to wait"), make_option("-n", "--numPCUpdates", dest="numWaitUpdate", type="int", default=2, help="Num of pc wait for updates"), make_option("-v", "--verbose", action="store_true", dest="verbose_stats", default=False, help="Enable verbose stats"), make_option("-?", "--help", action="store_true", help="Help"), ] _STR_USAGE = "%prog [options]" # Get command line options cmdParser = OptionParser(option_list=_CMD_OPTIONS_LIST, usage=_STR_USAGE, add_help_option=False) cmdParser.allow_interspersed_args = False usage = cmdParser.format_help() # Parse arguments (options, remainingOptions) = cmdParser.parse_args(argv) try: # optparser does not have a destroy() method in older python cmdParser.destroy() except Exception: pass del cmdParser # Print usage if options.help: print(usage) print(testHelp) sys.exit(0) return (options, remainingOptions)
def main(): glia_path = os.path.dirname( os.path.realpath(__file__)) + '/command_line.py' usage = "glia-profile [-o output_file_path] [-s sort] [arg] ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option('-o', '--outfile', dest="outfile", help="Save stats to <outfile>", default=None) parser.add_option( '-s', '--sort', dest="sort", help="Sort order when printing to stdout, based on pstats.Stats class", default=-1) (options, args) = parser.parse_args() sys.argv[:] = ['glia'] + args if len(args) >= 0: progname = 'command_line.py' # sys.path.insert(0, os.path.dirname(progname)) with open(glia_path, 'rb') as fp: code = compile(fp.read(), progname, 'exec') globs = { '__file__': progname, '__name__': '__main__', '__package__': None, } pr = cProfile.Profile() pr.enable() try: exec( code, globs, None, ) except Exception as exception: traceback.print_tb(exception.__traceback__) print(exception) pass pr.disable() s = io.StringIO() sortby = 'cumulative' ps = pstats.Stats(pr, stream=s).sort_stats(sortby) ps.print_stats(20) print(s.getvalue()) else: parser.print_usage()
def main(argv=None): from optparse import OptionParser if argv is None: argv = sys.argv[1:] usage = "memprof [-o output_file_path] scriptfile [arg] ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option('-o', '--output', dest="output", default='./', help="Save stats to <outfile> directory") parser.add_option('-t', '--threshold', dest="threshold", default='1gb') parser.add_option('-n', '--tick', dest="tick", type=int, default=10.0) if not argv: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() sys.argv[:] = args if len(args) > 0: progname = args[0] sys.path.insert(0, os.path.dirname(progname)) from memprof.profiler import watch_thread def parse_threshold(string): if string.endswith('mb'): threshold = int(string[:-2]) * 1024 * 1024 elif string.endswith('gb'): threshold = int(string[:-2]) * 1024 * 1024 * 1024 elif string.endswith('kb'): threshold = int(string[:-2]) * 1024 elif string.endswith('b'): threshold = int(string[:-1]) else: threshold = int(string) return threshold watch_thread( output=options.output, threshold=parse_threshold(options.threshold), tick=options.tick, ) run_python_file(progname, args) else: parser.print_usage()
def _get_parser(): p = OptionParser(usage=USAGE, version=VERSION) p.allow_interspersed_args = False p.add_option( '--check', action='store_true', dest='dry_run', default=False, help='dry-run mode' ) p.add_option( '--debug', action='store_true', dest='debug', default=False, help='debug mode' ) return p
def main(): from optparse import OptionParser usage = "python -m greenlet_profiler [-b] [-s] [scriptfile] args ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option( "-b", "--builtins", action="store_true", dest="profile_builtins", default=False, help="Profiles builtin functions when set. [default: False]") parser.add_option( "-s", "--single_thread", action="store_true", dest="profile_single_thread", default=False, help="Profiles only the thread that calls start(). [default: False]") clock_types = ['wall', 'cpu'] parser.add_option("-c", "--clock_type", dest="clock_type", type='choice', choices=clock_types, default='cpu', help="One of %s" % clock_types) options, args = parser.parse_args() if len(args) > 0: sys.path.insert(0, os.path.dirname(args[0])) set_clock_type(options.clock_type) start(options.profile_builtins, not options.profile_single_thread) if sys.version_info >= (3, 0): exec(compile(open(args[0]).read(), args[0], 'exec'), sys._getframe(1).f_globals, sys._getframe(1).f_locals) else: execfile(args[0], sys._getframe(1).f_globals, sys._getframe(1).f_locals) stop() get_func_stats().print_all() get_thread_stats().print_all() else: parser.print_usage() sys.exit(2)
def main(): from optparse import OptionParser import atexit usage = "python -m greenlet_profiler [-b] [-s] [scriptfile] args ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option( "-b", "--builtins", action="store_true", dest="profile_builtins", default=False, help="Profiles builtin functions when set. [default: False]") parser.add_option( "-s", "--single_thread", action="store_true", dest="profile_single_thread", default=False, help="Profiles only the thread that calls start(). [default: False]") parser.add_option( "-l", "--log-file", dest="log_file", default=None, help="Log file name") clock_types = ['wall', 'cpu'] parser.add_option( "-c", "--clock_type", dest="clock_type", type='choice', choices=clock_types, default='cpu', help="One of %s" % clock_types) options, args = parser.parse_args() if len(args) > 0: sys.path.insert(0, os.path.dirname(args[0])) set_clock_type(options.clock_type) start(options.profile_builtins, not options.profile_single_thread) atexit.register(cleanup, options) if sys.version_info >= (3, 0): exec (compile(open(args[0]).read(), args[0], 'exec'), sys._getframe(1).f_globals, sys._getframe(1).f_locals) else: execfile(args[0], {}, {}) #execfile(args[0], sys._getframe(1).f_globals, # sys._getframe(1).f_locals) else: parser.print_usage() sys.exit(2)
def main(): from optparse import OptionParser usage = "%s [-b] [-c clock_type] [-o output_file] [-f output_format] [-s] [scriptfile] args ..." % os.path.basename(sys.argv[0]) parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option("-c", "--clock-type", default="cpu", choices=sorted(c.lower() for c in CLOCK_TYPES), metavar="clock_type", help="Clock type to use during profiling" "(\"cpu\" or \"wall\", default is \"cpu\").") parser.add_option("-b", "--builtins", action="store_true", dest="profile_builtins", default=False, help="Profiles builtin functions when set. [default: False]") parser.add_option("-o", "--output-file", metavar="output_file", help="Write stats to output_file.") parser.add_option("-f", "--output-format", default="pstat", choices=("pstat", "callgrind", "ystat"), metavar="output_format", help="Write stats in the specified" "format (\"pstat\", \"callgrind\" or \"ystat\", default is " "\"pstat\").") parser.add_option("-s", "--single_thread", action="store_true", dest="profile_single_thread", default=False, help="Profiles only the thread that calls start(). [default: False]") if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() sys.argv[:] = args if (len(sys.argv) > 0): sys.path.insert(0, os.path.dirname(sys.argv[0])) set_clock_type(options.clock_type) start(options.profile_builtins, not options.profile_single_thread) try: if sys.version_info >= (3, 0): exec(compile(open(sys.argv[0]).read(), sys.argv[0], 'exec'), sys._getframe(1).f_globals, sys._getframe(1).f_locals) else: execfile(sys.argv[0], sys._getframe(1).f_globals, sys._getframe(1).f_locals) finally: stop() if options.output_file: stats = get_func_stats() stats.save(options.output_file, options.output_format) else: # we will currently use default params for these get_func_stats().print_all() get_thread_stats().print_all() else: parser.print_usage()
def main(): parser = OptionParser(usage="%prog [options] script [script options]") parser.allow_interspersed_args = False parser.add_option('-o', '--outfile', help="Save report to <outfile>", default=None) parser.add_option('-u', '--user1', help='Install USR1 signal handler', action='store_true', default=False) parser.add_option('-U', '--user2', help='Install USR2 signal handler', action='store_true', default=False) parser.add_option('-i', '--interval', type="float", help="Timer interval in seconds. (default: 0.05", default=0.01) parser.add_option('-t', '--timer', help="Timer type used.", choices=('cpu', 'user', 'real'), default='real') if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() global _outfile _outfile = options.outfile if options.user1: signal.signal(signal.SIGUSR1, _show_profile_handler) if options.user2: signal.signal(signal.SIGUSR1, _show_profile_handler) install(options.timer, options.interval) import atexit atexit.register(_show_profile) if (len(args) > 0): progname = args[0] sys.argv[:] = args sys.path.insert(0, os.path.dirname(sys.argv[0])) import __main__ d = dict(__file__=progname, __name__='__main__', ) code = open(progname,'rb').read() code = compile(code, progname, 'exec') exec(code, d, d) else: parser.print_usage() return parser
def main(): import os import sys import runpy import pstats from optparse import OptionParser usage = "cProfile.py [-o output_file_path] [-s sort] [-m module | scriptfile] [arg] ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option('-o', '--outfile', dest="outfile", help="Save stats to <outfile>", default=None) parser.add_option('-s', '--sort', dest="sort", help="Sort order when printing to stdout, based on pstats.Stats class", default=-1, choices=sorted(pstats.Stats.sort_arg_dict_default)) parser.add_option('-m', dest="module", action="store_true", help="Profile a library module", default=False) if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() sys.argv[:] = args if len(args) > 0: if options.module: code = "run_module(modname, run_name='__main__')" globs = { 'run_module': runpy.run_module, 'modname': args[0] } else: progname = args[0] sys.path.insert(0, os.path.dirname(progname)) with open(progname, 'rb') as fp: code = compile(fp.read(), progname, 'exec') globs = { '__file__': progname, '__name__': '__main__', '__package__': None, '__cached__': None, } runctx(code, globs, None, options.outfile, options.sort) else: parser.print_usage() return parser
def main(): usage = "usage: %prog [-h] [[-o output_file_path] scriptfile [arg] ...] | [ -i infile ]" parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option('', '--html', dest="output_html", action='store_true', help="output HTML instead of text", default=False) parser.add_option('', '--json', dest="output_json", action='store_true', help="output raw JSON dump instead of text or HTML", default=False) parser.add_option('-o', '--outfile', dest="outfile", action='store', help="save stats to <outfile>", default=None) parser.add_option('-i', '--infile', dest="infile", action='store', help="load stats from JSON file <infile>", default=None) if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() sys.argv[:] = args if len(args) > 0: progname = args[0] sys.path.insert(0, os.path.dirname(progname)) with open(progname, 'rb') as fp: code = compile(fp.read(), progname, 'exec') globs = { '__file__': progname, '__name__': '__main__', '__package__': None, } profiler = Profiler() profiler.start() try: exec code in globs, None except SystemExit, KeyboardInterrupt: pass profiler.stop() write_output( options, profiler )
def _get_parser(): p = OptionParser(usage=USAGE, version=VERSION) p.allow_interspersed_args = False p.add_option('--check', action='store_true', dest='dry_run', default=False, help='dry-run mode') p.add_option('--debug', action='store_true', dest='debug', default=False, help='debug mode') return p
def main(): usage = ("usage: pycell [options] scriptfile [arg] ...") parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option( '-c', '--cell', dest="cell", type=int, help="select cell to run, defaults to the last one", default=-1 ) parser.add_option( '-s', '--strip-magics', dest="strip", action="store_true", help="strip IPython magic commands from source", ) if not sys.argv[1:]: parser.print_help() sys.exit(2) (options, args) = parser.parse_args() sys.argv[:] = args if len(args) > 0: progname = args[0] sys.path.insert(0, os.path.dirname(progname)) with open(progname, 'rb') as fp: codelist = split_cells(fp)[options.cell] if options.strip: codelist = strip_magics(codelist) code = compile("\n".join(codelist), progname, 'exec') globs = { '__file__': progname, '__name__': '__main__', '__package__': None, } exec_(code, globs, None) else: parser.print_usage()
def main(): usage = r"""%prog WORK_DIR SOURCE_DIR CONFIG_JSON_PATH [CONFIG2_JSON_PATH...] Build a given CMake based project located in SOURCE_DIR with multiple generators/options.dry_run as described in CONFIG_JSON_PATH building in WORK_DIR. Example of call: python devtools\batchbuild.py e:\buildbots\jsoncpp\build . devtools\agent_vmw7.json """ from optparse import OptionParser parser = OptionParser(usage=usage) parser.allow_interspersed_args = True # parser.add_option('-v', '--verbose', dest="verbose", action='store_true', # help="""Be verbose.""") parser.enable_interspersed_args() options, args = parser.parse_args() if len(args) < 3: parser.error("Missing one of WORK_DIR SOURCE_DIR CONFIG_JSON_PATH.") work_dir = args[0] source_dir = args[1].rstrip('/\\') config_paths = args[2:] for config_path in config_paths: if not os.path.isfile(config_path): parser.error("Can not read: %r" % config_path) # generate build variants build_descs = [] for config_path in config_paths: build_descs_by_axis = load_build_variants_from_config(config_path) build_descs.extend(generate_build_variants(build_descs_by_axis)) print('Build variants (%d):' % len(build_descs)) # assign build directory for each variant if not os.path.isdir(work_dir): os.makedirs(work_dir) builds = [] with open(os.path.join(work_dir, 'matrix-dir-map.txt'), 'wt') as fmatrixmap: for index, build_desc in enumerate(build_descs): build_desc_work_dir = os.path.join(work_dir, '%03d' % (index + 1)) builds.append( BuildData(build_desc, build_desc_work_dir, source_dir)) fmatrixmap.write('%s: %s\n' % (build_desc_work_dir, build_desc)) for build in builds: build.execute_build() html_report_path = os.path.join(work_dir, 'batchbuild-report.html') generate_html_report(html_report_path, builds) print('Done')
def main(): from optparse import OptionParser usage = "yappi.py [-b] [-o output_file] [-f output_format] [-s] [scriptfile] args ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option("-b", "--builtins", action="store_true", dest="profile_builtins", default=False, help="Profiles builtin functions when set. [default: False]") parser.add_option("-o", "--output-file", metavar="output_file", help="Write stats to output_file.") parser.add_option("-f", "--output-format", default="pstat", choices=("pstat", "callgrind", "ystat"), metavar="output_format", help="Write stats in the specified" "format (\"pstat\", \"callgrind\" or \"ystat\", default is " "\"pstat\").") parser.add_option("-s", "--single_thread", action="store_true", dest="profile_single_thread", default=False, help="Profiles only the thread that calls start(). [default: False]") if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() sys.argv[:] = args if (len(sys.argv) > 0): sys.path.insert(0, os.path.dirname(sys.argv[0])) start(options.profile_builtins, not options.profile_single_thread) try: if sys.version_info >= (3, 0): exec(compile(open(sys.argv[0]).read(), sys.argv[0], 'exec'), sys._getframe(1).f_globals, sys._getframe(1).f_locals) else: execfile(sys.argv[0], sys._getframe(1).f_globals, sys._getframe(1).f_locals) finally: stop() if options.output_file: stats = get_func_stats() stats.save(options.output_file, options.output_format) else: # we will currently use default params for these get_func_stats().print_all() get_thread_stats().print_all() else: parser.print_usage()
def main(): usage = """%prog [options] Generate a single amalgated source and header file from the sources. """ from optparse import OptionParser parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option( "-s", "--source", dest="target_source_path", action="store", default="dist/jsoncpp.cpp", help="""Output .cpp source path. [Default: %default]""", ) parser.add_option( "-i", "--include", dest="header_include_path", action="store", default="json/json.h", help="""Header include path. Used to include the header from the amalgated source file. [Default: %default]""", ) parser.add_option( "-t", "--top-dir", dest="top_dir", action="store", default=os.getcwd(), help="""Source top-directory. [Default: %default]""", ) parser.enable_interspersed_args() options, args = parser.parse_args() msg = amalgate_source( source_top_dir=options.top_dir, target_source_path=options.target_source_path, header_include_path=options.header_include_path, ) if msg: sys.stderr.write(msg + "\n") sys.exit(1) else: print "Source succesfully amalagated"
def main(): usage = r"""%prog WORK_DIR SOURCE_DIR CONFIG_JSON_PATH [CONFIG2_JSON_PATH...] Build a given CMake based project located in SOURCE_DIR with multiple generators/options.dry_run as described in CONFIG_JSON_PATH building in WORK_DIR. Example of call: python devtools\batchbuild.py e:\buildbots\jsoncpp\build . devtools\agent_vmw7.json """ from optparse import OptionParser parser = OptionParser(usage=usage) parser.allow_interspersed_args = True # parser.add_option('-v', '--verbose', dest="verbose", action='store_true', # help="""Be verbose.""") parser.enable_interspersed_args() options, args = parser.parse_args() if len(args) < 3: parser.error( "Missing one of WORK_DIR SOURCE_DIR CONFIG_JSON_PATH." ) work_dir = args[0] source_dir = args[1].rstrip('/\\') config_paths = args[2:] for config_path in config_paths: if not os.path.isfile( config_path ): parser.error( "Can not read: %r" % config_path ) # generate build variants build_descs = [] for config_path in config_paths: build_descs_by_axis = load_build_variants_from_config( config_path ) build_descs.extend( generate_build_variants( build_descs_by_axis ) ) print 'Build variants (%d):' % len(build_descs) # assign build directory for each variant if not os.path.isdir( work_dir ): os.makedirs( work_dir ) builds = [] with open( os.path.join( work_dir, 'matrix-dir-map.txt' ), 'wt' ) as fmatrixmap: for index, build_desc in enumerate( build_descs ): build_desc_work_dir = os.path.join( work_dir, '%03d' % (index+1) ) builds.append( BuildData( build_desc, build_desc_work_dir, source_dir ) ) fmatrixmap.write( '%s: %s\n' % (build_desc_work_dir, build_desc) ) for build in builds: build.execute_build() html_report_path = os.path.join( work_dir, 'batchbuild-report.html' ) generate_html_report( html_report_path, builds ) print 'Done'
def main(): from optparse import OptionParser usage = "yappi.py [-b] [-s] [scriptfile] args ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option( "-b", "--builtins", action="store_true", dest="profile_builtins", default=False, help="Profiles builtin functions when set. [default: False]") parser.add_option( "-s", "--single_thread", action="store_true", dest="profile_single_thread", default=False, help="Profiles only the thread that calls start(). [default: False]") if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() sys.argv[:] = args if (len(sys.argv) > 0): sys.path.insert(0, os.path.dirname(sys.argv[0])) start(options.profile_builtins, not options.profile_single_thread) if sys.version_info >= (3, 0): exec(compile(open(sys.argv[0]).read(), sys.argv[0], 'exec'), sys._getframe(1).f_globals, sys._getframe(1).f_locals) else: execfile(sys.argv[0], sys._getframe(1).f_globals, sys._getframe(1).f_locals) stop() # we will currently use default params for these get_func_stats().print_all() get_thread_stats().print_all() else: parser.print_usage()
def __init__(self): parser = OptionParser( usage = "%prog [options] <command> [command-options]", version = "%prog " + i18ntoolbox_version ) parser.description = "I18NToolBox is intented to provide some " + \ "centralized helper function for gettext translatable " + \ "strings extraction and compilation." parser.allow_interspersed_args = False parser.add_option( '-b', '--base', dest='basedir', default='.', #os.getcwd(), help = "Project Base Directory. Defaults to current directory." ) parser.add_option( '-p', '--package-dir', dest="package_dir", help = "Package's path." ) parser.add_option( "-i", "--i18n-path", dest="i18n_path", help = "Path to package's i18n dir." ) commands = {} for entrypoint in pkg_resources.iter_entry_points("I18NToolBox.command"): command = entrypoint.load() commands[entrypoint.name] = (command.desc, entrypoint) self.commands = commands # Setup The Needed Default Dicts defaults = AttrsDict() defaults.project = AttrsDict() defaults.cfgfile = AttrsDict() defaults.parsed_opts = AttrsDict() defaults.gettext_opts = [] self.defaults = defaults # Setup our custom parser help message parser.print_help = self._help self.parser = parser
def main(): usage = """%prog [options] Generate a single amalgated source and header file from the sources. """ from optparse import OptionParser parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option('-s', '--source', dest="target_source_path", action='store', default='dist/amalgated-src/cppunit_lib.cpp', help="""Output .cpp source path. [Default: %default]""") parser.add_option('-t', '--top-dir', dest="top_dir", action='store', default=os.getcwd(), help="""Source top-directory. [Default: %default]""") parser.enable_interspersed_args() options, args = parser.parse_args() msg = amalgamate_source( source_top_dir=options.top_dir, target_source_path=options.target_source_path ) if msg: sys.stderr.write( msg + '\n' ) sys.exit( 1 ) else: print 'Source succesfully amalagated'
def main(): usage = "profile.py [-o output_file_path] [-s sort] scriptfile [arg] ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option('-o', '--outfile', dest="outfile", help="Save stats to <outfile>", default=None) parser.add_option('-s', '--sort', dest="sort", help="Sort order when printing to stdout, based on pstats.Stats class", default=-1) if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() if (len(args) > 0): sys.argv[:] = args sys.path.insert(0, os.path.dirname(sys.argv[0])) run('execfile(%r)' % (sys.argv[0],), options.outfile, options.sort) else: parser.print_usage() return parser
def main(argv=None): from optparse import OptionParser if argv is None: argv = sys.argv[1:] usage = "python -m peek [-o output_file_path] scriptfile [arg] ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option('-o', '--output', dest="output", help="Save stats to <outfile> directory", default=None) if not argv: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() sys.argv[:] = args if len(args) > 0: progname = args[0] sys.path.insert(0, os.path.dirname(progname)) from peek.collector import Collector from peek.reporter import HTMLReporter collector = Collector(log=(not options.output)) collector.start() try: run_python_file(progname, args) finally: collector.stop() reporter = HTMLReporter(progname, collector, output=options.output) reporter.report() else: parser.print_usage()
def main(): usage = """%prog [options] Generate a single amalgated source and header file from the sources. """ from optparse import OptionParser parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option("-s", "--source", dest="target_source_path", action="store", default="dist/jsoncpp.cpp", help="""Output .cpp source path. [Default: %default]""") parser.add_option( "-i", "--include", dest="header_include_path", action="store", default="json/json.h", help= """Header include path. Used to include the header from the amalgated source file. [Default: %default]""" ) parser.add_option("-t", "--top-dir", dest="top_dir", action="store", default=os.getcwd(), help="""Source top-directory. [Default: %default]""") parser.enable_interspersed_args() options, args = parser.parse_args() msg = amalgamate_source(source_top_dir=options.top_dir, target_source_path=options.target_source_path, header_include_path=options.header_include_path) if msg: sys.stderr.write(msg + "\n") sys.exit(1) else: print("Source succesfully amalagated")
def parse_options(): usage = "logmon.py scriptfile [arg] ..." parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option('-d', '--daemonize', action='store_true', default=False, help='Run the monitor application as daemon. This will make it ' 'exit automatically once the monitored application finishes. For ' 'the graphical window, you may not want this to happen!') parser.add_option('-u', '--ui', default='tk', metavar='UI', help='Select the user interface to run. Currently only "tk" is ' 'supported.') if not sys.argv[1:]: parser.print_usage() sys.exit(2) (options, args) = parser.parse_args() if not args: parser.print_usage() sys.exit(2) return options, args
def main(): usage = """%prog DIR [DIR2...] Updates license text in sources of the project in source files found in the directory specified on the command-line. Example of call: python devtools\licenseupdater.py include src -n --diff => Show change that would be made to the sources. python devtools\licenseupdater.py include src => Update license statement on all sources in directories include/ and src/. """ from optparse import OptionParser parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option('-n', '--dry-run', dest="dry_run", action='store_true', default=False, help="""Only show what files are updated, do not update the files""") parser.add_option('--diff', dest="show_diff", action='store_true', default=False, help="""On update, show change made to the file.""") parser.enable_interspersed_args() options, args = parser.parse_args() update_license_in_source_directories(args, options.dry_run, options.show_diff) print('Done')
def main(): usage = """%prog release_version next_dev_version Update 'version' file to release_version and commit. Generates the document tarball. Tags the sandbox revision with release_version. Update 'version' file to next_dev_version and commit. Performs an svn export of tag release version, and build a source tarball. Must be started in the project top directory. Warning: --force should only be used when developing/testing the release script. """ from optparse import OptionParser parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option('--dot', dest="dot_path", action='store', default=doxybuild.find_program('dot'), help="""Path to GraphViz dot tool. Must be full qualified path. [Default: %default]""") parser.add_option('--doxygen', dest="doxygen_path", action='store', default=doxybuild.find_program('doxygen'), help="""Path to Doxygen tool. [Default: %default]""") parser.add_option('--force', dest="ignore_pending_commit", action='store_true', default=False, help="""Ignore pending commit. [Default: %default]""") parser.add_option('--retag', dest="retag_release", action='store_true', default=False, help="""Overwrite release existing tag if it exist. [Default: %default]""") parser.add_option('-p', '--platforms', dest="platforms", action='store', default='', help="""Comma separated list of platform passed to scons for build check.""") parser.add_option('--no-test', dest="no_test", action='store_true', default=False, help="""Skips build check.""") parser.add_option('--no-web', dest="no_web", action='store_true', default=False, help="""Do not update web site.""") parser.add_option('-u', '--upload-user', dest="user", action='store', help="""Sourceforge user for SFTP documentation upload.""") parser.add_option('--sftp', dest='sftp', action='store', default=doxybuild.find_program('psftp', 'sftp'), help="""Path of the SFTP compatible binary used to upload the documentation.""") parser.enable_interspersed_args() options, args = parser.parse_args() if len(args) != 2: parser.error('release_version missing on command-line.') release_version = args[0] next_version = args[1] if not options.platforms and not options.no_test: parser.error('You must specify either --platform or --no-test option.') if options.ignore_pending_commit: msg = '' else: msg = check_no_pending_commit() if not msg: print('Setting version to', release_version) set_version(release_version) svn_commit('Release ' + release_version) tag_url = svn_join_url(SVN_TAG_ROOT, release_version) if svn_check_if_tag_exist(tag_url): if options.retag_release: svn_remove_tag(tag_url, 'Overwriting previous tag') else: print('Aborting, tag %s already exist. Use --retag to overwrite it!' % tag_url) sys.exit(1) svn_tag_sandbox(tag_url, 'Release ' + release_version) print('Generated doxygen document...') ## doc_dirname = r'jsoncpp-api-html-0.5.0' ## doc_tarball_path = r'e:\prg\vc\Lib\jsoncpp-trunk\dist\jsoncpp-api-html-0.5.0.tar.gz' doc_tarball_path, doc_dirname = doxybuild.build_doc(options, make_release=True) doc_distcheck_dir = 'dist/doccheck' tarball.decompress(doc_tarball_path, doc_distcheck_dir) doc_distcheck_top_dir = os.path.join(doc_distcheck_dir, doc_dirname) export_dir = 'dist/export' svn_export(tag_url, export_dir) fix_sources_eol(export_dir) source_dir = 'jsoncpp-src-' + release_version source_tarball_path = 'dist/%s.tar.gz' % source_dir print('Generating source tarball to', source_tarball_path) tarball.make_tarball(source_tarball_path, [export_dir], export_dir, prefix_dir=source_dir) amalgamation_tarball_path = 'dist/%s-amalgamation.tar.gz' % source_dir print('Generating amalgamation source tarball to', amalgamation_tarball_path) amalgamation_dir = 'dist/amalgamation' amalgamate.amalgamate_source(export_dir, '%s/jsoncpp.cpp' % amalgamation_dir, 'json/json.h') amalgamation_source_dir = 'jsoncpp-src-amalgamation' + release_version tarball.make_tarball(amalgamation_tarball_path, [amalgamation_dir], amalgamation_dir, prefix_dir=amalgamation_source_dir) # Decompress source tarball, download and install scons-local distcheck_dir = 'dist/distcheck' distcheck_top_dir = distcheck_dir + '/' + source_dir print('Decompressing source tarball to', distcheck_dir) rmdir_if_exist(distcheck_dir) tarball.decompress(source_tarball_path, distcheck_dir) scons_local_path = 'dist/scons-local.tar.gz' print('Downloading scons-local to', scons_local_path) download(SCONS_LOCAL_URL, scons_local_path) print('Decompressing scons-local to', distcheck_top_dir) tarball.decompress(scons_local_path, distcheck_top_dir) # Run compilation print('Compiling decompressed tarball') all_build_status = True for platform in options.platforms.split(','): print('Testing platform:', platform) build_status, log_path = check_compile(distcheck_top_dir, platform) print('see build log:', log_path) print(build_status and '=> ok' or '=> FAILED') all_build_status = all_build_status and build_status if not build_status: print('Testing failed on at least one platform, aborting...') svn_remove_tag(tag_url, 'Removing tag due to failed testing') sys.exit(1) if options.user: if not options.no_web: print('Uploading documentation using user', options.user) sourceforge_web_synchro(SOURCEFORGE_PROJECT, doc_distcheck_top_dir, user=options.user, sftp=options.sftp) print('Completed documentation upload') print('Uploading source and documentation tarballs for release using user', options.user) sourceforge_release_tarball(SOURCEFORGE_PROJECT, [source_tarball_path, doc_tarball_path], user=options.user, sftp=options.sftp) print('Source and doc release tarballs uploaded') else: print('No upload user specified. Web site and download tarball were not uploaded.') print('Tarball can be found at:', doc_tarball_path) # Set next version number and commit set_version(next_version) svn_commit('Released ' + release_version) else: sys.stderr.write(msg + '\n')
def cleanup(self): if self.started: try: self.p.kill() self.p.wait() except: pass safejoin(self.mpiout_t) self.publisher.close() super(MPIScheduler, self).cleanup() if __name__ == '__main__': parser = OptionParser(usage='Usage: drun [options] <command>') parser.allow_interspersed_args = False parser.add_option('-s', '--master', type='string', default='mesos', help='url of master (default: mesos)') parser.add_option('-i', '--mpi', action='store_true', help='run MPI tasks') parser.add_option('-n', '--tasks', type='int', default=1, help='number task to launch (default: 1)') parser.add_option('-b', '--start', type='int', default=0, help='which task to start (default: 0)') parser.add_option('-p', '--task_per_node', type='int', default=0, help='max number of tasks on one node (default: 0)') parser.add_option('-r', '--retry', type='int', default=0, help='retry times when failed (default: 0)') parser.add_option('-t', '--timeout', type='int', default=3600 * 24,
import numpy as np import pickle import cv2 from utils_yolo_v2 import WeightReader, decode_netout, draw_boxes from preprocessing_yolo_v2 import parse_annotation, BatchGenerator import json import logging from optparse import OptionParser logging.basicConfig(level=logging.INFO) #logging.basicConfig(level=logging.DEBUG) logger = logging.getLogger("logger-retrain-yolo.py") parser = OptionParser() parser.allow_interspersed_args = True parser.add_option( "--out_model", default="/data/preprocessed/retrained_models/test_model_face_yolo_v2.json", dest="OUT_MODEL", help="serialized model to json") parser.add_option( "--out_weights", default="/data/preprocessed/retrained_models/test_weights_face_yolo_v2.h5", dest="OUT_WEIGHTS", help="serialized weights") parser.add_option( "--out_full", default= "/data/preprocessed/retrained_models/test_full_model_face_yolo_v2.h5", dest="OUT_FULL",
def main(): usage = """%prog [options] Generate a single amalgamated source and header file from the sources. """ from optparse import OptionParser parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option("-s", "--source", dest="target_source_path", action="store", default="dist/arbiter.cpp", help="""Output .cpp source path. [Default: %default]""") parser.add_option( "-i", "--include", dest="header_include_path", action="store", default="arbiter.hpp", help= """Header include path. Used to include the header from the amalgamated source file. [Default: %default]""" ) parser.add_option("-t", "--top-dir", dest="top_dir", action="store", default=os.getcwd(), help="""Source top-directory. [Default: %default]""") parser.add_option("-x", "--no-include-xml", dest="include_xml", action="store_false", default=True) parser.add_option("-d", "--define-curl", dest="define_curl", action="store_true", default=False) parser.add_option("-j", "--bundle-json", dest="bundle_json", action="store_true", default=False) parser.add_option("-c", "--custom-namespace", dest="custom_namespace", action="store", default=None) parser.enable_interspersed_args() options, args = parser.parse_args() msg = amalgamate_source(source_top_dir=options.top_dir, target_source_path=options.target_source_path, header_include_path=options.header_include_path, include_xml=options.include_xml, custom_namespace=options.custom_namespace, define_curl=options.define_curl, bundle_json=options.bundle_json) if msg: sys.stderr.write(msg + "\n") sys.exit(1) else: print("Source successfully amalgamated")
def main(): usage = ("usage: pyinstrument [options] scriptfile [arg] ...") parser = OptionParser(usage=usage) parser.allow_interspersed_args = False parser.add_option('', '--setprofile', dest='setprofile', action='store_true', help='run in setprofile mode, instead of signal mode', default=False) parser.add_option('', '--html', dest="output_html", action='store_true', help="output HTML instead of text", default=False) parser.add_option('', '--flame', dest='output_flame', action='store_true', help='output an HTML flame chart', default=False) parser.add_option('-r', '--renderer', dest='output_renderer', action='store', type='string', help='python import path to a renderer class', default=None) parser.add_option('-o', '--outfile', dest="outfile", action='store', help="save report to <outfile>", default=None) parser.add_option('', '--unicode', dest='unicode', action='store_true', help='force unicode text output') parser.add_option('', '--no-unicode', dest='unicode', action='store_false', help='force ascii text output') parser.add_option('', '--color', dest='color', action='store_true', help='force ansi color text output') parser.add_option('', '--no-color', dest='color', action='store_false', help='force no color text output') parser.add_option('-m', '', dest='module_name', action='store', help='searches sys.path for the named module and runs the corresponding .py file as a script.') if not sys.argv[1:]: parser.print_help() sys.exit(2) options, args = parser.parse_args() if args == [] and options.module_name is None: parser.print_help() sys.exit(2) if options.module_name is not None: sys.argv[:] = [options.module_name] + args code = "run_module(modname, run_name='__main__')" globs = { 'run_module': runpy.run_module, 'modname': options.module_name } else: sys.argv[:] = args progname = args[0] sys.path.insert(0, os.path.dirname(progname)) with open(progname, 'rb') as fp: code = compile(fp.read(), progname, 'exec') globs = { '__file__': progname, '__name__': '__main__', '__package__': None, } if options.output_renderer: renderer = options.output_renderer elif options.output_html: renderer = 'html' else: renderer = 'text' recorder = get_renderer_class(renderer).preferred_recorder profiler = Profiler(recorder=recorder) profiler.start() try: exec_(code, globs, None) except (SystemExit, KeyboardInterrupt): pass profiler.stop() if options.outfile: f = codecs.open(options.outfile, 'w', 'utf-8') else: f = sys.stdout renderer_kwargs = {} if renderer == 'text': unicode_override = options.unicode != None color_override = options.color != None unicode = options.unicode if unicode_override else file_supports_unicode(f) color = options.color if color_override else file_supports_color(f) renderer_kwargs = {'unicode': unicode, 'color': color} f.write(profiler.output(renderer=renderer, **renderer_kwargs)) f.close()