1 #!/usr/bin/env python
   2 
   3 # #!/usr/bin/env python - will search for the first python 
   4 #                         interpreter on your path
   5 # unlike
   6 # #!/usr/bin/python2.5  - which will only run if there is a file 
   7 #                         python 2.5 is installed at /usr/bin
   8 """Module summary
   9 
  10 If you import this module and do help (module) you'll see this.
  11 The first line of a docstring is the "summary", and should be
  12 a one line description.
  13 
  14 You can go into more detail after the summary if needed.
  15 See http://www.python.org/dev/peps/pep-0257/
  16 for the python docstring style guide.
  17 """
  18 
  19 # optparse is both easy to use and produces clean code
  20 # the main optparse docs can be found here:
  21 # http://docs.python.org/library/optparse.html
  22 # there's a much better tutorial that works you through optparse
  23 # starting with a simple example and slowly adding complexity.
  24 from optparse import OptionParser
  25 import os
  26 import sys
  27 
  28 
  29 def main(cmdline=None):
  30     """Example main function.
  31     
  32     If cmdline is none, parser.parse_args will look at 
  33     sys.argv[1:] by default
  34 
  35     However if import this module in python call this main function
  36     like this:
  37     
  38     main(["-n", "3", "asdf", "jkl"])
  39     
  40     in addition to running it from the shell.
  41     """
  42     parser = make_parser()
  43 
  44     opts, args = parser.parse_args(cmdline)
  45 
  46     if opts.error is not None:
  47         return opts.error
  48     elif opts.bad_option:
  49         # you can call parser.error, which will show an error message
  50         # displays the help, and then exits the program
  51         parser.error("you called a bad option")
  52     elif opts.make_template:
  53         make_template()
  54         return 0
  55 
  56     # args is now just a list, of everything that wasn't an
  57     # "option". AKA everything that started with - or --
  58     for i in range(len(args)):
  59         print "arg %d: %s" % (i, args[i])
  60 
  61     print "the number is:", opts.number
  62     # opts.number is always defined, as I set a default value 
  63     # up in the make_parser
  64     
  65     return 0
  66 
  67 
  68 def make_parser():
  69     """Construct an option parser"""
  70 
  71     usage = """%prog: args
  72 
  73 Sometimes you might explain the purpose of this program as well.
  74 """
  75     
  76     parser = OptionParser(usage)
  77 
  78     # add_options takes at least one long option
  79     # you can optionally include a short option.
  80     # - are one character (short) options (e.g. -h)
  81     #
  82     # -- are long options, the name is also used as the 
  83     #    variable name attached that holds the option
  84 
  85     parser.add_option("-e", "--error", help="set error code")
  86 
  87     # opt_parse can be configured to store different kinds of values
  88     # like filenames, and boolean options
  89     parser.add_option("-b", "--bad-option", action="store_true",
  90                       help="trigger an option error")
  91     
  92     # you can also do simple type checking on parameters
  93     parser.add_option("-n", "--number", help="set a number", type="int")
  94 
  95     # if needed you can tell optparse to use a different variable name.
  96     # with the dest argument.
  97     parser.add_option("--index", dest="createRDSIndex", action="store_true")
  98 
  99     parser.add_option("--make-template", action="store_true",
 100                       help="print a simplified template")
 101     parser.set_defaults(bad_option=False, 
 102                         createRDSIndex=False,
 103                         error=None,
 104                         make_template=False,
 105                         number=0)
 106 
 107     return parser
 108 
 109 def make_template():
 110     """Read current source file and print a version with no comments
 111 
 112     run like:
 113     $ script.py --make-template > my_program.py
 114     """
 115     import re
 116     source = open( __file__,'r' )
 117     for line in source:
 118         # include the starting #!, but remove comments
 119         if not re.match(" *#[^!]", line):
 120             sys.stdout.write(line)
 121     
 122 if __name__ == "__main__":
 123     # this runs when the application is run from the command
 124     # it grabs sys.argv[1:] which is everything after the program name
 125     # and passes it to main
 126     # the return value from main is then used as the argument to
 127     # sys.exit, which you can test for in the shell.
 128     # program exit codes are usually 0 for ok, and non-zero for something
 129     # going wrong.
 130     sys.exit(main(sys.argv[1:]))
 131 
 132 # Try the following examples
 133 # python script_template.py
 134 # python script_template.py --help
 135 # ./script_template.py a b c
 136 # ./script_template.py --bad-option
 137 # python ./script_template.py -n 4
 138 # python ./script_template.py --number foo
 139 #
 140 #
 141 # Guido von Rossum (inventor of python) has this write up on how to
 142 # write a main
 143 # http://www.artima.com/weblogs/viewpost.jsp?thread=4829
 144 # however he used the older getopt module which isn't as easy
 145 # to configure as optparse