def construct_options(f): """ Common CLI Options that are shared for service related commands ('start-api' and 'start_lambda') Parameters ---------- f function Callback passed by Click port int port number to use Returns ------- function The callback function """ service_options = [ click.option('--host', default="127.0.0.1", help="Local hostname or IP address to bind to (default: '127.0.0.1')"), click.option("--port", "-p", default=port, help="Local port number to listen on (default: '{}')".format(str(port))) ] # Reverse the list to maintain ordering of options in help text printed with --help for option in reversed(service_options): option(f) return f
def _produce_method(self, disassociate=False): method = self._produce_raw_method() # Apply options for user to specify the 2 resources to associate method = click.option( '--{}'.format(self.other_name.replace('_', '-')), type=types.Related(self.other_name), required=True )(method) method = click.option( '--{}'.format(self.res_name.replace('_', '-')), type=types.Related(self.res_name), required=True )(method) # This does the same thing as @resources.command, but without importing method._cli_command = True method._cli_command_attrs = dict(use_fields_as_options=False) # Define field-specific parameters that control functionality method._relationship = self.relationship method._res_name = self.res_name method._other_name = self.other_name if disassociate: method._internal_name = '_disassoc' method.__doc__ = self._produce_doc(action='disassociate') else: method._internal_name = '_assoc' method.__doc__ = self._produce_doc() return method
def decorate_command(command): command = click.option('--archive-dir', required=True, multiple=True, help="The base path where materials are stored (ArchiveDir in indico.conf). " "When used multiple times, the dirs are checked in order until a file is " "found.")(command) command = click.option('--janitor-user-id', type=int, required=True, help="The ID of the Janitor user")(command) return command
def global_options(f): def config_callback(ctx, option, config): prepare_context(ctx, config) def verbosity_callback(ctx, option, verbose): if verbose: logger.setLevel(logging.DEBUG) else: logger.setLevel(logging.INFO) config = click.option( '--config', '-c', is_eager=True, # make sure other options can access config help='The config file to use.', default=None, metavar='PATH', expose_value=False, callback=config_callback ) verbose = click.option( '--verbose', '-v', is_eager=True, # make sure to log config when debugging help='Output debugging information.', is_flag=True, expose_value=False, callback=verbosity_callback ) version = click.version_option(version=__version__) return config(verbose(version(f)))
def connect_options(f): f = click.argument('host', nargs=1)(f) f = click.option('--port', help='port to connect to, default per platform')(f) f = click.option('--type', help='type of connection')(f) f = click.option('--user', help='username', envvar='NGAGE_USER')(f) f = click.option('--password', help='password to use if not using key auth')(f) return f
def debug_option(func): @wraps(func) def debug_wrapper(debug, debug_perform, **kwargs): if debug: DebugSettings.settings = DebugSettings(dict(debug)) logging_config(DebugSettings.settings.loglevel) if debug_perform: DebugSettings.perform_settings = DebugSettings(dict(debug_perform)) return func(**kwargs) f = click.option( '--debug-perform', type=click.Tuple([str, str]), multiple=True, metavar='<variable> <value>', help='Debug perform options.' ) return f( click.option( '--debug', type=click.Tuple([str, str]), multiple=True, metavar='<variable> <value>', help='Debug options.' )(debug_wrapper) )
def save_metadata(f): from mcvine import version, git_revision mcvine_vers = dict(version=version, git_revision=git_revision) def _(*args, **kwds): c = click.get_current_context() cmdpath = c.command_path # clean parameter dictionary import copy params = copy.deepcopy(c.params) for popt in provenance_opts: del params[popt] # deal with option --use-cache use_cache = kwds.pop('use_cache', None) save_metadata_only = kwds.pop('save_metadata_only', None) if use_cache and not save_metadata_only: path = cache_path(cmdpath, params, c.args) if os.path.exists(path): # if requested to use cache and the cache exists, # use it. logger.info("%s already exists. reuse results there" % path) # XXX assume the current working directory is the output directory out = "." copy_withhardlinks(path,out) return # deal with --save-metadata-only # construct metadata metadata = dict( cmd=cmdpath, params=params, args=c.args, mcvine=mcvine_vers) # output path fn = cmdpath.replace(' ', '-') + ".params" # save json.dump(metadata, open(fn, 'wt')) # run the cmd only if we are not just saving meta data # no need to continue if the only request is to save metadata if save_metadata_only: return # deal with option --keep-in-cache keep_in_cache = kwds.pop('keep_in_cache', None) if not keep_in_cache: return f(*args, **kwds) # run the command in the subprocess so that we # can make sure it is finished before moving on to # the next step cmd = "%s %s" % (cmdpath, arg_str(params, c.args)) ret = sp.call(cmd, shell=True) if ret: raise RuntimeError("%s failed" % cmd) # add output to cache path = cache_path(cmdpath, params, c.args) if not os.path.exists(path): os.makedirs(path) # XXX assume the current working directory is the output directory out = "." copy_withhardlinks(out, path) return _.__name__ = f.__name__ _.__doc__ = f.__doc__ d1 = click.option("--save-metadata-only", is_flag=True) d2 = click.option("--keep-in-cache", is_flag=True) d3 = click.option("--use-cache", is_flag=True) return d1(d2(d3(_)))
def decorate_command(command): command = click.option("--janitor-user-id", type=int, required=True, help="The ID of the Janitor user")(command) command = click.option( "--default-group-provider", default="legacy-ldap", help="Name of the default group provider" )(command) command = super(AttachmentImporter, AttachmentImporter).decorate_command(command) return command
def codegen_options(f): f = click.option( "-c", "--categories", multiple=True, default=default_categories, type=click.Choice(all_categories), help="A list of the categories of inputs and outputs that should " "be enabled" )(f) f = click.option( "-f", "--param_file", type=click.File(), help="""YAML or JSON file describing the firmware module configuration to be flashed. This is the same file that is used for rosparam in the launch file.""" "code" )(f) f = click.option( "-p", "--plugin", multiple=True, help="Enable a specific plugin" )(f) f = click.option( "-t", "--target", help="PlatformIO target (e.g. upload)" )(f) f = click.option( "--status_update_interval", default=5, help="Minimum interval between driver status updates (in seconds)" )(f) return f
def ssh_command(func): func = click.option( "-i", "--identity-file", type=click.File(lazy=False), default=str(get_private_key_path()), help="Path to the private key file", show_default=True )(func) func = click.option( "-b", "--batch-size", type=int, default=20, help="By default, command won't connect to all servers " "simultaneously, it is trying to process servers in batches. " "Negative number or 0 means connect to all hosts", show_default=True, )(func) @functools.wraps(func) @click.pass_context def decorator(ctx, identity_file, batch_size, *args, **kwargs): private_key = asyncssh.import_private_key(identity_file.read()) batch_size = batch_size if batch_size > 0 else None identity_file.close() ctx.obj["private_key"] = private_key ctx.obj["batch_size"] = batch_size ctx.obj["event_loop"] = asyncio.get_event_loop() return func(*args, **kwargs) return decorator
def ssh_file_operations(func): func = click.option( "--no-preserve", is_flag=True, help="The access and modification times and permissions of the " "original file are not set on the processed file." )(func) func = click.option( "--no-recursive", is_flag=True, help="The remote path points at a directory, the entire subtree " "under that directory is not processed" )(func) func = click.option( "--no-follow-symlinks", is_flag=True, help="Do not process symbolic links" )(func) @functools.wraps(func) @click.pass_context def decorator(ctx, no_preserve, no_recursive, no_follow_symlinks, *args, **kwargs): ctx.obj["preserve"] = not no_preserve ctx.obj["recursive"] = not no_recursive ctx.obj["follow_symlinks"] = not no_follow_symlinks return func(*args, **kwargs) return decorator
def decorate_command(command): command = click.option('--rb-zodb-uri', required=True, help="ZODB URI for the room booking database")(command) command = click.option('--photo-path', type=click.Path(exists=True, file_okay=False), help="path to the folder containing room photos")(command) command = click.option('--no-merged-avatars', default=False, is_flag=True, help="speed up migration by not checking for merged avatars")(command) return command
def unified_job_template_options(method): """ Adds the decorators for all types of unified job templates, and if the non-unified type is specified, converts it into the unified_job_template kwarg. """ jt_dec = click.option( '--job-template', type=types.Related('job_template'), help='Use this job template as unified_job_template field') prj_dec = click.option( '--project', type=types.Related('project'), help='Use this project as unified_job_template field') inv_src_dec = click.option( '--inventory-source', type=types.Related('inventory_source'), help='Use this inventory source as unified_job_template field') def ujt_translation(_method): def _ujt_translation(*args, **kwargs): for fd in ['job_template', 'project', 'inventory_source']: if fd in kwargs and kwargs[fd] is not None: kwargs['unified_job_template'] = kwargs.pop(fd) return _method(*args, **kwargs) return functools.wraps(_method)(_ujt_translation) return ujt_translation( inv_src_dec( prj_dec( jt_dec( method ) ) ) )
def global_options(f): def color_callback(ctx, option, value): ctx.color = value def logfile_callback(ctx, option, path): ctx.logfilepath = path config = click.option( '--config', '-c', help='The config file to use.', default=None, metavar='PATH' ) color = click.option( '--color/--no-color', help=('Use colored/uncolored output. Default is to only enable colors ' 'when not part of a pipe.'), expose_value=False, default=None, callback=color_callback ) logfile = click.option( '--logfile', '-l', help='The logfile to use [defaults to stdout]', type=click.Path(), callback=logfile_callback, default=None, expose_value=False, metavar='LOGFILE', ) version = click.version_option(version=__version__) return logfile(config(color(version(f))))
def test_report_options(): return _compose( click.option( "--test_output", type=click.Path(file_okay=True, resolve_path=True), callback=get_default_callback("tool_test_output.html", resolve_path=True), help=("Output test report (HTML - for humans) defaults to " "tool_test_output.html."), default=None, ), click.option( "--test_output_text", type=click.Path(file_okay=True, resolve_path=True), callback=get_default_callback(None, resolve_path=True), help=("Output test report (Basic text - for display in CI)"), default=None, ), click.option( "--test_output_markdown", type=click.Path(file_okay=True, resolve_path=True), callback=get_default_callback(None, resolve_path=True), help=("Output test report (Markdown style - for humans & " "computers)"), default=None, ), )
def attrib_parser(__f: Callable) -> Callable: __f = click.option('-o', '--order', default='number', type=click.Choice(['number', 'updated']), help='Sort order for listing bugs.')(__f) __f = click.option('-s', '--state', default='open', type=click.Choice(['open', 'closed', 'all']), help='State of bugs to operate on.')(__f) return __f
def global_options(f): config = click.option('--config', '-c', default=None, metavar='PATH', help='The config file to use.') verbose = click.option('--verbose', '-v', is_flag=True, help='Output debugging information.') version = click.version_option(version=__version__) return config(verbose(version(f)))
def addInitFlag(app): """ Add init flag to given clickObj: calls create_example """ click.option("--init", is_flag=True, callback=create_example, expose_value=False, is_eager=True)( app.baseGroup.clickObj )
def decorate_command(command): command = click.option('--archive-dir', required=True, multiple=True, help="The base path where resources are stored (ArchiveDir in indico.conf). " "When used multiple times, the dirs are checked in order until a file is " "found.")(command) command = click.option('--default-group-provider', required=True, help="Name of the default group provider")(command) return command
def print_completer_option(f): bash_shell_completer = textwrap.dedent( """\ _globus_completion () { local IFS=$'\\t' if type globus > /dev/null; then COMPREPLY=( $( env COMP_LINE="$COMP_LINE" COMP_POINT="$COMP_POINT" \\ globus --shell-complete BASH ) ) else COMPREPLY=( ) fi return 0 } complete -F _globus_completion -o default globus; """ ) zsh_shell_completer = textwrap.dedent( """\ #compdef globus _globus () { if type globus > /dev/null; then eval "$(env COMMANDLINE="${words[1,$CURRENT]}" \\ globus --shell-complete ZSH)" fi } compdef _globus globus """ ) def callback(ctx, param, value): if not value or ctx.resilient_parsing: return if value == "BASH": safeprint(bash_shell_completer) elif value == "ZSH": safeprint(zsh_shell_completer) else: raise ValueError("Unsupported shell completion") click.get_current_context().exit(0) f = click.option( "--completer", "--bash-completer", cls=HiddenOption, is_eager=True, expose_value=False, flag_value="BASH", callback=callback, )(f) f = click.option( "--zsh-completer", cls=HiddenOption, is_eager=True, expose_value=False, flag_value="ZSH", callback=callback, )(f) return f
def inner_decorator( f, allow_anonymous=False, allow_all_authenticated=False, allow_provision=False ): # order matters here -- the preprocessor must run after option # application, so it has to be applied first if isinstance(f, click.Command): # if we're decorating a command, put the preprocessor on its # callback, not on `f` itself f.callback = preprocess_security_principals(f.callback) else: # otherwise, we're applying to a function, but other decorators may # have been applied to give it params # so, copy __click_params__ to preserve those parameters oldfun = f f = preprocess_security_principals(f) f.__click_params__ = getattr(oldfun, "__click_params__", []) f = click.option( "--identity", metavar="IDENTITY_ID_OR_NAME", help="Identity to use as a security principal", )(f) f = click.option( "--group", metavar="GROUP_ID", help="Group to use as a security principal" )(f) if allow_anonymous: f = click.option( "--anonymous", "principal", flag_value=("anonymous", ""), help=( "Allow anyone access, even without logging in " "(treated as a security principal)" ), )(f) if allow_all_authenticated: f = click.option( "--all-authenticated", "principal", flag_value=("all_authenticated_users", ""), help=( "Allow anyone access, as long as they login" "(treated as a security principal)" ), )(f) if allow_provision: f = click.option( "--provision-identity", metavar="IDENTITY_USERNAME", help="Identity username to use as a security principal. " "Identity will be provisioned if it does not exist.", )(f) return f
def multi_calendar_option(f): a = click.option('--include-calendar', '-a', multiple=True, metavar='CAL', help=('Include the given calendar. Can be specified ' 'multiple times.')) d = click.option('--exclude-calendar', '-d', multiple=True, metavar='CAL', help=('Exclude the given calendar. Can be specified ' 'multiple times.')) return d(a(f))
def submit_options(func): func = click.option("--commit", type=int, help="deprecated/ignored option", expose_value=False)(func) func = click.option("--select-machine", default='match', type=click.Choice(['match', 'update', 'split']), help="How to select and create missing machine")(func) func = click.option("--merge", default="replace", show_default=True, type=click.Choice(['reject', 'replace', 'append']), help="Merge strategy when run already exists")(func) return func
def decorator(fn): fn = click.option('--dev', is_flag=True, default=False, help="Build in dev mode")(fn) fn = click.option('--clean/--no-clean', default=None, help="Delete everything in dist. This is disabled by default for `--dev` builds.")(fn) fn = click.option('--url-root', default='/', metavar='PATH', help='URL root from which the assets are loaded. ' 'Defaults to / and should usually not be changed')(fn) if allow_watch: fn = click.option('--watch', is_flag=True, default=False, help="Run the watcher to rebuild on changes")(fn) return fn
def lib_options(f): f = click.option('--sample-data-dir', expose_value=False, required=True, type=click.Path(exists=True), callback=callback, help=("LIBRARY: Path to directory (usually INBOX) containing the project " "(one dir per sample, scilife structure project/sample/flowcell/)"))(f) f = click.option('--insert', expose_value=False, required=True, callback=callback, help="LIBRARY: insert size", type=int)(f) f = click.option('--std', expose_value=False, required=True, callback=callback, help="LIBRARY: Insert size standard deviation", type=int)(f) f = click.option('--orientation', type=click.Choice(['innie', 'outtie']), expose_value=False, required=True, callback=callback, help="LIBRARY: orientation, ie. 'innie' for paired-end and 'outtie' for mate-pairs")(f) return f
def telegram_options(function): options = [ click.option('-o', '--offset', default=0), click.option('-t', '--timeout', help="poll timeout"), click.option('-c', '--config', type=click.Path(dir_okay=False, exists=True)) ] for option in options: function = option(function) return function
def mode_option(f): o1 = click.option('-f', '--force', 'mode', flag_value=Scaffold.EXISTING_OVERWRITE, help='Force overwriting of existing files') o2 = click.option('-p', '--prompt', 'mode', default=True, flag_value=Scaffold.EXISTING_PROMPT, help='Prompt to overwrite existing files (default)') o3 = click.option('-s', '--skip', 'mode', flag_value=Scaffold.EXISTING_SKIP, help='Skip existing files') return o1(o2(o3(f)))
def calendar_selector(f): a = click.option('--include-calendar', '-a', multiple=True, metavar='CAL', expose_value=False, callback=_calendar_select_callback, help=('Include the given calendar. Can be specified ' 'multiple times.')) d = click.option('--exclude-calendar', '-d', multiple=True, metavar='CAL', expose_value=False, callback=_calendar_select_callback, help=('Exclude the given calendar. Can be specified ' 'multiple times.')) return d(a(f))
def apic_options(f): """Aggregate multiple common options into one. This decorator should be used by CLI commands that need an APIC client.""" f = click.option('--apic-ip', help='APIC ip address', required=True)(f) f = click.option('--apic-username', help='APIC username', default=None)(f) f = click.option('--apic-password', help='APIC password', default=None)(f) f = click.option('--ssl/--no-ssl', default=True, help='Whether to use SSL or not')(f) f = click.option('--secure/--no-secure', default=True, help='Verify server certificate')(f) return f
def signature_analysis(cmd): cmd = click.option('--model', '-m', default=None, type=click.Path(exists=True, dir_okay=False), help='Path to model file.')(cmd) cmd = click.option('--parameter', '-p', default=None, type=click.Path(exists=True, dir_okay=False), help='(optional) Path to parameter file.' )(cmd) cmd = click.argument("scheme", type=click.Path(exists=True, dir_okay=False), required=False )(cmd) return cmd
formatter.write("\n") formatter.write_dl(attr_tuples) help_text += formatter.getvalue() return help_text # All the command line options defined here FILES_ARGUMENT = click.argument( "files", metavar="FILE", nargs=-1, type=click.Path(exists=True) ) HELP_OPTION = click.option( # add this only so I can show help text via echo_via_pager "--help", "-h", "help_", help="Show this message and exit.", is_flag=True, default=False, required=False, ) WALK_OPTION = click.option( "--walk", "-w", is_flag=True, help="Walk directory tree, processing each file in the tree.", default=False, ) JSON_OPTION = click.option( "--json", "-j", "json_",
def decorator(f): return click.option('--id', help='Workspace identifier.', **extra_kwargs)(f)
from ravenml.utils.question import cli_spinner, user_confirms from ravenml.data.interfaces import CreateInput from ravenml.data.options import pass_create from ravenml.data.interfaces import CreateInput, CreateOutput from ravenml.utils.config import get_config, load_yaml_config from ravenml.utils.aws import upload_directory # metedata fields to exclude when printing metadata to the user # these are specific to datasets at the moment EXCLUDED_METADATA = ['filters', 'transforms', 'image_ids'] ### OPTIONS ### explore_details_opt = click.option( '-e', '--explore_details', 'explore_details', is_flag=True, help= 'Explore detailed metadata about all imagesets/datasets currently on S3 via a pager view.' ) print_details_opt = click.option( '-p', '--print-details', 'print_details', is_flag=True, help= 'Print detailed metadata about all imagesets/datasets currently on S3 to the console.' ) filter_details_opt = click.option( '-f',
# -*- coding: utf-8 -*- import click import os from asyncpg import utils, connect from logging import debug, info from .helpers import drier, timeit DEFAULT_HOST = 'localhost' DEFAULT_PORT = 5432 DEFAULT_DATABASE = 'musicbot_prod' DEFAULT_USER = '******' DEFAULT_PASSWORD = '******' options = [ click.option('--db-host', envvar='MB_DB_HOST', help='DB host', default=DEFAULT_HOST), click.option('--db-port', envvar='MB_DB_PORT', help='DB port', default=DEFAULT_PORT), click.option('--db-database', envvar='MB_DATABASE', help='DB name', default=DEFAULT_DATABASE), click.option('--db-user', envvar='MB_DB_USER', help='DB user', default=DEFAULT_USER), click.option('--db-password', envvar='MB_DB_PASSWORD', help='DB password', default=DEFAULT_PASSWORD) ] class Database(object): def __init__(self, max_conn=100, **kwargs): self.set(**kwargs) self.max_conn = max_conn def set(self, db_host=None, db_port=None, db_database=None, db_user=None, db_password=None, **kwargs): self.host = db_host if db_host is not None else os.getenv('MB_DB_HOST', DEFAULT_HOST) self.port = db_port if db_port is not None else os.getenv('MB_DB_PORT', DEFAULT_PORT) self.database = db_database if db_database is not None else os.getenv('MB_DATABASE', DEFAULT_DATABASE)
def service_id(required=False): return click.option('-s', '--service-id', required=required, help=helptexts.SERVICE_ID)
else: out_red("deleting account directory: {}".format(account.dir)) account.remove() if not os.path.exists(account.dir): os.mkdir(account.dir) account.init() click.echo("account directory initialized: {}".format(account.dir)) if not no_identity: account.add_identity("default") _status(account) option_use_key = click.option( "--use-key", default=None, type=str, metavar="KEYHANDLE", help= # NOQA "use specified secret key which must be findable " "through the specified keyhandle (e.g. email, keyid, fingerprint)") option_use_system_keyring = click.option( "--use-system-keyring", default=False, is_flag=True, help= # NOQA "use system keyring for all secret/public keys instead of storing " "keyring state inside our account identity directory.") option_gpgbin = click.option( "--gpgbin", default="gpg",
def service_template_name(required=False): return click.option('-t', '--service-template-name', required=required, help=helptexts.SERVICE_ID)
option_parameters) from nucypher.cli.painting.deployment import ( paint_contract_deployment, paint_deployer_contract_inspection, paint_deployment_delay, paint_staged_deployment) from nucypher.cli.painting.help import echo_solidity_version from nucypher.cli.painting.multisig import paint_multisig_proposed_transaction from nucypher.cli.painting.transactions import paint_receipt_summary from nucypher.cli.types import EIP55_CHECKSUM_ADDRESS, EXISTING_READABLE_FILE, WEI from nucypher.cli.utils import (deployer_pre_launch_warnings, ensure_config_root, establish_deployer_registry, initialize_deployer_interface) from nucypher.types import NuNits option_deployer_address = click.option('--deployer-address', help="Deployer's checksum address", type=EIP55_CHECKSUM_ADDRESS) option_registry_infile = click.option( '--registry-infile', help="Input path for contract registry file", type=EXISTING_READABLE_FILE) option_registry_outfile = click.option( '--registry-outfile', help="Output path for contract registry file", type=click.Path(file_okay=True)) option_target_address = click.option('--target-address', help="Address of the target contract", type=EIP55_CHECKSUM_ADDRESS) option_gas = click.option( '--gas', help="Operate with a specified gas per-transaction limit",
def to_string(function): function = click.option('--to-string', help='stringify output', default=False, type=bool)(function) return function
class NaturalOrderGroup(click.Group): """Click group that lists commmands in the order added""" def list_commands(self, ctx): return self.commands.keys() @click.group(cls=NaturalOrderGroup) def main(): """Release helper scripts""" pass # Extracted common options version_cmd_options = [ click.option("--version-cmd", envvar="VERSION_CMD", help="The version command") ] branch_options = [ click.option("--branch", envvar="BRANCH", help="The target branch"), click.option( "--remote", envvar="REMOTE", default="upstream", help="The git remote name" ), click.option("--repo", envvar="REPOSITORY", help="The git repo"), ] auth_options = [ click.option("--auth", envvar="GITHUB_ACCESS_TOKEN", help="The GitHub auth token"), ] changelog_path_options = [
def config_option(config_function): """Helper decorator that turns an option function into a cli option""" return lambda function: \ click.option('--' + config_function.__name__, help=f'{config_function.__doc__}. Default: "{config_function()}"')(function)
installed_targets = [target for target in interface.plugin_store.registry] if len(installed_targets) > 0: supported_targets_msg = "Support is currently installed for deployment to: " \ "{targets}".format(targets=", ".join(installed_targets)) else: supported_targets_msg = "NOTE: you currently do not have support for installed for any " \ "deployment targets." target_details = click.option("--target", "-t", required=True, help=""" Deployment target URI. Run `mlflow deployments help --target-name <target-name>` for more details on the supported URI format and config options for a given target. {supported_targets_msg} See all supported deployment targets and installation instructions at https://mlflow.org/docs/latest/plugins.html#community-plugins """.format( supported_targets_msg=supported_targets_msg)) deployment_name = click.option("--name", "name", required=True, help="Name of the deployment") parse_custom_arguments = click.option( "--config", "-C", metavar="NAME=VALUE",
import functools import json import click from click_didyoumean import DYMMixin from click_help_colors import HelpColorsGroup api_key_option = click.option( "--apiKey", "api_key", help="API key to use this time only", ) def del_if_value_is_none(dict_): """Remove all elements with value == None""" for key, val in list(dict_.items()): if val is None: del dict_[key] def jsonify_dicts(dict_): json_fields = ["envVars", "nodeAttrs"] for field in json_fields: if field in dict_: dict_[field] = json.dumps(dict_[field]) class ClickGroup(DYMMixin, HelpColorsGroup): pass
def option_performance(f): """Defines options for all aspects of performance tuning""" _preset = { # Fixed 'O1': { 'opt': 'noop' }, 'O2': { 'opt': 'advanced' }, } def from_preset(ctx, param, value): """Set all performance options according to bench-mode preset""" ctx.params.update(_preset[value]) return value def from_value(ctx, param, value): """Prefer preset values and warn for competing values.""" return ctx.params[param.name] or value def config_blockshape(ctx, param, value): if value: # Block innermost loops if a full block shape is provided # Note: see https://github.com/devitocodes/devito/issues/320 for why # we use blockinner=True only if the backend compiler is Intel flag = isinstance(configuration['compiler'], IntelCompiler) configuration['opt-options']['blockinner'] = flag # Normalize value: # 1. integers, not strings # 2. sanity check the (hierarchical) blocking shape normalized_value = [] for i, block_shape in enumerate(value): # If hierarchical blocking is activated, say with N levels, here in # `bs` we expect to see 3*N entries bs = [int(x) for x in block_shape.split()] levels = [bs[x:x + 3] for x in range(0, len(bs), 3)] if any(len(level) != 3 for level in levels): raise ValueError( "Expected 3 entries per block shape level, but got " "one level with less than 3 entries (`%s`)" % levels) normalized_value.append(levels) if not all_equal(len(i) for i in normalized_value): raise ValueError( "Found different block shapes with incompatible " "number of levels (`%s`)" % normalized_value) configuration['opt-options']['blocklevels'] = len( normalized_value[0]) else: normalized_value = [] return tuple(normalized_value) def config_autotuning(ctx, param, value): """Setup auto-tuning to run in ``{basic,aggressive,...}+preemptive`` mode.""" if value != 'off': # Sneak-peek at the `block-shape` -- if provided, keep auto-tuning off if ctx.params['block_shape']: warning( "Skipping autotuning (using explicit block-shape `%s`)" % str(ctx.params['block_shape'])) level = False else: # Make sure to always run in preemptive mode configuration['autotuning'] = [value, 'preemptive'] # We apply blocking to all parallel loops, including the innermost ones # Note: see https://github.com/devitocodes/devito/issues/320 for why # we use blockinner=True only if the backend compiler is Intel flag = isinstance(configuration['compiler'], IntelCompiler) configuration['opt-options']['blockinner'] = flag level = value else: level = False return level options = [ click.option('-bm', '--bench-mode', is_eager=True, callback=from_preset, expose_value=False, default='O2', type=click.Choice(['O1', 'O2']), help='Choose what to benchmark; ignored if execmode=run'), click.option('--arch', default='unknown', help='Architecture on which the simulation is/was run'), click.option('--opt', callback=from_value, type=click.Choice([ str(i) if type(i) is tuple else i for i in configuration._accepted['opt'] ]), help='Performance optimization level'), click.option('-bs', '--block-shape', callback=config_blockshape, multiple=True, is_eager=True, help='Loop-blocking shape, bypass autotuning'), click.option('-a', '--autotune', default='aggressive', callback=config_autotuning, type=click.Choice([ str(tuple(i)) if type(i) is list else i for i in configuration._accepted['autotuning'] ]), help='Select autotuning mode') ] for option in reversed(options): f = option(f) return f
def mark_pattern(): return click.option('-m', '--mark-pattern', help=helptexts.MARK_PATTERN, type=str, required=False)
def service_template_id(required=False): return click.option('-t', '--service-template-id', required=required, help=helptexts.SERVICE_TEMPLATE_ID)
import logging import os import contextlib import click from itertools import groupby import ckan.migration as migration_repo import ckan.plugins as p import ckan.model as model from ckan.common import config from . import error_shout log = logging.getLogger(__name__) applies_to_plugin = click.option(u"-p", u"--plugin", help=u"Affected plugin.") @click.group(short_help=u"Database management commands.") def db(): """Database management commands. """ pass @db.command() def init(): """Initialize the database. """ log.info(u"Initialize the Database") try:
for cmd_name in cmd_list: cmd_class = getattr(frontend, re.sub(r'_js$', '', cmd_name)) cmd = click.command(cmd_name)(wrap_distutils_command(cmd_class)) for opt, short_opt, description in cmd_class.user_options: long_opt_name = opt.rstrip('=') var_name = long_opt_name.replace('-', '_') opts = ['--' + long_opt_name] if short_opt: opts.append('-' + short_opt) default = DEFAULT_OPTIONS.get(cmd_name, {}).get(var_name) is_flag = not opt.endswith('=') cmd = click.option(*(opts + [var_name]), is_flag=is_flag, default=default, help=description)(cmd) cli.add_command(cmd) @cli.command() def check_format_strings(): """Check whether format strings match. This helps finding cases where e.g. the original string uses ``{error}`` but the translation uses ``{erro}``, resulting in errors when using the translated string. """ root_path = os.path.join(current_app.root_path, 'translations') paths = set() for root, dirs, files in os.walk(root_path):
def service_template_path(required=False): return click.option('-p', '--service-template-path', required=required, type=click.Path(exists=True))
def get_command(self, ctx, name): """Retrieve the appropriate method from the Resource, decorate it as a click command, and return that method. """ # Sanity check: Does a method exist corresponding to this # command? If not, None is returned for click to raise # exception. if not hasattr(self.resource, name): return None # Get the method. method = getattr(self.resource, name) # Get any attributes that were given at command-declaration # time. attrs = getattr(method, '_cli_command_attrs', {}) # If the help message comes from the docstring, then # convert it into a message specifically for this resource. help_text = inspect.getdoc(method) attrs['help'] = self._auto_help_text(help_text or '') # On some methods, we ignore the defaults, which are intended # for writing and not reading; process this. ignore_defaults = attrs.pop('ignore_defaults', False) # Wrap the method, such that it outputs its final return # value rather than returning it. new_method = self._echo_method(method) # Soft copy the "__click_params__", if any exist. # This is the internal holding method that the click library # uses to store @click.option and @click.argument directives # before the method is converted into a command. # # Because self._echo_method uses @functools.wraps, this is # actually preserved; the purpose of copying it over is # so we can get our resource fields at the top of the help; # the easiest way to do this is to load them in before the # conversion takes place. (This is a happy result of Armin's # work to get around Python's processing decorators # bottom-to-top.) click_params = getattr(method, '__click_params__', []) new_method.__click_params__ = copy(click_params) # Write options based on the fields available on this resource. fao = attrs.pop('use_fields_as_options', True) if fao: for field in reversed(self.resource.fields): if not field.is_option: continue # If we got an iterable rather than a boolean, # then it is a list of fields to use; check for # presence in that list. if not isinstance(fao, bool) and field.name not in fao: continue # Create the initial arguments based on the # option value. If we have a different key to use # (which is what gets routed to the Tower API), # ensure that is the first argument. args = [field.option] if field.key: args.insert(0, field.key) # short name aliases for common flags short_fields = { 'name': 'n', 'description': 'd', 'inventory': 'i', 'extra_vars': 'e' } if field.name in short_fields: args.append('-' + short_fields[field.name]) # Apply the option to the method. option_help = field.help if field.required: option_help = '[REQUIRED] ' + option_help click.option(*args, default=field.default if not ignore_defaults else None, help=option_help, type=field.type, show_default=field.show_default, multiple=field.multiple)(new_method) # Make a click Command instance using this method # as the callback, and return it. cmd = command(name=name, cls=Command, **attrs)(new_method) # If this method has a `pk` positional argument, # then add a click argument for it. code = six.get_function_code(method) if 'pk' in code.co_varnames: click.argument('pk', nargs=1, required=False, type=int, metavar='[ID]')(cmd) # Done; return the command. return cmd
def execution_id(required=False): return click.option('-e', '--execution-id', required=required, help=helptexts.EXECUTION_ID)
def verbose_option(): return click.option('-v', '--verbose', count=True)
from rq.serializers import DefaultSerializer from rq.suspension import (suspend as connection_suspend, resume as connection_resume, is_suspended) from rq.worker_registration import clean_worker_registry from rq.job import JobStatus blue = make_colorizer('darkblue') # Disable the warning that Click displays (as of Click version 5.0) when users # use unicode_literals in Python 2. # See http://click.pocoo.org/dev/python3/#unicode-literals for more details. click.disable_unicode_literals_warning = True shared_options = [ click.option('--url', '-u', envvar='RQ_REDIS_URL', help='URL describing Redis connection details.'), click.option('--config', '-c', envvar='RQ_CONFIG', help='Module containing RQ settings.'), click.option('--worker-class', '-w', envvar='RQ_WORKER_CLASS', default=DEFAULT_WORKER_CLASS, help='RQ Worker class to use'), click.option('--job-class', '-j', envvar='RQ_JOB_CLASS', default=DEFAULT_JOB_CLASS, help='RQ Job class to use'),
before=sys.path, after=[''], )) def print_environment_variables(env, *variables): for name in variables: value = env.get(name) if value is None: print('{} is not set'.format(name)) else: print('{}: {}'.format(name, value)) qt_debug_plugins_option = click.option( '--qt-debug-plugins/--no-qt-debug-plugins', help='Set QT_DEBUG_PLUGINS=1', ) @click.command( context_settings={ 'ignore_unknown_options': True, 'allow_extra_args': True, }, ) @click.pass_context @click.option( '--widget-path', '-p', 'widget_paths', help='Paths to be combined with PYQTDESIGNERPATH', type=click.Path(exists=True, file_okay=False, resolve_path=True),
def task_retry_interval(default=defaults.TASK_RETRY_INTERVAL): return click.option('--task-retry-interval', type=int, default=default, help=helptexts.TASK_RETRY_INTERVAL.format(default))
def pruneflag(cli): return click.option( "--prune/--no-prune", default=True, help="Controls if old " 'artifacts should be pruned. "prune" is the default.', )(cli)
import click from py42.clients.trustedactivities import TrustedActivityType from code42cli.bulk import generate_template_cmd_factory from code42cli.bulk import run_bulk_process from code42cli.click_ext.groups import OrderedGroup from code42cli.errors import Code42CLIError from code42cli.file_readers import read_csv_arg from code42cli.options import format_option from code42cli.options import sdk_options from code42cli.output_formats import OutputFormatter resource_id_arg = click.argument("resource-id", type=int) type_option = click.option( "--type", help= f"Type of trusted activity. Valid types include {', '.join(TrustedActivityType.choices())}.", type=click.Choice(TrustedActivityType.choices()), ) value_option = click.option( "--value", help= "The value of the trusted activity, such as the domain or Slack workspace name.", ) description_option = click.option( "--description", help="The description of the trusted activity.") def _get_trust_header(): return { "resourceId": "Resource Id", "type": "Type",
from code42cli.file_readers import read_csv_arg from code42cli.file_readers import read_flat_file_arg from code42cli.options import format_option from code42cli.options import sdk_options def _get_filter_choices(): filters = DepartingEmployeeFilters.choices() return get_choices(filters) DATE_FORMAT = "%Y-%m-%d" filter_option = click.option( "--filter", help="Departing employee filter options. Defaults to {}.".format( ALL_FILTER), type=click.Choice(_get_filter_choices()), default=ALL_FILTER, callback=lambda ctx, param, arg: handle_filter_choice(arg), ) @click.group(cls=OrderedGroup) @sdk_options(hidden=True) def departing_employee(state): """Add and remove employees from the Departing Employees detection list.""" pass @departing_employee.command("list") @sdk_options() @format_option
) @cached_property def formatter(self): return self.formatter_class( self.config['main']['date_format'], self.config['main']['time_format'], self.config['main']['dt_separator'] ) pass_ctx = click.make_pass_decorator(AppContext) _interactive_option = click.option( '--interactive', '-i', is_flag=True, default=None, help='Go into interactive mode before saving the task.') @click.group(invoke_without_command=True) @click_log.init('todoman') @click_log.simple_verbosity_option() @click.option('--colour', '--color', default=None, type=click.Choice(['always', 'auto', 'never']), help=('By default todoman will disable colored output if stdout ' 'is not a TTY (value `auto`). Set to `never` to disable ' 'colored output entirely, or `always` to enable it ' 'regardless.')) @click.option('--porcelain', is_flag=True, help='Use a JSON format that will ' 'remain stable regardless of configuration or version.') @click.option('--humanize', '-h', default=None, is_flag=True,
__AIRFLOW_SOURCES_ROOT = airflow_sources_root else: console.print( f"\n[yellow]Could not find Airflow sources location. Assuming {__AIRFLOW_SOURCES_ROOT}" ) os.chdir(__AIRFLOW_SOURCES_ROOT) @click.group() def main(): find_airflow_sources_root() option_verbose = click.option( "--verbose", is_flag=True, help="Print verbose information about performed steps", ) @main.command() def version(): """Prints version of breeze.py.""" console.print(ASCIIART, style=ASCIIART_STYLE) console.print(f"\n[green]{NAME} version: {VERSION}[/]\n") @option_verbose @main.command() def shell(verbose: bool): """Enters breeze.py environment. this is the default command use when no other is selected."""