¿Cómo puedo obtener OptionParser de optparse para ignorar las opciones no válidas?

Question

En python OptionParser, ¿cómo puedo indicarle que ignore las opciones indefinidas proporcionadas al método parse_args?

p. Ej.
He única opción --foo definido para mi OptionParser ejemplo, pero yo llamo parse_args con la lista
[ '--foo', '--bar' ]

EDIT:
no me importa si las filtra fuera de la lista original. Solo quiero que las opciones indefinidas sean ignoradas.

La razón por la que hago esto es porque estoy usando la interfaz AddOption de SCons para agregar opciones de compilación personalizadas. Sin embargo, algunas de esas opciones guían la declaración de los objetivos. Por lo tanto, necesito analizarlos en sys.argv en diferentes puntos del guión sin tener acceso a todas las opciones. Al final, el nivel superior Scons OptionParser captará todas las opciones indefinidas en la línea de comando.

Answer 1

según la petición del SynAck en los comentarios de una respuesta diferente, les dejo mi truco de una solución que desinfecta las entradas antes de pasarlos a los padres 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 

Answer 2

De manera predeterminada, no hay forma de modificar el comportamiento de la llamada al error() que se genera cuando se pasa una opción no definida. A partir de la documentación en la parte inferior de la sección sobre how optparse handles errors:

Si optparse de control de errores por defecto comportamiento no se ajusta a sus necesidades, que necesitará para OptionParser subclase y anular su salida() y/o métodos de error()

El ejemplo más simple de esto sería:

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

esto simplemente hacer que todas las llamadas a error() no hacen nada. Por supuesto, esto no es ideal, pero creo que esto ilustra lo que necesitarías hacer. Tenga en cuenta la cadena de documentación de error() y usted debe ser bueno para ir a medida que avanza:

Imprimir un mensaje de uso incorporando 'msg' en stderr y salida. Si anula esto en una subclase, no debería regresar; debe salir o generar una excepción.

Answer 3

He aquí una manera de tener argumentos desconocidos añadido al resultado args de OptionParser.parse_args, con una subclase simple.

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) 

Y aquí es un fragmento para mostrar que funciona:

# 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 

Answer 4

Python 2.7 (que no existía cuando se hizo esta pregunta) proporciona ahora el módulo argparse. Puede usar ArgumentParser.parse_known_args() para lograr el objetivo de esta pregunta.

Answer 5

Esto es pass_through.py ejemplo de Optik distribution.

#!/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()