argparse default option based on another option

Question

Suppose I have an argparse python script:

import argparse

parser = argparse.ArgumentParser()
    
parser.add_argument("--foo", required=True)

Now I want to add another option --bar, which would default to appending "_BAR" to whatever was specified by --foo argument.

My goal:

>>> parser.parse_args(['--foo', 'FOO'])
>>> Namespace(foo='FOO', bar="FOO_BAR")

AND

>>> parser.parse_args(['--foo', 'FOO', '--bar', 'BAR'])
>>> Namespace(foo='FOO', bar="BAR")

I need something like this:

parser.add_argument("--bar", default=get_optional_foo + "_BAR")

hmm, how could argparse implement this natively? Perhaps pass a tuple of the names of the arguments you want passed to the function, and a function. — SIGSTACKFAULT, Jun 15 '18 at 16:19

score 31 · Answer 1 · answered Nov 18 '13 at 17:23

31

I would, as a first try, get this working using an after-argparse function.

def addbar(args):
    if args.bar is None:
        args.bar = args.foo+'_BAR'

If this action needs to be reflected in the help, put it there yourself.

In theory you could write a custom Action for foo that would set the value of the bar value as well. But that requires more familiarity with the Action class.

I tried a custom Action that tweaks the default of the bar action, but that is tricky. parse_args uses the defaults right at the start, before it has acted on any of the arguments.

answered Nov 18 '13 at 17:23

hpaulj

221,503
14
230
353

I would like to know why this was down voted. No one else has suggested a solution, much less a better one. – hpaulj Jun 13 '14 at 01:48
Dunno, but +1 from me. I like the simplicity of this solution better than a custom Action, though an ArgumentParser subclass that added dependencies between arguments would be pretty cool. – sfink Mar 22 '16 at 21:35

score 14 · Accepted Answer · edited Jul 19 '21 at 18:36

Here's another attempt at writing a custom Action class

import argparse
class FooAction(argparse.Action):
    # adapted from documentation
    def __call__(self, parser, namespace, values, option_string=None):
        setattr(namespace, self.dest, values)
        defaultbar = getattr(namespace, 'bar')
        try:
            defaultbar = defaultbar%values
        except TypeError:
            # BAR has already been replaced
            pass
        setattr(namespace, 'bar', defaultbar)

parser = argparse.ArgumentParser()
parser.add_argument("--foo", required=True, action=FooAction)
parser.add_argument("--bar", default="%s_BAR")

args = parser.parse_args(['--foo', 'Foo', '--bar', 'Bar'])
# Namespace(bar='Bar', foo='Foo')
args = parser.parse_args(['--foo', 'Foo'])
# Namespace(bar='Foo_BAR', foo='Foo')
args = parser.parse_args(['--bar', 'Bar', '--foo', 'Foo'])
# Namespace(bar='Bar', foo='Foo')

Note that the class has to know the dest of the --bar argument. Also I use a '%s_BAR' to readily distinguish between a default value, and a non default one. This handles the case where --bar appears before --foo.

Things that complicate this approach are:

default values are evaluated at add_argument time.
default values are placed in the Namespace at the start of parse_args.
flagged (optionals) arguments can occur in any order
the Action class is not designed to handle interacting arguments.
the bar action will not be called in the default case.
the bar default could be a function, but something would have to check after parse_args whether it needs to be evaluated or not.

While this custom Action does the trick, I still think the addbar function in my other answer is a cleaner solution.

@AT, an `Action` is called if the user provides a value, which would be always be the case if `required`. It is not called when just returning the default. — hpaulj, Feb 20 '21 at 05:21

argparse default option based on another option

2 Answers2

Linked

Related