optparse und parameter ignorieren

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
buexy
User
Beiträge: 2
Registriert: Dienstag 23. Mai 2006, 09:32

optparse und parameter ignorieren

Beitragvon buexy » Dienstag 23. Mai 2006, 11:26

Hallo!

Ich benutze optparse, um einem script bestimmte Parameter zu übergeben.
Dazu habe ich mir einige Kommandos reserviert (Bsp.: -a -b -c).
Wenn ich das script jetzt mit dem Kommando -z aufrufe wird das script mit einem Fehler beendet.
Ich möchte aber alle anderen Kommandos die ich nicht definiert habe einfach ignorieren.

Was gibt es da für Möglichkeiten?


CODE:

import sys
import time
import getopt
import string
import os
import types
import optparse

VERSION = "0.1"



def getCANopt (argv,net=0,node=1,baud=0):
print argv
print len(argv)
usage = "usage: %prog [options] arg"
#usage=="%prog [-n] [-b] [-o]", version="%prog 1.0"
parser = optparse.OptionParser(usage, version="%prog 1.0")
parser.add_option("-n", "--net", dest="net",
help="net number", default=0, type="int")
parser.add_option("-b", "--baud", dest="baud",
help="baudrate", default=0, type="int")
parser.add_option("-m", "--module", dest="node",
help="node", default=1, type="int")
parser.add_option("-q", "--quiet",
action="store_false", dest="verbose", default=True,
help="don't print status messages to stdout")

(options, args) = parser.parse_args()
#print options
#print args
#if len(args) < 2:
# parser.error("incorrect number of arguments")
if options.verbose:
print "Baudrate: %d" % options.baud
print "Net : %d" % options.net
print "Node : %d" % options.node
return options.net,options.node,options.baud





#------------------------------------------------------------------------------
# main program
#------------------------------------------------------------------------------
def main():
print "getCANopt"
net,node,baud=getCANopt(sys.argv)
print net
print node
print baud
print "getCANopt done"
print

sys.exit(0)


if __name__ == '__main__':
main()





Gruß
Büxy
Benutzeravatar
gerold
Python-Forum Veteran
Beiträge: 5554
Registriert: Samstag 28. Februar 2004, 22:04
Wohnort: Telfs (Tirol)
Kontaktdaten:

Beitragvon gerold » Dienstag 23. Mai 2006, 11:34

Hi!

Bitte schließe Code in Code-Tags ein.

Siehe: http://www.python-forum.de/faq.php#21

Mit dem [Edit]-Button kannst du deinen Beitrag noch einmal überarbeiten.

mfg
Gerold
:-)
http://halvar.at | Kleiner Bascom AVR Kurs
Wissen hat eine wunderbare Eigenschaft: Es verdoppelt sich, wenn man es teilt.
Benutzeravatar
gerold
Python-Forum Veteran
Beiträge: 5554
Registriert: Samstag 28. Februar 2004, 22:04
Wohnort: Telfs (Tirol)
Kontaktdaten:

Beitragvon gerold » Dienstag 23. Mai 2006, 12:14

Hi Büxy!

Ich habe keine Möglichkeit gefunden, "optparse" so einzustellen, dass unbekannte Parameter nicht reklamiert werden.

Als mögliche Lösung, bietet es sich an, die Methode "_process_short_opts" der Klasse "OptionParser" zu überschreiben und dadurch die Prüfung auf bekannte Parameter auszuschalten. Wie das geht, zeige ich hier in diesem Beispiel, weiter unten. Allerdings ist das nicht unbedingt das Beste was man tun kann. Ändert sich die Klasse "OptionParser" im Original, dann kann es zu Problemen kommen.

Du könntest das Modul "optparse.py" kopieren, unter einem anderen Namen abspeichern, ändern und (umbenannt) in dein Programm einbinden. Dann wäre es egal, wenn später einmal das Original-Modul "optparse.py" geändert wird.

Bevor ich das Beispiel aufzeige, noch ein Hinweis: Du könntest einfach für alle möglichen Buchstaben und Zahlen eine Kurzoption definieren, die später im Programm ignoriert wird. Allerdings wird dann bei der Option "-h" jede dieser Dummy-Optionen angezeigt.

Das Beispiel ist ein wenig länger, da ich einfach ein anderes Beispiel abgeändert habe...

Code: Alles auswählen

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from optparse import OptionParser


#----------------------------------------------------------------------
class OptionParserEx(OptionParser):

    #----------------------------------------------------------------------
    def _process_short_opts(self, rargs, values):
        arg = rargs.pop(0)
        stop = False
        i = 1
        for ch in arg[1:]:
            opt = "-" + ch
            option = self._short_opt.get(opt)
            i += 1                      # we have consumed a character

            if not option:
                i -= 1
                continue
            if option.takes_value():
                # Any characters left in arg?  Pretend they're the
                # next arg, and stop consuming characters of arg.
                if i < len(arg):
                    rargs.insert(0, arg[i:])
                    stop = True

                nargs = option.nargs
                if len(rargs) < nargs:
                    if nargs == 1:
                        self.error(_("%s option requires an argument") % opt)
                    else:
                        self.error(_("%s option requires %d arguments")
                                   % (opt, nargs))
                elif nargs == 1:
                    value = rargs.pop(0)
                else:
                    value = tuple(rargs[0:nargs])
                    del rargs[0:nargs]

            else:                       # option doesn't take a value
                value = None

            option.process(opt, value, values, self)

            if stop:
                break
   

#----------------------------------------------------------------------
def parse_options():
    """
    Wertet die Argumente aus und gibt diese zurück
    """

    #Usage-Text angeben und Parser-Objekt erzeugen
    usage = "%prog [options]\n\n" + \
            "    Kurze Erklaerung zum Programm\n" + \
            "    by Gerold Penz 2006 -- gerold.penz@tirol.utanet.at"
    parser = OptionParserEx(usage = usage)

    #Optionen hinzufuegen
    parser.add_option("-d", "--debug",
        dest = "debug",
        action = "store_true",
        default = False,
        help = "show debug messages"
    )

    #Optionen parsen
    (options, args) = parser.parse_args()

    # DEBUG als globale Variable setzen
    global DEBUG
    DEBUG = options.debug

    #Rueckgabe
    return (options, args)

#----------------------------------------------------------------------
def main():
    """
    Hauptprozedur
    """
   
    #Optionen und Argumente parsen
    (options, args) = parse_options()
   
    # Ab hier kann gearbeitet werden.
    # ...
    # ...
    if DEBUG:
        print "Ich bin im Debug-Modus!"
   
#----------------------------------------------------------------------
if __name__ == "__main__":
    main()
http://halvar.at | Kleiner Bascom AVR Kurs

Wissen hat eine wunderbare Eigenschaft: Es verdoppelt sich, wenn man es teilt.

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder