bee_python 0.0.3 → 0.0.4

data/tools/epydoc/cli.py

@@ -1,1470 +0,0 @@
-# epydoc -- Command line interface
-#
-# Copyright (C) 2005 Edward Loper
-# Author: Edward Loper <edloper@loper.org>
-# URL: <http://epydoc.sf.net>
-#
-# $Id: cli.py,v 1.1 2009/11/26 13:20:36 casa Exp $
-
-"""
-Command-line interface for epydoc.  Abbreviated Usage::
-
- epydoc [options] NAMES...
- 
-     NAMES...                  The Python modules to document.
-     --html                    Generate HTML output (default).
-     --latex                   Generate LaTeX output.
-     --pdf                     Generate pdf output, via LaTeX.
-     -o DIR, --output DIR      The output directory.
-     --inheritance STYLE       The format for showing inherited objects.
-     -V, --version             Print the version of epydoc.
-     -h, --help                Display a usage message.
-
-Run \"epydoc --help\" for a complete option list.  See the epydoc(1)
-man page for more information.
-
-Config Files
-============
-Configuration files can be specified with the C{--config} option.
-These files are read using U{ConfigParser
-<http://docs.python.org/lib/module-ConfigParser.html>}.  Configuration
-files may set options or add names of modules to document.  Option
-names are (usually) identical to the long names of command line
-options.  To specify names to document, use any of the following
-option names::
-
-  module modules value values object objects
-
-A simple example of a config file is::
-
-  [epydoc]
-  modules: sys, os, os.path, re, %(MYSANDBOXPATH)/utilities.py
-  name: Example
-  graph: classtree
-  introspect: no
-
-All ConfigParser interpolations are done using local values and the
-environment variables.
-
-
-Verbosity Levels
-================
-The C{-v} and C{-q} options increase and decrease verbosity,
-respectively.  The default verbosity level is zero.  The verbosity
-levels are currently defined as follows::
-
-                Progress    Markup warnings   Warnings   Errors
- -3               none            no             no        no
- -2               none            no             no        yes
- -1               none            no             yes       yes
-  0 (default)     bar             no             yes       yes
-  1               bar             yes            yes       yes
-  2               list            yes            yes       yes
-"""
-__docformat__ = 'epytext en'
-
-import sys, os, time, re, pickle, textwrap
-from glob import glob
-from optparse import OptionParser, OptionGroup, SUPPRESS_HELP
-import optparse
-import epydoc
-from epydoc import log
-from epydoc.util import wordwrap, run_subprocess, RunSubprocessError
-from epydoc.util import plaintext_to_html
-from epydoc.apidoc import UNKNOWN
-from epydoc.compat import *
-import ConfigParser
-from epydoc.docwriter.html_css import STYLESHEETS as CSS_STYLESHEETS
-
-# This module is only available if Docutils are in the system
-try:
-    from epydoc.docwriter import xlink
-except:
-    xlink = None
-
-INHERITANCE_STYLES = ('grouped', 'listed', 'included')
-GRAPH_TYPES = ('classtree', 'callgraph', 'umlclasstree')
-ACTIONS = ('html', 'text', 'latex', 'dvi', 'ps', 'pdf', 'check')
-DEFAULT_DOCFORMAT = 'epytext'
-PROFILER = 'profile' #: Which profiler to use: 'hotshot' or 'profile'
-
-######################################################################
-#{ Help Topics
-######################################################################
-
-DOCFORMATS = ('epytext', 'plaintext', 'restructuredtext', 'javadoc')
-HELP_TOPICS = {
-    'docformat': textwrap.dedent('''\
-        __docformat__ is a module variable that specifies the markup
-        language for the docstrings in a module.  Its value is a 
-        string, consisting the name of a markup language, optionally 
-        followed by a language code (such as "en" for English).  Epydoc
-        currently recognizes the following markup language names:
-        ''' + ', '.join(DOCFORMATS)),
-    'inheritance': textwrap.dedent('''\
-        The following inheritance formats are currently supported:
-            - grouped: inherited objects are gathered into groups,
-              based on what class they were inherited from.
-            - listed: inherited objects are listed in a short list
-              at the end of their section.
-            - included: inherited objects are mixed in with 
-              non-inherited objects.'''),
-    'css': textwrap.dedent(
-        'The following built-in CSS stylesheets are available:\n' +
-        '\n'.join(['  %10s: %s' % (key, descr)
-                   for (key, (sheet, descr))
-                   in CSS_STYLESHEETS.items()])),
-    #'checks': textwrap.dedent('''\
-    #
-    #    '''),
-    }
-        
-
-HELP_TOPICS['topics'] = wordwrap(
-    'Epydoc can provide additional help for the following topics: ' +
-    ', '.join(['%r' % topic for topic in HELP_TOPICS.keys()]))
-    
-######################################################################
-#{ Argument & Config File Parsing
-######################################################################
-
-OPTION_DEFAULTS = dict(
-    action="html", show_frames=True, docformat=DEFAULT_DOCFORMAT, 
-    show_private=True, show_imports=False, inheritance="listed",
-    verbose=0, quiet=0, load_pickle=False, parse=True, introspect=True,
-    debug=epydoc.DEBUG, profile=False, graphs=[],
-    list_classes_separately=False, graph_font=None, graph_font_size=None,
-    include_source_code=True, pstat_files=[], simple_term=False, fail_on=None,
-    exclude=[], exclude_parse=[], exclude_introspect=[],
-    external_api=[], external_api_file=[], external_api_root=[],
-    redundant_details=False, src_code_tab_width=8)
-
-def parse_arguments():
-    # Construct the option parser.
-    usage = '%prog [ACTION] [options] NAMES...'
-    version = "Epydoc, version %s" % epydoc.__version__
-    optparser = OptionParser(usage=usage, add_help_option=False)
-
-    optparser.add_option('--config',
-        action='append', dest="configfiles", metavar='FILE',
-        help=("A configuration file, specifying additional OPTIONS "
-              "and/or NAMES.  This option may be repeated."))
-
-    optparser.add_option("--output", "-o",
-        dest="target", metavar="PATH",
-        help="The output directory.  If PATH does not exist, then "
-        "it will be created.")
-
-    optparser.add_option("--quiet", "-q",
-        action="count", dest="quiet",
-        help="Decrease the verbosity.")
-
-    optparser.add_option("--verbose", "-v",
-        action="count", dest="verbose",
-        help="Increase the verbosity.")
-
-    optparser.add_option("--debug",
-        action="store_true", dest="debug",
-        help="Show full tracebacks for internal errors.")
-
-    optparser.add_option("--simple-term",
-        action="store_true", dest="simple_term",
-        help="Do not try to use color or cursor control when displaying "
-        "the progress bar, warnings, or errors.")
-
-
-    action_group = OptionGroup(optparser, 'Actions')
-    optparser.add_option_group(action_group)
-
-    action_group.add_option("--html",
-        action="store_const", dest="action", const="html",
-        help="Write HTML output.")
-
-    action_group.add_option("--text",
-        action="store_const", dest="action", const="text",
-        help="Write plaintext output. (not implemented yet)")
-
-    action_group.add_option("--latex",
-        action="store_const", dest="action", const="latex",
-        help="Write LaTeX output.")
-
-    action_group.add_option("--dvi",
-        action="store_const", dest="action", const="dvi",
-        help="Write DVI output.")
-
-    action_group.add_option("--ps",
-        action="store_const", dest="action", const="ps",
-        help="Write Postscript output.")
-
-    action_group.add_option("--pdf",
-        action="store_const", dest="action", const="pdf",
-        help="Write PDF output.")
-
-    action_group.add_option("--check",
-        action="store_const", dest="action", const="check",
-        help="Check completeness of docs.")
-
-    action_group.add_option("--pickle",
-        action="store_const", dest="action", const="pickle",
-        help="Write the documentation to a pickle file.")
-
-    # Provide our own --help and --version options.
-    action_group.add_option("--version",
-        action="store_const", dest="action", const="version",
-        help="Show epydoc's version number and exit.")
-
-    action_group.add_option("-h", "--help",
-        action="store_const", dest="action", const="help",
-        help="Show this message and exit.  For help on specific "
-        "topics, use \"--help TOPIC\".  Use \"--help topics\" for a "
-        "list of available help topics")
-
-
-    generation_group = OptionGroup(optparser, 'Generation Options')
-    optparser.add_option_group(generation_group)
-
-    generation_group.add_option("--docformat",
-        dest="docformat", metavar="NAME",
-        help="The default markup language for docstrings.  Defaults "
-        "to \"%s\"." % DEFAULT_DOCFORMAT)
-
-    generation_group.add_option("--parse-only",
-        action="store_false", dest="introspect",
-        help="Get all information from parsing (don't introspect)")
-
-    generation_group.add_option("--introspect-only",
-        action="store_false", dest="parse",
-        help="Get all information from introspecting (don't parse)")
-
-    generation_group.add_option("--exclude",
-        dest="exclude", metavar="PATTERN", action="append",
-        help="Exclude modules whose dotted name matches "
-             "the regular expression PATTERN")
-
-    generation_group.add_option("--exclude-introspect",
-        dest="exclude_introspect", metavar="PATTERN", action="append",
-        help="Exclude introspection of modules whose dotted name matches "
-             "the regular expression PATTERN")
-
-    generation_group.add_option("--exclude-parse",
-        dest="exclude_parse", metavar="PATTERN", action="append",
-        help="Exclude parsing of modules whose dotted name matches "
-             "the regular expression PATTERN")
-
-    generation_group.add_option("--inheritance",
-        dest="inheritance", metavar="STYLE",
-        help="The format for showing inheritance objects.  STYLE "
-        "should be one of: %s." % ', '.join(INHERITANCE_STYLES))
-
-    generation_group.add_option("--show-private",
-        action="store_true", dest="show_private",
-        help="Include private variables in the output. (default)")
-
-    generation_group.add_option("--no-private",
-        action="store_false", dest="show_private",
-        help="Do not include private variables in the output.")
-
-    generation_group.add_option("--show-imports",
-        action="store_true", dest="show_imports",
-        help="List each module's imports.")
-
-    generation_group.add_option("--no-imports",
-        action="store_false", dest="show_imports",
-        help="Do not list each module's imports. (default)")
-
-    generation_group.add_option('--show-sourcecode',
-        action='store_true', dest='include_source_code',
-        help=("Include source code with syntax highlighting in the "
-              "HTML output. (default)"))
-
-    generation_group.add_option('--no-sourcecode',
-        action='store_false', dest='include_source_code',
-        help=("Do not include source code with syntax highlighting in the "
-              "HTML output."))
-
-    generation_group.add_option('--include-log',
-        action='store_true', dest='include_log',
-        help=("Include a page with the process log (epydoc-log.html)"))
-
-    generation_group.add_option(
-        '--redundant-details',
-        action='store_true', dest='redundant_details',
-        help=("Include values in the details lists even if all info "
-              "about them is already provided by the summary table."))
-
-    output_group = OptionGroup(optparser, 'Output Options')
-    optparser.add_option_group(output_group)
-
-    output_group.add_option("--name", "-n",
-        dest="prj_name", metavar="NAME",
-        help="The documented project's name (for the navigation bar).")
-
-    output_group.add_option("--css", "-c",
-        dest="css", metavar="STYLESHEET",
-        help="The CSS stylesheet.  STYLESHEET can be either a "
-        "builtin stylesheet or the name of a CSS file.")
-
-    output_group.add_option("--url", "-u",
-        dest="prj_url", metavar="URL",
-        help="The documented project's URL (for the navigation bar).")
-
-    output_group.add_option("--navlink",
-        dest="prj_link", metavar="HTML",
-        help="HTML code for a navigation link to place in the "
-        "navigation bar.")
-
-    output_group.add_option("--top",
-        dest="top_page", metavar="PAGE",
-        help="The \"top\" page for the HTML documentation.  PAGE can "
-        "be a URL, the name of a module or class, or one of the "
-        "special names \"trees.html\", \"indices.html\", or \"help.html\"")
-
-    output_group.add_option("--help-file",
-        dest="help_file", metavar="FILE",
-        help="An alternate help file.  FILE should contain the body "
-        "of an HTML file -- navigation bars will be added to it.")
-
-    output_group.add_option("--show-frames",
-        action="store_true", dest="show_frames",
-        help="Include frames in the HTML output. (default)")
-
-    output_group.add_option("--no-frames",
-        action="store_false", dest="show_frames",
-        help="Do not include frames in the HTML output.")
-
-    output_group.add_option('--separate-classes',
-        action='store_true', dest='list_classes_separately',
-        help=("When generating LaTeX or PDF output, list each class in "
-              "its own section, instead of listing them under their "
-              "containing module."))
-
-    output_group.add_option('--src-code-tab-width',
-        action='store', type='int', dest='src_code_tab_width',
-        help=("When generating HTML output, sets the number of spaces "
-              "each tab in source code listings is replaced with."))
-    
-    # The group of external API options.
-    # Skip if the module couldn't be imported (usually missing docutils)
-    if xlink is not None:
-        link_group = OptionGroup(optparser,
-                                 xlink.ApiLinkReader.settings_spec[0])
-        optparser.add_option_group(link_group)
-
-        for help, names, opts in xlink.ApiLinkReader.settings_spec[2]:
-            opts = opts.copy()
-            opts['help'] = help
-            link_group.add_option(*names, **opts)
-
-    graph_group = OptionGroup(optparser, 'Graph Options')
-    optparser.add_option_group(graph_group)
-
-    graph_group.add_option('--graph',
-        action='append', dest='graphs', metavar='GRAPHTYPE',
-        help=("Include graphs of type GRAPHTYPE in the generated output.  "
-              "Graphs are generated using the Graphviz dot executable.  "
-              "If this executable is not on the path, then use --dotpath "
-              "to specify its location.  This option may be repeated to "
-              "include multiple graph types in the output.  GRAPHTYPE "
-              "should be one of: all, %s." % ', '.join(GRAPH_TYPES)))
-
-    graph_group.add_option("--dotpath",
-        dest="dotpath", metavar='PATH',
-        help="The path to the Graphviz 'dot' executable.")
-
-    graph_group.add_option('--graph-font',
-        dest='graph_font', metavar='FONT',
-        help=("Specify the font used to generate Graphviz graphs.  (e.g., "
-              "helvetica or times)."))
-
-    graph_group.add_option('--graph-font-size',
-        dest='graph_font_size', metavar='SIZE',
-        help=("Specify the font size used to generate Graphviz graphs, "
-              "in points."))
-
-    graph_group.add_option('--pstat',
-        action='append', dest='pstat_files', metavar='FILE',
-        help="A pstat output file, to be used in generating call graphs.")
-
-    # this option is for developers, not users.
-    graph_group.add_option("--profile-epydoc",
-        action="store_true", dest="profile",
-        help=SUPPRESS_HELP or
-             ("Run the hotshot profiler on epydoc itself.  Output "
-              "will be written to profile.out."))
-
-
-    return_group = OptionGroup(optparser, 'Return Value Options')
-    optparser.add_option_group(return_group)
-
-    return_group.add_option("--fail-on-error",
-        action="store_const", dest="fail_on", const=log.ERROR,
-        help="Return a non-zero exit status, indicating failure, if any "
-        "errors are encountered.")
-
-    return_group.add_option("--fail-on-warning",
-        action="store_const", dest="fail_on", const=log.WARNING,
-        help="Return a non-zero exit status, indicating failure, if any "
-        "errors or warnings are encountered (not including docstring "
-        "warnings).")
-
-    return_group.add_option("--fail-on-docstring-warning",
-        action="store_const", dest="fail_on", const=log.DOCSTRING_WARNING,
-        help="Return a non-zero exit status, indicating failure, if any "
-        "errors or warnings are encountered (including docstring "
-        "warnings).")
-
-    # Set the option parser's defaults.
-    optparser.set_defaults(**OPTION_DEFAULTS)
-
-    # Parse the arguments.
-    options, names = optparser.parse_args()
-
-    # Print help message, if requested.  We also provide support for
-    # --help [topic]
-    if options.action == 'help':
-        names = set([n.lower() for n in names])
-        for (topic, msg) in HELP_TOPICS.items():
-            if topic.lower() in names:
-                print '\n' + msg.rstrip() + '\n'
-                sys.exit(0)
-        optparser.print_help()
-        sys.exit(0)
-
-    # Print version message, if requested.
-    if options.action == 'version':
-        print version
-        sys.exit(0)
-    
-    # Process any config files.
-    if options.configfiles:
-        try:
-            parse_configfiles(options.configfiles, options, names)
-        except (KeyboardInterrupt,SystemExit): raise
-        except Exception, e:
-            if len(options.configfiles) == 1:
-                cf_name = 'config file %s' % options.configfiles[0]
-            else:
-                cf_name = 'config files %s' % ', '.join(options.configfiles)
-            optparser.error('Error reading %s:\n    %s' % (cf_name, e))
-
-    # Check if the input file is a pickle file.
-    for name in names:
-        if name.endswith('.pickle'):
-            if len(names) != 1:
-                optparser.error("When a pickle file is specified, no other "
-                               "input files may be specified.")
-            options.load_pickle = True
-    
-    # Check to make sure all options are valid.
-    if len(names) == 0:
-        optparser.error("No names specified.")
-        
-    # perform shell expansion.
-    for i, name in reversed(list(enumerate(names[:]))):
-        if '?' in name or '*' in name:
-            names[i:i+1] = glob(name)
-        
-    if options.inheritance not in INHERITANCE_STYLES:
-        optparser.error("Bad inheritance style.  Valid options are " +
-                        ",".join(INHERITANCE_STYLES))
-    if not options.parse and not options.introspect:
-        optparser.error("Invalid option combination: --parse-only "
-                        "and --introspect-only.")
-    if options.action == 'text' and len(names) > 1:
-        optparser.error("--text option takes only one name.")
-
-    # Check the list of requested graph types to make sure they're
-    # acceptable.
-    options.graphs = [graph_type.lower() for graph_type in options.graphs]
-    for graph_type in options.graphs:
-        if graph_type == 'callgraph' and not options.pstat_files:
-            optparser.error('"callgraph" graph type may only be used if '
-                            'one or more pstat files are specified.')
-        # If it's 'all', then add everything (but don't add callgraph if
-        # we don't have any profiling info to base them on).
-        if graph_type == 'all':
-            if options.pstat_files:
-                options.graphs = GRAPH_TYPES
-            else:
-                options.graphs = [g for g in GRAPH_TYPES if g != 'callgraph']
-            break
-        elif graph_type not in GRAPH_TYPES:
-            optparser.error("Invalid graph type %s." % graph_type)
-
-    # Calculate verbosity.
-    verbosity = getattr(options, 'verbosity', 0)
-    options.verbosity = verbosity + options.verbose - options.quiet
-
-    # The target default depends on the action.
-    if options.target is None:
-        options.target = options.action
-    
-    # Return parsed args.
-    options.names = names
-    return options, names
-
-def parse_configfiles(configfiles, options, names):
-    configparser = ConfigParser.ConfigParser()
-    # ConfigParser.read() silently ignores errors, so open the files
-    # manually (since we want to notify the user of any errors).
-    for configfile in configfiles:
-        fp = open(configfile, 'r') # may raise IOError.
-        configparser.readfp(fp, configfile)
-        fp.close()
-    for optname in configparser.options('epydoc'):
-        val = configparser.get('epydoc', optname, vars=os.environ).strip()
-        optname = optname.lower().strip()
-
-        if optname in ('modules', 'objects', 'values',
-                       'module', 'object', 'value'):
-            names.extend(_str_to_list(val))
-        elif optname == 'target':
-            options.target = val
-        elif optname == 'output':
-            if val.lower() not in ACTIONS:
-                raise ValueError('"%s" expected one of: %s' %
-                                 (optname, ', '.join(ACTIONS)))
-            options.action = val.lower()
-        elif optname == 'verbosity':
-            options.verbosity = _str_to_int(val, optname)
-        elif optname == 'debug':
-            options.debug = _str_to_bool(val, optname)
-        elif optname in ('simple-term', 'simple_term'):
-            options.simple_term = _str_to_bool(val, optname)
-
-        # Generation options
-        elif optname == 'docformat':
-            options.docformat = val
-        elif optname == 'parse':
-            options.parse = _str_to_bool(val, optname)
-        elif optname == 'introspect':
-            options.introspect = _str_to_bool(val, optname)
-        elif optname == 'exclude':
-            options.exclude.extend(_str_to_list(val))
-        elif optname in ('exclude-parse', 'exclude_parse'):
-            options.exclude_parse.extend(_str_to_list(val))
-        elif optname in ('exclude-introspect', 'exclude_introspect'):
-            options.exclude_introspect.extend(_str_to_list(val))
-        elif optname == 'inheritance':
-            if val.lower() not in INHERITANCE_STYLES:
-                raise ValueError('"%s" expected one of: %s.' %
-                                 (optname, ', '.join(INHERITANCE_STYLES)))
-            options.inheritance = val.lower()
-        elif optname =='private':
-            options.show_private = _str_to_bool(val, optname)
-        elif optname =='imports':
-            options.show_imports = _str_to_bool(val, optname)
-        elif optname == 'sourcecode':
-            options.include_source_code = _str_to_bool(val, optname)
-        elif optname in ('include-log', 'include_log'):
-            options.include_log = _str_to_bool(val, optname)
-        elif optname in ('redundant-details', 'redundant_details'):
-            options.redundant_details = _str_to_bool(val, optname)
-
-        # Output options
-        elif optname == 'name':
-            options.prj_name = val
-        elif optname == 'css':
-            options.css = val
-        elif optname == 'url':
-            options.prj_url = val
-        elif optname == 'link':
-            options.prj_link = val
-        elif optname == 'top':
-            options.top_page = val
-        elif optname == 'help':
-            options.help_file = val
-        elif optname =='frames':
-            options.show_frames = _str_to_bool(val, optname)
-        elif optname in ('separate-classes', 'separate_classes'):
-            options.list_classes_separately = _str_to_bool(val, optname)
-        elif optname in ('src-code-tab-width', 'src_code_tab_width'):
-            options.src_code_tab_width = _str_to_int(val, optname)
-
-        # External API
-        elif optname in ('external-api', 'external_api'):
-            options.external_api.extend(_str_to_list(val))
-        elif optname in ('external-api-file', 'external_api_file'):
-            options.external_api_file.extend(_str_to_list(val))
-        elif optname in ('external-api-root', 'external_api_root'):
-            options.external_api_root.extend(_str_to_list(val))
-
-        # Graph options
-        elif optname == 'graph':
-            graphtypes = _str_to_list(val)
-            for graphtype in graphtypes:
-                if graphtype not in GRAPH_TYPES + ('all',):
-                    raise ValueError('"%s" expected one of: all, %s.' %
-                                     (optname, ', '.join(GRAPH_TYPES)))
-            options.graphs.extend(graphtypes)
-        elif optname == 'dotpath':
-            options.dotpath = val
-        elif optname in ('graph-font', 'graph_font'):
-            options.graph_font = val
-        elif optname in ('graph-font-size', 'graph_font_size'):
-            options.graph_font_size = _str_to_int(val, optname)
-        elif optname == 'pstat':
-            options.pstat_files.extend(_str_to_list(val))
-
-        # Return value options
-        elif optname in ('failon', 'fail-on', 'fail_on'):
-            if val.lower().strip() in ('error', 'errors'):
-                options.fail_on = log.ERROR
-            elif val.lower().strip() in ('warning', 'warnings'):
-                options.fail_on = log.WARNING
-            elif val.lower().strip() in ('docstring_warning',
-                                         'docstring_warnings'):
-                options.fail_on = log.DOCSTRING_WARNING
-            else:
-                raise ValueError("%r expected one of: error, warning, "
-                                 "docstring_warning" % optname)
-        else:
-            raise ValueError('Unknown option %s' % optname)
-
-def _str_to_bool(val, optname):
-    if val.lower() in ('0', 'no', 'false', 'n', 'f', 'hide'):
-        return False
-    elif val.lower() in ('1', 'yes', 'true', 'y', 't', 'show'):
-        return True
-    else:
-        raise ValueError('"%s" option expected a boolean' % optname)
-        
-def _str_to_int(val, optname):
-    try:
-        return int(val)
-    except ValueError:
-        raise ValueError('"%s" option expected an int' % optname)
-
-def _str_to_list(val):
-    return val.replace(',', ' ').split()
-
-######################################################################
-#{ Interface
-######################################################################
-
-def main(options, names):
-    # Set the debug flag, if '--debug' was specified.
-    if options.debug:
-        epydoc.DEBUG = True
-
-    ## [XX] Did this serve a purpose?  Commenting out for now:
-    #if options.action == 'text':
-    #    if options.parse and options.introspect:
-    #        options.parse = False
-
-    # Set up the logger
-    if options.simple_term:
-        TerminalController.FORCE_SIMPLE_TERM = True
-    if options.action == 'text':
-        logger = None # no logger for text output.
-    elif options.verbosity > 1:
-        logger = ConsoleLogger(options.verbosity)
-        log.register_logger(logger)
-    else:
-        # Each number is a rough approximation of how long we spend on
-        # that task, used to divide up the unified progress bar.
-        stages = [40,  # Building documentation
-                  7,   # Merging parsed & introspected information
-                  1,   # Linking imported variables
-                  3,   # Indexing documentation
-                  1,   # Checking for overridden methods
-                  30,  # Parsing Docstrings
-                  1,   # Inheriting documentation
-                  2]   # Sorting & Grouping
-        if options.load_pickle:
-            stages = [30] # Loading pickled documentation
-        if options.action == 'html': stages += [100]
-        elif options.action == 'text': stages += [30]
-        elif options.action == 'latex': stages += [60]
-        elif options.action == 'dvi': stages += [60,30]
-        elif options.action == 'ps': stages += [60,40]
-        elif options.action == 'pdf': stages += [60,50]
-        elif options.action == 'check': stages += [10]
-        elif options.action == 'pickle': stages += [10]
-        else: raise ValueError, '%r not supported' % options.action
-        if options.parse and not options.introspect:
-            del stages[1] # no merging
-        if options.introspect and not options.parse:
-            del stages[1:3] # no merging or linking
-        logger = UnifiedProgressConsoleLogger(options.verbosity, stages)
-        log.register_logger(logger)
-
-    # check the output directory.
-    if options.action not in ('text', 'check', 'pickle'):
-        if os.path.exists(options.target):
-            if not os.path.isdir(options.target):
-                log.error("%s is not a directory" % options.target)
-                sys.exit(1)
-
-    if options.include_log:
-        if options.action == 'html':
-            if not os.path.exists(options.target):
-                os.mkdir(options.target)
-            log.register_logger(HTMLLogger(options.target, options))
-        else:
-            log.warning("--include-log requires --html")
-
-    # Set the default docformat
-    from epydoc import docstringparser
-    docstringparser.DEFAULT_DOCFORMAT = options.docformat
-
-    # Configure the external API linking
-    if xlink is not None:
-        try:
-            xlink.ApiLinkReader.read_configuration(options, problematic=False)
-        except Exception, exc:
-            log.error("Error while configuring external API linking: %s: %s"
-                % (exc.__class__.__name__, exc))
-
-    # Set the dot path
-    if options.dotpath:
-        from epydoc.docwriter import dotgraph
-        dotgraph.DOT_COMMAND = options.dotpath
-
-    # Set the default graph font & size
-    if options.graph_font:
-        from epydoc.docwriter import dotgraph
-        fontname = options.graph_font
-        dotgraph.DotGraph.DEFAULT_NODE_DEFAULTS['fontname'] = fontname
-        dotgraph.DotGraph.DEFAULT_EDGE_DEFAULTS['fontname'] = fontname
-    if options.graph_font_size:
-        from epydoc.docwriter import dotgraph
-        fontsize = options.graph_font_size
-        dotgraph.DotGraph.DEFAULT_NODE_DEFAULTS['fontsize'] = fontsize
-        dotgraph.DotGraph.DEFAULT_EDGE_DEFAULTS['fontsize'] = fontsize
-
-    # If the input name is a pickle file, then read the docindex that
-    # it contains.  Otherwise, build the docs for the input names.
-    if options.load_pickle:
-        assert len(names) == 1
-        log.start_progress('Deserializing')
-        log.progress(0.1, 'Loading %r' % names[0])
-        t0 = time.time()
-        unpickler = pickle.Unpickler(open(names[0], 'rb'))
-        unpickler.persistent_load = pickle_persistent_load
-        docindex = unpickler.load()
-        log.debug('deserialization time: %.1f sec' % (time.time()-t0))
-        log.end_progress()
-    else:
-        # Build docs for the named values.
-        from epydoc.docbuilder import build_doc_index
-        exclude_parse = '|'.join(options.exclude_parse+options.exclude)
-        exclude_introspect = '|'.join(options.exclude_introspect+
-                                      options.exclude)
-        docindex = build_doc_index(names, options.introspect, options.parse,
-                                   add_submodules=(options.action!='text'),
-                                   exclude_introspect=exclude_introspect,
-                                   exclude_parse=exclude_parse)
-
-    if docindex is None:
-        if log.ERROR in logger.reported_message_levels:
-            sys.exit(1)
-        else:
-            return # docbuilder already logged an error.
-
-    # Load profile information, if it was given.
-    if options.pstat_files:
-        try: import pstats
-        except ImportError:
-            log.error("Could not import pstats -- ignoring pstat files.")
-        try:
-            profile_stats = pstats.Stats(options.pstat_files[0])
-            for filename in options.pstat_files[1:]:
-                profile_stats.add(filename)
-        except KeyboardInterrupt: raise
-        except Exception, e:
-            log.error("Error reading pstat file: %s" % e)
-            profile_stats = None
-        if profile_stats is not None:
-            docindex.read_profiling_info(profile_stats)
-
-    # Perform the specified action.
-    if options.action == 'html':
-        write_html(docindex, options)
-    elif options.action in ('latex', 'dvi', 'ps', 'pdf'):
-        write_latex(docindex, options, options.action)
-    elif options.action == 'text':
-        write_text(docindex, options)
-    elif options.action == 'check':
-        check_docs(docindex, options)
-    elif options.action == 'pickle':
-        write_pickle(docindex, options)
-    else:
-        print >>sys.stderr, '\nUnsupported action %s!' % options.action
-
-    # If we suppressed docstring warnings, then let the user know.
-    if logger is not None and logger.suppressed_docstring_warning:
-        if logger.suppressed_docstring_warning == 1:
-            prefix = '1 markup error was found'
-        else:
-            prefix = ('%d markup errors were found' %
-                      logger.suppressed_docstring_warning)
-        log.warning("%s while processing docstrings.  Use the verbose "
-                    "switch (-v) to display markup errors." % prefix)
-
-    # Basic timing breakdown:
-    if options.verbosity >= 2 and logger is not None:
-        logger.print_times()
-
-    # If we encountered any message types that we were requested to
-    # fail on, then exit with status 2.
-    if options.fail_on is not None:
-        max_reported_message_level = max(logger.reported_message_levels)
-        if max_reported_message_level >= options.fail_on:
-            sys.exit(2)
-
-def write_html(docindex, options):
-    from epydoc.docwriter.html import HTMLWriter
-    html_writer = HTMLWriter(docindex, **options.__dict__)
-    if options.verbose > 0:
-        log.start_progress('Writing HTML docs to %r' % options.target)
-    else:
-        log.start_progress('Writing HTML docs')
-    html_writer.write(options.target)
-    log.end_progress()
-
-def write_pickle(docindex, options):
-    """Helper for writing output to a pickle file, which can then be
-    read in at a later time.  But loading the pickle is only marginally
-    faster than building the docs from scratch, so this has pretty
-    limited application."""
-    if options.target == 'pickle':
-        options.target = 'api.pickle'
-    elif not options.target.endswith('.pickle'):
-        options.target += '.pickle'
-
-    log.start_progress('Serializing output')
-    log.progress(0.2, 'Writing %r' % options.target)
-    outfile = open(options.target, 'wb')
-    pickler = pickle.Pickler(outfile, protocol=0)
-    pickler.persistent_id = pickle_persistent_id
-    pickler.dump(docindex)
-    outfile.close()
-    log.end_progress()
-
-def pickle_persistent_id(obj):
-    """Helper for pickling, which allows us to save and restore UNKNOWN,
-    which is required to be identical to apidoc.UNKNOWN."""
-    if obj is UNKNOWN: return 'UNKNOWN'
-    else: return None
-
-def pickle_persistent_load(identifier):
-    """Helper for pickling, which allows us to save and restore UNKNOWN,
-    which is required to be identical to apidoc.UNKNOWN."""
-    if identifier == 'UNKNOWN': return UNKNOWN
-    else: raise pickle.UnpicklingError, 'Invalid persistent id'
-
-_RERUN_LATEX_RE = re.compile(r'(?im)^LaTeX\s+Warning:\s+Label\(s\)\s+may'
-                             r'\s+have\s+changed.\s+Rerun')
-
-def write_latex(docindex, options, format):
-    from epydoc.docwriter.latex import LatexWriter
-    latex_writer = LatexWriter(docindex, **options.__dict__)
-    log.start_progress('Writing LaTeX docs')
-    latex_writer.write(options.target)
-    log.end_progress()
-    # If we're just generating the latex, and not any output format,
-    # then we're done.
-    if format == 'latex': return
-    
-    if format == 'dvi': steps = 4
-    elif format == 'ps': steps = 5
-    elif format == 'pdf': steps = 6
-    
-    log.start_progress('Processing LaTeX docs')
-    oldpath = os.path.abspath(os.curdir)
-    running = None # keep track of what we're doing.
-    try:
-        try:
-            os.chdir(options.target)
-
-            # Clear any old files out of the way.
-            for ext in 'tex aux log out idx ilg toc ind'.split():
-                if os.path.exists('apidoc.%s' % ext):
-                    os.remove('apidoc.%s' % ext)
-
-            # The first pass generates index files.
-            running = 'latex'
-            log.progress(0./steps, 'LaTeX: First pass')
-            run_subprocess('latex api.tex')
-
-            # Build the index.
-            running = 'makeindex'
-            log.progress(1./steps, 'LaTeX: Build index')
-            run_subprocess('makeindex api.idx')
-
-            # The second pass generates our output.
-            running = 'latex'
-            log.progress(2./steps, 'LaTeX: Second pass')
-            out, err = run_subprocess('latex api.tex')
-            
-            # The third pass is only necessary if the second pass
-            # changed what page some things are on.
-            running = 'latex'
-            if _RERUN_LATEX_RE.match(out):
-                log.progress(3./steps, 'LaTeX: Third pass')
-                out, err = run_subprocess('latex api.tex')
- 
-            # A fourth path should (almost?) never be necessary.
-            running = 'latex'
-            if _RERUN_LATEX_RE.match(out):
-                log.progress(3./steps, 'LaTeX: Fourth pass')
-                run_subprocess('latex api.tex')
-
-            # If requested, convert to postscript.
-            if format in ('ps', 'pdf'):
-                running = 'dvips'
-                log.progress(4./steps, 'dvips')
-                run_subprocess('dvips api.dvi -o api.ps -G0 -Ppdf')
-
-            # If requested, convert to pdf.
-            if format in ('pdf'):
-                running = 'ps2pdf'
-                log.progress(5./steps, 'ps2pdf')
-                run_subprocess(
-                    'ps2pdf -sPAPERSIZE#letter -dMaxSubsetPct#100 '
-                    '-dSubsetFonts#true -dCompatibilityLevel#1.2 '
-                    '-dEmbedAllFonts#true api.ps api.pdf')
-        except RunSubprocessError, e:
-            if running == 'latex':
-                e.out = re.sub(r'(?sm)\A.*?!( LaTeX Error:)?', r'', e.out)
-                e.out = re.sub(r'(?sm)\s*Type X to quit.*', '', e.out)
-                e.out = re.sub(r'(?sm)^! Emergency stop.*', '', e.out)
-            log.error("%s failed: %s" % (running, (e.out+e.err).lstrip()))
-        except OSError, e:
-            log.error("%s failed: %s" % (running, e))
-    finally:
-        os.chdir(oldpath)
-        log.end_progress()
-
-def write_text(docindex, options):
-    log.start_progress('Writing output')
-    from epydoc.docwriter.plaintext import PlaintextWriter
-    plaintext_writer = PlaintextWriter()
-    s = ''
-    for apidoc in docindex.root:
-        s += plaintext_writer.write(apidoc)
-    log.end_progress()
-    if isinstance(s, unicode):
-        s = s.encode('ascii', 'backslashreplace')
-    print s
-
-def check_docs(docindex, options):
-    from epydoc.checker import DocChecker
-    DocChecker(docindex).check()
-                
-def cli():
-    # Parse command-line arguments.
-    options, names = parse_arguments()
-
-    try:
-        try:
-            if options.profile:
-                _profile()
-            else:
-                main(options, names)
-        finally:
-            log.close()
-    except SystemExit:
-        raise
-    except KeyboardInterrupt:
-        print '\n\n'
-        print >>sys.stderr, 'Keyboard interrupt.'
-    except:
-        if options.debug: raise
-        print '\n\n'
-        exc_info = sys.exc_info()
-        if isinstance(exc_info[0], basestring): e = exc_info[0]
-        else: e = exc_info[1]
-        print >>sys.stderr, ('\nUNEXPECTED ERROR:\n'
-                             '%s\n' % (str(e) or e.__class__.__name__))
-        print >>sys.stderr, 'Use --debug to see trace information.'
-        sys.exit(3)
-    
-def _profile():
-    # Hotshot profiler.
-    if PROFILER == 'hotshot':
-        try: import hotshot, hotshot.stats
-        except ImportError:
-            print >>sys.stderr, "Could not import profile module!"
-            return
-        try:
-            prof = hotshot.Profile('hotshot.out')
-            prof = prof.runctx('main(*parse_arguments())', globals(), {})
-        except SystemExit:
-            pass
-        prof.close()
-        # Convert profile.hotshot -> profile.out
-        print 'Consolidating hotshot profiling info...'
-        hotshot.stats.load('hotshot.out').dump_stats('profile.out')
-
-    # Standard 'profile' profiler.
-    elif PROFILER == 'profile':
-        # cProfile module was added in Python 2.5 -- use it if its'
-        # available, since it's faster.
-        try: from cProfile import Profile
-        except ImportError:
-            try: from profile import Profile
-            except ImportError:
-                print >>sys.stderr, "Could not import profile module!"
-                return
-
-        # There was a bug in Python 2.4's profiler.  Check if it's
-        # present, and if so, fix it.  (Bug was fixed in 2.4maint:
-        # <http://mail.python.org/pipermail/python-checkins/
-        #                         2005-September/047099.html>)
-        if (hasattr(Profile, 'dispatch') and
-            Profile.dispatch['c_exception'] is
-            Profile.trace_dispatch_exception.im_func):
-            trace_dispatch_return = Profile.trace_dispatch_return.im_func
-            Profile.dispatch['c_exception'] = trace_dispatch_return
-        try:
-            prof = Profile()
-            prof = prof.runctx('main(*parse_arguments())', globals(), {})
-        except SystemExit:
-            pass
-        prof.dump_stats('profile.out')
-
-    else:
-        print >>sys.stderr, 'Unknown profiler %s' % PROFILER
-        return
-    
-######################################################################
-#{ Logging
-######################################################################
-    
-class TerminalController:
-    """
-    A class that can be used to portably generate formatted output to
-    a terminal.  See
-    U{http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/475116}
-    for documentation.  (This is a somewhat stripped-down version.)
-    """
-    BOL = ''             #: Move the cursor to the beginning of the line
-    UP = ''              #: Move the cursor up one line
-    DOWN = ''            #: Move the cursor down one line
-    LEFT = ''            #: Move the cursor left one char
-    RIGHT = ''           #: Move the cursor right one char
-    CLEAR_EOL = ''       #: Clear to the end of the line.
-    CLEAR_LINE = ''      #: Clear the current line; cursor to BOL.
-    BOLD = ''            #: Turn on bold mode
-    NORMAL = ''          #: Turn off all modes
-    COLS = 75            #: Width of the terminal (default to 75)
-    BLACK = BLUE = GREEN = CYAN = RED = MAGENTA = YELLOW = WHITE = ''
-    
-    _STRING_CAPABILITIES = """
-    BOL=cr UP=cuu1 DOWN=cud1 LEFT=cub1 RIGHT=cuf1
-    CLEAR_EOL=el BOLD=bold UNDERLINE=smul NORMAL=sgr0""".split()
-    _COLORS = """BLACK BLUE GREEN CYAN RED MAGENTA YELLOW WHITE""".split()
-    _ANSICOLORS = "BLACK RED GREEN YELLOW BLUE MAGENTA CYAN WHITE".split()
-
-    #: If this is set to true, then new TerminalControllers will
-    #: assume that the terminal is not capable of doing manipulation
-    #: of any kind.
-    FORCE_SIMPLE_TERM = False
-
-    def __init__(self, term_stream=sys.stdout):
-        # If the stream isn't a tty, then assume it has no capabilities.
-        if not term_stream.isatty(): return
-        if self.FORCE_SIMPLE_TERM: return
-
-        # Curses isn't available on all platforms
-        try: import curses
-        except:
-            # If it's not available, then try faking enough to get a
-            # simple progress bar.
-            self.BOL = '\r'
-            self.CLEAR_LINE = '\r' + ' '*self.COLS + '\r'
-            
-        # Check the terminal type.  If we fail, then assume that the
-        # terminal has no capabilities.
-        try: curses.setupterm()
-        except: return
-
-        # Look up numeric capabilities.
-        self.COLS = curses.tigetnum('cols')
-        
-        # Look up string capabilities.
-        for capability in self._STRING_CAPABILITIES:
-            (attrib, cap_name) = capability.split('=')
-            setattr(self, attrib, self._tigetstr(cap_name) or '')
-        if self.BOL and self.CLEAR_EOL:
-            self.CLEAR_LINE = self.BOL+self.CLEAR_EOL
-
-        # Colors
-        set_fg = self._tigetstr('setf')
-        if set_fg:
-            for i,color in zip(range(len(self._COLORS)), self._COLORS):
-                setattr(self, color, curses.tparm(set_fg, i) or '')
-        set_fg_ansi = self._tigetstr('setaf')
-        if set_fg_ansi:
-            for i,color in zip(range(len(self._ANSICOLORS)), self._ANSICOLORS):
-                setattr(self, color, curses.tparm(set_fg_ansi, i) or '')
-
-    def _tigetstr(self, cap_name):
-        # String capabilities can include "delays" of the form "$<2>".
-        # For any modern terminal, we should be able to just ignore
-        # these, so strip them out.
-        import curses
-        cap = curses.tigetstr(cap_name) or ''
-        return re.sub(r'\$<\d+>[/*]?', '', cap)
-
-class ConsoleLogger(log.Logger):
-    def __init__(self, verbosity, progress_mode=None):
-        self._verbosity = verbosity
-        self._progress = None
-        self._message_blocks = []
-        # For ETA display:
-        self._progress_start_time = None
-        # For per-task times:
-        self._task_times = []
-        self._progress_header = None
-
-        self.reported_message_levels = set()
-        """This set contains all the message levels (WARNING, ERROR,
-        etc) that have been reported.  It is used by the options
-        --fail-on-warning etc to determine the return value."""
-        
-        self.suppressed_docstring_warning = 0
-        """This variable will be incremented once every time a
-        docstring warning is reported tothe logger, but the verbosity
-        level is too low for it to be displayed."""
-
-        self.term = TerminalController()
-
-        # Set the progress bar mode.
-        if verbosity >= 2: self._progress_mode = 'list'
-        elif verbosity >= 0:
-            if progress_mode is not None:
-                self._progress_mode = progress_mode
-            elif self.term.COLS < 15:
-                self._progress_mode = 'simple-bar'
-            elif self.term.BOL and self.term.CLEAR_EOL and self.term.UP:
-                self._progress_mode = 'multiline-bar'
-            elif self.term.BOL and self.term.CLEAR_LINE:
-                self._progress_mode = 'bar'
-            else:
-                self._progress_mode = 'simple-bar'
-        else: self._progress_mode = 'hide'
-
-    def start_block(self, header):
-        self._message_blocks.append( (header, []) )
-
-    def end_block(self):
-        header, messages = self._message_blocks.pop()
-        if messages:
-            width = self.term.COLS - 5 - 2*len(self._message_blocks)
-            prefix = self.term.CYAN+self.term.BOLD+'| '+self.term.NORMAL
-            divider = (self.term.CYAN+self.term.BOLD+'+'+'-'*(width-1)+
-                       self.term.NORMAL)
-            # Mark up the header:
-            header = wordwrap(header, right=width-2, splitchars='\\/').rstrip()
-            header = '\n'.join([prefix+self.term.CYAN+l+self.term.NORMAL
-                                for l in header.split('\n')])
-            # Construct the body:
-            body = ''
-            for message in messages:
-                if message.endswith('\n'): body += message
-                else: body += message+'\n'
-            # Indent the body:
-            body = '\n'.join([prefix+'  '+l for l in body.split('\n')])
-            # Put it all together:
-            message = divider + '\n' + header + '\n' + body + '\n'
-            self._report(message)
-            
-    def _format(self, prefix, message, color):
-        """
-        Rewrap the message; but preserve newlines, and don't touch any
-        lines that begin with spaces.
-        """
-        lines = message.split('\n')
-        startindex = indent = len(prefix)
-        for i in range(len(lines)):
-            if lines[i].startswith(' '):
-                lines[i] = ' '*(indent-startindex) + lines[i] + '\n'
-            else:
-                width = self.term.COLS - 5 - 4*len(self._message_blocks)
-                lines[i] = wordwrap(lines[i], indent, width, startindex, '\\/')
-            startindex = 0
-        return color+prefix+self.term.NORMAL+''.join(lines)
-
-    def log(self, level, message):
-        self.reported_message_levels.add(level)
-        if self._verbosity >= -2 and level >= log.ERROR:
-            message = self._format('  Error: ', message, self.term.RED)
-        elif self._verbosity >= -1 and level >= log.WARNING:
-            message = self._format('Warning: ', message, self.term.YELLOW)
-        elif self._verbosity >= 1 and level >= log.DOCSTRING_WARNING:
-            message = self._format('Warning: ', message, self.term.YELLOW)
-        elif self._verbosity >= 3 and level >= log.INFO:
-            message = self._format('   Info: ', message, self.term.NORMAL)
-        elif epydoc.DEBUG and level == log.DEBUG:
-            message = self._format('  Debug: ', message, self.term.CYAN)
-        else:
-            if level >= log.DOCSTRING_WARNING:
-                self.suppressed_docstring_warning += 1
-            return
-            
-        self._report(message)
-
-    def _report(self, message):
-        if not message.endswith('\n'): message += '\n'
-        
-        if self._message_blocks:
-            self._message_blocks[-1][-1].append(message)
-        else:
-            # If we're in the middle of displaying a progress bar,
-            # then make room for the message.
-            if self._progress_mode == 'simple-bar':
-                if self._progress is not None:
-                    print
-                    self._progress = None
-            if self._progress_mode == 'bar':
-                sys.stdout.write(self.term.CLEAR_LINE)
-            if self._progress_mode == 'multiline-bar':
-                sys.stdout.write((self.term.CLEAR_EOL + '\n')*2 +
-                                 self.term.CLEAR_EOL + self.term.UP*2)
-
-            # Display the message message.
-            sys.stdout.write(message)
-            sys.stdout.flush()
-                
-    def progress(self, percent, message=''):
-        percent = min(1.0, percent)
-        message = '%s' % message
-        
-        if self._progress_mode == 'list':
-            if message:
-                print '[%3d%%] %s' % (100*percent, message)
-                sys.stdout.flush()
-                
-        elif self._progress_mode == 'bar':
-            dots = int((self.term.COLS/2-8)*percent)
-            background = '-'*(self.term.COLS/2-8)
-            if len(message) > self.term.COLS/2:
-                message = message[:self.term.COLS/2-3]+'...'
-            sys.stdout.write(self.term.CLEAR_LINE + '%3d%% '%(100*percent) +
-                             self.term.GREEN + '[' + self.term.BOLD +
-                             '='*dots + background[dots:] + self.term.NORMAL +
-                             self.term.GREEN + '] ' + self.term.NORMAL +
-                             message + self.term.BOL)
-            sys.stdout.flush()
-            self._progress = percent
-        elif self._progress_mode == 'multiline-bar':
-            dots = int((self.term.COLS-10)*percent)
-            background = '-'*(self.term.COLS-10)
-            
-            if len(message) > self.term.COLS-10:
-                message = message[:self.term.COLS-10-3]+'...'
-            else:
-                message = message.center(self.term.COLS-10)
-
-            time_elapsed = time.time()-self._progress_start_time
-            if percent > 0:
-                time_remain = (time_elapsed / percent) * (1-percent)
-            else:
-                time_remain = 0
-
-            sys.stdout.write(
-                # Line 1:
-                self.term.CLEAR_EOL + '      ' +
-                '%-8s' % self._timestr(time_elapsed) +
-                self.term.BOLD + 'Progress:'.center(self.term.COLS-26) +
-                self.term.NORMAL + '%8s' % self._timestr(time_remain) + '\n' +
-                # Line 2:
-                self.term.CLEAR_EOL + ('%3d%% ' % (100*percent)) +
-                self.term.GREEN + '[' +  self.term.BOLD + '='*dots +
-                background[dots:] + self.term.NORMAL + self.term.GREEN +
-                ']' + self.term.NORMAL + '\n' +
-                # Line 3:
-                self.term.CLEAR_EOL + '      ' + message + self.term.BOL +
-                self.term.UP + self.term.UP)
-            
-            sys.stdout.flush()
-            self._progress = percent
-        elif self._progress_mode == 'simple-bar':
-            if self._progress is None:
-                sys.stdout.write('  [')
-                self._progress = 0.0
-            dots = int((self.term.COLS-2)*percent)
-            progress_dots = int((self.term.COLS-2)*self._progress)
-            if dots > progress_dots:
-                sys.stdout.write('.'*(dots-progress_dots))
-                sys.stdout.flush()
-                self._progress = percent
-
-    def _timestr(self, dt):
-        dt = int(dt)
-        if dt >= 3600:
-            return '%d:%02d:%02d' % (dt/3600, dt%3600/60, dt%60)
-        else:
-            return '%02d:%02d' % (dt/60, dt%60)
-
-    def start_progress(self, header=None):
-        if self._progress is not None:
-            raise ValueError
-        self._progress = None
-        self._progress_start_time = time.time()
-        self._progress_header = header
-        if self._progress_mode != 'hide' and header:
-            print self.term.BOLD + header + self.term.NORMAL
-
-    def end_progress(self):
-        self.progress(1.)
-        if self._progress_mode == 'bar':
-            sys.stdout.write(self.term.CLEAR_LINE)
-        if self._progress_mode == 'multiline-bar':
-                sys.stdout.write((self.term.CLEAR_EOL + '\n')*2 +
-                                 self.term.CLEAR_EOL + self.term.UP*2)
-        if self._progress_mode == 'simple-bar':
-            print ']'
-        self._progress = None
-        self._task_times.append( (time.time()-self._progress_start_time,
-                                  self._progress_header) )
-
-    def print_times(self):
-        print
-        print 'Timing summary:'
-        total = sum([time for (time, task) in self._task_times])
-        max_t = max([time for (time, task) in self._task_times])
-        for (time, task) in self._task_times:
-            task = task[:31]
-            print '  %s%s %7.1fs' % (task, '.'*(35-len(task)), time),
-            if self.term.COLS > 55:
-                print '|'+'=' * int((self.term.COLS-53) * time / max_t)
-            else:
-                print
-        print
-
-class UnifiedProgressConsoleLogger(ConsoleLogger):
-    def __init__(self, verbosity, stages, progress_mode=None):
-        self.stage = 0
-        self.stages = stages
-        self.task = None
-        ConsoleLogger.__init__(self, verbosity, progress_mode)
-        
-    def progress(self, percent, message=''):
-        #p = float(self.stage-1+percent)/self.stages
-        i = self.stage-1
-        p = ((sum(self.stages[:i]) + percent*self.stages[i]) /
-             float(sum(self.stages)))
-
-        if message is UNKNOWN: message = None
-        if message: message = '%s: %s' % (self.task, message)
-        ConsoleLogger.progress(self, p, message)
-
-    def start_progress(self, header=None):
-        self.task = header
-        if self.stage == 0:
-            ConsoleLogger.start_progress(self)
-        self.stage += 1
-
-    def end_progress(self):
-        if self.stage == len(self.stages):
-            ConsoleLogger.end_progress(self)
-
-    def print_times(self):
-        pass
-
-class HTMLLogger(log.Logger):
-    """
-    A logger used to generate a log of all warnings and messages to an
-    HTML file.
-    """
-    
-    FILENAME = "epydoc-log.html"
-    HEADER = textwrap.dedent('''\
-        <?xml version="1.0" encoding="ascii"?>
-        <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-                  "DTD/xhtml1-transitional.dtd">
-        <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-        <head>
-          <title>Epydoc Log</title>
-          <link rel="stylesheet" href="epydoc.css" type="text/css" />
-        </head>
-        
-        <body bgcolor="white" text="black" link="blue" vlink="#204080"
-              alink="#204080">
-        <h1 class="epydoc">Epydoc Log</h1>
-        <p class="log">Epydoc started at %s</p>''')
-    START_BLOCK = '<div class="log-block"><h2 class="log-hdr">%s</h2>'
-    MESSAGE = ('<div class="log-%s"><b>%s</b>: \n'
-               '%s</div>\n')
-    END_BLOCK = '</div>'
-    FOOTER = "</body>\n</html>\n"
-    
-    def __init__(self, directory, options):
-        self.start_time = time.time()
-        self.out = open(os.path.join(directory, self.FILENAME), 'w')
-        self.out.write(self.HEADER % time.ctime(self.start_time))
-        self.is_empty = True
-        self.options = options
-
-    def write_options(self, options):
-        self.out.write(self.START_BLOCK % 'Epydoc Options')
-        msg = '<table border="0" cellpadding="0" cellspacing="0">\n'
-        opts = [(key, getattr(options, key)) for key in dir(options)
-                if key not in dir(optparse.Values)]
-        opts = [(val==OPTION_DEFAULTS.get(key), key, val)
-                for (key, val) in opts]
-        for is_default, key, val in sorted(opts):
-            css = is_default and 'opt-default' or 'opt-changed'
-            msg += ('<tr valign="top" class="%s"><td valign="top">%s</td>'
-                    '<td valign="top"><tt>&nbsp;=&nbsp;</tt></td>'
-                    '<td valign="top"><tt>%s</tt></td></tr>' %
-                    (css, key, plaintext_to_html(repr(val))))
-        msg += '</table>\n'
-        self.out.write('<div class="log-info">\n%s</div>\n' % msg)
-        self.out.write(self.END_BLOCK)
-
-    def start_block(self, header):
-        self.out.write(self.START_BLOCK % header)
-
-    def end_block(self):
-        self.out.write(self.END_BLOCK)
-
-    def log(self, level, message):
-        if message.endswith("(-v) to display markup errors."): return
-        if level >= log.ERROR:
-            self.out.write(self._message('error', message))
-        elif level >= log.WARNING:
-            self.out.write(self._message('warning', message))
-        elif level >= log.DOCSTRING_WARNING:
-            self.out.write(self._message('docstring warning', message))
-
-    def _message(self, level, message):
-        self.is_empty = False
-        message = plaintext_to_html(message)
-        if '\n' in message:
-            message = '<pre class="log">%s</pre>' % message
-        hdr = ' '.join([w.capitalize() for w in level.split()])
-        return self.MESSAGE % (level.split()[-1], hdr, message)
-
-    def close(self):
-        if self.is_empty:
-            self.out.write('<div class="log-info">'
-                           'No warnings or errors!</div>')
-        self.write_options(self.options)
-        self.out.write('<p class="log">Epydoc finished at %s</p>\n'
-                       '<p class="log">(Elapsed time: %s)</p>' %
-                       (time.ctime(), self._elapsed_time()))
-        self.out.write(self.FOOTER)
-        self.out.close()
-
-    def _elapsed_time(self):
-        secs = int(time.time()-self.start_time)
-        if secs < 60:
-            return '%d seconds' % secs
-        if secs < 3600:
-            return '%d minutes, %d seconds' % (secs/60, secs%60)
-        else:
-            return '%d hours, %d minutes' % (secs/3600, secs%3600)
-            
-
-######################################################################
-## main
-######################################################################
-
-if __name__ == '__main__':
-    cli()
-