mirror of https://github.com/python/cpython
140 lines
4.9 KiB
Python
140 lines
4.9 KiB
Python
"""Parser for command line options.
|
|
|
|
This module helps scripts to parse the command line arguments in
|
|
sys.argv. It supports the same conventions as the Unix getopt()
|
|
function (including the special meanings of arguments of the form `-'
|
|
and `--'). Long options similar to those supported by GNU software
|
|
may be used as well via an optional third argument. This module
|
|
provides a single function and an exception:
|
|
|
|
Gerrit Holl <gerrit@nl.linux.org> moved the string-based exceptions
|
|
to class-based exceptions.
|
|
|
|
getopt() -- Parse command line options
|
|
GetoptError -- exception (class) raised with 'opt' attribute, which is the
|
|
option involved with the exception.
|
|
"""
|
|
|
|
# Long option support added by Lars Wirzenius <liw@iki.fi>.
|
|
|
|
import string
|
|
|
|
class GetoptError(Exception):
|
|
opt = ''
|
|
msg = ''
|
|
def __init__(self, *args):
|
|
self.args = args
|
|
if len(args) == 1:
|
|
self.msg = args[0]
|
|
elif len(args) == 2:
|
|
self.msg = args[0]
|
|
self.opt = args[1]
|
|
|
|
def __str__(self):
|
|
return self.msg
|
|
|
|
error = GetoptError # backward compatibility
|
|
|
|
def getopt(args, shortopts, longopts = []):
|
|
"""getopt(args, options[, long_options]) -> opts, args
|
|
|
|
Parses command line options and parameter list. args is the
|
|
argument list to be parsed, without the leading reference to the
|
|
running program. Typically, this means "sys.argv[1:]". shortopts
|
|
is the string of option letters that the script wants to
|
|
recognize, with options that require an argument followed by a
|
|
colon (i.e., the same format that Unix getopt() uses). If
|
|
specified, longopts is a list of strings with the names of the
|
|
long options which should be supported. The leading '--'
|
|
characters should not be included in the option name. Options
|
|
which require an argument should be followed by an equal sign
|
|
('=').
|
|
|
|
The return value consists of two elements: the first is a list of
|
|
(option, value) pairs; the second is the list of program arguments
|
|
left after the option list was stripped (this is a trailing slice
|
|
of the first argument). Each option-and-value pair returned has
|
|
the option as its first element, prefixed with a hyphen (e.g.,
|
|
'-x'), and the option argument as its second element, or an empty
|
|
string if the option has no argument. The options occur in the
|
|
list in the same order in which they were found, thus allowing
|
|
multiple occurrences. Long and short options may be mixed.
|
|
|
|
"""
|
|
|
|
opts = []
|
|
if type(longopts) == type(""):
|
|
longopts = [longopts]
|
|
else:
|
|
longopts = list(longopts)
|
|
longopts.sort()
|
|
while args and args[0][:1] == '-' and args[0] != '-':
|
|
if args[0] == '--':
|
|
args = args[1:]
|
|
break
|
|
if args[0][:2] == '--':
|
|
opts, args = do_longs(opts, args[0][2:], longopts, args[1:])
|
|
else:
|
|
opts, args = do_shorts(opts, args[0][1:], shortopts, args[1:])
|
|
|
|
return opts, args
|
|
|
|
def do_longs(opts, opt, longopts, args):
|
|
try:
|
|
i = string.index(opt, '=')
|
|
opt, optarg = opt[:i], opt[i+1:]
|
|
except ValueError:
|
|
optarg = None
|
|
|
|
has_arg, opt = long_has_args(opt, longopts)
|
|
if has_arg:
|
|
if optarg is None:
|
|
if not args:
|
|
raise GetoptError('option --%s requires argument' % opt, opt)
|
|
optarg, args = args[0], args[1:]
|
|
elif optarg:
|
|
raise GetoptError('option --%s must not have an argument' % opt, opt)
|
|
opts.append(('--' + opt, optarg or ''))
|
|
return opts, args
|
|
|
|
# Return:
|
|
# has_arg?
|
|
# full option name
|
|
def long_has_args(opt, longopts):
|
|
optlen = len(opt)
|
|
for i in range(len(longopts)):
|
|
x, y = longopts[i][:optlen], longopts[i][optlen:]
|
|
if opt != x:
|
|
continue
|
|
if y != '' and y != '=' and i+1 < len(longopts):
|
|
if opt == longopts[i+1][:optlen]:
|
|
raise GetoptError('option --%s not a unique prefix' % opt, opt)
|
|
if longopts[i][-1:] in ('=', ):
|
|
return 1, longopts[i][:-1]
|
|
return 0, longopts[i]
|
|
raise GetoptError('option --%s not recognized' % opt, opt)
|
|
|
|
def do_shorts(opts, optstring, shortopts, args):
|
|
while optstring != '':
|
|
opt, optstring = optstring[0], optstring[1:]
|
|
if short_has_arg(opt, shortopts):
|
|
if optstring == '':
|
|
if not args:
|
|
raise GetoptError('option -%s requires argument' % opt, opt)
|
|
optstring, args = args[0], args[1:]
|
|
optarg, optstring = optstring, ''
|
|
else:
|
|
optarg = ''
|
|
opts.append(('-' + opt, optarg))
|
|
return opts, args
|
|
|
|
def short_has_arg(opt, shortopts):
|
|
for i in range(len(shortopts)):
|
|
if opt == shortopts[i] != ':':
|
|
return shortopts[i+1:i+2] == ':'
|
|
raise GetoptError('option -%s not recognized' % opt, opt)
|
|
|
|
if __name__ == '__main__':
|
|
import sys
|
|
print getopt(sys.argv[1:], "a:b", ["alpha=", "beta"])
|