class OptionParser(compat.optparse.OptionContainer):

def __init__(self,

             usage=None,

             option_list=None,

             option_class=Option,

             version=None,

             conflict_handler="error",

             description=None,

             formatter=None,

             add_help_option=True,

             prog=None):

    OptionContainer.__init__(

        self, option_class, conflict_handler, description)

    self.set_usage(usage)

    self.prog = prog

    self.version = version

    self.allow_interspersed_args = True

    self.process_default_values = True

    if formatter is None:

        formatter = IndentedHelpFormatter()

    self.formatter = formatter

    self.formatter.set_parser(self)

    # Populate the option list; initial sources are the

    # standard_option_list class attribute, the 'option_list'

    # argument, and (if applicable) the _add_version_option() and

    # _add_help_option() methods.

    self._populate_option_list(option_list,

                               add_help=add_help_option)

    self._init_parsing_state()

def add_option(self, *args, **kwargs):

    """add_option(Option)

           add_option(opt_str, ..., kwarg=val, ...)

        """

    if type(args[0]) is types.StringType:

        option = self.option_class(*args, **kwargs)

    elif len(args) == 1 and not kwargs:

        option = args[0]

        if not isinstance(option, Option):

            raise TypeError, "not an Option instance: %r" % option

    else:

        raise TypeError, "invalid arguments"

    self._check_conflict(option)

    self.option_list.append(option)

    option.container = self

    for opt in option._short_opts:

        self._short_opt[opt] = option

    for opt in option._long_opts:

        self._long_opt[opt] = option

    if option.dest is not None:     # option has a dest, we need a default

        if option.default is not NO_DEFAULT:

            self.defaults[option.dest] = option.default

        elif not self.defaults.has_key(option.dest):

            self.defaults[option.dest] = None

    return option

def add_option_group(self, *args, **kwargs):

    # XXX lots of overlap with OptionContainer.add_option()

    if type(args[0]) is types.StringType:

        group = OptionGroup(self, *args, **kwargs)

    elif len(args) == 1 and not kwargs:

        group = args[0]

        if not isinstance(group, OptionGroup):

            raise TypeError, "not an OptionGroup instance: %r" % group

        if group.parser is not self:

            raise ValueError, "invalid OptionGroup (wrong parser)"

    else:

        raise TypeError, "invalid arguments"

    self.option_groups.append(group)

    return group

def add_options(self, option_list):

    for option in option_list:

        self.add_option(option)

def check_values(self, values, args):

    """

        check_values(values : Values, args : [string])

        -> (values : Values, args : [string])

        Check that the supplied option values and leftover arguments are

        valid.  Returns the option values and leftover arguments

        (possibly adjusted, possibly completely new -- whatever you

        like).  Default implementation just returns the passed-in

        values; subclasses may override as desired.

        """

    return (values, args)

def disable_interspersed_args(self):

    self.allow_interspersed_args = False

def enable_interspersed_args(self):

    self.allow_interspersed_args = True

def error(self, msg):

    """error(msg : string)

        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.

        """

    self.print_usage(sys.stderr)

    self.exit(2, "%s: error: %s\n" % (self.get_prog_name(), msg))

def exit(self, status=0, msg=None):

    if msg:

        sys.stderr.write(msg)

    sys.exit(status)

def expand_prog_name(self, s):

    return s.replace("%prog", self.get_prog_name())

def format_description(self, formatter):

    return formatter.format_description(self.get_description())

def format_help(self, formatter=None):

    if formatter is None:

        formatter = self.formatter

    result = []

    if self.usage:

        result.append(self.get_usage() + "\n")

    if self.description:

        result.append(self.format_description(formatter) + "\n")

    result.append(self.format_option_help(formatter))

    return "".join(result)

def format_option_help(self, formatter=None):

    if formatter is None:

        formatter = self.formatter

    formatter.store_option_strings(self)

    result = []

    result.append(formatter.format_heading(_("options")))

    formatter.indent()

    if self.option_list:

        result.append(OptionContainer.format_option_help(self, formatter))

        result.append("\n")

    for group in self.option_groups:

        result.append(group.format_help(formatter))

        result.append("\n")

    formatter.dedent()

    # Drop the last "\n", or the header if no options or option groups:

    return "".join(result[:-1])

def get_default_values(self):

    if not self.process_default_values:

        # Old, pre-Optik 1.5 behaviour.

        return Values(self.defaults)

    defaults = self.defaults.copy()

    for option in self._get_all_options():

        default = defaults.get(option.dest)

        if isinstance(default, basestring):

            opt_str = option.get_opt_string()

            defaults[option.dest] = option.check_value(opt_str, default)

    return Values(defaults)

def get_description(self):

    return self.expand_prog_name(self.description)

def get_option(self, opt_str):

    return (self._short_opt.get(opt_str) or

            self._long_opt.get(opt_str))

def get_option_group(self, opt_str):

    option = (self._short_opt.get(opt_str) or

              self._long_opt.get(opt_str))

    if option and option.container is not self:

        return option.container

    return None

def get_prog_name(self):

    if self.prog is None:

        return os.path.basename(sys.argv[0])

    else:

        return self.prog

def get_usage(self):

    if self.usage:

        return self.formatter.format_usage(

            self.expand_prog_name(self.usage))

    else:

        return ""

def get_version(self):

    if self.version:

        return self.expand_prog_name(self.version)

    else:

        return ""

def has_option(self, opt_str):

    return (self._short_opt.has_key(opt_str) or

            self._long_opt.has_key(opt_str))

def parse_args(self, args=None, values=None):

    """

        parse_args(args : [string] = sys.argv[1:],

                   values : Values = None)

        -> (values : Values, args : [string])

        Parse the command-line options found in 'args' (default:

        sys.argv[1:]).  Any errors result in a call to 'error()', which

        by default prints the usage message to stderr and calls

        sys.exit() with an error message.  On success returns a pair

        (values, args) where 'values' is an Values instance (with all

        your option values) and 'args' is the list of arguments left

        over after parsing options.

        """

    rargs = self._get_args(args)

    if values is None:

        values = self.get_default_values()

    # Store the halves of the argument list as attributes for the

    # convenience of callbacks:

    #   rargs

    #     the rest of the command-line (the "r" stands for

    #     "remaining" or "right-hand")

    #   largs

    #     the leftover arguments -- ie. what's left after removing

    #     options and their arguments (the "l" stands for "leftover"

    #     or "left-hand")

    self.rargs = rargs

    self.largs = largs = []

    self.values = values

    try:

        stop = self._process_args(largs, rargs, values)

    except (BadOptionError, OptionValueError), err:

        self.error(err.msg)

    args = largs + rargs

    return self.check_values(values, args)

def print_help(self, file=None):

    """print_help(file : file = stdout)

        Print an extended help message, listing all options and any

        help text provided with them, to 'file' (default stdout).

        """

    if file is None:

        file = sys.stdout

    file.write(self.format_help())

def print_usage(self, file=None):

    """print_usage(file : file = stdout)

        Print the usage message for the current program (self.usage) to

        'file' (default stdout).  Any occurence of the string "%prog" in

        self.usage is replaced with the name of the current program

        (basename of sys.argv[0]).  Does nothing if self.usage is empty

        or not defined.

        """

    if self.usage:

        print >>file, self.get_usage()

def print_version(self, file=None):

    """print_version(file : file = stdout)

        Print the version message for this program (self.version) to

        'file' (default stdout).  As with print_usage(), any occurence

        of "%prog" in self.version is replaced by the current program's

        name.  Does nothing if self.version is empty or undefined.

        """

    if self.version:

        print >>file, self.get_version()

def remove_option(self, opt_str):

    option = self._short_opt.get(opt_str)

    if option is None:

        option = self._long_opt.get(opt_str)

    if option is None:

        raise ValueError("no such option %r" % opt_str)

    for opt in option._short_opts:

        del self._short_opt[opt]

    for opt in option._long_opts:

        del self._long_opt[opt]

    option.container.option_list.remove(option)

def set_conflict_handler(self, handler):

    if handler not in ("error", "resolve"):

        raise ValueError, "invalid conflict_resolution value %r" % handler

    self.conflict_handler = handler

def set_default(self, dest, value):

    self.defaults[dest] = value

def set_defaults(self, **kwargs):

    self.defaults.update(kwargs)

def set_description(self, description):

    self.description = description

def set_process_default_values(self, process):

    self.process_default_values = process

def set_usage(self, usage):

    if usage is None:

        self.usage = _("%prog [options]")

    elif usage is SUPPRESS_USAGE:

        self.usage = None

    # For backwards compatibility with Optik 1.3 and earlier.

    elif usage.startswith("usage:" + " "):

        self.usage = usage[7:]

    else:

        self.usage = usage