def execute(argv=None, settings=None):
"""The entry point of command line"""
if argv is None:
argv = sys.argv
if settings is None:
settings = 'nothing'
cmds = _get_commands_dict(settings)
cmdname = _pop_command_name(argv)
parser = optparse.OptionParser(formatter=optparse.TitledHelpFormatter(),
conflict_handler='resolve')
if not cmdname:
_print_commands(settings)
sys.exit(0)
elif cmdname not in cmds:
_print_unknown_command(settings, cmdname)
sys.exit(2)
cmd = cmds[cmdname]
parser.usage = "robotx %s %s" % (cmdname, cmd.syntax())
parser.description = cmd.long_desc()
cmd.add_options(parser)
opts, args = parser.parse_args(args=argv[1:])
_run_print_help(parser, cmd.process_options, args, opts)
_run_print_help(parser, _run_command, cmd, args, opts)
sys.exit(cmd.exitcode)
def execute(argv=None):
if argv is None:
argv = sys.argv
crawler = CrawlerProcess(settings)
crawler.install()
inproject = inside_project()
_check_deprecated_scrapy_ctl(argv, inproject) # TODO: remove for Scrapy 0.11
cmds = _get_commands_dict(inproject)
cmdname = _pop_command_name(argv)
parser = optparse.OptionParser(formatter=optparse.TitledHelpFormatter(), \
conflict_handler='resolve')
if not cmdname:
_print_commands(inproject)
sys.exit(0)
elif cmdname not in cmds:
_print_unknown_command(cmdname, inproject)
sys.exit(2)
cmd = cmds[cmdname]
parser.usage = "scrapy %s %s" % (cmdname, cmd.syntax())
parser.description = cmd.long_desc()
settings.defaults.update(cmd.default_settings)
cmd.settings = settings
cmd.add_options(parser)
opts, args = parser.parse_args(args=argv[1:])
_run_print_help(parser, cmd.process_options, args, opts)
cmd.set_crawler(crawler)
_run_print_help(parser, _run_command, cmd, args, opts)
sys.exit(cmd.exitcode)
def process_command_line(argv):
"""
Return a 2-tuple: (settings object, args list).
`argv` is a list of arguments, or `None` for ``sys.argv[1:]``.
"""
if argv is None:
argv = sys.argv[1:]
# initialize the parser object:
parser = optparse.OptionParser(
formatter=optparse.TitledHelpFormatter(width=100),
add_help_option=None)
parser.add_option("-t",
"--threshold",
help="threshold of minimal reads count allowed")
parser.add_option( # customized description; put --help last
"-h", "--help", action="help",
help="Show this help message and exit.")
settings, args = parser.parse_args(argv)
# check number of arguments, verify values, etc.:
if args:
parser.error('program takes no command-line arguments; '
'"%s" ignored.' % (args,))
# further process settings & args if necessary
return settings, args
def process_command_line(argv):
"""
Return a 2-tuple: (settings object, args list).
`argv` is a list of arguments, or `None` for ``sys.argv[1:]``.
"""
if argv is None:
argv = sys.argv[1:]
# initialize the parser object:
parser = optparse.OptionParser(
formatter=optparse.TitledHelpFormatter(width=78), add_help_option=None)
# define options here:
parser.add_option( # customized description; put --help last
'-h',
'--help',
action='help',
help='Show this help message and exit.')
parser.add_option('-u',
'--url',
action='store',
dest='link',
help='Open a link.')
parser.add_option('-v',
'--version',
action='store_true',
help='Show version.')
parser.add_option('-q', '--quit', action='store_false', help='Quit')
settings, args = parser.parse_args(argv)
# check number of arguments, verify values, etc.:
if args:
parser.error('program takes no command-line arguments; '
'"%s" ignored.' % (args, ))
# further process settings & args if necessary
return settings, args
def parse():
parser = optparse.OptionParser(
formatter=optparse.TitledHelpFormatter())
parser.add_option('-v',
'--verbose',
action='store_true',
default=DEFAULT_VERBOSE,
help='verbose output')
parser.add_option('--host',
action='store',
type='string',
default=DEFAULT_HOST,
help='Host, default LocalHost')
parser.add_option('-p',
'--port',
action='store',
type='int',
default=DEFAULT_PORT,
help='Listening port, default 1234')
(options, args) = parser.parse_args()
if len(args) > 0:
parser.error('bad args, use --help for help')
if options.port is not None:
port = options.port
if options.host is not None:
host = options.host
return host, port, options.verbose
def get_options():
p = optparse.OptionParser(
description="Description: Check mapped JSON files for correct fields",
formatter=optparse.TitledHelpFormatter(),
prog='check_json.py',
version="%prog 0.1")
p.add_option('--dir',
'-d',
help='\nInput directory which contains the JSON files.',
default=None,
metavar='PATH')
p.add_option('--outputdir',
'-o',
help='\nOutput directory for the results.',
default='failed',
metavar='PATH')
p.add_option('--checklist',
'-c',
help='\nFile with orders for checking and validating',
default='scripts/checklist',
metavar='FILE')
p.add_option('--show',
'-s',
help='\nShow failed files in terminal.',
default=False,
metavar='BOOLEAN')
p.add_option('--show_limit',
help='\nThe limit of showed failed files in terminal.',
default=20,
type='int',
metavar='INTEGER')
return p.parse_args()
def process_command_line(argv):
"""
Return a 2-tuple: (settings object, args list).
Arguments:
argv - list of arguments, or 'None' for "sys.argv[1:]".
"""
if argv is None:
argv = sys.argv[1:]
# Initialize the parser object:
parser = optparse.OptionParser(
formatter=optparse.TitledHelpFormatter(width=78), add_help_option=None)
# define options here:
parser.add_option( # customized description; put --help last
'-h',
'--help',
action='help',
help='Show this help message and exit.')
settings, args = parser.parse_args(argv)
# Check number of arguments, verify values, etc.
if args:
parser.error('program takes no command-line arguments: '
'"%s" ignored.' % (args, ))
# Further process settings & args if necessary
return settings, args
def main():
import optparse
import sys
usage = """%prog [options] <url> [url]...""" \
"""
Examples:
%prog https://10.11.41.73/1MB https://10.11.41.69/1MB -v
%prog https://10.11.41.73/1MB https://10.11.41.69/1MB -s -p 2:300:-2:300"""
formatter = optparse.TitledHelpFormatter(indent_increment=2,
max_help_position=60)
p = optparse.OptionParser(usage=usage, formatter=formatter,
version="HTTP/S Traffic Generator %s" % __version__
)
p.add_option("-v", "--verbose", action="store_true",
help="Debug logging")
p.add_option("-s", "--stats", action="store_true", default=False,
help="Show statistics when done (default: no)")
p.add_option("-k", "--keepalive", action="store_true",
help="Reuse HTTP/1.1 connections for subsequent requests")
p.add_option("-c", "--concurrency", metavar="INTEGER",
default=1, type="int",
help="Number of parallel threads (default: 10)")
p.add_option("-n", "--requests", metavar="INTEGER",
default=-1, type="int",
help="Total number of requests (default: -1/infinite)")
p.add_option("-r", "--rate", metavar="INTEGER",
default=1*1024*1024, type="int",
help="Maximum bandwidth in bytes per sec (default: 1 Mbps)")
p.add_option("-d", "--dns", metavar="ADDRESS",
default=None, type="string",
help="DNS server to use (required for GTM testing)")
p.add_option("-p", "--pattern", metavar="STRING",
default="0:10", type="string",
help="[Threads delta:Sleep]... (default: 1:300:-1:300)")
p.add_option("-t", "--timeout", metavar="SECONDS", type="int", default=10,
help="Timeout (default: 10)")
options, args = p.parse_args()
if options.verbose:
level = logging.DEBUG
else:
level = logging.INFO
logging.getLogger('f5test').setLevel(logging.INFO)
logging.getLogger('f5test.macros').setLevel(logging.INFO)
LOG.setLevel(level)
logging.basicConfig(level=level)
if not args:
p.print_version()
p.print_help()
sys.exit(2)
cs = TrafficGen(options=options, urls=args)
cs.run()
def process_command_line(argv):
"""
Return a 2-tuple: (settings object, args list).
`argv` is a list of arguments, or `None` for ``sys.argv[1:]``.
"""
if argv is None:
argv = sys.argv[1:]
# initialize the parser object:
parser = optparse.OptionParser(
formatter=optparse.TitledHelpFormatter(width=78), add_help_option=None)
# define options here:
parser.add_option('-n',
type='int',
dest='highnum',
action='store',
help='Number of high samples (the rest are 0)')
parser.add_option( # customized description; put --help last
'-h',
'--help',
action='help',
help='Show this help message and exit.')
(options, args) = parser.parse_args(argv)
# check number of arguments, verify values, etc.:
if args:
parser.error('program takes no command-line arguments; '
'"%s" ignored.' % (args, ))
# further process settings & args if necessary
return (options, args)
def process_command_line(argv):
"""
Return a 2-tuple: (settings object, args list).
`argv` is a list of arguments, or `None` for ``sys.argv[1:]``.
"""
if argv is None:
argv = sys.argv[1:]
# initialize the parser object:
parser = optparse.OptionParser(
formatter=optparse.TitledHelpFormatter(width=78), add_help_option=None)
parser.add_option(
'-r',
'--reads_file',
help=
'The reads_fusion.txt file - the output of detect_fusion_point.py script'
)
parser.add_option( # customized description; put --help last
'-h',
'--help',
action='help',
help='Show this help message and exit.')
settings, args = parser.parse_args(argv)
# check number of arguments, verify values, etc.:
if args:
parser.error('program takes no command-line arguments; '
'"%s" ignored.' % (args, ))
# further process settings & args if necessary
return settings, args
def process_command_line(argv):
"""
Return a 2-tuple: (settings object, args list).
`argv` is a list of arguments, or `None` for ``sys.argv[1:]``.
"""
if argv is None:
argv = sys.argv[1:]
# initialize the parser object:
parser = optparse.OptionParser(
formatter=optparse.TitledHelpFormatter(width=78), add_help_option=None)
# define options here:
parser.add_option( # customized description; put --help last
'-h',
'--help',
action='help',
help='Show this help message and exit.')
settings, args = parser.parse_args(argv)
# check number of arguments, verify values, etc.:
#if args:
# parser.error('program takes no command-line arguments; '
# '"%s" ignored.' % (args,))
# further process settings & args if necessary
# For future versions, use args to specify what cleaning/prettifying ops to perform on the input files
return settings, args
def main():
import optparse
import sys
usage = """%prog [options] <emaddress>"""
formatter = optparse.TitledHelpFormatter(indent_increment=2,
max_help_position=60)
p = optparse.OptionParser(usage=usage, formatter=formatter,
version="Big3d Updater v%s" % __version__
)
p.add_option("-v", "--verbose", action="store_true",
help="Debug messages")
p.add_option("-u", "--admin-username", metavar="USERNAME",
default=ADMIN_USERNAME, type="string",
help="An user with admin rights (default: %s)"
% ADMIN_USERNAME)
p.add_option("-p", "--admin-password", metavar="PASSWORD",
default=ADMIN_PASSWORD, type="string",
help="An user with admin rights (default: %s)"
% ADMIN_PASSWORD)
p.add_option("-r", "--root-username", metavar="USERNAME",
default=ROOT_USERNAME, type="string",
help="An user with admin rights (default: %s)"
% ROOT_USERNAME)
p.add_option("-a", "--root-password", metavar="PASSWORD",
default=ROOT_PASSWORD, type="string",
help="An user with admin rights (default: %s)"
% ROOT_PASSWORD)
p.add_option("-d", "--devices", metavar="DEVICE", type="string",
action="append",
help="Include only this device(s). Multiple occurrences allowed.")
p.add_option("-n", "--task-name", metavar="STRING",
default='Big3d install task', type="string",
help="The task name.")
p.add_option("-t", "--timeout", metavar="TIMEOUT", type="int", default=60,
help="Timeout. (default: 60)")
options, args = p.parse_args()
if options.verbose:
level = logging.DEBUG
else:
level = logging.INFO
logging.getLogger('paramiko.transport').setLevel(logging.ERROR)
logging.getLogger('f5test').setLevel(logging.INFO)
logging.getLogger('f5test.macros').setLevel(logging.INFO)
LOG.setLevel(level)
logging.basicConfig(level=level)
if not args:
p.print_version()
p.print_help()
sys.exit(2)
cs = Big3dUtil(options=options, address=args[0])
cs.run()
def process_command_line(argv):
if argv is None:
argv = sys.argv[1:]
usage = "usage: %prog [options] f_pool sam1 [sam2 ..]"
parser = optparse.OptionParser(
usage,
formatter=optparse.TitledHelpFormatter(width=178),
add_help_option=None)
parser.add_option('-o',
'--outfile',
dest='outfile',
help='outfile name[default None, to stdout]',
metavar="FILE")
parser.add_option('-h',
'--help',
action='help',
help='Show this help message and exit.')
(options, args) = parser.parse_args(argv)
if len(args) < 2:
parser.error('No required parameters')
return options, args
def __init__(self, components=(), defaults=None, read_config_files=None,
*args, **kwargs):
"""
`components` is a list of Docutils components each containing a
``.settings_spec`` attribute. `defaults` is a mapping of setting
default overrides.
"""
self.lists = {}
"""Set of list-type settings."""
self.config_files = []
"""List of paths of applied configuration files."""
optparse.OptionParser.__init__(
self, option_class=Option, add_help_option=None,
formatter=optparse.TitledHelpFormatter(width=78),
*args, **kwargs)
if not self.version:
self.version = self.version_template
# Make an instance copy (it will be modified):
self.relative_path_settings = list(self.relative_path_settings)
self.components = (self,) + tuple(components)
self.populate_from_components(self.components)
self.set_defaults_from_dict(defaults or {})
if read_config_files and not self.defaults['_disable_config']:
try:
config_settings = self.get_standard_config_settings()
except ValueError as error:
self.error(SafeString(error))
self.set_defaults_from_dict(config_settings.__dict__)
def main():
import optparse
import sys
usage = """%prog [options] <address>"""
formatter = optparse.TitledHelpFormatter(indent_increment=2,
max_help_position=60)
p = optparse.OptionParser(usage=usage,
formatter=formatter,
version="SSH Key Exchange Tool v%s" %
__version__)
p.add_option("-v", "--verbose", action="store_true", help="Debug messages")
p.add_option("-u",
"--username",
metavar="USERNAME",
default=ROOT_USERNAME,
type="string",
help="An user with root rights (default: %s)" % ROOT_USERNAME)
p.add_option("-p",
"--password",
metavar="PASSWORD",
default=ROOT_PASSWORD,
type="string",
help="An user with root rights (default: %s)" % ROOT_PASSWORD)
p.add_option("",
"--port",
metavar="INTEGER",
type="int",
default=22,
help="SSH Port (default: 22)")
p.add_option("-t",
"--timeout",
metavar="TIMEOUT",
type="int",
default=60,
help="Timeout. (default: 60)")
options, args = p.parse_args()
if options.verbose:
level = logging.DEBUG
else:
level = logging.INFO
logging.getLogger('paramiko.transport').setLevel(logging.ERROR)
logging.getLogger('f5test').setLevel(logging.ERROR)
logging.getLogger('f5test.macros').setLevel(logging.INFO)
LOG.setLevel(level)
logging.basicConfig(level=level)
if not args:
p.print_version()
p.print_help()
sys.exit(2)
cs = KeySwap(options=options, address=args[0])
cs.run()
def execute(url, project, spider, callback, **kwargs):
argv = sys.argv
print(argv)
argv.append(url)
if spider:
argv.append('--spider')
argv.append(spider)
if callback:
argv.append('--callback')
argv.append(callback)
print(argv)
work_cwd = os.getcwd()
print(work_cwd)
try:
os.chdir(project)
settings = get_project_settings()
check_deprecated_settings(settings)
cmd = Parser()
parser = optparse.OptionParser(formatter=optparse.TitledHelpFormatter(), conflict_handler='resolve')
settings.setdict(cmd.default_settings, priority='command')
cmd.settings = settings
cmd.add_options(parser)
opts, args = parser.parse_args(args=argv[1:])
print('opt, args', opts, args)
cmd.process_options(args, opts)
cmd.crawler_process = CrawlerProcess(settings)
cmd.run(args, opts)
finally:
os.chdir(work_cwd)
def main():
'''
Parse argv for options and arguments, and start schema generation.
'''
parser = optparse.OptionParser(
usage="%prog [options] <model_path> [another_model_path...]",
version=xtuml.version.complete_string,
formatter=optparse.TitledHelpFormatter())
parser.set_description(__doc__.strip())
parser.add_option("-c",
"--component",
dest="component",
metavar="NAME",
help="export sql schema for the component named NAME",
action="store",
default=None)
parser.add_option("-d",
"--derived-attributes",
dest="derived",
help="include derived attributes in the schema",
action="store_true",
default=False)
parser.add_option("-o",
"--output",
dest='output',
metavar="PATH",
help="save sql schema to PATH (required)",
action="store",
default=None)
parser.add_option("-v",
"--verbosity",
dest='verbosity',
action="count",
help="increase debug logging level",
default=2)
(opts, args) = parser.parse_args()
if len(args) == 0 or opts.output is None:
parser.print_help()
sys.exit(1)
levels = {
0: logging.ERROR,
1: logging.WARNING,
2: logging.INFO,
3: logging.DEBUG,
}
logging.basicConfig(level=levels.get(opts.verbosity, logging.DEBUG))
loader = ooaofooa.Loader()
for filename in args:
loader.filename_input(filename)
c = loader.build_component(opts.component, opts.derived)
xtuml.persist_database(c, opts.output)
def run(argv):
commands = import_command("commands")
dict_command = get_command_dict(commands)
parser = optparse.OptionParser(prog="Command", formatter=optparse.TitledHelpFormatter(), \
conflict_handler='resolve')
"""
for k, v in dict_command.items():
print("%s : %s" %(k,v))
"""
print(argv)
cmdname = _resovle_argv(argv)
print(argv)
if cmdname in dict_command:
print()
cmd = dict_command[cmdname]
else:
_print_commands(commands)
parser.description = cmd.long_desc()
cmd.add_options(parser)
opts, argv = parser.parse_args(argv[1:])
print(opts)
print(argv)
cmd.process_option(argv, opts)
try:
cmd.process_option(argv, opts)
except Exception as e:
if str(e):
parser.error(str(e))
parser.print_help()
def _readOptions(self):
usage = "%prog [options] [-k FILE] [-r FILE] -i FILE [-o FILE]"
# Build option parser.
parser = optparse.OptionParser(usage=usage, formatter=optparse.TitledHelpFormatter())
parser.add_option("-V", "--version", action="store_true", dest="showVersion", default=False, help="Show version information.")
parser.add_option("-i", "--input", action="store", type="string", dest="inputFilePath", default=None, metavar="PATH", help="Specify the input OTP bit settings file.")
parser.add_option("-o", "--output", action="store", type="string", dest="outputFilePath", default=None, metavar="PATH", help="Write output to this file. Optional; if not provided then the output file name is generated from the input file name.")
parser.add_option("-k", "--key", action="store", type="string", dest="keyFilePath", default=None, metavar="PATH", help="Specify the input crypto key file.")
parser.add_option("-n", "--key-number", action="store", type="int", dest="keyIndex", default=0, metavar="NUM", help="Use key number N from the crypto key file (default 0).")
parser.add_option("-r", "--srk", action="store", type="string", dest="superRootKeyPath", default=None, metavar="PATH", help="Specify the binary super root key hash file.")
parser.add_option("-p", "--print-otp", action="store_true", dest="printResult", default=False, help="Print the resulting OTP registers.")
parser.add_option("-e", "--elftosb", action="store_true", dest="runElftosb", default=True, help="Run elftosb to generate the .sb file (the default).")
parser.add_option("-E", "--no-elftosb", action="store_false", dest="runElftosb", default=True, help="Do not run elftosb.")
parser.add_option("-a", "--hab", action="store_true", dest="useHab", default=True, help="generate a HAB compatible .sb (MX28 only; default)")
parser.add_option("-A", "--no-hab", action="store_false", dest="useHab", default=True, help="generate a non-HAB .sb (MX28 only)")
#Retrieve agruments(list) and options(dictionary)
return parser.parse_args()
def execute(argv=None, settings=None):
if argv is None:
argv = sys.argv
if settings is None:
settings = Settings()
inproject = inside_project()
if inproject:
if not get_project_settings(settings):
sys.exit(2)
cmds = _get_commands_dict(settings, inproject)
cmdname = _pop_command_name(argv)
parser = optparse.OptionParser(formatter=optparse.TitledHelpFormatter(),
conflict_handler='resolve')
if not cmdname:
_print_commands(settings, inproject)
sys.exit(0)
elif cmdname not in cmds:
_print_unknown_command(settings, cmdname, inproject)
sys.exit(2)
cmd = cmds[cmdname]
parser.usage = "devspace %s %s" % (cmdname, cmd.syntax())
parser.description = cmd.long_desc()
cmd.settings = settings
cmd.add_options(parser)
opts, args = parser.parse_args(args=argv[1:])
_run_print_help(parser, cmd.process_options, args, opts)
_run_print_help(parser, _run_command, cmd, args, opts)
sys.exit(cmd.exitcode)
def do_command_line():
parser = optparse.OptionParser(formatter=optparse.TitledHelpFormatter(), \
usage=globals()['__doc__'])
parser.add_option ('-l', '--lat', action='store', dest="latitude", \
type=float, help='Latitude in decimal degrees' )
parser.add_option ('-g', '--lon', action='store', dest="longitude", \
type=float, help='Longitude in decimal degrees' )
parser.add_option('-o', '--output', action="store", dest="output_file", \
default="grabba", type=str, help="Output file and directory" )
parser.add_option('-b', '--begin', action="store", dest="year_start", \
default=2003, type=int, help="Start year" )
parser.add_option('-e', '--end', action="store", dest="year_end", \
type=int, default=2014, help="End year" )
parser.add_option('-p', '--pool', action="store", dest="pool_size", \
type=int, default=10, help="Number of simultaneous threads to use" )
parser.add_option('-P', '--password', action="store", dest="password", \
type=str, help="EarthData Login password" )
parser.add_option('-U', '--user', action="store", dest="user", \
type=str, help="EarthData Login username" )
(options, args) = parser.parse_args()
if 'user' not in options.__dict__:
parser.error("You need to provide a username! Sgrunt!")
if 'password' not in options.__dict__:
parser.error("You need to provide a password! Sgrunt!")
return options.user, options.password, options.latitude, \
options.longitude, options.output_file, \
options.year_start, options.year_end, options.pool_size
def __init__(self,
components=(),
defaults=None,
read_config_files=None,
*args,
**kwargs):
"""
`components` is a list of Docutils components each containing a
``.settings_spec`` attribute. `defaults` is a mapping of setting
default overrides.
"""
optparse.OptionParser.__init__(
self,
add_help_option=None,
formatter=optparse.TitledHelpFormatter(width=78),
*args,
**kwargs)
if not self.version:
self.version = self.version_template
# Make an instance copy (it will be modified):
self.relative_path_settings = list(self.relative_path_settings)
self.populate_from_components((self, ) + tuple(components))
defaults = defaults or {}
if read_config_files and not self.defaults['_disable_config']:
config = ConfigParser()
config.read_standard_files(self)
config_settings = config.get_section('options')
make_paths_absolute(config_settings, self.relative_path_settings)
defaults.update(config_settings)
# Internal settings with no defaults from settings specifications;
# initialize manually:
self.set_defaults(_source=None, _destination=None, **defaults)
def process_command_line(argv):
"""
Return a 2-tuple: (settings object, args list).
`argv` is a list of arguments, or `None` for ``sys.argv[1:]``.
"""
if argv is None:
argv = sys.argv[1:]
# initialize the parser object:
parser = optparse.OptionParser(
formatter=optparse.TitledHelpFormatter(width=78), add_help_option=None)
parser.add_option('-g', '--gtf', help='GTF file containing the features.')
parser.add_option('-s', '--samfile', help='Input sam or bam file.')
parser.add_option(
'-r',
'--reverse',
action='store_true',
default=False,
help='Count the genes on the reverse strand of the mapping.')
parser.add_option(
'-f',
'--feature',
default='exon',
help='Name of features to count on the GTF file (column 2).')
parser.add_option(
'-i',
'--identifier',
default='gene_id',
help='Name of identifier to print (in column 8 of the GTF file).')
parser.add_option(
'-o',
'--overlap',
type='int',
default=5,
help='Minimal required overlap between the fragment and the feature.')
parser.add_option(
'-t',
'--strict',
default=False,
action='store_true',
help="Assign the read to a feature only if it covers only one feature."
)
parser.add_option( # customized description; put --help last
'-h',
'--help',
action='help',
help='Show this help message and exit.')
settings, args = parser.parse_args(argv)
# check number of arguments, verify values, etc.:
if args:
parser.error('program takes no command-line arguments; '
'"%s" ignored.' % (args, ))
# further process settings & args if necessary
return settings, args
def main():
import optparse
import sys
usage = """%prog [options] <address> [regex]...""" \
u"""
Extract TMOS configuration recursively from existing systems.
Examples:
%prog 10.1.2.3 ltm virtual cgnat_http
%prog 10.1.2.3 'ltm virtual cgnat_http|net vlan *'
"""
formatter = optparse.TitledHelpFormatter(indent_increment=2,
max_help_position=60)
p = optparse.OptionParser(usage=usage, formatter=formatter,
version="TMOS config extractor %s" % __version__)
p.add_option("-v", "--verbose", action="store_true",
help="Debug logging")
p.add_option("-c", "--cache", action="store_true",
help="Don't remove SCF file ({}) after parsing".format(SCF_OUTPUT))
p.add_option("-s", "--sort", action="store_true",
help="Sort objects alphabetically")
p.add_option("-u", "--username", metavar="USERNAME",
default=ROOT_USERNAME, type="string",
help="Root username (default: %s)"
% ROOT_USERNAME)
p.add_option("-p", "--password", metavar="PASSWORD",
default=ROOT_PASSWORD, type="string",
help="Root password (default: %s)"
% ROOT_PASSWORD)
p.add_option("", "--ucs", metavar="FILE", type="string",
help="UCS File to look at (Optional)")
p.add_option("-t", "--timeout", metavar="SECONDS", type="int", default=60,
help="Timeout (default: 60)")
options, args = p.parse_args()
if options.verbose:
level = logging.DEBUG
else:
level = logging.INFO
logging.getLogger('paramiko.transport').setLevel(logging.ERROR)
logging.getLogger('f5test').setLevel(logging.INFO)
logging.getLogger('f5test.macros').setLevel(logging.INFO)
LOG.setLevel(level)
logging.basicConfig(level=level)
if len(args) < 2:
p.print_version()
p.print_help()
sys.exit(2)
cs = Extractor(options=options, address=args[0],
params=args[1:])
print cs.run()
def setUp(self):
self.command = ScrapyCommand()
self.command.settings = Settings()
self.parser = optparse.OptionParser(
formatter=optparse.TitledHelpFormatter(),
conflict_handler='resolve',
)
self.command.add_options(self.parser)
def process_command_line(argv):
"""
Return a 2-tuple: (settings object, args list).
`argv` is a list of arguments, or `None` for ``sys.argv[1:]``.
"""
global LOG
global COMMIT_MODE
if argv is None:
argv = sys.argv[1:]
# initialize the parser object:
parser = optparse.OptionParser(
formatter=optparse.TitledHelpFormatter(width=78), add_help_option=None)
# define options here:
parser.add_option("-v",
"--verbose",
dest="verbose",
default=False,
action='store_true',
help="write debug level logs to log")
parser.add_option("-L",
"--log",
dest="logfile",
help="write log output to logfile")
parser.add_option(
"-C",
"--commit",
dest="commit",
default=False,
action='store_true',
help=
"if true, will Commit the data change; if false this script will just log what would have happened if set to true."
)
parser.add_option( # customized description; put --help last
'-h',
'--help',
action='help',
help='Show this help message and exit.')
options, args = parser.parse_args(argv)
# set up logging
log_file = None
log_level = logging.INFO
if options.verbose:
log_level = logging.DEBUG
if options.logfile:
log_file = options.logfile
LOG = set_logging(log_file, log_level)
# Check for required arguments
# Set commit_mode
COMMIT_MODE = options.commit
return options, args
def process_command_line(argv):
"""
Return an args list
`argv` is a list of arguments, or `None` for ``sys.argv[1:]``.
"""
if argv is None:
argv = sys.argv[1:]
# initialize the parser object:
parser = optparse.OptionParser(
formatter=optparse.TitledHelpFormatter(width=78), add_help_option=None)
# define options here:
parser.add_option(
'-w',
'--workdir',
help='Workdir where temporary and final files will be saved.')
parser.add_option(
'-a',
'--assembly_file',
help=
'File with a list of assemblies for which a reference genome is to be determined.'
)
parser.add_option('--installation', help='Pipeline installation.')
parser.add_option('--EDIRECT', help='edirect tools installation.')
parser.add_option('--QUAST', help='Quast installation.')
parser.add_option('--mail', help='Email for edirect.')
parser.add_option('-o',
'--organism',
help='Organism to be searched for on NCBI Assembly.')
parser.add_option('--dont_delete',
action="store_true",
help='Do not delete temporary files after running.')
parser.add_option(
'-s',
'--script',
default=
"/home/users/yair/Documents/PhD_projects/project_B/bin/downloading_database/determine_best_genome.sh",
help='Path of determine_best_genome.sh script')
parser.add_option( # customized description; put --help last
'-h',
'--help',
action='help',
help='Show this help message and exit.')
settings, args = parser.parse_args(argv)
return settings, args
def execute(argv=None, settings=None):
if argv is None:
argv = sys.argv
# --- backwards compatibility for scrapy.conf.settings singleton ---
if settings is None and 'scrapy.conf' in sys.modules:
from scrapy import conf
if hasattr(conf, 'settings'):
settings = conf.settings
# ------------------------------------------------------------------
if settings is None:
settings = get_project_settings()
# set EDITOR from environment if available
try:
editor = os.environ['EDITOR']
except KeyError:
pass
else:
settings['EDITOR'] = editor
check_deprecated_settings(settings)
# --- backwards compatibility for scrapy.conf.settings singleton ---
import warnings
from scrapy.exceptions import ScrapyDeprecationWarning
with warnings.catch_warnings():
warnings.simplefilter("ignore", ScrapyDeprecationWarning)
from scrapy import conf
conf.settings = settings
# ------------------------------------------------------------------
inproject = inside_project()
cmds = _get_commands_dict(settings, inproject)
cmdname = _pop_command_name(argv)
parser = optparse.OptionParser(formatter=optparse.TitledHelpFormatter(), \
conflict_handler='resolve')
if not cmdname:
_print_commands(settings, inproject)
sys.exit(0)
elif cmdname not in cmds:
_print_unknown_command(settings, cmdname, inproject)
sys.exit(2)
#cmds中有scrapy.commands目录下所有命令
cmd = cmds[cmdname]
parser.usage = "scrapy %s %s" % (cmdname, cmd.syntax())
parser.description = cmd.long_desc()
settings.setdict(cmd.default_settings, priority='command')
cmd.settings = settings
cmd.add_options(parser)
opts, args = parser.parse_args(args=argv[1:])
_run_print_help(parser, cmd.process_options, args, opts)
# 真正执行CrawlerProcess的入口在这里
cmd.crawler_process = CrawlerProcess(settings)
#运行CrawlerProcess
_run_print_help(parser, _run_command, cmd, args, opts)
sys.exit(cmd.exitcode)
def main(args):
parser = optparse.OptionParser(
usage="%prog [options] <model_path> [another_model_path...]",
version=xtuml.version.complete_string,
formatter=optparse.TitledHelpFormatter())
parser.set_description(__doc__.strip())
parser.add_option("-c",
"--component",
dest="component",
metavar="NAME",
help="export xsd schema for the component named NAME",
action="store",
default=None)
parser.add_option("-o",
"--output",
dest='output',
metavar="PATH",
action="store",
help="save xsd schema to PATH (required)",
default=None)
parser.add_option("-v",
"--verbosity",
dest='verbosity',
action="count",
help="increase debug logging level",
default=2)
(opts, args) = parser.parse_args(args)
if len(args) == 0 or None in [opts.component, opts.output]:
parser.print_help()
sys.exit(1)
levels = {
0: logging.ERROR,
1: logging.WARNING,
2: logging.INFO,
3: logging.DEBUG,
}
logging.basicConfig(level=levels.get(opts.verbosity, logging.DEBUG))
m = ooaofooa.load_metamodel(args)
c_c = m.select_any('C_C', lambda inst: inst.Name == opts.component)
if c_c:
schema = build_schema(m, c_c)
with open(opts.output, 'w') as f:
s = ET.tostring(schema, 'utf-8')
s = prettify(s)
f.write(s)
else:
logger.error('unable to find a component named %s' % opts.component)
logger.info('available components to choose from are: %s' %
', '.join([c_c.Name for c_c in m.select_many('C_C')]))
sys.exit(1)
def __init__(self, *args, **kwargs):
kwargs.setdefault('formatter', optparse.TitledHelpFormatter())
self._optparse = optparse.OptionParser(*args, **kwargs)
self._optparse.disable_interspersed_args()
self._allopts = {}
# current option group
self._group = self._optparse
