def make_template_command(name): return click.Command(name)
def test_suggest_possible_options(runner, value, expect): cli = click.Command( "cli", params=[click.Option(["--bound"]), click.Option(["--count"])]) result = runner.invoke(cli, [value]) assert expect in result.output
'swap', 'miqqe_patch_applied' ] def fn(method, *args, **kwargs): """Helper to access the right properties""" from cfme.utils.appliance import IPAppliance appliance_ip = kwargs.get('appliance_ip', None) app = get_appliance(appliance_ip) descriptor = getattr(IPAppliance, method) if isinstance(descriptor, (cached_property, property)): out = getattr(app, method) else: out = getattr(app, method)(*args, **kwargs) if out is not None: print(out) for method in methods_to_install: command = click.Command( method.replace('_', '-'), short_help='Returns the {} property'.format(method), callback=partial(fn, method), params=[ click.Argument(['appliance_ip'], default=None, required=False) ]) main.add_command(command) if __name__ == "__main__": main()
def __init__(self, name=None, commands=None, **attrs): click.Group.__init__(self, name, commands, **attrs) self._commands = {} self._ordered = [] self._dummy_command = click.Command('')
def test_show_default_string(runner): """When show_default is a string show that value as default.""" opt = click.Option(["--limit"], show_default="unlimited") ctx = click.Context(click.Command("cli")) message = opt.get_help_record(ctx)[1] assert "[default: (unlimited)]" in message
def set_context_level(self, level): self.context_level = level back = click.Command('back', help='go back', callback=self.do_back) self.ctx.command.commands[level].commands['back'] = back
def _get_command(self, ctx, lp, cmd_name): """ This function returns the function that click will actually use to execute a specific launch plan. It also stores the launch plan python object and the command name in the closure. :param ctx: :param flytekit.common.launch_plan.SdkLaunchPlan lp: :param Text cmd_name: The name of the launch plan, as passed in from the abstract class """ def _execute_lp(**kwargs): for input_name in _six.iterkeys(kwargs): if isinstance(kwargs[input_name], tuple): kwargs[input_name] = list(kwargs[input_name]) inputs = _construct_literal_map_from_parameter_map( lp.default_inputs, kwargs) execution = lp.execute_with_literals( ctx.obj[_constants.CTX_PROJECT], ctx.obj[_constants.CTX_DOMAIN], literal_inputs=inputs, notification_overrides=ctx.obj.get( _constants.CTX_NOTIFICATIONS, None)) click.echo( click.style("Workflow scheduled, execution_id={}".format( _six.text_type(execution.id)), fg='blue')) command = click.Command(name=cmd_name, callback=_execute_lp) # Iterate through the workflow's inputs for var_name in sorted(lp.default_inputs.parameters): param = lp.default_inputs.parameters[var_name] # TODO: Figure out how to better handle the fact that we want strings to parse, # but we probably shouldn't have click say that that's the type on the CLI. help_msg = '{} Type: {}'.format( _six.text_type(param.var.description), _six.text_type(param.var.type)).strip() if param.required: # If it's a required input, add the required flag wrapper = click.option('--{}'.format(var_name), required=True, type=_six.text_type, help=help_msg) else: # If it's not a required input, it should have a default # Use to_python_std so that the text of the default ends up being parseable, if not, the click # arg would look something like 'Integer(10)'. If the user specified '11' on the cli, then # we'd get '11' and then we'd need annoying logic to differentiate between the default text # and user text. default = param.default.to_python_std() wrapper = click.option( '--{}'.format(var_name), default='{}'.format(_six.text_type(default)), type=_six.text_type, help='{}. Default: {}'.format(help_msg, _six.text_type(default))) command = wrapper(command) return command
key = keyfmt.format(inputfn=csvfile, name=basestem, basestem=basestem, dirname=dirname) if not quiet: print(f"Writing CSV data to table '{key}' in file: {outputfn}") df.to_hdf(outputfn, key=key, mode=mode) outputfiles.append(outputfn) return outputfiles # Click CLI: csv_to_hdf5_cli = click.Command( callback=csv_to_hdf5, name=csv_to_hdf5.__name__, help=inspect.getdoc(csv_to_hdf5), params=[ click.Option(['--outputfnfmt', '-f'], default="{inputfn}.hdf5"), click.Option(['--keyfmt'], default="/locs"), # remember: param_decls is a list, *decls. click.Option(['--mode'], default="a"), click.Option(['--append/--no-append'], default=True), click.Option(['--quiet/--no-quiet']), # click.Option(['--verbose', '-v'], count=True), click.Argument(['csvfiles']) ]) def hdf5_to_csv( hdffiles, outputfnfmt="{inputfn}_{key}.csv", keys=None, convert_slash='_', sep=",", header=True, index=True, quotechar='"', line_terminator="\n", doublequote=True, escapechar=None, decimal=".", dateformat=None, chunksize=None, tupleize_cols=None, quiet=False ):
print(df if print_cols == 'all' else df[print_cols]) find_duplicate_files_cli = click.Command( callback=find_duplicate_files, name=find_duplicate_files.__name__, help=inspect.getdoc(find_duplicate_files), params=[ click.Option(['--grouping-scheme', '-g']), # remember: param_decls is a list, *decls. click.Option(['--fsize-min']), click.Option(['--exclude'], multiple=True), click.Option(['--follow-links/--no-follow-links'], default=False), click.Option(['--exclude-links/--no-exclude-links'], default=False), click.Option(['--abspaths/--no-abspaths'], default=False), click.Option(['--realpaths/--no-realpaths'], default=False), click.Option(['--remove-realpath-dups/--no-remove-realpath-dups'], default=False), click.Option(['--save-fnpat']), click.Option(['--save-cols']), click.Option(['--print-cols']), click.Option(['--verbose', '-v'], count=True), click.Option(['--quiet/--no-quiet']), click.Argument(['start-points'], required=True, nargs=-1, type=click.Path(dir_okay=True, file_okay=False, exists=True)) ])
def test_count_default_type_help(): """A count option with the default type should not show >=0 in help.""" option = click.Option(["--count"], count=True, help="some words") context = click.Context(click.Command("test")) result = option.get_help_record(context)[1] assert result == "some words"
def test_show_default_precedence(ctx_value, opt_value, expect): ctx = click.Context(click.Command("test"), show_default=ctx_value) opt = click.Option("-a", default=1, help="value", show_default=opt_value) help = opt.get_help_record(ctx)[1] assert ("default:" in help) is expect
def test_metadata(): ctx = click.Context(click.Command('edit-metadata'), obj=mocked_obj) with ctx: runner = click.testing.CliRunner() runner.invoke(metadata)
def test_config(): ctx = click.Context(click.Command('edit-config'), obj=mocked_obj) with ctx: runner = click.testing.CliRunner() runner.invoke(config)
# Copyright 2018 Rasmus Scholer Sorensen, <*****@*****.**> import inspect import click from zepto_eln.eln_utils.eln_md_pico import print_document_yfm_issues from zepto_eln.eln_utils.eln_exp_filters import print_started_exps, print_unfinished_exps print_started_exps_cli = click.Command( callback=print_started_exps, name=print_started_exps.__name__, help=inspect.getdoc(print_started_exps), params=[ # remember: param_decls is a list, *decls. click.Option(['--rowfmt'], default='{status:^10}: {expid:<10} {titledesc}'), click.Argument(['basedir'], default='.', nargs=1, type=click.Path(dir_okay=True, file_okay=False, exists=True)) ]) print_unfinished_exps_cli = click.Command( callback=print_unfinished_exps, name=print_unfinished_exps.__name__, help=inspect.getdoc(print_unfinished_exps), params=[ click.Option( ['--rowfmt'],
app.Dependent(d["repository"], d["toxenv_regex"]) for d in dependents_ ] dependents = [ click.Command( "dependents-from-librariesio", params=[ click.Argument(["pypi-name"]), click.Option( ["--api-key"], required=True, envvar="CHECKON_LIBRARIESIO_API_KEY", help="libraries.io API key", ), click.Option( ["--limit"], type=int, help="Maximum number of dependents to find.", default=5, show_default=True, ), ], callback=app.get_dependents, help="Get dependent projects on PyPI, via https://libraries.io API", ), click.Command( "dependents-from-file", params=[click.Argument(["file"], type=click.File())], help="List dependent project urls in a toml file.", callback=read_from_file,
def setUp(self): self.ctx = click.Context(click.Command("foo")) self.param = click.Option(["--config"]) return super(ConfigFileTests, self).setUp()
def get_dummy_context() -> click.Context: """Return a dummy click context to allow using eg click.echo when not running an actual click command""" ctx = click.Context(click.Command("dummy")) ctx.params["verbose"] = True return ctx
def test_get_config_path(self): ctx = click.Context(click.Command('cli')) ctx.obj = {'project_dir': 'foo/bar/baz/'} path = _get_config_path(ctx) self.assertEqual(path, 'foo/bar/baz/.pipetree/config.json')
def setUp(self): self.data_dir = pathlib.Path(__file__).parent / "data" self.ctx = click.Context(click.Command("foo")) self.param = click.Option(["--config"]) return super().setUp()
keep_history=keep_history, dbname=db, experiment_name=experiment_name, cuda=cuda, debug=debug, base_integrand_params=base_integrand_params) benchmarker.run(integrand=SineIntegrand, sql_dtypes=dtypes, **benchmark_config) cli = click.Command("cli", callback=benchmark_camel, params=[ PythonLiteralOption(["--dimensions"], default=None), click.Option(["--debug/--no-debug"], default=None, type=bool), click.Option(["--cuda"], default=None, type=int), click.Option(["--db"], default=None, type=str), click.Option(["--experiment_name"], default=None, type=str), click.Option(["--config"], default=None, type=str), click.Option(["--n_search"], default=10, type=int) ]) if __name__ == '__main__': cli()
) async def chain(items, exit_stack): return await exit_stack.enter_async_context(traversals.sync_chain(items)) @registry.add_traversal( "async-chain", calculate_more_params=lambda x: calculate_function( x, howcall=interpret.HowCall.NONE), ) async def async_chain(items, exit_stack): return await exit_stack.enter_async_context(traversals.async_chain(items)) subcommands = [ click.Command("map", short_help="Call <code> on each line of input."), click.Command("async-map", short_help="Call <code> on each line of input."), click.Command("apply", short_help="Call <code> on input as a sequence."), click.Command( "async-apply", short_help="Call <code> asynchronously on input as a sequence."), click.Command( "filter", short_help= "Call <code> on each line of input and exclude false values.", ), click.Command( "async-filter", short_help= "Async call <code> on each line of input and exclude false values.",
Module with all click CLIs. """ import inspect import click from .video_io import convert_imagestack_file_to_video # CLI for convert_stack_to_video_ffmpeg: convert_imagestack_file_to_video_cli = click.Command( callback=convert_imagestack_file_to_video, name=convert_imagestack_file_to_video.__name__, help=inspect.getdoc(convert_imagestack_file_to_video), params=[ click.Option(['--frame-range'], type=int, nargs=2), click.Option(['--framerate'], type=click.types.FLOAT), click.Option(['--vmin'], type=click.types.FLOAT, default=0), click.Option(['--vmax'], type=click.types.FLOAT), click.Option(['--o-pix-fmt'], default='yuv420p'), click.Option(['--normalization_dtype'], default='uint8'), click.Option(['--normalization_batching'], default=1, type=int), click.Option(['--verbose', '-v'], count=True), click.Option(['--quiet/--no-quiet']), click.Argument(['inputfn'], required=True, type=click.Path(dir_okay=False, file_okay=True, exists=True)), click.Argument(['outputfn'], required=False) ])
def build_command(name, description, version, command_group, project_name=None, app_name=None): """Build a click command with subcommands :param name: command name :description: command description :version: command version :command_group: the entry point group for the subcommand extensions :project_name: project that contains the primary command :app_name: the app name used for config files """ if not project_name: project_name = name if not app_name: app_name = name subcommands = get_plugins(command_group) class MyGroup(click.Group): # override to set the project and app name def get_command(self, ctx, cmd_name): ctx.meta['qwcore.project_name'] = project_name ctx.meta['qwcore.app_name'] = app_name return super(MyGroup, self).get_command(ctx, cmd_name) def show_version(ctx, param, value): if value: click.echo(version) ctx.exit() def set_debug(ctx, param, value): if value: log = logging.getLogger(name) log.setLevel(getattr(logging, 'DEBUG')) version_flag = click.Option(['--version'], is_flag=True, expose_value=False, callback=show_version, is_eager=True, help='Show the version and exit.') debug_flag = click.Option(['--debug'], is_flag=True, callback=set_debug, expose_value=False, help='Turn on debug logging.') description = "{description}".format(description=description) command = MyGroup(command_group, help=description, params=[version_flag, debug_flag]) for plugin_name, cls in six.iteritems(subcommands): subcommand = click.Command(cls.name, short_help=cls.help, help=textwrap.dedent(' ' * 4 + cls.__doc__), params=cls.params, callback=cls().run) command.add_command(subcommand) return command
base_integrator_config["n_epochs"] = 1 base_integrator_config["n_iter"] = 1 run_benchmark_grid_known_integrand( dimensions=dimensions, integrand=RegulatedHyperSphericalCamel, base_integrand_params=base_integrand_params, base_integrator_config=base_integrator_config, integrand_params_grid=integrands_params_grid, integrator_config_grid=None, n_batch=100000, debug=debug, cuda=cuda, sql_dtypes=dtypes, dbname="benchmarks-debug.db", experiment_name="hypercamel") cli = click.Command("cli", callback=hypercamel_benchmark, params=[ PythonLiteralOption(["--dimensions"], default=[2]), PythonLiteralOption(["--fracs"], default=[0.3, 0.5, 0.7]), click.Option(["--debug/--no-debug"], default=True), click.Option(["--cuda"], default=0, type=int) ]) if __name__ == '__main__': cli()
def test_do_not_show_no_default(runner): """When show_default is True and no default is set do not show None.""" opt = click.Option(["--limit"], show_default=True) ctx = click.Context(click.Command("cli")) message = opt.get_help_record(ctx)[1] assert "[default: None]" not in message
# Integrand specific defaults base_integrand_params = { "s": 0.3, "norm": 1. } benchmarker = VegasSequentialBenchmarker() benchmark_config = benchmarker.set_benchmark_grid_config(config=config, keep_history=keep_history, dbname=db, experiment_name=experiment_name, cuda=cuda, debug=debug, base_integrand_params=base_integrand_params) # Integrand specific CLI argument mapped to standard API benchmarker.run(integrand=SymmetricCamelIntegrand, sql_dtypes=dtypes, **benchmark_config) cli = click.Command("cli", callback=benchmark_camel, params=[ click.Option(["--debug/--no-debug"], default=None, type=bool), click.Option(["--cuda"], default=None, type=int), click.Option(["--db"], default=None, type=str), click.Option(["--experiment_name"], default=None, type=str), click.Option(["--config"], default=None, type=str) ]) if __name__ == '__main__': cli()
def test_formatting_with_options_metavar_empty(runner): cli = click.Command("cli", options_metavar="", params=[click.Argument(["var"])]) result = runner.invoke(cli, ["--help"]) assert "Usage: cli VAR\n" in result.output
def ctx(): """Return an empty `click.Context` instance.""" return click.Context(click.Command(name='dummy'))
def test_intrange_default_help_text(runner, type, expect): option = click.Option(["--count"], type=type, show_default=True, default=2) context = click.Context(click.Command("test")) result = option.get_help_record(context)[1] assert expect in result
click.Option(["--mem_capacity"], default=128, type=click.INT), click.Option(["--mem_update_size"], default=16, type=click.INT), click.Option(["--mem_update_prob"], default=0.7, type=click.FLOAT), click.Option(["--learning_rate_g"], default=3.e-5, type=click.FLOAT), click.Option(["--learning_rate_d"], default=6.e-5, type=click.FLOAT), click.Option(["--noise_level"], default=0.2, type=click.FLOAT), click.Option(["--noise_damping"], default=1.5, type=click.FLOAT), click.Option(["--noise_damping_period"], default=5, type=click.INT), click.Option(["--data_root"], default="celebA/unlabelled_centered", type=click.STRING), click.Option(["--num_workers"], default=1, type=click.INT), click.Option(["--torch_seed"], default=None, type=click.INT), click.Option(["--checkpoint_period"], default=10, type=click.INT), ] train_dcgan32_cli = click.Command(name="train", callback=train_dcgan32, help="Train DCGAN32", params=train_dcgan32_options) dcgan32.add_command(train_dcgan32_cli) @click.group() def dcgan32_inversion(): """Commands related to the inversion model""" @dcgan32_inversion.command("prepare-dataset", help="Load a checkpoint for the DCGAN32 generator and generate an hdf5 inversion dataset") @click.option("--dataset_root", default="data/processed/dcgan32_inversion", type=click.Path()) @click.option("--dataset_size", default=100000, type=click.INT) @click.option("--val_size", default=10000, type=click.INT)