class Option():

def __init__(self, *opts, **attrs):

    # Set _short_opts, _long_opts attrs from 'opts' tuple.

    # Have to be set now, in case no option strings are supplied.

    self._short_opts = []

    self._long_opts = []

    opts = self._check_opt_strings(opts)

    self._set_opt_strings(opts)

    # Set all other attrs (action, type, etc.) from 'attrs' dict

    self._set_attrs(attrs)

    # Check all the attributes we just set.  There are lots of

    # complicated interdependencies, but luckily they can be farmed

    # out to the _check_*() methods listed in CHECK_METHODS -- which

    # could be handy for subclasses!  The one thing these all share

    # is that they raise OptionError if they discover a problem.

    for checker in self.CHECK_METHODS:

        checker(self)

def check_value(self, opt, value):

    checker = self.TYPE_CHECKER.get(self.type)

    if checker is None:

        return value

    else:

        return checker(self, opt, value)

def convert_value(self, opt, value):

    if value is not None:

        if self.nargs == 1:

            return self.check_value(opt, value)

        else:

            return tuple([self.check_value(opt, v) for v in value])

def get_opt_string(self):

    if self._long_opts:

        return self._long_opts[0]

    else:

        return self._short_opts[0]

def process(self, opt, value, values, parser):

    # First, convert the value(s) to the right type.  Howl if any

    # value(s) are bogus.

    value = self.convert_value(opt, value)

    # And then take whatever action is expected of us.

    # This is a separate method to make life easier for

    # subclasses to add new actions.

    return self.take_action(

        self.action, self.dest, opt, value, values, parser)

def take_action(self, action, dest, opt, value, values, parser):

    if action == "store":

        setattr(values, dest, value)

    elif action == "store_const":

        setattr(values, dest, self.const)

    elif action == "store_true":

        setattr(values, dest, True)

    elif action == "store_false":

        setattr(values, dest, False)

    elif action == "append":

        values.ensure_value(dest, []).append(value)

    elif action == "count":

        setattr(values, dest, values.ensure_value(dest, 0) + 1)

    elif action == "callback":

        args = self.callback_args or ()

        kwargs = self.callback_kwargs or {}

        self.callback(self, opt, value, parser, *args, **kwargs)

    elif action == "help":

        parser.print_help()

        parser.exit()

    elif action == "version":

        parser.print_version()

        parser.exit()

    else:

        raise RuntimeError, "unknown action %r" % self.action

    return 1

def takes_value(self):

    return self.type is not None

def _repr(self):

    return "<%s at 0x%x: %s>" % (self.__class__.__name__, id(self), self)

def __str__(self):

    return "/".join(self._short_opts + self._long_opts)