1 """distutils.fancy_getopt 2 3 Wrapper around the standard getopt module that provides the following 4 additional features: 5 * short and long options are tied together 6 * options have help strings, so fancy_getopt could potentially 7 create a complete usage summary 8 * options set attributes of a passed-in object 9 """ 10 11 __revision__ = "$Id$" 12 13 import sys 14 import string 15 import re 16 import getopt 17 from distutils.errors import DistutilsGetoptError, DistutilsArgError 18 19 # Much like command_re in distutils.core, this is close to but not quite 20 # the same as a Python NAME -- except, in the spirit of most GNU 21 # utilities, we use '-' in place of '_'. (The spirit of LISP lives on!) 22 # The similarities to NAME are again not a coincidence... 23 longopt_pat = r'[a-zA-Z](?:[a-zA-Z0-9-]*)' 24 longopt_re = re.compile(r'^%s$' % longopt_pat) 25 26 # For recognizing "negative alias" options, eg. "quiet=!verbose" 27 neg_alias_re = re.compile("^(%s)=!(%s)$" % (longopt_pat, longopt_pat)) 28 29 # This is used to translate long options to legitimate Python identifiers 30 # (for use as attributes of some object). 31 longopt_xlate = string.maketrans('-', '_') 32 33 class FancyGetopt: 34 """Wrapper around the standard 'getopt()' module that provides some 35 handy extra functionality: 36 * short and long options are tied together 37 * options have help strings, and help text can be assembled 38 from them 39 * options set attributes of a passed-in object 40 * boolean options can have "negative aliases" -- eg. if 41 --quiet is the "negative alias" of --verbose, then "--quiet" 42 on the command line sets 'verbose' to false 43 """ 44 45 def __init__ (self, option_table=None): 46 47 # The option table is (currently) a list of tuples. The 48 # tuples may have 3 or four values: 49 # (long_option, short_option, help_string [, repeatable]) 50 # if an option takes an argument, its long_option should have '=' 51 # appended; short_option should just be a single character, no ':' 52 # in any case. If a long_option doesn't have a corresponding 53 # short_option, short_option should be None. All option tuples 54 # must have long options. 55 self.option_table = option_table 56 57 # 'option_index' maps long option names to entries in the option 58 # table (ie. those 3-tuples). 59 self.option_index = {} 60 if self.option_table: 61 self._build_index() 62 63 # 'alias' records (duh) alias options; {'foo': 'bar'} means 64 # --foo is an alias for --bar 65 self.alias = {} 66 67 # 'negative_alias' keeps track of options that are the boolean 68 # opposite of some other option 69 self.negative_alias = {} 70 71 # These keep track of the information in the option table. We 72 # don't actually populate these structures until we're ready to 73 # parse the command-line, since the 'option_table' passed in here 74 # isn't necessarily the final word. 75 self.short_opts = [] 76 self.long_opts = [] 77 self.short2long = {} 78 self.attr_name = {} 79 self.takes_arg = {} 80 81 # And 'option_order' is filled up in 'getopt()'; it records the 82 # original order of options (and their values) on the command-line, 83 # but expands short options, converts aliases, etc. 84 self.option_order = [] 85 86 # __init__ () 87 88 89 def _build_index (self): 90 self.option_index.clear() 91 for option in self.option_table: 92 self.option_index[option[0]] = option 93 94 def set_option_table (self, option_table): 95 self.option_table = option_table 96 self._build_index() 97 98 def add_option (self, long_option, short_option=None, help_string=None): 99 if long_option in self.option_index: 100 raise DistutilsGetoptError, \ 101 "option conflict: already an option '%s'" % long_option 102 else: 103 option = (long_option, short_option, help_string) 104 self.option_table.append(option) 105 self.option_index[long_option] = option 106 107 108 def has_option (self, long_option): 109 """Return true if the option table for this parser has an 110 option with long name 'long_option'.""" 111 return long_option in self.option_index 112 113 def get_attr_name (self, long_option): 114 """Translate long option name 'long_option' to the form it 115 has as an attribute of some object: ie., translate hyphens 116 to underscores.""" 117 return string.translate(long_option, longopt_xlate) 118 119 120 def _check_alias_dict (self, aliases, what): 121 assert isinstance(aliases, dict) 122 for (alias, opt) in aliases.items(): 123 if alias not in self.option_index: 124 raise DistutilsGetoptError, \ 125 ("invalid %s '%s': " 126 "option '%s' not defined") % (what, alias, alias) 127 if opt not in self.option_index: 128 raise DistutilsGetoptError, \ 129 ("invalid %s '%s': " 130 "aliased option '%s' not defined") % (what, alias, opt) 131 132 def set_aliases (self, alias): 133 """Set the aliases for this option parser.""" 134 self._check_alias_dict(alias, "alias") 135 self.alias = alias 136 137 def set_negative_aliases (self, negative_alias): 138 """Set the negative aliases for this option parser. 139 'negative_alias' should be a dictionary mapping option names to 140 option names, both the key and value must already be defined 141 in the option table.""" 142 self._check_alias_dict(negative_alias, "negative alias") 143 self.negative_alias = negative_alias 144 145 146 def _grok_option_table (self): 147 """Populate the various data structures that keep tabs on the 148 option table. Called by 'getopt()' before it can do anything 149 worthwhile. 150 """ 151 self.long_opts = [] 152 self.short_opts = [] 153 self.short2long.clear() 154 self.repeat = {} 155 156 for option in self.option_table: 157 if len(option) == 3: 158 long, short, help = option 159 repeat = 0 160 elif len(option) == 4: 161 long, short, help, repeat = option 162 else: 163 # the option table is part of the code, so simply 164 # assert that it is correct 165 raise ValueError, "invalid option tuple: %r" % (option,) 166 167 # Type- and value-check the option names 168 if not isinstance(long, str) or len(long) < 2: 169 raise DistutilsGetoptError, \ 170 ("invalid long option '%s': " 171 "must be a string of length >= 2") % long 172 173 if (not ((short is None) or 174 (isinstance(short, str) and len(short) == 1))): 175 raise DistutilsGetoptError, \ 176 ("invalid short option '%s': " 177 "must a single character or None") % short 178 179 self.repeat[long] = repeat 180 self.long_opts.append(long) 181 182 if long[-1] == '=': # option takes an argument? 183 if short: short = short + ':' 184 long = long[0:-1] 185 self.takes_arg[long] = 1 186 else: 187 188 # Is option is a "negative alias" for some other option (eg. 189 # "quiet" == "!verbose")? 190 alias_to = self.negative_alias.get(long) 191 if alias_to is not None: 192 if self.takes_arg[alias_to]: 193 raise DistutilsGetoptError, \ 194 ("invalid negative alias '%s': " 195 "aliased option '%s' takes a value") % \ 196 (long, alias_to) 197 198 self.long_opts[-1] = long # XXX redundant?! 199 self.takes_arg[long] = 0 200 201 else: 202 self.takes_arg[long] = 0 203 204 # If this is an alias option, make sure its "takes arg" flag is 205 # the same as the option it's aliased to. 206 alias_to = self.alias.get(long) 207 if alias_to is not None: 208 if self.takes_arg[long] != self.takes_arg[alias_to]: 209 raise DistutilsGetoptError, \ 210 ("invalid alias '%s': inconsistent with " 211 "aliased option '%s' (one of them takes a value, " 212 "the other doesn't") % (long, alias_to) 213 214 215 # Now enforce some bondage on the long option name, so we can 216 # later translate it to an attribute name on some object. Have 217 # to do this a bit late to make sure we've removed any trailing 218 # '='. 219 if not longopt_re.match(long): 220 raise DistutilsGetoptError, \ 221 ("invalid long option name '%s' " + 222 "(must be letters, numbers, hyphens only") % long 223 224 self.attr_name[long] = self.get_attr_name(long) 225 if short: 226 self.short_opts.append(short) 227 self.short2long[short[0]] = long 228 229 # for option_table 230 231 # _grok_option_table() 232 233 234 def getopt (self, args=None, object=None): 235 """Parse command-line options in args. Store as attributes on object. 236 237 If 'args' is None or not supplied, uses 'sys.argv[1:]'. If 238 'object' is None or not supplied, creates a new OptionDummy 239 object, stores option values there, and returns a tuple (args, 240 object). If 'object' is supplied, it is modified in place and 241 'getopt()' just returns 'args'; in both cases, the returned 242 'args' is a modified copy of the passed-in 'args' list, which 243 is left untouched. 244 """ 245 if args is None: 246 args = sys.argv[1:] 247 if object is None: 248 object = OptionDummy() 249 created_object = 1 250 else: 251 created_object = 0 252 253 self._grok_option_table() 254 255 short_opts = string.join(self.short_opts) 256 try: 257 opts, args = getopt.getopt(args, short_opts, self.long_opts) 258 except getopt.error, msg: 259 raise DistutilsArgError, msg 260 261 for opt, val in opts: 262 if len(opt) == 2 and opt[0] == '-': # it's a short option 263 opt = self.short2long[opt[1]] 264 else: 265 assert len(opt) > 2 and opt[:2] == '--' 266 opt = opt[2:] 267 268 alias = self.alias.get(opt) 269 if alias: 270 opt = alias 271 272 if not self.takes_arg[opt]: # boolean option? 273 assert val == '', "boolean option can't have value" 274 alias = self.negative_alias.get(opt) 275 if alias: 276 opt = alias 277 val = 0 278 else: 279 val = 1 280 281 attr = self.attr_name[opt] 282 # The only repeating option at the moment is 'verbose'. 283 # It has a negative option -q quiet, which should set verbose = 0. 284 if val and self.repeat.get(attr) is not None: 285 val = getattr(object, attr, 0) + 1 286 setattr(object, attr, val) 287 self.option_order.append((opt, val)) 288 289 # for opts 290 if created_object: 291 return args, object 292 else: 293 return args 294 295 # getopt() 296 297 298 def get_option_order (self): 299 """Returns the list of (option, value) tuples processed by the 300 previous run of 'getopt()'. Raises RuntimeError if 301 'getopt()' hasn't been called yet. 302 """ 303 if self.option_order is None: 304 raise RuntimeError, "'getopt()' hasn't been called yet" 305 else: 306 return self.option_order 307 308 309 def generate_help (self, header=None): 310 """Generate help text (a list of strings, one per suggested line of 311 output) from the option table for this FancyGetopt object. 312 """ 313 # Blithely assume the option table is good: probably wouldn't call 314 # 'generate_help()' unless you've already called 'getopt()'. 315 316 # First pass: determine maximum length of long option names 317 max_opt = 0 318 for option in self.option_table: 319 long = option[0] 320 short = option[1] 321 l = len(long) 322 if long[-1] == '=': 323 l = l - 1 324 if short is not None: 325 l = l + 5 # " (-x)" where short == 'x' 326 if l > max_opt: 327 max_opt = l 328 329 opt_width = max_opt + 2 + 2 + 2 # room for indent + dashes + gutter 330 331 # Typical help block looks like this: 332 # --foo controls foonabulation 333 # Help block for longest option looks like this: 334 # --flimflam set the flim-flam level 335 # and with wrapped text: 336 # --flimflam set the flim-flam level (must be between 337 # 0 and 100, except on Tuesdays) 338 # Options with short names will have the short name shown (but 339 # it doesn't contribute to max_opt): 340 # --foo (-f) controls foonabulation 341 # If adding the short option would make the left column too wide, 342 # we push the explanation off to the next line 343 # --flimflam (-l) 344 # set the flim-flam level 345 # Important parameters: 346 # - 2 spaces before option block start lines 347 # - 2 dashes for each long option name 348 # - min. 2 spaces between option and explanation (gutter) 349 # - 5 characters (incl. space) for short option name 350 351 # Now generate lines of help text. (If 80 columns were good enough 352 # for Jesus, then 78 columns are good enough for me!) 353 line_width = 78 354 text_width = line_width - opt_width 355 big_indent = ' ' * opt_width 356 if header: 357 lines = [header] 358 else: 359 lines = ['Option summary:'] 360 361 for option in self.option_table: 362 long, short, help = option[:3] 363 text = wrap_text(help, text_width) 364 if long[-1] == '=': 365 long = long[0:-1] 366 367 # Case 1: no short option at all (makes life easy) 368 if short is None: 369 if text: 370 lines.append(" --%-*s %s" % (max_opt, long, text[0])) 371 else: 372 lines.append(" --%-*s " % (max_opt, long)) 373 374 # Case 2: we have a short option, so we have to include it 375 # just after the long option 376 else: 377 opt_names = "%s (-%s)" % (long, short) 378 if text: 379 lines.append(" --%-*s %s" % 380 (max_opt, opt_names, text[0])) 381 else: 382 lines.append(" --%-*s" % opt_names) 383 384 for l in text[1:]: 385 lines.append(big_indent + l) 386 387 # for self.option_table 388 389 return lines 390 391 # generate_help () 392 393 def print_help (self, header=None, file=None): 394 if file is None: 395 file = sys.stdout 396 for line in self.generate_help(header): 397 file.write(line + "\n") 398 399 # class FancyGetopt 400 401 402 def fancy_getopt (options, negative_opt, object, args): 403 parser = FancyGetopt(options) 404 parser.set_negative_aliases(negative_opt) 405 return parser.getopt(args, object) 406 407 408 WS_TRANS = string.maketrans(string.whitespace, ' ' * len(string.whitespace)) 409 410 def wrap_text (text, width): 411 """wrap_text(text : string, width : int) -> [string] 412 413 Split 'text' into multiple lines of no more than 'width' characters 414 each, and return the list of strings that results. 415 """ 416 417 if text is None: 418 return [] 419 if len(text) <= width: 420 return [text] 421 422 text = string.expandtabs(text) 423 text = string.translate(text, WS_TRANS) 424 chunks = re.split(r'( +|-+)', text) 425 chunks = filter(None, chunks) # ' - ' results in empty strings 426 lines = [] 427 428 while chunks: 429 430 cur_line = [] # list of chunks (to-be-joined) 431 cur_len = 0 # length of current line 432 433 while chunks: 434 l = len(chunks[0]) 435 if cur_len + l <= width: # can squeeze (at least) this chunk in 436 cur_line.append(chunks[0]) 437 del chunks[0] 438 cur_len = cur_len + l 439 else: # this line is full 440 # drop last chunk if all space 441 if cur_line and cur_line[-1][0] == ' ': 442 del cur_line[-1] 443 break 444 445 if chunks: # any chunks left to process? 446 447 # if the current line is still empty, then we had a single 448 # chunk that's too big too fit on a line -- so we break 449 # down and break it up at the line width 450 if cur_len == 0: 451 cur_line.append(chunks[0][0:width]) 452 chunks[0] = chunks[0][width:] 453 454 # all-whitespace chunks at the end of a line can be discarded 455 # (and we know from the re.split above that if a chunk has 456 # *any* whitespace, it is *all* whitespace) 457 if chunks[0][0] == ' ': 458 del chunks[0] 459 460 # and store this line in the list-of-all-lines -- as a single 461 # string, of course! 462 lines.append(string.join(cur_line, '')) 463 464 # while chunks 465 466 return lines 467 468 469 def translate_longopt(opt): 470 """Convert a long option name to a valid Python identifier by 471 changing "-" to "_". 472 """ 473 return string.translate(opt, longopt_xlate) 474 475 476 class OptionDummy: 477 """Dummy class just used as a place to hold command-line option 478 values as instance attributes.""" 479 480 def __init__ (self, options=[]): 481 """Create a new OptionDummy instance. The attributes listed in 482 'options' will be initialized to None.""" 483 for opt in options: 484 setattr(self, opt, None) 485
