Using argparse to accept only one group of required arguments - argparse

Question

I'm trying to use parser = argparse.ArgumentParser for a lil program I write.
The program accepts as an input EITHER ( a path to a txt file ) OR (opt1 && opt2 && opt3 ).
Meaning if the user wants to use a txt file as an input he cant provide neither of opt and if he provided any opt - he have to provide all 3 and cant provide a path to a txt file.
I tried using add_mutually_exclusive_group but not sure how to because the second group of arguments is a group itself.
This is what I tried so far:
import argparse
parser = argparse.ArgumentParser(description='this is the description',)
root_group = parser.add_mutually_exclusive_group()
group_list = root_group.add_mutually_exclusive_group()
group_list.add_argument('-path', help='path to the txt file')
group_list = root_group.add_mutually_exclusive_group()
group_list.add_argument('-opt1', help='opt1')
group_list.add_argument('-opt2', help='opt2')
group_list.add_argument('-opt3', help='opt3')
args = parser.parse_args()
-
python tests.py -path txt -opt1 asdasd
usage: tests.py [-h] [[-path PATH] [-opt1 OPT1 | -opt2 OPT2 | -opt3 OPT3]
tests.py: error: argument -opt1: not allowed with argument -path
path is not allowed with any of opt - that's exactly what I want.
But I want that if the user supplied even 1 opt he will have to provide all of them.
I also want that at least 1 group have be to satisfied.

Answer 1

Mutually exclusive groups aren't designed for nesting. It accepts it your code, but the net effect into make a 4 arguments exclusive. It will accept only one of path, opt1, opt2, etc.
While I have explored defining nesting groups, and allowing any or and operations within groups, such a feature is a long way off.
Since your user has to provide all 3 --opt I'd suggest condensing that into one argument:
root_group.add_argument('--opt', nargs=3)
root_group.add_argument('--path')
Usage should look something like
usage: tests.py [-h] [--path PATH | --opt OPT OPT OPT]
Contrast that with a hypothetical usage that allows nested inclusive groups:
[-path PATH | [-opt1 OPT1 & -opt2 OPT2 & -opt3 OPT3]]
===========
With a tuple metavar, the usage can be refined to:
g.add_argument('--opt',nargs=3,metavar=('OPT1','OPT2','OPT3'))
usage: ipython3 [-h] [--path PATH | --opt OPT1 OPT2 OPT3]
=============
Your other option is to write a custom usage and perform you own logical tests after parsing.

Answer 2

I would use a subcommand parser instead. Your "options" aren't really optional; they are 3 required arguments in a particular context.
import argparse
p = argparse.ArgumentParser()
sp = p.add_subparsers()
p1 = sp.add_parser('file')
p1.add_argument('path')
p2 = sp.add_parser('opts')
p2.add_argument('opt1')
p2.add_argument('opt2')
p2.add_argument('opt3')
args = parser.parse_args()
Then you would invoke your script with
python tmp.py file foo.txt
or
python tmp.py opts 1 2 3
The help will tell you about the required positional argument whose value is either file or opts:
% python tmp.py -h
usage: tmp.py [-h] {file,opts} ...
positional arguments:
{file,opts}
optional arguments:
-h, --help show this help message and exit
and each subcommand has its own usage message:
% python tmp.py file -h
usage: tmp.py file [-h] path
positional arguments:
path
optional arguments:
-h, --help show this help message and exit
% python tmp.py opts -h
usage: tmp.py opts [-h] opt1 opt2 opt3
positional arguments:
opt1
opt2
opt3
optional arguments:
-h, --help show this help message and exit