Develop Reference

How do I detect when '--help' has been called?

My Click 7.0 application has one group, having multiple commands, called by the main cli function like so:
import click
#click.group()
#click.pass_context
def cli(ctx):
"This is cli helptext"
click.echo('cli called')
click.echo('cli args: {0}'.format(ctx.args))
#cli.group(chain=True)
#click.option('-r', '--repeat', default=1, type=click.INT, help='repeat helptext')
#click.pass_context
def chainedgroup(ctx, repeat):
"This is chainedgroup helptext"
for _ in range(repeat):
click.echo('chainedgroup called')
click.echo('chainedgroup args: {0}'.format(ctx.args))
#chainedgroup.command()
#click.pass_context
def command1(ctx):
"This is command1 helptext"
print('command1 called')
print('command1 args: {0}'.format(ctx.args))
#chainedgroup.command()
#click.pass_context
def command2(ctx):
"This is command2 helptext"
print('command2 called')
print('command2 args: {0}'.format(ctx.args))
Run:
$ testcli --help
$ testcli chainedgroup --help
$ testcli chainedgroup command1 --help
The help-text displays as expected--except that the parent functions are inadvertently run in the process. A single conditional checking to see if '--help' is contained in ctx.args should be enough to solve this problem, but does anyone know how/when '--help' is passed? Because with this code, ctx.args is empty every time.

If argparse is not an option, how about:
if '--help' in sys.argv:
...

click stores the arguments passed to a command in a list. The method get_os_args() returns such list. You can check if --help is in that list to determine if the help flag was invoked. Something like the following:
if '--help' in click.get_os_args():
pass

It is prebuilt - Click looks like a decorator for argparse (Hurrah for common sense).
import click
#click.command()
#click.option('--count', default=1, help='Number of greetings.')
#click.option('--name', prompt='Your name',
help='The person to greet.')
def hello(count, name):
"""Simple program that greets NAME for a total of COUNT times."""
for x in range(count):
click.echo('Hello %s!' % name)
if __name__ == '__main__':
hello()
So you can write
python cl.py --name bob
And see
Hello bob!
Help is already done (as it is argparse)
python cl.py --help
Usage: cl.py [OPTIONS]
Simple program that greets NAME for a total of COUNT times.
Options:
--count INTEGER Number of greetings.
--name TEXT The person to greet.
--help Show this message and exit.
Been busy only just had time to read into this.
Sorry for the delay

Why not use argparse ? It has excellent for CLI parsing.

How to add help to CommandCollection click's command?

I'm trying to add help to the command line application using click library. As mentioned in official documentation,
For commands, a short help snippet is generated. By default, it’s the
first sentence of the help message of the command, unless it’s too
long. This can also be overridden
With simple #click.command everything works as expected:
import click
#click.command()
def cli():
"""This is sample description of script."""
if __name__ == '__main__':
cli()
Running this would display description for the script from the method's doscstring:
Usage: example.py [OPTIONS]
This is sample description of script.
Options:
--help Show this message and exit.
But I need to use CommandCollection, as I'm creating a script consisting from multiple commands. Here is an example from official help:
import click
#click.group()
def cli1():
pass
#cli1.command()
def cmd1():
"""Command on cli1"""
#click.group()
def cli2():
pass
#cli2.command()
def cmd2():
"""Command on cli2"""
cli = click.CommandCollection(sources=[cli1, cli2])
if __name__ == '__main__':
cli()
And I don't know how to add description to whole command collection. What I've tried so far:
provide help with additional short_help parameter
set __doc__ argument for cli parameter, after creating CommandCollection
add docstring to cli1 method, decorated with #click.group
Any help is much appreciated.

Just use help parameter:
cli = click.CommandCollection(sources=[cli1, cli2], help="This would be your description, dude!")

How do I make a command line program using click in python that takes separates command parameters that run different scripts?

I have the following code:
import click
#click.group()
def cli():
pass
#click.command()
def initdb():
click.echo('Initialized the database')
#click.command()
def dropdb():
click.echo('Dropped the database')
cli.add_command(initdb)
cli.add_command(dropdb)
At the command line I want to be able to do something like the following:
python clicktest.py cli initdb
and have the following happen echo at the terminal:
Initialized the database
Or to enter into the terminal:
python clicktest.py cli dropdb
and have the following happen on the terminal:
Dropped the database
My problem is currently when I do this at the terminal:
python clicktest.py cli initdb
Nothing happens at the terminal, nothing prints when I think something should, namely the 'Initialized Database' echo. What am i doing wrong??

First, you should use it in command line like:
python clicktest.py initdb
python clicktest.py dropdb
And in your clicktest.py file, place these lines at the bottom of your code:
if __name__ == '__main__':
cli()
Unless, your code won't get work.
EDIT:
If you really want to use it in a way python clicktest.py cli initdb, then you have another choice:
#click.group()
def main():
pass
#click.group()
def cli():
pass
#click.command()
def initdb():
click.echo('Initialized the database')
#click.command()
def dropdb():
click.echo('Dropped the database')
cli.add_command(initdb)
cli.add_command(dropdb)
main.add_command(cli)
if __name__ == '__main__':
main()
Or even better (Using decorators instead):
#click.group()
def main():
pass
#main.group()
def cli():
pass
#cli.command()
def initdb():
click.echo('Initialized the database')
#cli.command()
def dropdb():
click.echo('Dropped the database')
if __name__ == '__main__':
main()

python click usage of standalone_mode

This question is about the Python Click library.
I want click to gather my commandline arguments. When gathered, I want to reuse these values. I dont want any crazy chaining of callbacks, just use the return value. By default, click disables using the return value and calls sys.exit().
I was wondering how to correctly invoke standalone_mode (http://click.pocoo.org/5/exceptions/#what-if-i-don-t-want-that) in case I want to use the decorator style. The above linked doc only shows the usage when (manually) creating Commands using click.
Is it even possible? A minimal example is shown below. It illustrates how click calls sys.exit() directly after returning from gatherarguments
import click
#click.command()
#click.option('--name', help='Enter Name')
#click.pass_context
def gatherarguments(ctx, name):
return ctx
def usectx(ctx):
print("Name is %s" % ctx.params.name)
if __name__ == '__main__':
ctx = gatherarguments()
print(ctx) # is never called
usectx(ctx) # is never called
$ python test.py --name Your_Name
I would love this to be stateless, meaning, without any click.group functionality - I just want the results, without my application exiting.

Just sending standalone_mode as a keyword argument worked for me:
from __future__ import print_function
import click
#click.command()
#click.option('--name', help='Enter Name')
#click.pass_context
def gatherarguments(ctx, name):
return ctx
def usectx(ctx):
print("Name is %s" % ctx.params['name'])
if __name__ == '__main__':
ctx = gatherarguments(standalone_mode=False)
print(ctx)
usectx(ctx)
Output:
./clickme.py --name something
<click.core.Context object at 0x7fb671a51690>
Name is something

Creating a shell command line application with Python and Click

I'm using click (http://click.pocoo.org/3/) to create a command line application, but I don't know how to create a shell for this application.
Suppose I'm writing a program called test and I have commands called subtest1 and subtest2
I was able to make it work from terminal like:
$ test subtest1
$ test subtest2
But what I was thinking about is a shell, so I could do:
$ test
>> subtest1
>> subtest2
Is this possible with click?

This is not impossible with click, but there's no built-in support for that either. The first you would have to do is making your group callback invokable without a subcommand by passing invoke_without_command=True into the group decorator (as described here). Then your group callback would have to implement a REPL. Python has the cmd framework for doing this in the standard library. Making the click subcommands available there involves overriding cmd.Cmd.default, like in the code snippet below. Getting all the details right, like help, should be doable in a few lines.
import click
import cmd
class REPL(cmd.Cmd):
def __init__(self, ctx):
cmd.Cmd.__init__(self)
self.ctx = ctx
def default(self, line):
subcommand = cli.commands.get(line)
if subcommand:
self.ctx.invoke(subcommand)
else:
return cmd.Cmd.default(self, line)
#click.group(invoke_without_command=True)
#click.pass_context
def cli(ctx):
if ctx.invoked_subcommand is None:
repl = REPL(ctx)
repl.cmdloop()
#cli.command()
def a():
"""The `a` command prints an 'a'."""
print "a"
#cli.command()
def b():
"""The `b` command prints a 'b'."""
print "b"
if __name__ == "__main__":
cli()

There is now a library called click_repl that does most of the work for you. Thought I'd share my efforts in getting this to work.
The one difficulty is that you have to make a specific command the repl command, but we can repurpose #fpbhb's approach to allow calling that command by default if another one isn't provided.
This is a fully working example that supports all click options, with command history, as well as being able to call commands directly without entering the REPL:
import click
import click_repl
import os
from prompt_toolkit.history import FileHistory
#click.group(invoke_without_command=True)
#click.pass_context
def cli(ctx):
"""Pleasantries CLI"""
if ctx.invoked_subcommand is None:
ctx.invoke(repl)
#cli.command()
#click.option('--name', default='world')
def hello(name):
"""Say hello"""
click.echo('Hello, {}!'.format(name))
#cli.command()
#click.option('--name', default='moon')
def goodnight(name):
"""Say goodnight"""
click.echo('Goodnight, {}.'.format(name))
#cli.command()
def repl():
"""Start an interactive session"""
prompt_kwargs = {
'history': FileHistory(os.path.expanduser('~/.repl_history'))
}
click_repl.repl(click.get_current_context(), prompt_kwargs=prompt_kwargs)
if __name__ == '__main__':
cli(obj={})
Here's what it looks like to use the REPL:
$ python pleasantries.py
> hello
Hello, world!
> goodnight --name fpbhb
Goodnight, fpbhb.
And to use the command line subcommands directly:
$ python pleasntries.py goodnight
Goodnight, moon.

I know this is super old, but I've been working on fpbhb's solution to support options as well. I'm sure this could use some more work, but here is a basic example of how it could be done:
import click
import cmd
import sys
from click import BaseCommand, UsageError
class REPL(cmd.Cmd):
def __init__(self, ctx):
cmd.Cmd.__init__(self)
self.ctx = ctx
def default(self, line):
subcommand = line.split()[0]
args = line.split()[1:]
subcommand = cli.commands.get(subcommand)
if subcommand:
try:
subcommand.parse_args(self.ctx, args)
self.ctx.forward(subcommand)
except UsageError as e:
print(e.format_message())
else:
return cmd.Cmd.default(self, line)
#click.group(invoke_without_command=True)
#click.pass_context
def cli(ctx):
if ctx.invoked_subcommand is None:
repl = REPL(ctx)
repl.cmdloop()
#cli.command()
#click.option('--foo', required=True)
def a(foo):
print("a")
print(foo)
return 'banana'
#cli.command()
#click.option('--foo', required=True)
def b(foo):
print("b")
print(foo)
if __name__ == "__main__":
cli()

I was trying to do something similar to the OP, but with additional options / nested sub-sub-commands. The first answer using the builtin cmd module did not work in my case; maybe with some more fiddling.. But I did just run across click-shell. Haven't had a chance to test it extensively, but so far, it seems to work exactly as expected.