Question

I’m creating a python script with usage in the same style as pacman in Arch Linux, summarized by:

prog <operation> [options] [targets]

• operations are of the form -X (hyphen, uppercase letter), and one is required when calling the script.
• options are of the form -x (hyphen, lowercase letter), and can mean different things for different operations.

For example:

• pacman -Syu means perform the sync operation with refresh and sysupgrade options, upgrading the entire system with fresh packages.
• pacman -Qu means perform the query operation with the upgrades option, listing all outdated packages.
• pacman -Ss <arg> means perform the sync operation with the search option, which expects another argument as the pattern to search for in the sync packages.

The punchline:

I’ve been looking into the argparse library for python, trying to figure out how to implement this. I’ve run into some problems/design issues so far:

• argparse only accepts hyphen-prefixed arguments as optional arguments. All my “operations” would show up as optional arguments, when one is definitely required.
• I could make my script have one “positional”/required argument, which would be the operation (I would have to switch operations to words, like upgrade or add), followed by optional arguments. This, however, still wouldn’t solve the same-option-symbol-working-differently issue, and also wouldn’t let me easily list all the supported operations in the --help text.

What’s the smoothest way to handle this argument parsing? I’m not against changing my command’s usage, but as I said above, it doesn’t seem to help my situation as far as I can tell.

Thanks

Answer 1

So I found this support for sub-commands buried in the argparse help. It’s exactly what I need, with the only caveat being I am not using -X as the format for operations; I am just using words like add and search instead.

For completeness here’s an example of using sub-parsers from the link above:

>>> # create the top-level parser
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('--foo', action='store_true', help='foo help')
>>> subparsers = parser.add_subparsers(help='sub-command help')
>>>
>>> # create the parser for the "a" command
>>> parser_a = subparsers.add_parser('a', help='a help')
>>> parser_a.add_argument('bar', type=int, help='bar help')
>>>
>>> # create the parser for the "b" command
>>> parser_b = subparsers.add_parser('b', help='b help')
>>> parser_b.add_argument('--baz', choices='XYZ', help='baz help')
>>>
>>> # parse some argument lists
>>> parser.parse_args(['a', '12'])
Namespace(bar=12, foo=False)
>>> parser.parse_args(['--foo', 'b', '--baz', 'Z'])
Namespace(baz='Z', foo=True)