Lib/getopt.py

   1 # -*- coding: iso-8859-1 -*-
   2 """Parser for command line options.
   3
   4 This module helps scripts to parse the command line arguments in
   5 sys.argv.  It supports the same conventions as the Unix getopt()
   6 function (including the special meanings of arguments of the form `-'
   7 and `--').  Long options similar to those supported by GNU software
   8 may be used as well via an optional third argument.  This module
   9 provides two functions and an exception:
  10
  11 getopt() -- Parse command line options
  12 gnu_getopt() -- Like getopt(), but allow option and non-option arguments
  13 to be intermixed.
  14 GetoptError -- exception (class) raised with 'opt' attribute, which is the
  15 option involved with the exception.
  16 """
  17
  18 # Long option support added by Lars Wirzenius <liw@iki.fi>.
  19 #
  20 # Gerrit Holl <gerrit@nl.linux.org> moved the string-based exceptions
  21 # to class-based exceptions.
  22 #
  23 # Peter Åstrand <astrand@lysator.liu.se> added gnu_getopt().
  24 #
  25 # TODO for gnu_getopt():
  26 #
  27 # - GNU getopt_long_only mechanism
  28 # - allow the caller to specify ordering
  29 # - RETURN_IN_ORDER option
  30 # - GNU extension with '-' as first character of option string
  31 # - optional arguments, specified by double colons
  32 # - a option string with a W followed by semicolon should
  33 #   treat "-W foo" as "--foo"
  34
  35 __all__ = ["GetoptError","error","getopt","gnu_getopt"]
  36
  37 import os
  38
  39 class GetoptError(Exception):
  40     opt = ''
  41     msg = ''
  42     def __init__(self, msg, opt=''):
  43         self.msg = msg
  44         self.opt = opt
  45         Exception.__init__(self, msg, opt)
  46
  47     def __str__(self):
  48         return self.msg
  49
  50 error = GetoptError # backward compatibility
  51
  52 def getopt(args, shortopts, longopts = []):
  53     """getopt(args, options[, long_options]) -> opts, args
  54
  55     Parses command line options and parameter list.  args is the
  56     argument list to be parsed, without the leading reference to the
  57     running program.  Typically, this means "sys.argv[1:]".  shortopts
  58     is the string of option letters that the script wants to
  59     recognize, with options that require an argument followed by a
  60     colon (i.e., the same format that Unix getopt() uses).  If
  61     specified, longopts is a list of strings with the names of the
  62     long options which should be supported.  The leading '--'
  63     characters should not be included in the option name.  Options
  64     which require an argument should be followed by an equal sign
  65     ('=').
  66
  67     The return value consists of two elements: the first is a list of
  68     (option, value) pairs; the second is the list of program arguments
  69     left after the option list was stripped (this is a trailing slice
  70     of the first argument).  Each option-and-value pair returned has
  71     the option as its first element, prefixed with a hyphen (e.g.,
  72     '-x'), and the option argument as its second element, or an empty
  73     string if the option has no argument.  The options occur in the
  74     list in the same order in which they were found, thus allowing
  75     multiple occurrences.  Long and short options may be mixed.
  76
  77     """
  78
  79     opts = []
  80     if type(longopts) == type(""):
  81         longopts = [longopts]
  82     else:
  83         longopts = list(longopts)
  84     while args and args[0].startswith('-') and args[0] != '-':
  85         if args[0] == '--':
  86             args = args[1:]
  87             break
  88         if args[0].startswith('--'):
  89             opts, args = do_longs(opts, args[0][2:], longopts, args[1:])
  90         else:
  91             opts, args = do_shorts(opts, args[0][1:], shortopts, args[1:])
  92
  93     return opts, args
  94
  95 def gnu_getopt(args, shortopts, longopts = []):
  96     """getopt(args, options[, long_options]) -> opts, args
  97
  98     This function works like getopt(), except that GNU style scanning
  99     mode is used by default. This means that option and non-option
 100     arguments may be intermixed. The getopt() function stops
 101     processing options as soon as a non-option argument is
 102     encountered.
 103
 104     If the first character of the option string is `+', or if the
 105     environment variable POSIXLY_CORRECT is set, then option
 106     processing stops as soon as a non-option argument is encountered.
 107
 108     """
 109
 110     opts = []
 111     prog_args = []
 112     if isinstance(longopts, str):
 113         longopts = [longopts]
 114     else:
 115         longopts = list(longopts)
 116
 117     # Allow options after non-option arguments?
 118     if shortopts.startswith('+'):
 119         shortopts = shortopts[1:]
 120         all_options_first = True
 121     elif os.environ.get("POSIXLY_CORRECT"):
 122         all_options_first = True
 123     else:
 124         all_options_first = False
 125
 126     while args:
 127         if args[0] == '--':
 128             prog_args += args[1:]
 129             break
 130
 131         if args[0][:2] == '--':
 132             opts, args = do_longs(opts, args[0][2:], longopts, args[1:])
 133         elif args[0][:1] == '-':
 134             opts, args = do_shorts(opts, args[0][1:], shortopts, args[1:])
 135         else:
 136             if all_options_first:
 137                 prog_args += args
 138                 break
 139             else:
 140                 prog_args.append(args[0])
 141                 args = args[1:]
 142
 143     return opts, prog_args
 144
 145 def do_longs(opts, opt, longopts, args):
 146     try:
 147         i = opt.index('=')
 148     except ValueError:
 149         optarg = None
 150     else:
 151         opt, optarg = opt[:i], opt[i+1:]
 152
 153     has_arg, opt = long_has_args(opt, longopts)
 154     if has_arg:
 155         if optarg is None:
 156             if not args:
 157                 raise GetoptError('option --%s requires argument' % opt, opt)
 158             optarg, args = args[0], args[1:]
 159     elif optarg:
 160         raise GetoptError('option --%s must not have an argument' % opt, opt)
 161     opts.append(('--' + opt, optarg or ''))
 162     return opts, args
 163
 164 # Return:
 165 #   has_arg?
 166 #   full option name
 167 def long_has_args(opt, longopts):
 168     possibilities = [o for o in longopts if o.startswith(opt)]
 169     if not possibilities:
 170         raise GetoptError('option --%s not recognized' % opt, opt)
 171     # Is there an exact match?
 172     if opt in possibilities:
 173         return False, opt
 174     elif opt + '=' in possibilities:
 175         return True, opt
 176     # No exact match, so better be unique.
 177     if len(possibilities) > 1:
 178         # XXX since possibilities contains all valid continuations, might be
 179         # nice to work them into the error msg
 180         raise GetoptError('option --%s not a unique prefix' % opt, opt)
 181     assert len(possibilities) == 1
 182     unique_match = possibilities[0]
 183     has_arg = unique_match.endswith('=')
 184     if has_arg:
 185         unique_match = unique_match[:-1]
 186     return has_arg, unique_match
 187
 188 def do_shorts(opts, optstring, shortopts, args):
 189     while optstring != '':
 190         opt, optstring = optstring[0], optstring[1:]
 191         if short_has_arg(opt, shortopts):
 192             if optstring == '':
 193                 if not args:
 194                     raise GetoptError('option -%s requires argument' % opt,
 195                                       opt)
 196                 optstring, args = args[0], args[1:]
 197             optarg, optstring = optstring, ''
 198         else:
 199             optarg = ''
 200         opts.append(('-' + opt, optarg))
 201     return opts, args
 202
 203 def short_has_arg(opt, shortopts):
 204     for i in range(len(shortopts)):
 205         if opt == shortopts[i] != ':':
 206             return shortopts.startswith(':', i+1)
 207     raise GetoptError('option -%s not recognized' % opt, opt)
 208
 209 if __name__ == '__main__':
 210     import sys
 211     print getopt(sys.argv[1:], "a:b", ["alpha=", "beta"])