mirror of
https://github.com/python/cpython.git
synced 2024-11-27 15:27:06 +01:00
ef172521a9
As reported in #117847 and #115366, an unpaired backtick in a docstring
tends to confuse e.g. Sphinx running on subclasses of standard library
objects, and the typographic style of using a backtick as an opening
quote is no longer in favor. Convert almost all uses of the form
The variable `foo' should do xyz
to
The variable 'foo' should do xyz
and also fix up miscellaneous other unpaired backticks (extraneous /
missing characters).
No functional change is intended here other than in human-readable
docstrings.
216 lines
7.3 KiB
Python
216 lines
7.3 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 two functions and an exception:
|
|
|
|
getopt() -- Parse command line options
|
|
gnu_getopt() -- Like getopt(), but allow option and non-option arguments
|
|
to be intermixed.
|
|
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>.
|
|
#
|
|
# Gerrit Holl <gerrit@nl.linux.org> moved the string-based exceptions
|
|
# to class-based exceptions.
|
|
#
|
|
# Peter Åstrand <astrand@lysator.liu.se> added gnu_getopt().
|
|
#
|
|
# TODO for gnu_getopt():
|
|
#
|
|
# - GNU getopt_long_only mechanism
|
|
# - allow the caller to specify ordering
|
|
# - RETURN_IN_ORDER option
|
|
# - GNU extension with '-' as first character of option string
|
|
# - optional arguments, specified by double colons
|
|
# - an option string with a W followed by semicolon should
|
|
# treat "-W foo" as "--foo"
|
|
|
|
__all__ = ["GetoptError","error","getopt","gnu_getopt"]
|
|
|
|
import os
|
|
try:
|
|
from gettext import gettext as _
|
|
except ImportError:
|
|
# Bootstrapping Python: gettext's dependencies not built yet
|
|
def _(s): return s
|
|
|
|
class GetoptError(Exception):
|
|
opt = ''
|
|
msg = ''
|
|
def __init__(self, msg, opt=''):
|
|
self.msg = msg
|
|
self.opt = opt
|
|
Exception.__init__(self, msg, opt)
|
|
|
|
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 isinstance(longopts, str):
|
|
longopts = [longopts]
|
|
else:
|
|
longopts = list(longopts)
|
|
while args and args[0].startswith('-') and args[0] != '-':
|
|
if args[0] == '--':
|
|
args = args[1:]
|
|
break
|
|
if args[0].startswith('--'):
|
|
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 gnu_getopt(args, shortopts, longopts = []):
|
|
"""getopt(args, options[, long_options]) -> opts, args
|
|
|
|
This function works like getopt(), except that GNU style scanning
|
|
mode is used by default. This means that option and non-option
|
|
arguments may be intermixed. The getopt() function stops
|
|
processing options as soon as a non-option argument is
|
|
encountered.
|
|
|
|
If the first character of the option string is '+', or if the
|
|
environment variable POSIXLY_CORRECT is set, then option
|
|
processing stops as soon as a non-option argument is encountered.
|
|
|
|
"""
|
|
|
|
opts = []
|
|
prog_args = []
|
|
if isinstance(longopts, str):
|
|
longopts = [longopts]
|
|
else:
|
|
longopts = list(longopts)
|
|
|
|
# Allow options after non-option arguments?
|
|
if shortopts.startswith('+'):
|
|
shortopts = shortopts[1:]
|
|
all_options_first = True
|
|
elif os.environ.get("POSIXLY_CORRECT"):
|
|
all_options_first = True
|
|
else:
|
|
all_options_first = False
|
|
|
|
while args:
|
|
if args[0] == '--':
|
|
prog_args += args[1:]
|
|
break
|
|
|
|
if args[0][:2] == '--':
|
|
opts, args = do_longs(opts, args[0][2:], longopts, args[1:])
|
|
elif args[0][:1] == '-' and args[0] != '-':
|
|
opts, args = do_shorts(opts, args[0][1:], shortopts, args[1:])
|
|
else:
|
|
if all_options_first:
|
|
prog_args += args
|
|
break
|
|
else:
|
|
prog_args.append(args[0])
|
|
args = args[1:]
|
|
|
|
return opts, prog_args
|
|
|
|
def do_longs(opts, opt, longopts, args):
|
|
try:
|
|
i = opt.index('=')
|
|
except ValueError:
|
|
optarg = None
|
|
else:
|
|
opt, optarg = opt[:i], opt[i+1:]
|
|
|
|
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 is not None:
|
|
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):
|
|
possibilities = [o for o in longopts if o.startswith(opt)]
|
|
if not possibilities:
|
|
raise GetoptError(_('option --%s not recognized') % opt, opt)
|
|
# Is there an exact match?
|
|
if opt in possibilities:
|
|
return False, opt
|
|
elif opt + '=' in possibilities:
|
|
return True, opt
|
|
# No exact match, so better be unique.
|
|
if len(possibilities) > 1:
|
|
# XXX since possibilities contains all valid continuations, might be
|
|
# nice to work them into the error msg
|
|
raise GetoptError(_('option --%s not a unique prefix') % opt, opt)
|
|
assert len(possibilities) == 1
|
|
unique_match = possibilities[0]
|
|
has_arg = unique_match.endswith('=')
|
|
if has_arg:
|
|
unique_match = unique_match[:-1]
|
|
return has_arg, unique_match
|
|
|
|
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.startswith(':', i+1)
|
|
raise GetoptError(_('option -%s not recognized') % opt, opt)
|
|
|
|
if __name__ == '__main__':
|
|
import sys
|
|
print(getopt(sys.argv[1:], "a:b", ["alpha=", "beta"]))
|