#!/usr/bin/env python
 
"""
Facilities for generating random
passwords using the random module provided
in the python standard library.
"""
 
import string
import random
 
options = { 
            "upper" : string.uppercase,
            "digit" : string.digits,
            "punct" : string.punctuation,
            "lower" : string.lowercase
          }
 
class Generator(object):
    def __init__(self, length, *args):
        self.possible = parse_options(*args)
        self._length = length
 
    def generate(self):
        """Generate the password randomly
        from the possibilites specified in
        __init__().
 
        The resulting password is
        returned. A new password is created every time
        this method is called.
        """
        return ''.join(random.choice(self.possible) for l in xrange(self._length))
 
    def __len__(self):
        return self._length
 
def parse_options(*args):
    possible = []
 
    for key in args:
        if options.has_key(key):
            possible.extend(options[key])
 
    return possible
 
def main():
    print Generator(10, "upper", "punct", "digits", "lower").generate()
 
if __name__ == "__main__":
    main()

#!/usr/bin/env python
 
import optparse
import sys
 
import password
 
defined_options = password.options.keys()
 
def configure_options(usage):
    """
    Define the options for this program.
    """
    parser = optparse.OptionParser(usage=usage)
 
    parser.add_option("-d", "--digits",
                      help="Include the digits [0-9].",
                      action="store_true", default=False, dest="digit")
 
    parser.add_option("-p", "--punct",
                      help="Include common punctuation characters.",
                      action="store_true", default=False, dest="punct")
 
    parser.add_option("-u", "--uppercase",
                      help="Include uppercase characters.",
                      action="store_true", default=False, dest="upper")
 
    parser.add_option("-c", "--downcase",
                      help="Include lowercase characters.",
                      action="store_true", default=False, dest="lower")
 
    parser.add_option("-l", "--length",
                      help="The number of characters in the password.",
                      type="int", dest="length")
 
    return parser
 
def parse_opts(options):
    """
    Return a list of
    the options specified by the
    user.
 
    Takes the options after they have been
    parsed by the OptionParser.
 
    Example output: ["lower", "upper", "punct"]
    """
    result = []
 
    for k in defined_options:
        # if this option has been included by
        # the user...
        if getattr(options, k):
            # ...append it to the output list.
            result.append(k)
 
    return result
 
def error_check(options, parser):
    """
    Check for any invalid or missing options.
    """
    if not options.length:
        parser.error("A value for length is required.")
    else:
        # We need at least 1 type of
        # character in the password
        if not True in [getattr(options, k) for k in defined_options]:
            parser.error("Please specify at least one type of character.")
 
def main():
    parser = configure_options("usage: %prog [options]")
    (options, args) = parser.parse_args(sys.argv)
    error_check(options, parser)
 
    print password.Generator(options.length, *parse_opts(options)).generate()
 
if __name__ == "__main__":
    main()

$ pgen
usage: pgen [options]

pgen: error: A value for length is required.
$ pgen --help
usage: pgen [options]

options:
  -h, --help            show this help message and exit
  -d, --digits          Include the digits [0-9].
  -p, --punct           Include common punctuation characters.
  -u, --uppercase       Include uppercase characters.
  -c, --downcase        Include lowercase characters.
  -l LENGTH, --length=LENGTH
                        The number of characters in the password.
$ pgen -l10 -d
5722058132
$ pgen -l10 -dc
4d2ybboqth
$ pgen -l10 -dcu
L37uL2QN1W
$ pgen -l10 -dcup
S?U71dU8PT
$ pgen -l64 -dcup
I[Lqg#gcI5YdM;s%C(sF+{yl#EVsF%e/&20P^dCK&z!Lu,s,Y"^B0V!?W5,,VjRG
$ pgen --length=abc
usage: pgen [options]

pgen: error: option --length: invalid integer value: 'abc'