Example of argparse with subparsers for python

blame-praise.py

#!/usr/bin/env python
import argparse


def main(command_line=None):
    parser = argparse.ArgumentParser('Blame Praise app')
    parser.add_argument(
        '--debug',
        action='store_true',
        help='Print debug info'
    )
    subparsers = parser.add_subparsers(dest='command')
    blame = subparsers.add_parser('blame', help='blame people')
    blame.add_argument(
        '--dry-run',
        help='do not blame, just pretend',
        action='store_true'
    )
    blame.add_argument('name', nargs='+', help='name(s) to blame')
    praise = subparsers.add_parser('praise', help='praise someone')
    praise.add_argument('name', help='name of person to praise')
    praise.add_argument(
        'reason',
        help='what to praise for (optional)',
        default="no reason",
        nargs='?'
    )
    args = parser.parse_args(command_line)
    if args.debug:
        print("debug: " + str(args))
    if args.command == 'blame':
        if args.dry_run:
            print("Not for real")
        print("blaming " + ", ".join(args.name))
    elif args.command == 'praise':
        print('praising ' + args.name + ' for ' + args.reason)


if __name__ == '__main__':
    main()

@luhahn a small thing I don't quite like about this pattern is that it makes all the actual arguments hidden inside Namespace args instead being explicit. Which also makes it kinda difficult to "retrofit" argparse into a script that has batch of utility functions.

I prefer to keep my actual functions in format similar def func(url, headers=None).

This is what I come up with, I know it's not as pretty but works for me. Any input would be appreciated.

import argparse

def minus_one(x):
  print(int(x) - 1)

def time(x, y):
  print(int(x) * int(y))

def main():
  parser = argparse.ArgumentParser(description='Foo Bar')
  subparsers = parser.add_subparsers(dest='command', help='Commands to run', required=True)

  parser_minus_one = subparsers.add_parser('minusone')
  parser_minus_one.add_argument('x', help='X')
  parser_minus_one.set_defaults(func=minus_one)

  parser_time = subparsers.add_parser('time', help='X times Y')
  parser_time.add_argument('x', help='X')
  parser_time.add_argument('y', help='Y')
  parser_time.set_defaults(func=time)

  args = parser.parse_args()
  args_ = vars(args).copy()
  args_.pop('command', None)
  args_.pop('func', None)
  args.func(**args_)

if __name__ == '__main__':
  main()

Good evening @fireattack

Maybe something more elegant like:

import argparse
import inspect

from beartype.typing import Callable, Any


def minus_one(x: int) -> None:
    """
    Print the result of subtracting one from x.

    Args:
        x (int): The number to subtract

    Returns:
        None
    """
    print(int(x) - 1)


def time(x: int, y: int) -> None:
    """
    Print the product of x and y.

    Args:
        x (int): The first number
        y (int): The second number

    Returns:
        None
    """
    print(int(x) * int(y))


def call_function_with_args(func: Callable, args: argparse.Namespace) -> Any:
    """
    Call the function with the arguments extracted from the argparse.Namespace object.

    Args:
        func: The function to call.
        args: The argparse.Namespace object containing the arguments.

    Returns:
        Any: The result of the function call.

    Author:
        Laurent DECLERCQ, AGON PARTNERS INNOVATION <[email protected]>
    """
    # Let's inspect the signature of the function so that we can call it with the correct arguments.
    # We make use of the inspect module to get the function signature.
    signature = inspect.signature(func)

    # Get the parameters of the function using a dictionary comprehension.
    # Note: Could be enhanced to handle edge cases (default values, *args, **kwargs, etc.)
    args = {parameter: getattr(args, parameter) for parameter in signature.parameters}

    # Type cast the arguments to the correct type according to the function signature. We use the annotation of the
    # parameter to cast the argument. If the annotation is empty, we keep the argument as is. We only process the
    # arguments that are in the function signature.
    args = {
        parameter: (
            signature.parameters[parameter].annotation(args[parameter])
            if signature.parameters[parameter].annotation is not inspect.Parameter.empty else args[parameter]
        ) for parameter in args if parameter in signature.parameters
    }

    # Call the function with the arguments and return the result if any.
    return func(**arguments)


def cli():
    parser = argparse.ArgumentParser(description='Foo Bar')
    subparsers = parser.add_subparsers(dest='command', help='Commands to run', required=True)

    # Define the minusone sub-command.
    parser_minus_one = subparsers.add_parser('minusone')
    parser_minus_one.add_argument('x', help='X')
    parser_minus_one.set_defaults(func=minus_one)

    # Define the time sub-command.
    parser_time = subparsers.add_parser('time', help='X times Y')
    parser_time.add_argument('x', help='X')
    parser_time.add_argument('y', help='Y')
    parser_time.set_defaults(func=time)

    # Parse the arguments from the command line.
    args = parser.parse_args()

    # Call the function with the arguments.
    call_function_with_args(args.func, args)


if __name__ == '__main__':
    cli()

It can be useful to define a utility function to avoid duplication when defining subparsers.

#!/usr/bin/env python
import logging
import sys
from pathlib import Path
import argparse
from argparse import ArgumentParser, Namespace
from typing import Callable

logger = logging.getLogger(__name__)


def run_alpha(input_path: Path) -> int:
    logger.info(f"Running alpha for {input_path}")
    return 0


def run_beta(src: Path, dest: Path) -> int:
    logger.info(f"Running alpha with {src=} {dest=}")
    return 0


def _to_parser_alpha(p: ArgumentParser) -> ArgumentParser:
    p.add_argument("-i", "--input", type=Path, required=True)
    return p


def _to_parser_beta(p: ArgumentParser) -> ArgumentParser:
    p.add_argument("-s", "--src", type=Path, required=True)
    p.add_argument("-d", "--dest", type=Path, required=True)
    return p


def get_parser() -> ArgumentParser:
    p = ArgumentParser(prog="example.py")
    sp = p.add_subparsers()

    def _add(
        name: str,
        add_opts: Callable[[ArgumentParser], ArgumentParser],
        func: Callable[[Namespace], int],
        help_: str,
    ) -> argparse.ArgumentParser:
        px = sp.add_parser(name, help=help_)
        add_opts(px)
        px.set_defaults(func=func)
        return px

    _add("alpha", _to_parser_alpha, lambda ns: run_alpha(ns.input), "Running alpha")
    _add("beta", _to_parser_beta, lambda ns: run_beta(ns.src, ns.dest), "Run beta")

    p.add_argument("--version", action="version", version="0.1.0")
    return p


def main(argv: list[str]) -> int:
    logging.basicConfig(level=logging.DEBUG, stream=sys.stdout)
    p = get_parser()
    pargs = p.parse_args(argv)
    return pargs.func(pargs)


if __name__ == "__main__":
    sys.exit(main(sys.argv[1:]))

You can also get shell autocomplete functionality by adding shtab.

https://github.com/iterative/shtab

Support can added by:

import stab

# Add in get_parser()
shtab.add_argument_to(p)

Yielding --help:

 python shtab_test.py --help                
usage: example.py [-h] [--version] [--print-completion {bash,zsh,tcsh}] {alpha,beta} ...

positional arguments:
  {alpha,beta}
    alpha               Running alpha
    beta                Run beta

options:
  -h, --help            show this help message and exit
  --version             show program's version number and exit
  --print-completion {bash,zsh,tcsh}
                        print shell completion script

Then emitting the bash/zsh completion to stdout by:

python example.py --print-completion zsh