def _setup_command_line_interface():
parser = argparse.ArgumentParser(description=("Setup and manage an "
"embedded development "
"infrastructure."))
parser.add_argument("-v", "--verbose", action="store_true",
help="increase output verbosity to INFO")
parser.add_argument('--log', choices=['DEBUG', 'INFO', 'WARNING',
'ERROR', 'CRITICAL'],
help="modify log level (default is WARNING)")
subparsers = parser.add_subparsers(title='commands',
dest="command_name")
for _, command in get_sub_commands().items():
command.advertise(subparsers)
argcomplete.autocomplete(parser)
return parser
python类autocomplete()的实例源码
def finalizeOptions(self, availableTargets: list):
targetOption = self._parser.add_argument("targets", metavar="TARGET", nargs=argparse.ZERO_OR_MORE,
help="The targets to build", choices=availableTargets + [[]])
if argcomplete and "_ARGCOMPLETE" in os.environ:
# if IS_FREEBSD: # FIXME: for some reason this won't work
excludes = ["-t", "--skip-dependencies"]
if sys.platform.startswith("freebsd"):
excludes += ["--freebsd-builder-copy-only", "--freebsd-builder-hostname",
"--freebsd-builder-output-path"]
visibleTargets = availableTargets.copy()
visibleTargets.remove("__run_everything__")
targetCompleter = argcomplete.completers.ChoicesCompleter(visibleTargets)
targetOption.completer = targetCompleter
# make sure we get target completion for the unparsed args too by adding another zero_or more options
# not sure why this works but it's a nice hack
unparsed = self._parser.add_argument("targets", metavar="TARGET", type=list, nargs=argparse.ZERO_OR_MORE,
help=argparse.SUPPRESS, choices=availableTargets)
unparsed.completer = targetCompleter
argcomplete.autocomplete(
self._parser,
always_complete_options=None, # don't print -/-- by default
exclude=excludes, # hide these options from the output
print_suppressed=True, # also include target-specific options
)
def start(self, run_args=None):
""" Starts a command and registers single handlers.
Args:
run_args (:class:`list`): the list of run arguments. If None we use sys.argv[1:].
"""
if run_args is None:
run_args = sys.argv[1:]
parser = self._get_arg_parser()
argcomplete.autocomplete(parser)
if self.parse_unknown_args:
args, unknown = parser.parse_known_args(run_args)
self.run(args, unknown)
else:
args = parser.parse_args(run_args)
self.run(args, {})
def parse_args():
parser = argparse.ArgumentParser(formatter_class=RawTextHelpFormatter, description=\
"Usage: python brutespray.py <OPTIONS> \n")
menu_group = parser.add_argument_group(colors.lightblue + 'Menu Options' + colors.normal)
menu_group.add_argument('-f', '--file', help="GNMAP or XML file to parse", required=True)
menu_group.add_argument('-o', '--output', help="Directory containing successful attempts", default="brutespray-output")
menu_group.add_argument('-s', '--service', help="specify service to attack", default="all")
menu_group.add_argument('-t', '--threads', help="number of medusa threads", default="2")
menu_group.add_argument('-T', '--hosts', help="number of hosts to test concurrently", default="1")
menu_group.add_argument('-U', '--userlist', help="reference a custom username file", default=None)
menu_group.add_argument('-P', '--passlist', help="reference a custom password file", default=None)
menu_group.add_argument('-u', '--username', help="specify a single username", default=None)
menu_group.add_argument('-p', '--password', help="specify a single password", default=None)
menu_group.add_argument('-c', '--continuous', help="keep brute-forcing after success", default=False, action='store_true')
menu_group.add_argument('-i', '--interactive', help="interactive mode", default=False, action='store_true')
argcomplete.autocomplete(parser)
args = parser.parse_args()
return args
def create_parser(self, prog_name, subcommand): # noqa
"""
Create and return the ``ArgumentParser`` which will be used to
parse the arguments to this command.
"""
parser = CommandParser(
self, prog="%s %s" % (os.path.basename(prog_name), subcommand),
description=self.help or None)
parser.add_argument(
'--traceback', action='store_true',
help=SUPPRESS)
if self.args:
# Keep compatibility and always accept positional arguments,
# like optparse when args is set
parser.add_argument('args', nargs='*')
self.add_arguments(parser)
argcomplete.autocomplete(parser)
return parser
def run_with_sysargs():
import argparse
parser = argparse.ArgumentParser(description='Generates a project.')
parser.add_argument('sourcename', type=str,
help='name of source recipe/template').completer = TemplateCompleter()
parser.add_argument('destname', type=str,
help='name of new project to create')
parser.add_argument('servicename', type=str,
help='optional, name of service to create',
nargs='?')
if argcomplete:
argcomplete.autocomplete(parser)
args = parser.parse_args()
if (args.servicename):
generate(args.sourcename, args.destname, args.servicename)
else:
generate(args.sourcename, args.destname)
def __call__(self, args=None):
if args is None:
args = sys.argv[1:]
if argcomplete:
argcomplete.autocomplete(self.parser, exclude=['-P'])
elif 'COMP_LINE' in os.environ:
return 0
sys.excepthook = self.handle
args = self.read_configuration(args)
args = self.parser.parse_args(args)
self.configure_logging(args)
if args.debug:
try:
import pudb
except ImportError:
pudb = None
import pdb
return (pudb or pdb).runcall(self.main, args)
else:
return self.main(args) or 0
def __init__(self, application):
self.application = application
self.parser = parser = argparse.ArgumentParser(description='%s command line interface.' % application.name)
parser.add_argument('-p', '--process-name', metavar="PREFIX", default=application.name,
help='A string indicates the logger prefix for this process, it helps to configure '
'separate log files per process.')
parser.add_argument('-c', '--config-file', metavar="FILE",
help='List of configuration files separated by space. Default: ""')
parser.add_argument('-d', '--config-dir', metavar="DIR",
help='List of configuration directories separated by space. Default: ""')
subparsers = parser.add_subparsers(title="sub commands", prog=application.name, dest="command")
AdminLauncher.register(subparsers)
ServeLauncher.register(subparsers)
MigrateLauncher.register(subparsers)
WorkerLauncher.register(subparsers)
DevLauncher.register(subparsers)
application.register_cli_launchers(subparsers)
argcomplete.autocomplete(parser)
def main():
parser = get_parser()
if sys.stdin.isatty():
try:
import argcomplete
except ImportError:
pass
else:
argcomplete.autocomplete(parser)
args = parser.parse_args()
args = vars(args)
args.pop("command")
args.pop("subcommand", None)
func_name = args.pop("func")
func = import_func(func_name)
try:
result, exit_code = func(**args)
except:
if not sys.stdin.isatty():
import traceback
msg = traceback.format_exc()
handle_error(msg)
raise
else:
if result:
# nonzero exit codes for non-interactive commands should be
# logged
if exit_code > 0 and not sys.stdin.isatty() and not sys.stdout.isatty():
handle_error(result)
# otherwise print
else:
print(result)
return exit_code
def parse_args():
parser = argparse.ArgumentParser(formatter_class=RawTextHelpFormatter, description= \
"Usage: python passmaker.py <OPTIONS> \n")
menu_group = parser.add_argument_group('Menu Options')
menu_group.add_argument('-o', '--output', help="password dict file", default=None)
menu_group.add_argument('-i', '--interactive', help="interactive mode",action='store_true',default=False)
menu_group.add_argument('-g', '--gui', help="GUI mode", action='store_true', default=False)
argcomplete.autocomplete(parser)
args = parser.parse_args()
return args
def finalizeOptions(self, availableTargets: list, **kwargs):
targetOption = self._parser.add_argument("targets", metavar="TARGET", nargs=1, help="The target to build",
choices=availableTargets + [EXTRACT_SDK_TARGET])
if "_ARGCOMPLETE" in os.environ:
try:
import argcomplete
except ImportError:
sys.exit("argcomplete missing")
targetCompleter = argcomplete.completers.ChoicesCompleter(availableTargets)
targetOption.completer = targetCompleter
argcomplete.autocomplete(
self._parser,
always_complete_options=None, # don't print -/-- by default
print_suppressed=True, # also include target-specific options
)
def parseArguments():
"Argument parser for standalone hdlcc"
parser = argparse.ArgumentParser()
# Options
parser.add_argument('--host', action='store',)
parser.add_argument('--port', action='store',)
parser.add_argument('--attach-to-pid', action='store', type=int)
parser.add_argument('--log-level', action='store', )
parser.add_argument('--log-stream', action='store', )
parser.add_argument('--nocolor', action='store_true', default=False)
parser.add_argument('--stdout', action='store')
parser.add_argument('--stderr', action='store')
try:
import argcomplete
argcomplete.autocomplete(parser)
except ImportError: # pragma: no cover
pass
args = parser.parse_args()
args.host = args.host or 'localhost'
args.port = args.port or 50000
args.log_level = args.log_level or logging.INFO
args.log_stream = args.log_stream or sys.stdout
args.color = False if args.nocolor else True
del args.nocolor
return args
# Copied from ycmd!
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('degree', type=int)
parser.add_argument('prec', type=int, default=50)
parser.add_argument('data', help="""Data of matrix to compute exp of. Should
be in scipy sparse csr format.""")
parser.add_argument('time', type=float)
parser.add_argument('--expr', type=lambda e: sympify(e, locals=globals()), help="""Precomputed CRAM
expression. Should have the same prec as 'prec'. If not provided, will be
computed from scratch.""")
parser.add_argument('--log-level', default=None, choices=['debug', 'info',
'warning', 'error', 'critical'])
# TODO: Add options for arguments to pass to various functions as needed.
try:
import argcomplete
argcomplete.autocomplete(parser)
except ImportError:
pass
args = parser.parse_args()
if args.log_level:
logger.setLevel(getattr(logging, args.log_level.upper()))
res = run_transmute_test(args.data, args.degree, args.prec,
args.time,expr=args.expr, _print=True)
print("Column sums (min, max):")
errors = {}
colsums = {}
for r in sorted(res):
if res[r] is None:
print('Could not compute', r)
continue
colsums[r] = np.sum(res[r], axis=1)
errors[r] = np.max(colsums[r]) - np.min(colsums[r])
for r in sorted(errors, key=lambda i:errors[i], reverse=True):
print(r, np.min(colsums[r]), np.max(colsums[r]))
def main():
p = make_parser()
try:
import argcomplete
argcomplete.autocomplete(p)
except ImportError:
pass
args = p.parse_args()
execute(**vars(args))
def _get_arg_parser(self, doc_parser=False):
"""Create the auto parser. This should be implemented by the implementing class.
To enable autocomplete in your shell please execute activate-global-python-argcomplete in your shell.
The arg parser should support two output modes, one for the command line (default) and one for generating
the documentation. If the flag doc_parser is true the parser should be generated for the documentation.
Args:
doc_parser (boolean): If true the parser should be prepared for the documentation. If false (the default)
the parser should be generated for the command line.
Returns:
argparse.ArgumentParser: the argument parser
"""
description = textwrap.dedent("""
Basic parser introduction here.
Can be multiline.
""")
epilog = textwrap.dedent("""
Examples of use:
mdt-model-fit "BallStick (Cascade)" data.nii.gz data.prtcl roi_mask_0_50.nii.gz
""")
parser = argparse.ArgumentParser(description=description, epilog=epilog,
formatter_class=argparse.RawTextHelpFormatter)
return parser
manage_aws_s3_bucket.py 文件源码
项目：twitter_LDA_topic_modeling
作者: kenneth-orton
项目源码
文件源码
阅读 25
收藏 0
点赞 0
评论 0
def main():
parser = argparse.ArgumentParser(description='Upload or download files/directories to or from an S3 bucket')
subparsers = parser.add_subparsers(dest='mode')
upload_file_parser = subparsers.add_parser('up_file', help='Upload individual file to S3 bucket')
upload_file_parser.add_argument('-f', '--file_loc', required=True, action='store', dest='file_loc', help='Full path to filename')
upload_file_parser.add_argument('-b', '--bucket', required=True, action='store', dest='bucket_name', help='Name of the S3 bucket')
upload_file_parser.add_argument('-fs', '--file_store', required=True, action='store', dest='file_store', help='How the file will be named in S3 bucket')
upload_dir_parser = subparsers.add_parser('up_dir', help='Upload directory to S3 bucket')
upload_dir_parser.add_argument('-d', '--dir_loc', required=True, action='store', dest='dir_loc', help='Full path to directory')
upload_dir_parser.add_argument('-b', '--bucket', required=True, action='store', dest='bucket_name', help='Name of the S3 bucket')
dnload_file_parser = subparsers.add_parser('dn_file', help='Download individual file from S3 bucket')
dnload_file_parser.add_argument('-b', '--bucket', required=True, action='store', dest='bucket_name', help='Name of the S3 bucket')
dnload_file_parser.add_argument('-f', '--file_name', required=True, action='store', dest='file_name', help='Name of file in S3 bucket')
argcomplete.autocomplete(parser)
args = parser.parse_args()
s3 = boto3.resource('s3')
if args.mode == 'up_file':
print('Uploading: ' + args.file_loc)
s3.Bucket(args.bucket_name).put_object(Key=args.file_store, Body=open(args.file_loc))
if args.mode == 'up_dir':
for path, dirs, files in os.walk(args.dir_loc):
for filename in files:
print('Uploading: ' + (path + filename))
s3.Bucket(args.bucket_name).put_object(Key=filename, Body=open(path + filename, 'rb'))
if args.mode == 'dn_file':
s3.meta.client.download_file(args.bucket_name, args.file_name, './' + args.file_name)
def autocomplete(parser):
"""
Adds support for shell completion via argcomplete_ by patching given
`argparse.ArgumentParser` (sub)class.
If completion is not enabled, logs a debug-level message.
"""
if COMPLETION_ENABLED:
argcomplete.autocomplete(parser)
elif 'bash' in os.getenv('SHELL', ''):
logger.debug('Bash completion not available. Install argcomplete.')
def try_argcomplete(parser):
try:
import argcomplete
except ImportError:
pass
else:
argcomplete.autocomplete(parser)
def try_argcomplete(parser):
if os.environ.get('_ARGCOMPLETE'):
try:
import argcomplete
except ImportError:
pass
else:
argcomplete.autocomplete(parser)
def main():
parser = setup_parser()
argcomplete.autocomplete(parser)
options = parser.parse_args()
_setup_logger(options)
# Support the deprecated -c option
if getattr(options, 'config', None) is not None:
options.configs.append(options.config)
if options.subparser in ('report', 'logs', 'metrics', 'run'):
_default_region(options)
_default_account_id(options)
try:
command = options.command
if not callable(command):
command = getattr(
importlib.import_module(command.rsplit('.', 1)[0]),
command.rsplit('.', 1)[-1])
# Set the process name to something cleaner
process_name = [os.path.basename(sys.argv[0])]
process_name.extend(sys.argv[1:])
setproctitle(' '.join(process_name))
command(options)
except Exception:
if not options.debug:
raise
traceback.print_exc()
pdb.post_mortem(sys.exc_info()[-1])
def enable_autocomplete(parser):
argcomplete.autocomplete = argcomplete.CompletionFinder()
argcomplete.autocomplete(parser, validator=lambda c, p: c.lower().startswith(p.lower()),
default_completer=lambda _: ())
def parseArg():
"""
This fonction will the list of pdb files and the distance
@return: dictionnary of arguments
Ex :
python Cluster_Analysis.py -f *.pdb -s A:1-30:CA
"""
arguments=argparse.ArgumentParser(description="This program was developped in order to clusterize "
"molecular dynamictrajectories (Amber, gromacs, chamm, namd, PDB)")
try:
argcomplete.autocomplete(arguments)
except:
pass
arguments.add_argument('-f', "--traj", help="trajectory file", required=True)
arguments.add_argument('-t','--top', help="topfile", default=None)
arguments.add_argument('-l','--logfile', help="logfile (default : clustering.log). The "
"name of your output file will be the basename (name before the extention "
"of this logfile", default="clustering")
arguments.add_argument('-st','--select_traj', help="selection syntaxe for "
"Don't forget to add QUOTES besite this selection string."
"trajectory extraction (default : all).", default="all")
arguments.add_argument('-sa','--select_alignement', help="selection syntaxe"
" for alignement (default : backbone). Don't forget to add QUOTES besite this "
"selection string."
" If you don't want aligment use \"none\".", default="backbone")
arguments.add_argument('-sr','--select_rmsd', help="selection syntaxe for "
" RMSD (default : backbone). Don't forget to add QUOTES "
"besite this selection string.", default="backbone")
#Clustering arguments
arguments.add_argument('-m','--method', help="method for clustering : single "
"; complete; average; weighted; centroid; median. (ward)", default="ward")
arguments.add_argument('-cc',"--cutoff", help="cutoff for clusterization from "
"hierarchical clusturing with Scipy", default=None)
arguments.add_argument('-ng',"--ngroup", help="number of group asked. Use the "
"maxclust method to clusterize in this case", default=None)
#Interactive mode for distance matrix:
arguments.add_argument('-i','--interactive', help="Interactive mode for distance matrix (Y/n)", default="Y")
args = vars(arguments.parse_args())
return(args)
def init():
import argcomplete
if get_commands() is not None:
raise RuntimeError("Commands are already initialised")
init_commands()
# autocompletion
argcomplete.autocomplete(get_default_parser())
return get_commands()
def __call__ (self):
self.prep_parser( )
self.configure_parser(self.parser)
argcomplete.autocomplete(self.parser, always_complete_options=self.always_complete_options);
# print "FIXED INPUTS??", self.inputs
self.args = self.parser.parse_args(self.inputs)
self.prolog( )
self.run(self.args)
self.epilog( )
def main(args=None):
CoreServices.setup()
# inject existing libraries.
# because of that all the ansible modules should be imported after that
CoreServices.dependency_manager().inject_libraries()
specs_manager = api.SpecManager()
# Init Managers
specs_manager.register_spec(
WorkspaceManagerSpec('workspace',
description="Workspace manager. "
"Allows to create and use an "
"isolated environment for plugins "
"execution."))
specs_manager.register_spec(
PluginManagerSpec('plugin',
description="Plugin management"))
specs_manager.register_spec(
SSHSpec(
'ssh',
description="Interactive ssh session to node from inventory."))
# register all plugins
for plugin in CoreServices.plugins_manager().PLUGINS_DICT.values():
specs_manager.register_spec(api.InfraredPluginsSpec(plugin))
argcomplete.autocomplete(specs_manager.parser)
return specs_manager.run_specs(args) or 0
def enable_autocomplete(self, parser):
if self.cli_ctx.data['completer_active']:
argcomplete.autocomplete = argcomplete.CompletionFinder()
argcomplete.autocomplete(parser, validator=lambda c, p: c.lower().startswith(p.lower()),
default_completer=lambda _: ())
def cmany_main(in_args=None):
if in_args is None:
in_args = sys.argv[1:]
in_args = c4args.merge_envargs(cmds, in_args)
mymod = sys.modules[__name__]
parser = c4args.setup(cmds, mymod)
argcomplete.autocomplete(parser)
args = c4args.parse(parser, in_args)
if args:
args.func(args)
# -----------------------------------------------------------------------------
def __init__(self):
self.parser = parser = argparse.ArgumentParser(description='Restfulpy command line interface.')
subparsers = parser.add_subparsers(title="Restfulpy sub commands", prog=basename(sys.argv[0]), dest="command")
from restfulpy.mockupservers import SimpleMockupServerLauncher
SimpleMockupServerLauncher.register(subparsers)
argcomplete.autocomplete(parser)
def get_opt_parser( ):
parser = argparse.ArgumentParser( )
parser.add_argument('infile', nargs="+",
default=sys.stdin,
type=argparse.FileType('r'),
help="Find dates in this file.")
parser.add_argument('--collate',
dest='collate',
default=False,
action='store_true')
parser.add_argument('--data',
choices=['glucose', 'pump'],
default='pump')
parser.add_argument('--model',
# type=get_model,
choices=models.known.keys( ))
parser.add_argument('--larger',
dest='larger', action='store_true')
parser.add_argument('--no-larger',
dest='larger', action='store_false')
parser.add_argument('--out',
default=sys.stdout,
type=argparse.FileType('w'),
help="Write records here.")
parser.set_defaults(larger=False)
argcomplete.autocomplete(parser)
return parser
##
# move to history.py
#
def __init__(self):
self.env = self.parse_env( )
self.parser = self.get_parser( )
self.autocomplete( )
