from optparse import Option, OptionParser, _match_abbrev

#  Questo parser di opzioni insensibile a maiuscole/minuscole richiede 
#+ che sia disponibile un tipo di dizionario con la stessa caratteristica 
#+ nei confronti di maiuscole/minuscole. Questo è uno per il Python 2.2. 
#+ Notate che un dizionario reale insensibile a maiuscole/minuscole 
#+ richiede anche che siano implementati __new__(), update(), e 
#+ setdefault() -- ma non è questo l'oggetto di questo esercizio.

class caseless_dict (dict):
    def __setitem__ (self, key, value):
        dict.__setitem__(self, key.lower(), value)

    def __getitem__ (self, key):
        return dict.__getitem__(self, key.lower())

    def get (self, key, default=None):
        return dict.get(self, key.lower())

    def has_key (self, key):
        return dict.has_key(self, key.lower())

class CaselessOptionParser (OptionParser):

    def _create_option_list (self):
        self.option_list = []
        self._short_opt = caseless_dict()
        self._long_opt = caseless_dict()
        self._long_opts = []
        self.defaults = {}

    def _match_long_opt (self, opt):
        return _match_abbrev(opt.lower(), self._long_opt.keys())

if __name__ == "__main__":
    from optik.errors import OptionConflictError

    # test 1: nessuna opzione per partire con
    parser = CaselessOptionParser()
    try:
        parser.add_option("-H", dest="blah")
    except OptionConflictError:
        print "ok: ho OptionConflictError per -H"
    else:
        print "non è ok: nessuno conflitto tra  -h e -H"
    
    parser.add_option("-f", "--file", dest="file")
    #print repr(parser.get_option("-f"))
    #print repr(parser.get_option("-F"))
    #print repr(parser.get_option("--file"))
    #print repr(parser.get_option("--fIlE"))
    (options, args) = parser.parse_args(["--FiLe", "foo"])
    assert options.file == "foo", options.file
    print "ok: l'opzione lunga insensibile a maiuscole/minuscole lavora"

    (options, args) = parser.parse_args(["-F", "bar"])
    assert options.file == "bar", options.file
    print "ok: l'opzione lunga insensibile a maiuscole/minuscole lavora"

import optparse

class OptionParser (optparse.OptionParser):

    def check_required (self, opt):
      option = self.get_option(opt)

      # Assume che le opzioni predefinite siano impostate a None!
      if getattr(self.values, option.dest) is None:
          self.error("%s option not supplied" % option)

parser = OptionParser()
parser.add_option("-v", action="count", dest="verbose")
parser.add_option("-f", "--file", default=None)
(options, args) = parser.parse_args()

print "verbose:", options.verbose
print "file:", options.file
parser.check_required("-f")

import optparse

class Option (optparse.Option):
    ATTRS = optparse.Option.ATTRS + ['required']

    def _check_required (self):
        if self.required and not self.takes_value():
            raise OptionError(
                "opzione obbligatoria per azioni che non richiedono un valore",
                 self)

    # Assicuratevi che _check_required() sia chiamato dal costruttore!
    CHECK_METHODS = optparse.Option.CHECK_METHODS + [_check_required]

    def process (self, opt, value, values, parser):
        optparse.Option.process(self, opt, value, values, parser)
        parser.option_seen[self] = 1

class OptionParser (optparse.OptionParser):

    def _init_parsing_state (self):
        optparse.OptionParser._init_parsing_state(self)
        self.option_seen = {}

    def check_values (self, values, args):
        for option in self.option_list:
            if (isinstance(option, Option) and
                option.required and
                not self.option_seen.has_key(option)):
                self.error("%s non implementato" % option)
        return (values, args)

parser = OptionParser(option_list=[
    Option("-v", action="count", dest="verbose"),
    Option("-f", "--file", required=1)])
(options, args) = parser.parse_args()

print "verbose:", options.verbose
print "file:", options.file