如何让optparse的OptionParser忽略无效选项？

In python's OptionParser, how can I instruct it to ignore undefined options supplied to method parse_args?

在python的OptionParser中,我如何指示它忽略提供给方法parse_args的未定义选项?

e.g.
I've only defined option --foo for my OptionParser instance, but I call parse_args with list
[ '--foo', '--bar' ]

例如我只为我的OptionParser实例定义了选项--foo,但我用list [' - foo',' - bar']调用了parse_args

EDIT:
I don't care if it filters them out of the original list. I just want undefined options ignored.

编辑:我不在乎它是否将它们从原始列表中过滤掉。我只想忽略未定义的选项。

The reason I'm doing this is because I'm using SCons' AddOption interface to add custom build options. However, some of those options guide the declaration of the targets. Thus I need to parse them out of sys.argv at different points in the script without having access to all the options. In the end, the top level Scons OptionParser will catch all the undefined options in the command line.

我这样做的原因是因为我使用SCons的AddOption接口来添加自定义构建选项。但是,其中一些选项指导了目标的声明。因此,我需要在脚本中的不同点解析sys.argv,而无需访问所有选项。最后,*Scons OptionParser将捕获命令行中的所有未定义选项。

5 个解决方案

#1

Here's one way to have unknown arguments added to the result args of OptionParser.parse_args, with a simple subclass.

这里有一种方法可以将未知参数添加到OptionParser.parse_args的结果参数中,并使用一个简单的子类。

from optparse import (OptionParser,BadOptionError,AmbiguousOptionError)

class PassThroughOptionParser(OptionParser):
    """
    An unknown option pass-through implementation of OptionParser.

    When unknown arguments are encountered, bundle with largs and try again,
    until rargs is depleted.  

    sys.exit(status) will still be called if a known argument is passed
    incorrectly (e.g. missing arguments or bad argument types, etc.)        
    """
    def _process_args(self, largs, rargs, values):
        while rargs:
            try:
                OptionParser._process_args(self,largs,rargs,values)
            except (BadOptionError,AmbiguousOptionError), e:
                largs.append(e.opt_str)

And here's a snippet to show that it works:

这是一个片段,表明它的工作原理:

# Show that the pass-through option parser works.
if __name__ == "__main__": #pragma: no cover
    parser = PassThroughOptionParser()
    parser.add_option('-k', '--known-arg',dest='known_arg',nargs=1, type='int')
    (options,args) = parser.parse_args(['--shazbot','--known-arg=1'])    
    assert args[0] == '--shazbot'
    assert options.known_arg == 1

    (options,args) = parser.parse_args(['--k','4','--batman-and-robin'])
    assert args[0] == '--batman-and-robin'
    assert options.known_arg == 4

#2

By default there is no way to modify the behavior of the call to error() that is raised when an undefined option is passed. From the documentation at the bottom of the section on how optparse handles errors:

默认情况下,无法修改在传递未定义选项时引发的对error()的调用行为。从有关optparse如何处理错误的部分底部的文档:

If optparse‘s default error-handling behaviour does not suit your needs, you’ll need to subclass OptionParser and override its exit() and/or error() methods.

如果optparse的默认错误处理行为不符合您的需求,您需要继承OptionParser并覆盖其exit()和/或error()方法。

The simplest example of this would be:

最简单的例子是:

class MyOptionParser(OptionParser):
    def error(self, msg):
        pass

This would simply make all calls to error() do nothing. Of course this isn't ideal, but I believe that this illustrates what you'd need to do. Keep in mind the docstring from error() and you should be good to go as you proceed:

这只会使对error()的所有调用都不起作用。当然这并不理想,但我相信这说明了你需要做的事情。请记住error()中的docstring,你应该继续前进:

Print a usage message incorporating 'msg' to stderr and exit. If you override this in a subclass, it should not return -- it should either exit or raise an exception.

打印包含'msg'的用法消息到stderr并退出。如果在子类中重写它,它不应该返回 - 它应该退出或引发异常。

#3

Python 2.7 (which didn't exist when this question was asked) now provides the argparse module. You may be able to use ArgumentParser.parse_known_args() to accomplish the goal of this question.

Python 2.7(在询问此问题时不存在)现在提供了argparse模块。您可以使用ArgumentParser.parse_known_args()来完成此问题的目标。

#4

This is pass_through.py example from Optik distribution.

这是来自Optik发行版的pass_through.py示例。

#!/usr/bin/env python

# "Pass-through" option parsing -- an OptionParser that ignores
# unknown options and lets them pile up in the leftover argument
# list.  Useful for programs that pass unknown options through
# to a sub-program.

from optparse import OptionParser, BadOptionError

class PassThroughOptionParser(OptionParser):

    def _process_long_opt(self, rargs, values):
        try:
            OptionParser._process_long_opt(self, rargs, values)
        except BadOptionError, err:
            self.largs.append(err.opt_str)

    def _process_short_opts(self, rargs, values):
        try:
            OptionParser._process_short_opts(self, rargs, values)
        except BadOptionError, err:
            self.largs.append(err.opt_str)


def main():
    parser = PassThroughOptionParser()
    parser.add_option("-a", help="some option")
    parser.add_option("-b", help="some other option")
    parser.add_option("--other", action='store_true',
                      help="long option that takes no arg")
    parser.add_option("--value",
                      help="long option that takes an arg")
    (options, args) = parser.parse_args()
    print "options:", options
    print "args:", args

main()

#5

Per synack's request in a different answer's comments, I'm posting my hack of a solution which sanitizes the inputs before passing them to the parent OptionParser:

根据synack在不同答案评论中的请求,我发布了一个解决方案的hack,它在将输入传递给父OptionParser之前对输入进行消毒:

import optparse
import re
import copy
import SCons

class NoErrOptionParser(optparse.OptionParser):
    def __init__(self,*args,**kwargs):
        self.valid_args_cre_list = []
        optparse.OptionParser.__init__(self, *args, **kwargs)

    def error(self,msg):
        pass

    def add_option(self,*args,**kwargs):
        self.valid_args_cre_list.append(re.compile('^'+args[0]+'='))
        optparse.OptionParser.add_option(self, *args, **kwargs)

    def parse_args(self,*args,**kwargs):
        # filter out invalid options
        args_to_parse = args[0]
        new_args_to_parse = []
        for a in args_to_parse:
            for cre in self.valid_args_cre_list:
                if cre.match(a):
                    new_args_to_parse.append(a)


        # nuke old values and insert the new
        while len(args_to_parse) > 0:
            args_to_parse.pop()
        for a in new_args_to_parse:
            args_to_parse.append(a)

        return optparse.OptionParser.parse_args(self,*args,**kwargs)


def AddOption_and_get_NoErrOptionParser( *args, **kwargs):
    apply( SCons.Script.AddOption, args, kwargs)
    no_err_optparser = NoErrOptionParser(optparse.SUPPRESS_USAGE)
    apply(no_err_optparser.add_option, args, kwargs)

    return no_err_optpars