Using a decorator to simplify subcommand creation with argparse

cli.py

"""This is free and unencumbered software released into the public domain.

Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled
binary, for any purpose, commercial or non-commercial, and by any
means.

In jurisdictions that recognize copyright laws, the author or authors
of this software dedicate any and all copyright interest in the
software to the public domain. We make this dedication for the benefit
of the public at large and to the detriment of our heirs and
successors. We intend this dedication to be an overt act of
relinquishment in perpetuity of all present and future rights to this
software under copyright law.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.

For more information, please refer to <http://unlicense.org/>

"""

from argparse import ArgumentParser

cli = ArgumentParser()
subparsers = cli.add_subparsers(dest="subcommand")


def argument(*name_or_flags, **kwargs):
    """Convenience function to properly format arguments to pass to the
    subcommand decorator.

    """
    return (list(name_or_flags), kwargs)


def subcommand(args=[], parent=subparsers):
    """Decorator to define a new subcommand in a sanity-preserving way.
    The function will be stored in the ``func`` variable when the parser
    parses arguments so that it can be called directly like so::

        args = cli.parse_args()
        args.func(args)

    Usage example::

        @subcommand([argument("-d", help="Enable debug mode", action="store_true")])
        def subcommand(args):
            print(args)

    Then on the command line::

        $ python cli.py subcommand -d

    """
    def decorator(func):
        parser = parent.add_parser(func.__name__, description=func.__doc__)
        for arg in args:
            parser.add_argument(*arg[0], **arg[1])
        parser.set_defaults(func=func)
    return decorator


@subcommand()
def nothing(args):
    print("Nothing special!")


@subcommand([argument("-d", help="Debug mode", action="store_true")])
def test(args):
    print(args)


@subcommand([argument("-f", "--filename", help="A thing with a filename")])
def filename(args):
    print(args.filename)


@subcommand([argument("name", help="Name")])
def name(args):
    print(args.name)


if __name__ == "__main__":
    args = cli.parse_args()
    if args.subcommand is None:
        cli.print_help()
    else:
        args.func(args)

could the sudcommand() be expanded to support aliases?

For global arguments, as requested by @NSBum and @mivade , there are 2 approaches:

• If they're truly global, just add them directly to the main parser (in this example, cli). Note that when using the CLI such args must be specified before the subcommand (./cli.py --global arg subcommand subcmdargs...)
• If they're a useful set of args shared among many subcommands, create each set as a distinct ArgumentParser() instance and pass them as parents when creating the submmand. There are examples in the official docs. Something like this:

niceargs = ArgumentParser(add_help=False)
niceargs.add_argument(...)
niceargs.add_argument(...)
...
someargs = ArgumentParser(add_help=False)
someargsadd.add_argument(...)
...

# Adjust the subcommand decorator to take in parents
# None: in real world you should NEVER use `[]` (or any mutable) as default argument!
def subcommand(args=[], parent=subparsers, parents=[]):
    ...
    def decorator(func):
        parser = parent.add_parser(func.__name__, description=func.__doc__, parents=parents)
        ...

# Now each subcommand can specify their additional args:
@subcommand([argument("name", help="Name")], parents=[niceargs])
def name(args):
    print(args.name)

@subcommand([argument("extra", help="Complete")], parents=[niceargs, someargs])
def full(args):
    print(args.name)

I recently developed a related python library for creating subcommands with decorator. Though it would be nice to share here: https://github.com/guludo/python-argparse-subdec

Here is yet another python library for creating subcommands with decorators:

https://github.com/innot/argparseDecorator

While I started with this little gist the project grew quite more than intentioned to make it as simple as possible to use.

With this library all arguments are taken from the function signature (no add-argument() calls/decorators required) with some optional data in the docstring. Example:

from argparsedecorator import *
cli = ArgParseDecorator()

@cli.command
def add(values: OneOrMore[float], squared: Option = False) -> None:
    """
    Add up a list of numbers.
    :param values: one or more numbers
    :param squared: when present square each number first
    :alias squared: -sq
    """
    if squared:
        values = [x*x for x in values]
    print sum(values)

parser.execute("add --squared 1 2 3 4")    # output 30
parser.execute("help add")    # outputs help info for the add command

I have just released the first version, feel free to check it out and give feedback.

I just came here to say, thanks for sharing this approach, I really liked it and found it very clean.
Thanks!