273 lines
9.6 KiB
Python
273 lines
9.6 KiB
Python
# pylint: skip-file
|
|
#
|
|
# Copyright 2011 Avery Pennarun and options.py contributors.
|
|
# All rights reserved.
|
|
#
|
|
# (This license applies to this file but not necessarily the other files in
|
|
# this package.)
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions are
|
|
# met:
|
|
#
|
|
# 1. Redistributions of source code must retain the above copyright
|
|
# notice, this list of conditions and the following disclaimer.
|
|
#
|
|
# 2. Redistributions in binary form must reproduce the above copyright
|
|
# notice, this list of conditions and the following disclaimer in
|
|
# the documentation and/or other materials provided with the
|
|
# distribution.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY AVERY PENNARUN ``AS IS'' AND ANY
|
|
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> OR
|
|
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
#
|
|
"""Command-line options parser.
|
|
With the help of an options spec string, easily parse command-line options.
|
|
|
|
An options spec is made up of two parts, separated by a line with two dashes.
|
|
The first part is the synopsis of the command and the second one specifies
|
|
options, one per line.
|
|
|
|
Each non-empty line in the synopsis gives a set of options that can be used
|
|
together.
|
|
|
|
Option flags must be at the begining of the line and multiple flags are
|
|
separated by commas. Usually, options have a short, one character flag, and a
|
|
longer one, but the short one can be omitted.
|
|
|
|
Long option flags are used as the option's key for the OptDict produced when
|
|
parsing options.
|
|
|
|
When the flag definition is ended with an equal sign, the option takes one
|
|
string as an argument. Otherwise, the option does not take an argument and
|
|
corresponds to a boolean flag that is true when the option is given on the
|
|
command line.
|
|
|
|
The option's description is found at the right of its flags definition, after
|
|
one or more spaces. The description ends at the end of the line. If the
|
|
description contains text enclosed in square brackets, the enclosed text will
|
|
be used as the option's default value.
|
|
|
|
Options can be put in different groups. Options in the same group must be on
|
|
consecutive lines. Groups are formed by inserting a line that begins with a
|
|
space. The text on that line will be output after an empty line.
|
|
"""
|
|
import sys, os, textwrap, getopt, re, struct
|
|
|
|
class OptDict:
|
|
"""Dictionary that exposes keys as attributes.
|
|
|
|
Keys can be set or accessed with a "no-" or "no_" prefix to negate the
|
|
value.
|
|
"""
|
|
def __init__(self):
|
|
self._opts = {}
|
|
|
|
def __setitem__(self, k, v):
|
|
if k.startswith('no-') or k.startswith('no_'):
|
|
k = k[3:]
|
|
v = not v
|
|
self._opts[k] = v
|
|
|
|
def __getitem__(self, k):
|
|
if k.startswith('no-') or k.startswith('no_'):
|
|
return not self._opts[k[3:]]
|
|
return self._opts[k]
|
|
|
|
def __getattr__(self, k):
|
|
return self[k]
|
|
|
|
|
|
def _default_onabort(msg):
|
|
sys.exit(97)
|
|
|
|
|
|
def _intify(v):
|
|
try:
|
|
vv = int(v or '')
|
|
if str(vv) == v:
|
|
return vv
|
|
except ValueError:
|
|
pass
|
|
return v
|
|
|
|
|
|
def _atoi(v):
|
|
try:
|
|
return int(v or 0)
|
|
except ValueError:
|
|
return 0
|
|
|
|
|
|
def _remove_negative_kv(k, v):
|
|
if k.startswith('no-') or k.startswith('no_'):
|
|
return k[3:], not v
|
|
return k,v
|
|
|
|
def _remove_negative_k(k):
|
|
return _remove_negative_kv(k, None)[0]
|
|
|
|
|
|
def _tty_width():
|
|
s = struct.pack("HHHH", 0, 0, 0, 0)
|
|
try:
|
|
import fcntl, termios
|
|
s = fcntl.ioctl(sys.stderr.fileno(), termios.TIOCGWINSZ, s)
|
|
except (IOError, ImportError):
|
|
return _atoi(os.environ.get('WIDTH')) or 70
|
|
(ysize,xsize,ypix,xpix) = struct.unpack('HHHH', s)
|
|
return xsize or 70
|
|
|
|
|
|
class Options:
|
|
"""Option parser.
|
|
When constructed, a string called an option spec must be given. It
|
|
specifies the synopsis and option flags and their description. For more
|
|
information about option specs, see the docstring at the top of this file.
|
|
|
|
Two optional arguments specify an alternative parsing function and an
|
|
alternative behaviour on abort (after having output the usage string).
|
|
|
|
By default, the parser function is getopt.gnu_getopt, and the abort
|
|
behaviour is to exit the program.
|
|
"""
|
|
def __init__(self, optspec, optfunc=getopt.gnu_getopt,
|
|
onabort=_default_onabort):
|
|
self.optspec = optspec
|
|
self._onabort = onabort
|
|
self.optfunc = optfunc
|
|
self._aliases = {}
|
|
self._shortopts = 'h?'
|
|
self._longopts = ['help', 'usage']
|
|
self._hasparms = {}
|
|
self._defaults = {}
|
|
self._usagestr = self._gen_usage()
|
|
|
|
def _gen_usage(self):
|
|
out = []
|
|
lines = self.optspec.strip().split('\n')
|
|
lines.reverse()
|
|
first_syn = True
|
|
while lines:
|
|
l = lines.pop()
|
|
if l == '--': break
|
|
out.append('%s: %s\n' % (first_syn and 'usage' or ' or', l))
|
|
first_syn = False
|
|
out.append('\n')
|
|
last_was_option = False
|
|
while lines:
|
|
l = lines.pop()
|
|
if l.startswith(' '):
|
|
out.append('%s%s\n' % (last_was_option and '\n' or '',
|
|
l.lstrip()))
|
|
last_was_option = False
|
|
elif l:
|
|
(flags, extra) = l.split(' ', 1)
|
|
extra = extra.strip()
|
|
if flags.endswith('='):
|
|
flags = flags[:-1]
|
|
has_parm = 1
|
|
else:
|
|
has_parm = 0
|
|
g = re.search(r'\[([^\]]*)\]$', extra)
|
|
if g:
|
|
defval = g.group(1)
|
|
else:
|
|
defval = None
|
|
flagl = flags.split(',')
|
|
flagl_nice = []
|
|
for _f in flagl:
|
|
f,dvi = _remove_negative_kv(_f, _intify(defval))
|
|
self._aliases[f] = _remove_negative_k(flagl[0])
|
|
self._hasparms[f] = has_parm
|
|
self._defaults[f] = dvi
|
|
if f == '#':
|
|
self._shortopts += '0123456789'
|
|
flagl_nice.append('-#')
|
|
elif len(f) == 1:
|
|
self._shortopts += f + (has_parm and ':' or '')
|
|
flagl_nice.append('-' + f)
|
|
else:
|
|
f_nice = re.sub(r'\W', '_', f)
|
|
self._aliases[f_nice] = _remove_negative_k(flagl[0])
|
|
self._longopts.append(f + (has_parm and '=' or ''))
|
|
self._longopts.append('no-' + f)
|
|
flagl_nice.append('--' + _f)
|
|
flags_nice = ', '.join(flagl_nice)
|
|
if has_parm:
|
|
flags_nice += ' ...'
|
|
prefix = ' %-20s ' % flags_nice
|
|
argtext = '\n'.join(textwrap.wrap(extra, width=_tty_width(),
|
|
initial_indent=prefix,
|
|
subsequent_indent=' '*28))
|
|
out.append(argtext + '\n')
|
|
last_was_option = True
|
|
else:
|
|
out.append('\n')
|
|
last_was_option = False
|
|
return ''.join(out).rstrip() + '\n'
|
|
|
|
def usage(self, msg=""):
|
|
"""Print usage string to stderr and abort."""
|
|
sys.stderr.write(self._usagestr)
|
|
if msg:
|
|
sys.stderr.write(msg)
|
|
e = self._onabort and self._onabort(msg) or None
|
|
if e:
|
|
raise e
|
|
|
|
def fatal(self, msg):
|
|
"""Print an error message to stderr and abort with usage string."""
|
|
msg = '\nerror: %s\n' % msg
|
|
return self.usage(msg)
|
|
|
|
def parse(self, args):
|
|
"""Parse a list of arguments and return (options, flags, extra).
|
|
|
|
In the returned tuple, "options" is an OptDict with known options,
|
|
"flags" is a list of option flags that were used on the command-line,
|
|
and "extra" is a list of positional arguments.
|
|
"""
|
|
try:
|
|
(flags,extra) = self.optfunc(args, self._shortopts, self._longopts)
|
|
except getopt.GetoptError as e:
|
|
self.fatal(e)
|
|
|
|
opt = OptDict()
|
|
|
|
for k,v in self._defaults.items():
|
|
k = self._aliases[k]
|
|
opt[k] = v
|
|
|
|
for (k,v) in flags:
|
|
k = k.lstrip('-')
|
|
if k in ('h', '?', 'help', 'usage'):
|
|
self.usage()
|
|
if k.startswith('no-'):
|
|
k = self._aliases[k[3:]]
|
|
v = 0
|
|
elif (self._aliases.get('#') and
|
|
k in ('0','1','2','3','4','5','6','7','8','9')):
|
|
v = int(k) # guaranteed to be exactly one digit
|
|
k = self._aliases['#']
|
|
opt['#'] = v
|
|
else:
|
|
k = self._aliases[k]
|
|
if not self._hasparms[k]:
|
|
assert(v == '')
|
|
v = (opt._opts.get(k) or 0) + 1
|
|
else:
|
|
v = _intify(v)
|
|
opt[k] = v
|
|
for (f1,f2) in self._aliases.items():
|
|
opt[f1] = opt._opts.get(f2)
|
|
return (opt,flags,extra)
|