Is it possible to combine two argparse Python objects?

Question

I have an object A that contains parserA - an argparse.ArgumentParser object There is also an object B that contains parserB - another argparse.ArgumentParser

Object A contains an instance of object B, however, the arguments of object B should now be parsed in object A (since A is the one that is called from the command line with arguments, not B)

Is there a way to write in a Python object A: parserA + = B.parserB?

Answer 1

argparse was designed around objects. Besides a few constants and utility functions, these are all class definitions. The documentation focuses on the use, not the structure of the class. But it can help to understand it.

 parser = argparse.ArgumentParser(...) 

creates a parser object.

 arg1 = parser.add_argument(...) 

creates an argparse.Action object (subclass) and adds it to several parser attributes (lists). Usually we ignore the fact that the method returns this Action object, but sometimes I find it useful. And when I create a parser in an interactive shell, I see this action.

 args = parser.parse_args() 

launches another method and returns a namespace object ( argparse.Namespace class).

Group methods and subparameters also create and return objects (groups, actions, and / or parsers).

The ArgumentParser method takes the parents parameter, where the value is a list of parser objects.

WITH

 parsera = argparse.ArgumentParser(parents=[parserb]) 

during the creation of parsera actions and groups in parserb copied to parsera . Thus, parsera recognizes all the arguments parserb does. I recommend you check it out.

But there are several qualifications. Copy is a link. That is, parsera gets a pointer to every action defined in parserb . Sometimes this creates problems (I won’t go into it now). And one or the other should have add_help=False . Usually, the action is added to the parser at creation. But if parserb also helps, there will be a conflict (duplication) that needs to be resolved.

But parents cannot be used if parsera was created independently of parserb . There is no existing mechanism for adding actions from parserb . Maybe you can create a new parser with both parents

 parserc = argparse.ArgumentParser(parents=[parsera, parserb]) 

Perhaps I could write a function that would add arguments from parserb to parsera , borrowing ideas from a method that implements parents . But I have to know how to resolve conflicts.

Take a look at argparse._ActionsContainer._add_container_actions to see how the Actions are copies from parent to parser . Something that can be confusing is that each action is part of a group (user-defined or one of the two default groups (see Help)) in addition to parser .

Another possibility is to use

 [argsA, extrasA] = parserA.parse_known_args() [argsB, extrasB] = parserB.parse_known_args() # uses the same sys.argv # or args = parserB.parse_args(extrasA, namespace=argsA) 

In addition, each parser processes the arguments that it knows about, and returns the others in the extras list.

If parsers are not designed for this kind of integration, there will be jagged edges with that kind of integration. It may be easier to deal with those who are facing Arnial's approach, which should include defining common arguments in your own methods. Others like to put argument parameters in some kind of database (list, dictionary, etc.) and build a parser from them. You can wrap the creation of the parser with as many layers of the template as possible.

Answer 2

You cannot use one ArgumentParser inside another. But there is a way around. You need to extract the method code, which adds the arguments to the parser. Then you can use them to combine arguments in the parser. It will also be easier to group arguments (related to their parsers). But you have to be careful that the names of the argument sets do not intersect.

Example:

foo.py:

 def add_foo_params( group ): group.add_argument('--foo', help='foo help') if __name__ = "__main__": parser = argparse.ArgumentParser(prog='Foo') 

boo.py

 def add_boo_params( group ): group.add_argument('--boo', help='boo help') if __name__ = "__main__": parser = argparse.ArgumentParser(prog='Boo') 

fooboo.py

  from foo import add_foo_params from boo import add_boo_params if __name__ = "__main__": parser = argparse.ArgumentParser(prog='FooBoo') foo_group = parser.add_argument_group(title="foo params") boo_group = parser.add_argument_group(title="boo params") add_foo_params( foo_group ) add_boo_params( boo_group )