Optional argument for each positional argument

Question

Using argparse (or something else?) I would like each positional argument to have an optional argument with default value.

The arguments would be as so:

script.py arg1 arg2 -o 1 arg3 -o 2 arg4 arg5

and I want it to parse this into something usable, like a list of the positional arguments and a list of the optional arguments with defaults filled in. e.g. if the default for the optional is 0 in the example above:

positional = [arg1, arg2, arg3, arg4, arg5]
optional = [0, 1, 2, 0, 0]

in other words, parser.add_argument('-o', action='append') is not what I want because I lose the positional argument, each optional argument is associated to.

Answer 1

Here's a simple hack that I put together that might be a reasonable place to start:

import argparse

class PositionalAction(argparse.Action):
    def __call__(self,parser,namespace,values,option_string=None):
        lst = getattr(namespace,self.dest)
        lst.append(values)
        parser.last_positional_values = lst
        all_positional = getattr(namespace,'all_positional',[])
        all_positional.append(lst)
        namespace.all_positional = all_positional

class AssociateAction(argparse.Action):
    def __call__(self,parser,namespace,values,option_string=None):
        try:
            parser.last_positional_values.append(values)
        except AttributeError:
            pass

parser = argparse.ArgumentParser()
parser.add_argument('-o',action=AssociateAction,dest=argparse.SUPPRESS)
junk,unknown = parser.parse_known_args()

for i,_ in enumerate(unknown):
    parser.add_argument('arg%d'%i,action=PositionalAction,default=[])

print parser.parse_args()

And here it is in action:

temp $ python test1.py foo -o 1 bar -o 2 baz qux -o 4
Namespace(all_positional=[['foo', '1'], ['bar', '2'], ['baz'], ['qux', '4']], arg0=['foo', '1'], arg1=['bar', '2'], arg2=['baz'], arg3=['qux', '4'])

This problem has a few challenges. First, You want to accept an arbitrary number of positional arguments -- argparse doesn't like that. argparse wants to know up front what to expect. The solution is to build a parser and parse the commandline, but to tell argparse to only parse the known arguments only (in this case, the non-positional -o arguments are all parsed silently but the "positional" arguments aren't parsed.). parse_known_args is perfect for this as it returns a tuple in the form (namespace_of_parsed_stuff, uknown_args). So now we know the unknown arguments -- We just need to add a positional argument to the parser for each one to make parse_args happy.

Now, what are the custom actions actually doing? When a positional argument is found (on the second pass), we get the default (which is a list) and add the value to that list (hereafter I'll call it the "value" list). We then modify the parser with a reference to the "value" list. We also get the "all_positional" list from the namespace. If it doesn't have that attribute, we just get an empty list. We add the "value" list to the "all_positional" list and put it back on the namespace.

Now, when we hit a -o flag, we look at the parser to get the "value" list and we add the additional value to that list. We could do the same thing without touching the parser at all ... (we could look at namespace.all_positional[-1] -- It's the same list as parser.last_positional_values).