def main():
    from cmd import Cmd
    class dbcmd(Cmd):
        def deault(self, line):
            print 'Unknown command: ', line
        def do_EOF(self, line):
            print
            return 1
        def do_foo(self, line):
            print 'bar'
    import readline
    c = dbcmd()
    c.prompt = 'db> '
    readline.parse_and_bind('tab: complete')
    readline.set_completer(c.complete)
    c.cmdloop()

class Usage(Exception):
   ...


def CLI(argv):
   """
   Command-line interface implementation.
   """

   ...
   raise Usage, ...
   return 0


def main():
   try:
      sys.exit(CLI(sys.argv))

   except Usage, u:
      ...


if __name__ == '__main__':
   main()

if __name__ == '__main__':
    sys.exit(main(...) or 0)

>>> import anoption
>>> def main (
    a, b, c,
    d="", e=100, f=3.0, g=False,
    *args, **kwargs
    ):
    print a, b, c, d, e, f, g, args, kwargs
	
>>> anoption.cli (main, [
    "A", "B", "--extended", "C", "D",
    "-g=yes" "-f=12",
    ])
A B C D 100 12.0 True () {'extended': None}
	
>>> print anoption.doc (main)
a, b, c {-d="", -e=100, -f=3.0, -g=True, ...} [...]

"""Module docstring.

A long usage message.

"""

import sys

def main(*argv):     

    # code of choice; catch all exceptions and return exit status 

if __name__ == "__main__":
    sys.exit(main(*sys.argv))

"""Name
    command - do something
Synopsys
    command [-g file][-d] file ...
    command --help

Description
    command does something, dont know what.

Usage
    To start doing something:
        command file1 file2

Options
    -g file
    --grammar=file
        define grammar file, defailt kant.xml
    -h
    --help
        prints this use message
    -d  turns on debugging

Files
    Yeah, we need files. More files.
    
"""

import sys
import getopt
import pprint
pp = pprint.PrettyPrinter(indent=4)

class Usage(Exception):
    def __init__(self, msg):
        self.msg = msg

# def main():
def main(argv=None):
    if argv is None: argv = sys.argv

    # parse command line options
    try:
        try:
            # put the short and the long options in the same order
            opts, args = getopt.getopt(argv[1:], "hg:dx", ["help" "grammar="])
        except getopt.error as msg:
            raise Usage(msg)

        # define the defaults
        g_grammar = "kant.xml"
        g_debug=0
        g_list_of_files=[]

        # process options
        for opt, arg in opts:
            if opt in ("-h", "--help"):
                print(__doc__)
                return 0
            elif opt == '-d':
                g_debug = 1
            elif opt in ("-g", "--grammar"):
                g_grammar = arg
            else:
                # in case you defined an option with getopt,
                # but forgot to write the handler here
                raise Usage('option '+opt+' unhandled')

        # process arguments
        for arg in args:
            g_list_of_files.append(arg)

        print ('Starting program body with these arguments:')
        print ('grammar='+g_grammar)
        print ('debug='+str(g_debug))
        print ('list_of_files='+pp.pformat(g_list_of_files))
        # your code here, usually a procedure call
        return 0

    except Usage as err:
        print(sys.argv[0].split('/')[-1].split('\\')[-1] + ': ' \
              + str(err.msg) \
              , file=sys.stderr)
        print ("for help use --help", file=sys.stderr)
        return 2

if __name__ == "__main__":
    sys.exit(main())

"""Module information.

Put something useful here.
"""


from __future__ import print_function

import sys
import optparse


class optopt(optparse.OptionParser):
    """Subclassed OptionParser, to prevent exiting from the interpreter when
    called interactively."""

    class optexit(Exception):
        def __init__(self, msg, status):
            self.msg = msg
            self.status = status

        def __str__(self):
            return self.msg

    def exit(self, status=0, msg=None):
        """Base class version with sys.exit() replaced by raise."""

        if msg:
            sys.stderr.write(msg)
        raise self.optexit(msg, status)


def adjutant(a, b, c):
    """The starting point for code."""

    print(a, b, c)

    return 0


def main(argv=None):
    """Parse and check options, and then call adjutant()."""

    if argv is None:
        argv = sys.argv[1:]

    try:
        parser = optopt("%prog [options] arg")

        parser.add_option("-f", "--file", dest="filename", help="read data from FILENAME")
        parser.add_option("-v", "--verbose", action="store_true", dest="verbose")
        parser.add_option("-q", "--quiet", action="store_false", dest="verbose")

        (options, args) = parser.parse_args(argv)

        if len(args) != 1:
            parser.error("incorrect number of arguments")
        if options.verbose:
            print("reading ... {0:s} ".format(options.filename))

        return adjutant(1, 2, 3)

    except optopt.optexit as e:
        return e.status


if __name__ == "__main__":
    sys.exit(main())
else:
    sys.argv = [ "interpreter" ]