How to use argparse to create command groups like git?

Question

I'm trying to figure out how to use properly builtin argparse module to get a similar output than tools such as git where I can display a nice help with all "root commands" nicely grouped, ie:

$ git --help
usage: git [--version] [--help] [-C <path>] [-c <name>=<value>]
           [--exec-path[=<path>]] [--html-path] [--man-path] [--info-path]
           [-p | --paginate | -P | --no-pager] [--no-replace-objects] [--bare]
           [--git-dir=<path>] [--work-tree=<path>] [--namespace=<name>]
           [--super-prefix=<path>] [--config-env=<name>=<envvar>]
           <command> [<args>]

These are common Git commands used in various situations:

start a working area (see also: git help tutorial)
   clone     Clone a repository into a new directory
   init      Create an empty Git repository or reinitialize an existing one

work on the current change (see also: git help everyday)
   add       Add file contents to the index
   mv        Move or rename a file, a directory, or a symlink
   restore   Restore working tree files
   rm        Remove files from the working tree and from the index

examine the history and state (see also: git help revisions)
   bisect    Use binary search to find the commit that introduced a bug
   diff      Show changes between commits, commit and working tree, etc
   grep      Print lines matching a pattern
   log       Show commit logs
   show      Show various types of objects
   status    Show the working tree status

grow, mark and tweak your common history
   branch    List, create, or delete branches
   commit    Record changes to the repository
   merge     Join two or more development histories together
   rebase    Reapply commits on top of another base tip
   reset     Reset current HEAD to the specified state
   switch    Switch branches
   tag       Create, list, delete or verify a tag object signed with GPG

collaborate (see also: git help workflows)
   fetch     Download objects and refs from another repository
   pull      Fetch from and integrate with another repository or a local branch
   push      Update remote refs along with associated objects

'git help -a' and 'git help -g' list available subcommands and some
concept guides. See 'git help <command>' or 'git help <concept>'
to read about a specific subcommand or concept.
See 'git help git' for an overview of the system.

Here's my attempt:

from argparse import ArgumentParser


class FooCommand:
    def __init__(self, subparser):
        self.name = "Foo"
        self.help = "Foo help"
        subparser.add_parser(self.name, help=self.help)


class BarCommand:
    def __init__(self, subparser):
        self.name = "Bar"
        self.help = "Bar help"
        subparser.add_parser(self.name, help=self.help)


class BazCommand:
    def __init__(self, subparser):
        self.name = "Baz"
        self.help = "Baz help"
        subparser.add_parser(self.name, help=self.help)


def test1():
    parser = ArgumentParser(description="Test1 ArgumentParser")
    root = parser.add_subparsers(dest="command", description="All Commands:")

    # Group1
    FooCommand(root)
    BarCommand(root)

    # Group2
    BazCommand(root)

    args = parser.parse_args()
    print(args)


def test2():
    parser = ArgumentParser(description="Test2 ArgumentParser")

    # Group1
    cat1 = parser.add_subparsers(dest="command", description="Category1 Commands:")
    FooCommand(cat1)
    BarCommand(cat1)

    # Group2
    cat2 = parser.add_subparsers(dest="command", description="Category2 Commands:")
    BazCommand(cat2)

    args = parser.parse_args()
    print(args)

If you run test1 you'd get:

$ python mcve.py --help
usage: mcve.py [-h] {Foo,Bar,Baz} ...

Test1 ArgumentParser

options:
  -h, --help     show this help message and exit

subcommands:
  All Commands:

  {Foo,Bar,Baz}
    Foo          Foo help
    Bar          Bar help
    Baz          Baz help

Obviously this is not what I want, in there I just see all commands in a flat list, no groups or whatsoever... so the next logical attempt would be trying to group them. But if I run test2 I'll get:

$ python mcve.py --help
usage: mcve.py [-h] {Foo,Bar} ...
mcve.py: error: cannot have multiple subparser arguments

Which obviously means I'm not using properly argparse to accomplish the task at hand. So, is it possible to use argparse to achieve a similar behaviour than git? In the past I've relied on "hacks" so I thought the best practice here would be using the concept of add_subparsers but it seems I didn't understand properly that concept.

git doesn't use argparse, so don't expect to duplicate it. argparse lets you group arguments (with 2 default groups). It does not provide a way of grouping subparsers. — hpaulj
– hpaulj, Commented Dec 10, 2022 at 13:04
Constructing this sort of CLI is much easier using a library like click or Typer. — larsks
– larsks, Commented Dec 10, 2022 at 13:27
@larsks Thanks, I was aware of click but I didn't know about Typer. In any case, I'm aware of 3rd party solutions (ie: if you want something really robust I could also look at az-cli's parser from Microsoft, that's really good one). I've even built my own parsers in the past. But tbh, right now I just want to keep it simple, no 3rd party libs and just being able to learn how to use properly the good old robust argparse for this particular case — BPL
– BPL, Commented Dec 10, 2022 at 13:38
Maybe the idea would be using argument-groups instead subparsers? 🤔 — BPL
– BPL, Commented Dec 10, 2022 at 13:45
@larsks Wow, I've just tried typer and solved this problem naturally, really intuitive & dead simple modern library... it seems it's the right tool for the job 😁 — BPL
– BPL, Commented Dec 10, 2022 at 14:16

larsks · Accepted Answer · 2022-12-12 14:28:41Z

This isn't supported natively by argparse -- you can't nest subparsers, so if you want this sort of cli using argparse you're going to need to build a lot of logic on top of argparse. You can set nargs=argparse.REMAINDER to collect a subcommand and arguments without having them parsed by argparse, which means we can build something like this:

import argparse
import copy


class Command:
    def __init__(self):
        self.subcommands = {}
        self.parser = argparse.ArgumentParser()

    def add_subcommand(self, name, sub):
        self.subcommands[name] = sub

    def add_argument(self, *args, **kwargs):
        return self.parser.add_argument(*args, **kwargs)

    def parse_args(self, args=None):
        if not self.subcommands:
            args = self.parser.parse_args(args)
            return args

        p = copy.deepcopy(self.parser)
        p.add_argument("subcommand")
        p.add_argument("args", nargs=argparse.REMAINDER)
        args = p.parse_args(args)

        try:
            sub = self.subcommands[args.subcommand]
        except KeyError:
            return self.parser.parse_args(args)

        sub_args = sub.parse_args(args.args)

        for attr in dir(sub_args):
            if attr.startswith("_"):
                continue
            setattr(args, attr, getattr(sub_args, attr))

        return args


def main():
    root = Command()
    root.add_argument("-v", "--verbose", action="count")

    cmd1 = Command()
    cmd1_foo = Command()
    cmd1_foo.add_argument("-n", "--name")
    cmd1.add_subcommand("foo", cmd1_foo)
    root.add_subcommand("cmd1", cmd1)

    cmd2 = Command()
    cmd2_bar = Command()
    cmd2_bar.add_argument("-s", "--size", type=int)
    cmd2.add_subcommand("bar", cmd2_bar)
    root.add_subcommand("cmd2", cmd2)

    print(root.parse_args())


if __name__ == "__main__":
    main()

This is horrible and ugly and poorly structured, but it means we can do this:

$ python argtest.py --verbose cmd1 foo --name lars
Namespace(verbose=1, subcommand='foo', args=['--name', 'lars'], name='lars')

Or this:

$ python argtest.py --verbose cmd2 bar --size 10
Namespace(verbose=1, subcommand='bar', args=['--size', '10'], size=10)

If you're willing to look beyond argparse, libraries like Click and Typer make things much easier. For example, the above command could be implemented using Click like this:

import click

@click.group()
def main():
    pass

@main.group()
def cmd1():
    pass

@cmd1.command()
@click.option('-n', '--name')
def foo(name):
    pass

@main.group()
def cmd2():
    pass


@cmd2.command()
@click.option('-s', '--size', type=int)
def bar():
    pass

if __name__ == '__main__':
    main()

So much nicer!

Collectives™ on Stack Overflow

How to use argparse to create command groups like git?

1 Answer 1

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Related