homepage

Assuming following:
1. optional argument, say "--foo", in a subparser;
2. at least two different optional arguments in the main parser prefixed with "--foo", say "--foo1" and "--foo2";
parsing fails with "error: ambiguous option: --foo could match --foo1, --foo2".
It seems like argument abbreviation mechanism described at http://docs.python.org/library/argparse.html#argument-abbreviations is not working properly when in use with subparsers...

More or less a duplicate of 12713?

Sorry, I meant #12713.

Yep. Closing as duplicate.

I don't understand how both bugs are related. Surely, patch provided for #12713 does not fix the issue I described.

My mistake. I see that the error you're getting is a bad interaction between the option in the main parser and an ambiguous option in the subparser.

The problem is basically that _parse_known_args calls _parse_optional to determine whether something is an optional or a positional. But _parse_optional only checks "if arg_string in self._option_string_actions", that is, if the string can be found in the main parser actions.
So either this method needs to check the subparser actions, or the "if arg_string in self._option_string_actions" stuff needs to be delayed until the subparser. Neither of these seems like a simple change, but I agree it's a bug.

Attached quick&dirty fix I'm currently using in my project. Maybe this will help to create a valid patch.
Instead of changing _parse_optional, I've overridden _get_option_tuples to scan subparsers for matching optional arguments if option is ambiguous in the current parser.
I've only skimmed through the code, so forgive me if that fix is useless.

I think the real fix needs to search recursively though all subparsers. Here's a first draft of a patch that does this. I believe your sample code works after this patch.
I don't have the time to turn your bug report into proper test (and add a test for the recursive bit), but hopefully this is enough to let someone else finish up fixing this bug.
And yes, your "dirty hack" was still helpful in putting this together. ;-)

Steven's patch (subparse_optionals.diff) run with jakub's test case (argparse_subparses_ambiguous_bug.py) works. But if the input string is 
 print(parser.parse_args('--foo baz'.split()))
produces
 Namespace(cmd=None, foo='baz', foo1=None, foo2=None)
(I added the 'cmd' subparse 'dest'). 
Two things seem to be going on now: 
1) '--foo' is being parsed even though its subparser is not invoked, 
2) and the subparser is not required.
The issue of whether subparsers are required or not is another issue. They used to be required, but the testing for 'required' was changed, and subparsers fell through the crack.
I suspect that if the missing subparser error were raised, the first issue wouldn't be apparent.

I think the correction to the problem that I noted in the previous post is to return 'None, arg_string, None', rather than 'action, arg_string, None' in the case where the action is found in a subparser.
This is what '_parse_optional' does at the end:
 # it was meant to be an optional but there is no such option
 # in this parser (though it might be a valid option in a subparser)
 return None, arg_string, None
An input like '--foo baz' would then produce an 'invalid choice' error. Since '--foo' is an optional that the primary parser does not recognize, 'baz' in interpreted as a positional, in this case an invalid subparser choice.
I'm working on cleaning up a test script.

In the last patch, 'parser.scan = True' is needed to activate this fix. I left that switch in for testing convenience.

This the argparse patch as described in the previous post, along with test_argparse tests. 
For now the tests handle both subparser required cases and not required ones ( http://bugs.python.org/issue9253 ). While error messages can differ based on this requirement, it does not affect the 'ambiguity' that underlies the current issue.

Another issue dealing with abbreviations is close to being committed.
http://bugs.python.org/issue14910
argparse: disable abbreviation