Пример #1
0
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
Пример #2
0
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
Пример #3
0
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
Пример #4
0
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
Пример #5
0
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 )
Пример #7
0
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
Пример #8
0
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)
Пример #10
0
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'
Пример #11
0
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
Пример #12
0
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)
Пример #13
0
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)
Пример #14
0
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
Пример #15
0
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
Пример #16
0
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)
Пример #17
0
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
Пример #18
0
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
Пример #19
0
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)
Пример #21
0
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 )
Пример #23
0
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')
Пример #24
0
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
Пример #25
0
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
Пример #26
0
 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
Пример #27
0
 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
Пример #28
0
 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
Пример #29
0
 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
Пример #30
0
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()
Пример #31
0
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)
Пример #32
0
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()
Пример #33
0
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()
Пример #34
0
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
Пример #35
0
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)
Пример #36
0
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)
Пример #37
0
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()
Пример #38
0
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
Пример #39
0
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
Пример #40
0
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 )
Пример #41
0
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
Пример #42
0
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()
Пример #43
0
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')
Пример #44
0
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()
Пример #45
0
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"
Пример #46
0
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'
Пример #47
0
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()
Пример #48
0
    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
Пример #49
0
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'
Пример #50
0
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
Пример #51
0
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()
Пример #52
0
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")
Пример #53
0
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
Пример #54
0
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')
Пример #55
0
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')
Пример #56
0
    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,
Пример #57
0
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",
Пример #58
0
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")
Пример #59
0
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()