Method for setting auto_envvar_prefix as part of CLI declaration?

[rsyring]

An example inspired by the Click docs:

@click.command()
@click.option('--username')
def greet(username):
    click.echo(f'Hello {username}!')

def cli():
    greet(auto_envvar_prefix='GREETER')

Note that I wrap greet(...) so I have an entrypoint for scripts:

In pyproject.toml:

[project.scripts]
greet = 'greeter.cli:cli'

When testing, I also have to ensure that I use auto_envvar_prefix with invoke:

    runner = CliRunner()
    result = runner.invoke(env_config, args, auto_envvar_prefix='GREETER')

Its not a big thing but that permits drift between what's happening normally and testing. Am I missing an obvious way of being able to make auto_envvar_prefix part of the definition of the command rather than set when the command is invoked? I could subclass Command and use that with click.command(...) but it seems less ergonomic than it could be.

[ndellosa95]

Is there a way to get the CLIRunner to parse option values from environment variables? I've been banging my head against this all morning and feel like I'm losing my mind, I cannot get it to work no matter what I do.

[rsyring]

Maybe I'm misunderstanding what you are asking but I believe the code above is a demonstration of how to do it:

    runner = CliRunner()
    result = runner.invoke(env_config, args, auto_envvar_prefix='GREETER')

Obviously, you'd need to line up your prefix, option names, and then (presumably) mock the environment to get it to work. That's what I did.

[mbra]

I came across this discussion while I was looking for a solution that does not require me to pass auto_envvar_prefix multiple times and instead rely on the top-level group/command provide the information for click to interpret later. Which was my understand of "as part of CLI declaration" as opposed to the "imperative" way of wrapping the top-level callable and passing the prefix.

I found the context_settings argument to help with this

import click
import click.testing


@click.group(context_settings={"auto_envvar_prefix": "GREETER"})
def cli():
    pass


@cli.group()
def say():
    pass

@say.command()
@click.option("--who")
def hello(who):
    print(f"Hello {who}!")


def test_greeter():
    runner = click.testing.CliRunner()
    result = runner.invoke(cli, ["say", "hello"], env={"GREETER_SAY_HELLO_WHO": "World"})
    assert result.output == "Hello World!\n"


if __name__ == "__main__":
    cli()

I find this quite useful because the click callable does not need to be wrapped and you can just use it as-is in the entry-point declaration and do not need to worry about "preparing" the code before a test will run under the same condition as it would in production. "Obviously" the settings will also allow passing other stuff, like obj. Making a wrapper callable unnecessary in most circumstances (at least for us).

The code is a bit more elaborate because I needed to debug something and make sure it works across multiple levels of groups but of course this also works for a single click.command.

[jbf81tb]

The context_settings argument was exactly what I was looking for! It seemed like a very idiomatic thing to want to pass Context arguments to a Command so I was surprised I didn't see anything in the docs that covered that. Turns out I just happened not to read the few examples where it appears as a bit of a side character.