Wrapping subcommands — returning control to CommandGroup once sub-command finishes

[madduck]

Hello,

I am developing a CLI that uses asyncio and spawns a web server and … well, it does a bunch of things. I am using click.Group extensively, and I am loving the fact that a Group's callback's function body (let's call it main) is executed for a subcommand, too. This allows me to set up the API wrapper and/or Web server, and hand it over to the subcommand using ctx.obj.

So far so good. Now I've found myself in a situation where I really want control flow to return to main once the subcommand is done. I am aware that I can use result_callback, or that I could pass another type of callback in ctx.obj for the child to call, but I find neither of these very satisfying. Using result_callback foregos the possibility to use closure/context of main, and the second approach imposes responsibility to call the callback to the subcommand.

Let me illustrate:

import click

@click.group
@click.option('--foo', type=float, default=3.14)
@click.pass_context
def clitest(ctx, foo):
    click.echo("Parent starting")
    def callback(val):
        print(f"callback() called, {foo=} {val=}")
    ctx.obj  = {"callback": callback}
    click.echo("Parent finishing")

@clitest.result_callback()
def result_callback(*args, **kwargs):
    print(f"result_callback() called, {args=} {kwargs=}")

@clitest.command
@click.option('--bar', is_flag=True)
@click.pass_context
def subcmd1(ctx, bar):
    click.echo("Child 1 starting")
    ctx.obj["callback"]("cb arg")
    click.echo("Child 1 finishing")
    return "subcmd1 return"

@clitest.command
@click.option('--bar', is_flag=True)
@click.pass_context
def subcmd2(ctx, bar):
    click.echo("Child 2 starting")
    # forgot to call callback, oops
    click.echo("Child 2 finishing")
    return "subcmd2 return"

if __name__ == "__main__":
    clitest()

When run with subcmd1, this yields:

Parent starting
Parent finishing
Child 1 starting
callback() called, foo=3.14 val='cb arg'
Child 1 finishing
result_callback() called, args=('subcmd1 return',) kwargs={'foo': 3.14}

if I run with subcmd2, the callback()… line is omitted due to
a programming error. I'd like to avoid that.

All this made me think that it could be such an improvement to borrow from
context managers and treat each parent as a context manager of its child.

Imagine:

@click.group
[…]
def clitest(…):
    click.echo("Parent starting")
    ret = yield "info for the child"
    click.echo(f"Parent finishing, child returned {ret}")

@clitest.command
[…]
def subcmd(info, …):
    print("In child; parent sent:", info)
    return 42

and this will print:

Parent starting
In child; parent sent: info for the child
Parent finishing, child returned 42

I thought about implementing this as a custom decorator, or subclass of
Group, but it turns out that this would require quite a bit of work on the
intestines of click.

Hence my question: is this a path worth travelling? An idea worth
entertaining?

[madduck]

I understand that I can follow the "complex application like Git" example and have ctx.obj point to an instance of my class. Then, I can configure that instance how I want in the parent, and as long as the child calls myinstance.run() at the end of its subcommand handler, it'll work.

But for one, there is no logical way to handle exceptions. Every subcommand has to handle exceptions from within myinstance individually. Why can't I just handle them in one place in the parent?

I could handle them in the class, but then I'd have to infect the class with click to be able to e.g. raise ClickException.

Also, right now, to pass data from parent to child, I have to use ctx.obj. To pass data from a child, I have to use chaining and/or result_callback. None of these provide closure. The yield-based approach does.