Current Path :
/
usr
/
lib64
/
python2.7
/
site-packages
/
mx
/
Misc
/
Or
Select Your Path :
Upload File :
New :
File
Dir
//usr/lib64/python2.7/site-packages/mx/Misc/CommandLine.py
""" CommandLine - Get and parse command line options NOTE: This still is very much work in progress !!! Different version are likely to be incompatible. TODO: * Incorporate the changes made by (see Inbox) * Add number range option using srange() """ __copyright__ = """\ Copyright (c), 1997-2000, IKDS Marc-Andre Lemburg (mal@lemburg.com) Copyright (c), 2000-2009, eGenix.com Software GmbH (info@egenix.com) See the documentation for further information on copyrights, or contact the author. All Rights Reserved. """ __version__ = '1.3' import sys, getopt, glob, os, re, exceptions, traceback # For Python < 2.2 compatibility: try: True except NameError: True = 1 False = 0 ### Helpers def _getopt_flags(options): """ Convert the option list to a getopt flag string and long opt list """ s = [] l = [] for o in options: if o.prefix == '-': # short option s.append(o.name) if o.takes_argument: s.append(':') else: # long option if o.takes_argument: l.append(o.name+'=') else: l.append(o.name) return ''.join(s),l def invisible_input(prompt='>>> '): """ Get raw input from a terminal without echoing the characters to the terminal, e.g. for password queries. """ import getpass entry = getpass.getpass(prompt) if entry is None: raise KeyboardInterrupt return entry def fileopen(name, mode='wb', encoding=None): """ Open a file using mode. Default mode is 'wb' meaning to open the file for writing in binary mode. If encoding is given, I/O to and from the file is transparently encoded using the given encoding. Files opened for writing are chmod()ed to 0600. """ if name == 'stdout': return sys.stdout elif name == 'stderr': return sys.stderr elif name == 'stdin': return sys.stdin else: if encoding is not None: import codecs f = codecs.open(name, mode, encoding) else: f = open(name, mode) if 'w' in mode: os.chmod(name, 0600) return f def option_dict(options): """ Return a dictionary mapping option names to Option instances. """ d = {} for option in options: d[option.name] = option return d def parse_optionstring(optionstring): """ Split the optionstring into a tuple (prefix, name). """ if not optionstring[:1] == '-': raise TypeError,'option strings must start with "-"' if optionstring[:2] == '--': prefix = '--' name = optionstring[2:] else: prefix = '-' name = optionstring[1:] return prefix, name # Alias getpasswd = invisible_input _integerRE = re.compile('\s*(-?\d+)\s*$') _integerRangeRE = re.compile('\s*(-?\d+)\s*-\s*(-?\d+)\s*$') def srange(s, integer=_integerRE, integerRange=_integerRangeRE): """ Converts a textual representation of integer numbers and ranges to a Python list. Supported formats: 2,3,4,2-10,-1 - -3, 5 - -2 Values are appended to the created list in the order specified in the string. """ l = [] append = l.append for entry in s.split(','): m = integer.match(entry) if m: append(int(m.groups()[0])) continue m = integerRange.match(entry) if m: start,end = map(int,m.groups()) l[len(l):] = range(start,end+1) return l def abspath(path, expandvars=os.path.expandvars,expanduser=os.path.expanduser, join=os.path.join,getcwd=os.getcwd): """ Return the corresponding absolute path for path. path is expanded in the usual shell ways before joining it with the current working directory. """ try: path = expandvars(path) except AttributeError: pass try: path = expanduser(path) except AttributeError: pass return join(getcwd(), path) ### Option classes class Option: """ Option base class. Takes no argument. """ default = None helptext = '' prefix = '-' takes_argument = 0 has_default = 0 tab = 15 def __init__(self, optionstring, help=None): self.prefix, self.name = parse_optionstring(optionstring) if help: self.help = help def __str__(self): o = self name = o.prefix + o.name if o.takes_argument: name = name + ' arg' if len(name) > self.tab: name = name + '\n' + ' ' * (self.tab + 1 + len(o.prefix)) else: name = '%-*s ' % (self.tab, name) description = o.help if o.has_default: description = description + ' (%s)' % o.default return '%s %s' % (name, description) def get_optionstring(self): return self.prefix + self.name class ArgumentOption(Option): """ Option that takes an argument. An optional default argument can be given. """ def __init__(self,name,help=None,default=None): # Basemethod Option.__init__(self,name,help) if default is not None: self.default = default self.has_default = 1 self.takes_argument = 1 class SwitchOption(Option): """ Options that can be on or off. Has an optional default value. """ def __init__(self,name,help=None,default=None): # Basemethod Option.__init__(self,name,help) if default is not None: self.default = default self.has_default = 1 ### Application baseclass class Application: """ Command line application interface with builtin argument parsing. """ # Options the program accepts (Option instances) options = [] # Standard settings; these are appended to options in __init__ preset_options = [SwitchOption('-v', 'generate verbose output'), SwitchOption('--verbose', 'generate verbose output'), SwitchOption('-h', 'show this help text'), SwitchOption('--help', 'show this help text'), SwitchOption('--yes', 'answer yes to all confirmations'), SwitchOption('--debug', 'enable debugging'), SwitchOption('--copyright', 'show copyright'), SwitchOption('--examples', 'show examples of usage')] # The help layout looks like this: # [header] - defaults to '' # # [synopsis] - formatted as '<self.name> %s' % self.synopsis # # options: # [options] - formatted from self.options # # [version] - formatted as 'Version:\n %s' % self.version, if given # # [about] - defaults to '' # # Note: all fields that do not behave as template are formatted # using the instances dictionary as substitution namespace, # e.g. %(name)s will be replaced by the applications name. # # Header (default to program name) header = '' # Name (defaults to program name) name = '' # Synopsis (%(name)s is replaced by the program name) synopsis = '%(name)s [option] files...' # Version (optional) version = '' # General information printed after the possible options (optional) about = '' # Examples of usage to show when the --examples option is given (optional) examples = '' # Copyright to show copyright = __copyright__ # Apply file globbing ? globbing = 1 # Generate debug output ? debug = 0 # Generate verbose output ? verbose = 0 # Internal errors to catch InternalError = exceptions.Exception # Text to display if the user has not provided an entry value for # a required field missing_entry_text = 'missing entry' # Text to display if the user has entered an unsupported value wrong_entry_text = 'please only use the shown values' # Answer yes to all questions ? answer_yes = False # Instance variables: values = None # Dictionary of passed options (or default values) # indexed by the options name, e.g. '-h' files = None # List of passed filenames optionlist = None # List of passed options optionmap = None # Dictionary mapping option name to Option instance def __init__(self,argv=None): # Setup application specs if argv is None: argv = sys.argv self.filename = os.path.split(argv[0])[1] if not self.name: self.name = os.path.split(self.filename)[1] else: self.name = self.name if not self.header: self.header = self.name else: self.header = self.header # Init .arguments list self.arguments = argv[1:] # Setup Option mapping self.optionmap = option_dict(self.options) # Append preset options for option in self.preset_options: if not self.optionmap.has_key(option.name): self.add_option(option) # Init .files list self.files = [] # Start Application try: try: # Process startup rc = self.startup() if rc is not None: raise SystemExit,rc # Parse command line rc = self.parse() if rc is not None: raise SystemExit,rc # Start application rc = self.main() if rc is None: rc = 0 except SystemExit,rc: pass except KeyboardInterrupt: print print '* User Break' print rc = 1 except self.InternalError: print print '* Internal Error:' if self.verbose or self.debug: print traceback.print_exc(20, sys.stdout) else: print print ' %s: %s' % sys.exc_info()[:2] print print ' (use --debug to see the traceback)' print rc = 1 finally: new_rc = self.finished(rc) if new_rc is not None: rc = new_rc raise SystemExit,rc def add_option(self, option): """ Add a new Option instance to the Application dynamically. Note that this has to be done *before* .parse() is being executed. """ self.options.append(option) self.optionmap[option.name] = option def startup(self): """ Set user defined instance variables. If this method returns anything other than None, the process is terminated with the return value as exit code. """ return None def finished(self, rc): """ The program has finished with exit code rc. This method is always called at the end of script execution. An exit code of 0 means: no problems. All other exit codes refer to error situations. If this method returns anything other than None, the process is terminated with the return value as exit code (replacing the original exit code). """ return None def exit(self, rc=0): """ Exit the program. rc is used as exit code and passed back to the calling program. It defaults to 0 which usually means: OK. """ raise SystemExit, rc def parse(self): """ Parse the command line and fill in self.values and self.files. After having parsed the options, the remaining command line arguments are interpreted as files and passed to .handle_files() for processing. As final step the option handlers are called in the order of the options given on the command line. """ # Parse arguments self.values = values = {} for o in self.options: if o.has_default: values[o.prefix+o.name] = o.default else: values[o.prefix+o.name] = 0 flags,lflags = _getopt_flags(self.options) try: optlist,files = getopt.getopt(self.arguments,flags,lflags) if self.globbing: l = [] for f in files: gf = glob.glob(f) if not gf: l.append(f) else: l[len(l):] = gf files = l self.optionlist = optlist self.files = files + self.files except getopt.error,why: self.help(why) sys.exit(1) # Call file handler rc = self.handle_files(self.files) if rc is not None: sys.exit(rc) # Call option handlers for optionstring, value in optlist: # Get Option instance optionprefix, optionname = parse_optionstring(optionstring) option = self.optionmap[optionname] # Try to convert value to integer try: value = int(value) except ValueError: pass # Find handler and call it (or count the number of option # instances on the command line) handlername = 'handle' + optionstring.replace('-', '_') try: handler = getattr(self, handlername) except AttributeError: if value == '': # count the number of occurances if values.has_key(optionstring): values[optionstring] = values[optionstring] + 1 else: values[optionstring] = 1 else: values[optionstring] = value if self.debug: print ('no option handler found for %r, ' 'recorded value %r' % (optionstring, values[optionstring])) else: if option.takes_argument: if self.debug: print ('calling option handler %s(%r)' % (handlername, value)) rc = handler(value) else: if self.debug: print ('calling option handler %s()' % (handlername,)) rc = handler() if rc is not None: raise SystemExit, rc # Apply final file check (for backward compatibility) rc = self.check_files(self.files) if rc is not None: sys.exit(rc) def check_files(self, filelist): """ Apply some user defined checks on the files given in filelist. This may modify filelist in place. A typical application is checking that at least n files are given. If this method returns anything other than None, the process is terminated with the return value as exit code. """ return None def help(self, note=''): self.print_header() if self.synopsis: print 'Synopsis:' # To remain backward compatible: try: synopsis = self.synopsis % self.name except (NameError, KeyError, TypeError): synopsis = self.synopsis % self.__dict__ print ' ' + synopsis print self.print_options() if self.version: print 'Version:' print ' %s' % self.version print if self.about: print (self.about % self.__dict__).strip() print if note: print '-'*72 print 'Note:',note print def notice(self, note): print '-'*72 print 'Note:',note print '-'*72 print def print_header(self): print '-'*72 print self.header % self.__dict__ print '-'*72 print def print_options(self): options = self.options print 'Options and default settings:' if not options: print ' None' return long = filter(lambda x: x.prefix == '--', options) short = filter(lambda x: x.prefix == '-', options) items = short + long for o in options: print ' ',o print def ask(self, prompt, default=None, hidden=False): """ Ask the user for a string data entry. prompt is shown to the user. If default is given as string, the user can accept the default value by hitting return. The default value is displayed to the user after the prompt string. If no default is given, a value must be entered by the user. If he doesn't enter a value, the prompt is redisplayed. If hidden is true (default is false), the data entry is not displayed on the terminal. This is useful for password entries. """ while True: # Show prompt and default value (if any) if default: print '%s [%s]' % (prompt, default), else: print '%s' % prompt, # Get entry if hidden: entry = invisible_input(' ') else: entry = raw_input() # Check entry if entry: break else: if default is None: print '%s ... %s' % (prompt, self.missing_entry_text) continue else: entry = default break return entry def confirm(self, prompt, default=False, answers=('no', 'yes')): """ Get user confirmation. The prompt is shown to the user and he is asked to enter one of the possible answers. Returns a boolean with the answer. True means: the user accepted, False: the user did not confirm. default defines the default value to use in case the user does not provide an answer and just hits enter. answers defines the answers to accept. It must be given as tuple (no_value, yes_value). Defaults to ('no', 'yes'). Case does not matter when entering the answer. """ if self.answer_yes: return True default_answer = answers[default] lower_cased_answers = [answer.lower() for answer in answers] while True: entry = self.ask(prompt + ' (%s/%s)' % answers, default_answer) entry = entry.strip().lower() if entry not in lower_cased_answers: print '%s ... %s' % (prompt, self.wrong_entry_text) continue return entry == lower_cased_answers[True] # # Example handlers: # # If a handler returns anything other than None, processing stops # and the return value is passed to sys.exit() as argument. # # File handler def handle_files(self, files): """ This may process the files list in place. """ return None # Short option handler def handle_h(self, arg=None): self.help() return 0 def handle_v(self, value=None): """ Turn on verbose output. """ self.verbose = 1 # Handlers for long options have two underscores in their name def handle__help(self, arg=None): self.help() return 0 def handle__verbose(self, value=None): """ Turn on verbose output. """ self.verbose = 1 def handle__debug(self, arg=None): self.debug = 1 # We don't want to catch internal errors: self.InternalError = None def handle__copyright(self, arg=None): self.print_header() print (self.copyright % self.__dict__).strip() print return 0 def handle__examples(self, arg=None): self.print_header() if self.examples: print 'Examples:' print print (self.examples % self.__dict__).strip() print else: print 'No examples available.' print return 0 def handle__yes(self, dummy=None): self.answer_yes = True def main(self): """ Override this method as program entry point. The return value is passed to sys.exit() as argument. If it is None, 0 is assumed (meaning OK). Unhandled exceptions are reported with exit status code 1 (see __init__ for further details). """ return None # Alias CommandLine = Application def _test(): class MyApplication(Application): header = 'Test Application' version = __version__ options = [Option('-v','verbose')] def handle_v(self,arg): print 'VERBOSE, Yeah !' cmd = MyApplication() if not cmd.values['-h']: cmd.help() print 'files:',cmd.files print 'Bye...' if __name__ == '__main__': _test()
