argparse mutual exclusive group

While Jonathan's answer is perfectly fine for complex options, there is a very simple solution which will work for the simple cases, e.g. 1 option excludes 2 other options like in

command [- a xxx | [ -b yyy | -c zzz ]] 

or even as in the original question:

pro [-a xxx | [-b yyy -c zzz]]

Here is how I would do it:

parser = argparse.ArgumentParser()

# group 1 
parser.add_argument("-q", "--query", help="query")
parser.add_argument("-f", "--fields", help="field names")

# group 2 
parser.add_argument("-a", "--aggregation", help="aggregation")

I am using here options given to a command line wrapper for querying a mongodb. The collection instance can either call the method aggregate or the method find with to optional arguments query and fields, hence you see why the first two arguments are compatible and the last one isn't.

So now I run parser.parse_args() and check it's content:

args = parser.parse_args()

if args.aggregation and (args.query or args.fields):
    print "-a and -q|-f are mutually exclusive ..."
    sys.exit(2)

Of course, this little hack is only working for simple cases and it would become a nightmare to check all the possible options if you have many mutually exclusive options and groups. In that case you should break your options in to command groups like Jonathan suggested.

If you don't want subparsers, this can currently be done with mutually exclusive groups, but fair warning, it involves accessing private variables so use it at your own risk. The idea is you want -a to be mutually exclusive with -b and -c, but -b and -c don't want to be mutually exclusive with each other

import argparse
p = argparse.ArgumentParser()

# first set up a mutually exclusive group for a and b
g1 = p.add_mutually_exclusive_group()
arg_a = g1.add_argument('-a')  # save this _StoreAction for later
g1.add_argument('-b')

# now set up a second group for a and c 
g2 = p.add_mutually_exclusive_group()
g2.add_argument('-c')
g2._group_actions.append(arg_a)  # this is the magic/hack

Now we've got -a exclusive to both -c and -b.

a = p.parse_args(['-a', '1'])
# a.a = 1, a.b = None, a.c = None

a = p.parse_args(['-a', '1', '-b', '2'])
# usage: prog.py [-h] [-a A | -b B] [-c C]
# prog.py: error: argument -b: not allowed with argument -a

Note, it does mess up the help message, but you could probably override that, or just ignore it because you've got the functionality you want, which is probably more important anyway.

If you want to ensure if we're using any of b and c, we have to use both of them, then simply add the required=True keyword arg when instantiating the mutually exclusive groups.

There is a python patch (in development) that would allow you to do this.
http://bugs.python.org/issue10984

The idea is to allow overlapping mutually exclusive groups. So usage might look like:

pro [-a xxx | -b yyy] [-a xxx | -c zzz]

Changing the argparse code so you can create two groups like this was the easy part. Changing the usage formatting code required writing a custom HelpFormatter.

In argparse, action groups don't affect the parsing. They are just a help formatting tool. In the help, mutually exclusive groups only affect the usage line. When parsing, the parser uses the mutually exclusive groups to construct a dictionary of potential conflicts (a can't occur with b or c, b can't occur with a, etc), and then raises an error if a conflict arises.

Without that argparse patch, I think your best choice is to test the namespace produced by parse_args yourself (e.g. if both a and b have nondefault values), and raise your own error. You could even use the parser's own error mechanism.

parser.error('custom error message')