def _add_commands(self):
"""
Split up the functionality of nrfjprog into multiple sub-commands.
:param Object subparsers: https://docs.python.org/3/library/argparse.html#sub-commands.
"""
self._add_erase_command()
self._add_halt_command()
self._add_ids_command()
self._add_memrd_command()
self._add_memwr_command()
self._add_pinresetenable_command()
self._add_program_command()
self._add_readback_command()
self._add_readregs_command()
self._add_readtofile_command()
self._add_recover_command()
self._add_reset_command()
self._add_run_command()
self._add_verify_command()
self._add_version_command()
# The top-level positional commands of our command-line interface.
python类html()的实例源码
def add(self, *args, **kwargs):
default = kwargs.get('default')
dtype = kwargs.get('type')
if dtype is None:
if default is None:
dtype = str
else:
dtype = type(default)
typename = dtype.__name__
if 'metavar' not in kwargs:
# metavar: display --foo <float=0.05> in help string
if 'choices' in kwargs:
choices = kwargs['choices']
choices_str = '/'.join(['{}']*len(choices)).format(*choices)
kwargs['metavar'] = '<{}: {}>'.format(typename, choices_str)
elif 'nargs' in kwargs:
# better formatting handled in _SingleMetavarFormatter
kwargs['metavar'] = '{}'.format(typename)
elif not kwargs.get('action'):
# if 'store_true', then no metavar needed
# list of actions: https://docs.python.org/3/library/argparse.html#action
default_str = '={}'.format(default) if default else ''
kwargs['metavar'] = '<{}{}>'.format(typename, default_str)
self.parser.add_argument(*args, **kwargs)
def getparser():
filter_choices = ['range', 'absrange', 'perc', 'gauss', 'med', 'highpass', 'sigma', 'mad', 'dz']
parser = argparse.ArgumentParser(description='Filter input raster')
parser.add_argument('fn', help='Input filename (img1.tif)')
parser.add_argument('--stats', action='store_true', help='Print stats before and after filtering')
parser.add_argument('-outdir', default=None, help='Output directory')
#Should implement subparser here to handle different number of args for different filter types
#https://docs.python.org/2/library/argparse.html#sub-commands
#Can call functions directly
#Could specify sequence of filters here
#Should accept arbitrary number of ordered filter operations as cli argument
parser.add_argument('-filt', nargs=1, default='gauss', choices=filter_choices, help='Filter type (default: %(default)s)')
#size is a param
#parser.add_argument('-size', type=int, default=7, help='Filter size in pixels (default: %(default)s)')
parser.add_argument('-param', nargs='+', default=None, help='Filter parameter list (e.g., size, min max, ref_fn min max)')
return parser
def parse_args(argv):
"""
parse arguments/options
this uses the new argparse module instead of optparse
see: <https://docs.python.org/2/library/argparse.html>
"""
p = argparse.ArgumentParser(description='Report on test run timings')
p.add_argument('-v', '--verbose', dest='verbose', action='count', default=0,
help='verbose output. specify twice for debug-level output.')
c = ['acceptance36', 'acceptance27']
p.add_argument('-j', '--jobtype', dest='jobtype', action='store', type=str,
choices=c, default=c[0], help='TOXENV for job')
p.add_argument('BUILD_NUM', action='store', type=str, nargs='?',
default=None,
help='TravisCI X.Y build number to analyze; if not '
'specified, will use latest acceptance36 build.')
args = p.parse_args(argv)
return args
def error(self, message):
"""Override superclass to support customized error message.
Error message needs to be rewritten in order to display visible commands
only, when invalid command is called by user. Otherwise, hidden commands
will be displayed in stderr, which is not expected.
Refer the following argparse python documentation for detailed method
information:
http://docs.python.org/2/library/argparse.html#exiting-methods
Args:
message: original error message that will be printed to stderr
"""
subcommands_quoted = ', '.join(
[repr(command) for command in _VISIBLE_COMMANDS])
subcommands = ', '.join(_VISIBLE_COMMANDS)
message = re.sub(
r'(argument {%s}: invalid choice: .*) \(choose from (.*)\)$'
% subcommands, r'\1 (choose from %s)' % subcommands_quoted, message)
super(_EndpointsParser, self).error(message)
def error(self, message):
"""Override superclass to support customized error message.
Error message needs to be rewritten in order to display visible commands
only, when invalid command is called by user. Otherwise, hidden commands
will be displayed in stderr, which is not expected.
Refer the following argparse python documentation for detailed method
information:
http://docs.python.org/2/library/argparse.html#exiting-methods
Args:
message: original error message that will be printed to stderr
"""
# subcommands_quoted is the same as subcommands, except each value is
# surrounded with double quotes. This is done to match the standard
# output of the ArgumentParser, while hiding commands we don't want users
# to use, as they are no longer documented and only here for legacy use.
subcommands_quoted = ', '.join(
[repr(command) for command in _VISIBLE_COMMANDS])
subcommands = ', '.join(_VISIBLE_COMMANDS)
message = re.sub(
r'(argument {%s}: invalid choice: .*) \(choose from (.*)\)$'
% subcommands, r'\1 (choose from %s)' % subcommands_quoted, message)
super(_EndpointsParser, self).error(message)
def argument(*args, **kwargs):
"""Decorator to define an argparse option or argument.
The arguments to this decorator are the same as the
`ArgumentParser.add_argument <https://docs.python.org/3/library/\
argparse.html#the-add-argument-method>`_
method.
"""
def decorator(f):
if not hasattr(f, '_arguments'):
f._arguments = []
if not hasattr(f, '_argnames'):
f._argnames = []
f._arguments.append((args, kwargs))
f._argnames.append(_get_dest(*args, **kwargs))
return f
return decorator
def read_config(conf_path, section):
"""
Recipe mostly taken from
http://blog.vwelch.com/2011/04/combining-configparser-and-argparse.html
"""
# Try reading the conf file
try:
import ConfigParser
config = ConfigParser.SafeConfigParser()
config.read([conf_path])
defaults = dict(config.items(section))
except Exception as e:
raise RuntimeError('Failed reading %s: %s' % (conf_path, e))
return defaults
def config_and_args_parser(conf_path, section, description=''):
"""
Recipe mostly taken from
http://blog.vwelch.com/2011/04/combining-configparser-and-argparse.html
"""
# Parse directory
parser = argparse.ArgumentParser(
description=description)
parser.add_argument('-c', '--config-file', required=False,
default=conf_path, help='Specify config file', metavar='FILE')
args, remaining_argv = parser.parse_known_args()
# Try reading the conf file
try:
import ConfigParser
config = ConfigParser.SafeConfigParser()
config.read([args.config_file])
defaults = dict(config.items(section))
print('Loading config file: {}'.format(args.config_file))
except Exception as e:
raise RuntimeError('Failed reading %s: %s' % (args.config_file, e))
parser.set_defaults(**defaults)
# parser.add_argument("--option1", help="some option")
args = parser.parse_args(remaining_argv)
return args
def add_argument(self, *args, **kwargs):
# The type profile for this it really complex and we don't do anything substantive
# to it, so I would rather not duplicate the typeshed's effort keeping it up to date.
# https://github.com/python/typeshed/blob/master/stdlib/2and3/argparse.pyi#L53-L65
"""Adds the requested argument to the parser, also adding a dummy redirect argument
if a long-form argument (starts with two starting prefix characters) is found.
See: https://docs.python.org/dev/library/argparse.html#the-add-argument-method
"""
for long_arg in [arg for arg in args if arg.startswith(self.prefix_chars * 2)]:
self.add_dummy_redirect_argument(long_arg)
return super(CommentIgnoringArgumentParser, self).add_argument(*args, **kwargs)
def addoption(self, *opts, **attrs):
""" register a command line option.
:opts: option names, can be short or long options.
:attrs: same attributes which the ``add_option()`` function of the
`argparse library
<http://docs.python.org/2/library/argparse.html>`_
accepts.
After command line parsing options are available on the pytest config
object via ``config.option.NAME`` where ``NAME`` is usually set
by passing a ``dest`` attribute, for example
``addoption("--long", dest="NAME", ...)``.
"""
self._anonymous.addoption(*opts, **attrs)
def main():
"""
Set up a command line interface using the argparse module.
Above we will define what arguments our program requires and argparse will figure out how to parse those from sys.argv.
For info on argparse see: https://docs.python.org/3/library/argparse.html.
"""
cli = Nrfjprog()
cli.run()
def parse_args(args):
"""
Takes in the command-line arguments list (args), and returns a nice argparse
result with fields for all the options.
Borrows heavily from the argparse documentation examples:
<http://docs.python.org/library/argparse.html>
"""
# Construct the parser (which is stored in parser)
# Module docstring lives in __doc__
# See http://python-forum.com/pythonforum/viewtopic.php?f=3&t=36847
# And a formatter class so our examples in the docstring look good. Isn't it
# convenient how we already wrapped it to 80 characters?
# See http://docs.python.org/library/argparse.html#formatter-class
parser = argparse.ArgumentParser(description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
# General options
parser.add_argument("--input_sam", type=argparse.FileType("r"),
default=sys.stdin,
help="input SAM in name-sorted order.")
parser.add_argument("--fq1", type=argparse.FileType("w"),
default=sys.stdout,
help="FASTQ file to save the READ1 reads in (+READ2 if interleaved)")
parser.add_argument("--fq2", type=argparse.FileType("w"),
default=sys.stdout,
help="FASTQ file to save the READ2 reads in")
parser.add_argument("--interleaved", action="store_true",
help="write interleaved FASTQ to fq1")
parser.add_argument("--drop_secondary", action="store_true",
help="drop pairs where a primary alignment is not seen at both ends")
parser.add_argument("--expect_paired", action="store_true",
help="expect all reads to have a pair partner and abort otherwise")
# The command line arguments start with the program name, which we don't
# want to treat as an argument for argparse. So we remove it.
args = args[1:]
return parser.parse_args(args)
def parse_args(args):
"""
Takes in the command-line arguments list (args), and returns a nice argparse
result with fields for all the options.
Borrows heavily from the argparse documentation examples:
<http://docs.python.org/library/argparse.html>
"""
# Construct the parser (which is stored in parser)
# Module docstring lives in __doc__
# See http://python-forum.com/pythonforum/viewtopic.php?f=3&t=36847
# And a formatter class so our examples in the docstring look good. Isn't it
# convenient how we already wrapped it to 80 characters?
# See http://docs.python.org/library/argparse.html#formatter-class
parser = argparse.ArgumentParser(description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
# Add all the toil-vg options
toilvgfacade.add_options(parser)
# Add the Toil options so the job store is the first argument
Job.Runner.addToilOptions(parser)
parser.add_argument("--contig", default=None,
help="download just pairs touching this contig or its alts/randoms")
parser.add_argument("--sam_url", default=[], action="append",
help="URL to download reads from, accessible from Toil nodes")
# Output
parser.add_argument("out_url",
help="file: or other Toil-supported URL to place results in")
# The command line arguments start with the program name, which we don't
# want to treat as an argument for argparse. So we remove it.
args = args[1:]
return parser.parse_args(args)
def parse_args(args):
"""
Takes in the command-line arguments list (args), and returns a nice argparse
result with fields for all the options.
Borrows heavily from the argparse documentation examples:
<http://docs.python.org/library/argparse.html>
"""
# Construct the parser (which is stored in parser)
# Module docstring lives in __doc__
# See http://python-forum.com/pythonforum/viewtopic.php?f=3&t=36847
# And a formatter class so our examples in the docstring look good. Isn't it
# convenient how we already wrapped it to 80 characters?
# See http://docs.python.org/library/argparse.html#formatter-class
parser = argparse.ArgumentParser(description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
# Add the Toil options so the job store is the first argument
Job.Runner.addToilOptions(parser)
# General options
parser.add_argument("in_store", type=IOStore.absolute,
help="input IOStore to download from")
parser.add_argument("out_store", type=IOStore.absolute,
help="output IOStore to put things in")
parser.add_argument("--pattern", default="*",
help="fnmatch-style pattern for file names to copy")
parser.add_argument("--overwrite", default=False, action="store_true",
help="overwrite existing files")
parser.add_argument("--check_size", default=False, action="store_true",
help="check sizes on existing files and replace if wrong")
parser.add_argument("--batch_size", type=int, default=1000,
help="number of files to copy in a batch")
# The command line arguments start with the program name, which we don't
# want to treat as an argument for argparse. So we remove it.
args = args[1:]
return parser.parse_args(args)
def addoption(self, *opts, **attrs):
""" register a command line option.
:opts: option names, can be short or long options.
:attrs: same attributes which the ``add_option()`` function of the
`argparse library
<http://docs.python.org/2/library/argparse.html>`_
accepts.
After command line parsing options are available on the pytest config
object via ``config.option.NAME`` where ``NAME`` is usually set
by passing a ``dest`` attribute, for example
``addoption("--long", dest="NAME", ...)``.
"""
self._anonymous.addoption(*opts, **attrs)
def addoption(self, *opts, **attrs):
""" register a command line option.
:opts: option names, can be short or long options.
:attrs: same attributes which the ``add_option()`` function of the
`argparse library
<http://docs.python.org/2/library/argparse.html>`_
accepts.
After command line parsing options are available on the pytest config
object via ``config.option.NAME`` where ``NAME`` is usually set
by passing a ``dest`` attribute, for example
``addoption("--long", dest="NAME", ...)``.
"""
self._anonymous.addoption(*opts, **attrs)
def addoption(self, *opts, **attrs):
""" register a command line option.
:opts: option names, can be short or long options.
:attrs: same attributes which the ``add_option()`` function of the
`argparse library
<http://docs.python.org/2/library/argparse.html>`_
accepts.
After command line parsing options are available on the pytest config
object via ``config.option.NAME`` where ``NAME`` is usually set
by passing a ``dest`` attribute, for example
``addoption("--long", dest="NAME", ...)``.
"""
self._anonymous.addoption(*opts, **attrs)
def parse_args(self, args: Optional[Sequence[str]] = None):
"""
Parse command line arguments and store checked and converted values in self.
`"By default, the argument strings are taken from sys.argv"
<https://docs.python.org/3/library/argparse.html#argparse.ArgumentParser.parse_args>`_
:type args: Optional[Sequence[str]]
:param args: argument strings
"""
# NOTE: Call to parse_args with namespace=self does not set logging_level with default value, if argument is not
# in provided args, for some reason.
parsed_args = self.parser.parse_args(args=args)
if CommandRequirement('airmon-ng').check():
# if airmon-ng is available, check for wireless interface name can be performed here,
# if airmon-ng is NOT available, wifimitmcli will terminate upon requirements check after parsing args.
# Check if provided interface name is recognized as wireless interface name.
for i in list_wifi_interfaces():
if i.name == parsed_args.interface.name:
break
else:
self.parser.error('argument interface: {} is not recognized as a valid wireless interface'.format(
parsed_args.interface.name)
)
# name to value conversion as noted in `self.init_parser`
self.logging_level = self.LOGGING_LEVELS_DICT[parsed_args.logging_level]
self.phishing_enabled = parsed_args.phishing
if parsed_args.capture_file:
# `"FileType objects understand the pseudo-argument '-' and automatically convert this into sys.stdin
# for readable FileType objects and sys.stdout for writable FileType objects:"
# <https://docs.python.org/3/library/argparse.html>`_
if parsed_args.capture_file is sys.stdout:
self.parser.error('argument -cf/--capture-file: stdout is not allowed')
# The capture_file is opened by `argparse.ArgumentParser.parse_args` to make sure its writable for us.
self.capture_file = parsed_args.capture_file
self.essid = parsed_args.essid
self.interface = parsed_args.interface
def define_subcommands(self, subcommands):
'''
Define subcommands (as defined at https://docs.python.org/2/library/argparse.html#sub-commands)
eg: adding a sub-command called "blah" that invokes a function fn_blah
blah_command = subcommands.add_parser('blah')
blah_command.set_defaults(func=fn_blah)
'''
pass
def addoption(self, *opts, **attrs):
""" register a command line option.
:opts: option names, can be short or long options.
:attrs: same attributes which the ``add_option()`` function of the
`argparse library
<http://docs.python.org/2/library/argparse.html>`_
accepts.
After command line parsing options are available on the pytest config
object via ``config.option.NAME`` where ``NAME`` is usually set
by passing a ``dest`` attribute, for example
``addoption("--long", dest="NAME", ...)``.
"""
self._anonymous.addoption(*opts, **attrs)
def command(*args, **kwargs):
"""Decorator to define a command.
The arguments to this decorator are those of the
`ArgumentParser <https://docs.python.org/3/library/argparse.html\
#argumentparser-objects>`_
object constructor.
"""
def decorator(f):
if 'description' not in kwargs:
kwargs['description'] = f.__doc__
if 'parents' in kwargs:
if not hasattr(f, '_argnames'): # pragma: no cover
f._argnames = []
for p in kwargs['parents']:
f._argnames += p._argnames if hasattr(p, '_argnames') else []
kwargs['parents'] = [p.parser for p in kwargs['parents']]
f.parser = argparse.ArgumentParser(*args, **kwargs)
f.climax = True
for arg in getattr(f, '_arguments', []):
f.parser.add_argument(*arg[0], **arg[1])
@wraps(f)
def wrapper(args=None):
kwargs = f.parser.parse_args(args)
return f(**vars(kwargs))
wrapper.func = f
return wrapper
return decorator
def generate_options(self, group_parser):
'''Adds it's options to the group parser. The parser passed in is a result from
calling add_argument_group(ArgumentGroup): https://docs.python.org/2/library/argparse.html
Args:
group_parser(): The parser to add options too.
'''
raise NotImplementedError('Implement: generate_options')
def parse_args(args):
"""
Takes in the command-line arguments list (args), and returns a nice argparse
result with fields for all the options.
Borrows heavily from the argparse documentation examples:
<http://docs.python.org/library/argparse.html>
"""
# Construct the parser (which is stored in parser)
# Module docstring lives in __doc__
# See http://python-forum.com/pythonforum/viewtopic.php?f=3&t=36847
# And a formatter class so our examples in the docstring look good. Isn't it
# convenient how we already wrapped it to 80 characters?
# See http://docs.python.org/library/argparse.html#formatter-class
parser = argparse.ArgumentParser(description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument("ref_name",
help="name of BWA-indexed reference FASTA")
parser.add_argument("query_name",
help="name of query FASTA")
parser.add_argument("--chunk_size", type=int, default=10000,
help="size of chunks to align")
parser.add_argument("--chunk_stride", type=int, default=100000,
help="distabnce between chunks to align")
parser.add_argument("--max_children", type=int, default=10,
help="number of bwa children to run")
parser.add_argument("--batch_size", type=int, default=1000,
help="number of chunks to align at once")
parser.add_argument("--match_threshold", type=float, default=0.95,
help="min score for a hit as a fraction of possible score")
parser.add_argument("--out_file", type=argparse.FileType("w"),
default=sys.stdout,
help="TSV file of contig pairings to write")
parser.add_argument("--debug", action="store_true",
help="add extra debugging comments to output TSV")
# The command line arguments start with the program name, which we don't
# want to treat as an argument for argparse. So we remove it.
args = args[1:]
return parser.parse_args(args)
