option = self._short_opt.get(opt)            i += 1                      # we have consumed a character             if not option:                raise BadOptionError(opt)            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      # -- Feedback methods ----------------------------------------------     def get_prog_name(self):        if self.prog is None:            return os.path.basename(sys.argv[0])        else:            return self.prog     def expand_prog_name(self, s):        return s.replace("%prog", self.get_prog_name())     def get_description(self):        return self.expand_prog_name(self.description)     def exit(self, status=0, msg=None):        if msg:            sys.stderr.write(msg)        sys.exit(status)     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 get_usage(self):        if self.usage:            return self.formatter.format_usage(                self.expand_prog_name(self.usage))        else:            return ""     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 get_version(self):        if self.version:            return self.expand_prog_name(self.version)        else:            return ""     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 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 format_epilog(self, formatter):        return formatter.format_epilog(self.epilog)     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))        result.append(self.format_epilog(formatter))        return "".join(result)     # used by test suite    def _get_encoding(self, file):        encoding = getattr(file, "encoding", None)        if not encoding:            encoding = sys.getdefaultencoding()        return encoding     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        encoding = self._get_encoding(file)        file.write(self.format_help().encode(encoding, "replace")) # class OptionParser  def _match_abbrev(s, wordmap):    """_match_abbrev(s : string, wordmap : {string : Option}) -> string     Return the string key in 'wordmap' for which 's' is an unambiguous    abbreviation.  If 's' is found to be ambiguous or doesn't match any of    'words', raise BadOptionError.    """    # Is there an exact match?    if wordmap.has_key(s):        return s    else:        # Isolate all words with s as a prefix.        possibilities = [word for word in wordmap.keys()                         if word.startswith(s)]        # No exact match, so there had better be just one possibility.        if len(possibilities) == 1:            return possibilities[0]        elif not possibilities:            raise BadOptionError(s)        else:            # More than one possible completion: ambiguous prefix.            possibilities.sort()            raise AmbiguousOptionError(s, possibilities)  # Some day, there might be many Option classes.  As of Optik 1.3, the# preferred way to instantiate Options is indirectly, via make_option(),# which will become a factory function when there are many Option# classes.make_option = Option

Lines 1501–1682 of 1682. Previous lines