bee_python 0.0.1

data/tools/epydoc/docbuilder.py

@@ -0,0 +1,1358 @@
+# epydoc -- Documentation Builder
+#
+# Copyright (C) 2005 Edward Loper
+# Author: Edward Loper <edloper@loper.org>
+# URL: <http://epydoc.sf.net>
+#
+# $Id: docbuilder.py,v 1.1 2009/11/26 13:20:39 casa Exp $
+
+"""
+Construct data structures that encode the API documentation for Python
+objects.  These data structures are created using a series of steps:
+
+  1. B{Building docs}: Extract basic information about the objects,
+     and objects that are related to them.  This can be done by
+     introspecting the objects' values (with L{epydoc.docintrospecter}; or
+     by parsing their source code (with L{epydoc.docparser}.
+
+  2. B{Merging}: Combine the information obtained from introspection &
+     parsing each object into a single structure.
+
+  3. B{Linking}: Replace any 'pointers' that were created for imported
+     variables by their target (if it's available).
+  
+  4. B{Naming}: Chose a unique 'canonical name' for each
+     object.
+  
+  5. B{Docstring Parsing}: Parse the docstring of each object, and
+     extract any pertinant information.
+  
+  6. B{Inheritance}: Add information about variables that classes
+     inherit from their base classes.
+
+The documentation information for each individual object is
+represented using an L{APIDoc}; and the documentation for a collection
+of objects is represented using a L{DocIndex}.
+
+The main interface to C{epydoc.docbuilder} consists of two functions:
+
+  - L{build_doc()} -- Builds documentation for a single item, and
+    returns it as an L{APIDoc} object.
+  - L{build_doc_index()} -- Builds documentation for a collection of
+    items, and returns it as a L{DocIndex} object.
+
+The remaining functions are used by these two main functions to
+perform individual steps in the creation of the documentation.
+
+@group Documentation Construction: build_doc, build_doc_index,
+    _get_docs_from_*, _report_valdoc_progress
+@group Merging: *MERGE*, *merge*
+@group Linking: link_imports
+@group Naming: _name_scores, _unreachable_names, assign_canonical_names,
+    _var_shadows_self, _fix_self_shadowing_var, _unreachable_name_for
+@group Inheritance: inherit_docs, _inherit_info
+"""
+__docformat__ = 'epytext en'
+
+######################################################################
+## Contents
+######################################################################
+## 1. build_doc() & build_doc_index() -- the main interface.
+## 2. merge_docs() -- helper, used to merge parse & introspect info
+## 3. link_imports() -- helper, used to connect imported vars w/ values
+## 4. assign_canonical_names() -- helper, used to set canonical names
+## 5. inherit_docs() -- helper, used to inherit docs from base classes
+
+######################################################################
+## Imports
+######################################################################
+
+import sys, os, os.path, __builtin__, imp, re, inspect
+from epydoc.apidoc import *
+from epydoc.docintrospecter import introspect_docs
+from epydoc.docparser import parse_docs, ParseError
+from epydoc.docstringparser import parse_docstring
+from epydoc import log
+from epydoc.util import *
+from epydoc.compat import * # Backwards compatibility
+
+######################################################################
+## 1. build_doc()
+######################################################################
+
+class BuildOptions:
+    """
+    Holds the parameters for a documentation building process.
+    """
+    def __init__(self, introspect=True, parse=True,
+                 exclude_introspect=None, exclude_parse=None,
+                 add_submodules=True):
+        self.introspect = introspect
+        self.parse = parse
+        self.exclude_introspect = exclude_introspect
+        self.exclude_parse = exclude_parse
+        self.add_submodules = add_submodules
+
+        # Test for pattern syntax and compile them into pattern objects.
+        try:
+            self._introspect_regexp = (exclude_introspect
+                and re.compile(exclude_introspect) or None)
+            self._parse_regexp = (exclude_parse
+                and re.compile(exclude_parse) or None)
+        except Exception, exc:
+            log.error('Error in regular expression pattern: %s' % exc)
+            raise
+
+    def must_introspect(self, name):
+        """
+        Return C{True} if a module is to be introsepcted with the current
+        settings.
+
+        @param name: The name of the module to test
+        @type name: L{DottedName} or C{str}
+        """
+        return self.introspect \
+            and not self._matches_filter(name, self._introspect_regexp)
+
+    def must_parse(self, name):
+        """
+        Return C{True} if a module is to be parsed with the current settings.
+
+        @param name: The name of the module to test
+        @type name: L{DottedName} or C{str}
+        """
+        return self.parse \
+            and not self._matches_filter(name, self._parse_regexp)
+
+    def _matches_filter(self, name, regexp):
+        """
+        Test if a module name matches a pattern.
+
+        @param name: The name of the module to test
+        @type name: L{DottedName} or C{str}
+        @param regexp: The pattern object to match C{name} against.
+            If C{None}, return C{False}
+        @type regexp: C{pattern}
+        @return: C{True} if C{name} in dotted format matches C{regexp},
+            else C{False}
+        @rtype: C{bool}
+        """
+        if regexp is None: return False
+
+        if isinstance(name, DottedName):
+            name = str(name)
+
+        return bool(regexp.search(name))
+
+
+def build_doc(item, introspect=True, parse=True, add_submodules=True,
+              exclude_introspect=None, exclude_parse=None):
+    """
+    Build API documentation for a given item, and return it as
+    an L{APIDoc} object.
+
+    @rtype: L{APIDoc}
+    @param item: The item to document, specified using any of the
+        following:
+          - A string, naming a python package directory
+            (e.g., C{'epydoc/markup'})
+          - A string, naming a python file
+            (e.g., C{'epydoc/docparser.py'})
+          - A string, naming a python object
+            (e.g., C{'epydoc.docparser.DocParser'})
+          - Any (non-string) python object
+            (e.g., C{list.append})
+    @param introspect: If true, then use introspection to examine the
+        specified items.  Otherwise, just use parsing.
+    @param parse: If true, then use parsing to examine the specified
+        items.  Otherwise, just use introspection.
+    """
+    docindex = build_doc_index([item], introspect, parse, add_submodules,
+                               exclude_introspect=exclude_introspect,
+                               exclude_parse=exclude_parse)
+    return docindex.root[0]
+
+def build_doc_index(items, introspect=True, parse=True, add_submodules=True,
+                    exclude_introspect=None, exclude_parse=None):
+    """
+    Build API documentation for the given list of items, and
+    return it in the form of a L{DocIndex}.
+
+    @rtype: L{DocIndex}
+    @param items: The items to document, specified using any of the
+        following:
+          - A string, naming a python package directory
+            (e.g., C{'epydoc/markup'})
+          - A string, naming a python file
+            (e.g., C{'epydoc/docparser.py'})
+          - A string, naming a python object
+            (e.g., C{'epydoc.docparser.DocParser'})
+          - Any (non-string) python object
+            (e.g., C{list.append})
+    @param introspect: If true, then use introspection to examine the
+        specified items.  Otherwise, just use parsing.
+    @param parse: If true, then use parsing to examine the specified
+        items.  Otherwise, just use introspection.
+    """
+    try:
+        options = BuildOptions(parse=parse, introspect=introspect,
+            exclude_introspect=exclude_introspect, exclude_parse=exclude_parse,
+            add_submodules=add_submodules)
+    except Exception, e:
+        # log.error already reported by constructor.
+        return None
+
+    # Get the basic docs for each item.
+    doc_pairs = _get_docs_from_items(items, options)
+
+    # Merge the introspection & parse docs.
+    if options.parse and options.introspect:
+        log.start_progress('Merging parsed & introspected information')
+        docs = []
+        for i, (introspect_doc, parse_doc) in enumerate(doc_pairs):
+            if introspect_doc is not None and parse_doc is not None:
+                if introspect_doc.canonical_name not in (None, UNKNOWN):
+                    name = introspect_doc.canonical_name
+                else:
+                    name = parse_doc.canonical_name
+                log.progress(float(i)/len(doc_pairs), name)
+                docs.append(merge_docs(introspect_doc, parse_doc))
+            elif introspect_doc is not None:
+                docs.append(introspect_doc)
+            elif parse_doc is not None:
+                docs.append(parse_doc)
+        log.end_progress()
+    elif options.introspect:
+        docs = [doc_pair[0] for doc_pair in doc_pairs if doc_pair[0]]
+    else:
+        docs = [doc_pair[1] for doc_pair in doc_pairs if doc_pair[1]]
+
+    if len(docs) == 0:
+        log.error('Nothing left to document!')
+        return None
+
+    # Collect the docs into a single index.
+    docindex = DocIndex(docs)
+
+    # Replace any proxy valuedocs that we got from importing with
+    # their targets.
+    if options.parse:
+        log.start_progress('Linking imported variables')
+        valdocs = sorted(docindex.reachable_valdocs(
+            imports=False, submodules=False, packages=False, subclasses=False))
+        for i, val_doc in enumerate(valdocs):
+            _report_valdoc_progress(i, val_doc, valdocs)
+            link_imports(val_doc, docindex)
+        log.end_progress()
+
+    # Assign canonical names.
+    log.start_progress('Indexing documentation')
+    for i, val_doc in enumerate(docindex.root):
+        log.progress(float(i)/len(docindex.root), val_doc.canonical_name)
+        assign_canonical_names(val_doc, val_doc.canonical_name, docindex)
+    log.end_progress()
+
+    # Set overrides pointers
+    log.start_progress('Checking for overridden methods')
+    valdocs = sorted(docindex.reachable_valdocs(
+        imports=False, submodules=False, packages=False, subclasses=False))
+    for i, val_doc in enumerate(valdocs):
+        if isinstance(val_doc, ClassDoc):
+            percent = float(i)/len(valdocs)
+            log.progress(percent, val_doc.canonical_name)
+            find_overrides(val_doc)
+    log.end_progress()
+    
+    # Parse the docstrings for each object.
+    log.start_progress('Parsing docstrings')
+    suppress_warnings = set(valdocs).difference(
+        docindex.reachable_valdocs(
+            imports=False, submodules=False, packages=False, subclasses=False,
+            bases=False, overrides=True))
+    for i, val_doc in enumerate(valdocs):
+        _report_valdoc_progress(i, val_doc, valdocs)
+        # the value's docstring
+        parse_docstring(val_doc, docindex, suppress_warnings)
+        # the value's variables' docstrings
+        if (isinstance(val_doc, NamespaceDoc) and
+            val_doc.variables not in (None, UNKNOWN)):
+            for var_doc in val_doc.variables.values():
+                # Now we have a chance to propagate the defining module
+                # to objects for which introspection is not possible,
+                # such as properties.
+                if (isinstance(var_doc.value, ValueDoc)
+                    and var_doc.value.defining_module is UNKNOWN):
+                    var_doc.value.defining_module = val_doc.defining_module
+                parse_docstring(var_doc, docindex, suppress_warnings)
+    log.end_progress()
+
+    # Take care of inheritance.
+    log.start_progress('Inheriting documentation')
+    for i, val_doc in enumerate(valdocs):
+        if isinstance(val_doc, ClassDoc):
+            percent = float(i)/len(valdocs)
+            log.progress(percent, val_doc.canonical_name)
+            inherit_docs(val_doc)
+    log.end_progress()
+
+    # Initialize the groups & sortedvars attributes.
+    log.start_progress('Sorting & Grouping')
+    for i, val_doc in enumerate(valdocs):
+        if isinstance(val_doc, NamespaceDoc):
+            percent = float(i)/len(valdocs)
+            log.progress(percent, val_doc.canonical_name)
+            val_doc.init_sorted_variables()
+            val_doc.init_variable_groups()
+            if isinstance(val_doc, ModuleDoc):
+                val_doc.init_submodule_groups()
+            val_doc.report_unused_groups()
+    log.end_progress()
+
+    return docindex
+
+def _report_valdoc_progress(i, val_doc, val_docs):
+    if (isinstance(val_doc, (ModuleDoc, ClassDoc)) and
+        val_doc.canonical_name is not UNKNOWN and
+        not val_doc.canonical_name[0].startswith('??')):
+        log.progress(float(i)/len(val_docs), val_doc.canonical_name)
+
+#/////////////////////////////////////////////////////////////////
+# Documentation Generation
+#/////////////////////////////////////////////////////////////////
+
+def _get_docs_from_items(items, options):
+
+    # Start the progress bar.
+    log.start_progress('Building documentation')
+    progress_estimator = _ProgressEstimator(items)
+
+    # Check for duplicate item names.
+    item_set = set()
+    for item in items[:]:
+        if item in item_set:
+            log.warning("Name %r given multiple times" % item)
+            items.remove(item)
+        item_set.add(item)
+
+    # Keep track of what top-level canonical names we've assigned, to
+    # make sure there are no naming conflicts.  This dict maps
+    # canonical names to the item names they came from (so we can print
+    # useful error messages).
+    canonical_names = {}
+
+    # Collect (introspectdoc, parsedoc) pairs for each item.
+    doc_pairs = []
+    for item in items:
+        if isinstance(item, basestring):
+            if is_module_file(item):
+                doc_pairs.append(_get_docs_from_module_file(
+                    item, options, progress_estimator))
+            elif is_package_dir(item):
+                pkgfile = os.path.abspath(os.path.join(item, '__init__'))
+                doc_pairs.append(_get_docs_from_module_file(
+                    pkgfile, options, progress_estimator))
+            elif os.path.isfile(item):
+                doc_pairs.append(_get_docs_from_pyscript(
+                    item, options, progress_estimator))
+            elif hasattr(__builtin__, item):
+                val = getattr(__builtin__, item)
+                doc_pairs.append(_get_docs_from_pyobject(
+                    val, options, progress_estimator))
+            elif is_pyname(item):
+                doc_pairs.append(_get_docs_from_pyname(
+                    item, options, progress_estimator))
+            elif os.path.isdir(item):
+                log.error("Directory %r is not a package" % item)
+                continue
+            elif os.path.isfile(item):
+                log.error("File %s is not a Python module" % item)
+                continue
+            else:
+                log.error("Could not find a file or object named %s" %
+                          item)
+                continue
+        else:
+            doc_pairs.append(_get_docs_from_pyobject(
+                item, options, progress_estimator))
+
+        # Make sure there are no naming conflicts.
+        name = (getattr(doc_pairs[-1][0], 'canonical_name', None) or
+                getattr(doc_pairs[-1][1], 'canonical_name', None))
+        if name in canonical_names:
+            log.error(
+                'Two of the specified items, %r and %r, have the same '
+                'canonical name ("%s").  This may mean that you specified '
+                'two different files that both use the same module name.  '
+                'Ignoring the second item (%r)' %
+                (canonical_names[name], item, name, canonical_names[name]))
+            doc_pairs.pop()
+        else:
+            canonical_names[name] = item                
+
+        # This will only have an effect if doc_pairs[-1] contains a
+        # package's docs.  The 'not is_module_file(item)' prevents
+        # us from adding subdirectories if they explicitly specify
+        # a package's __init__.py file.
+        if options.add_submodules and not is_module_file(item):
+            doc_pairs += _get_docs_from_submodules(
+                item, doc_pairs[-1], options, progress_estimator)
+
+    log.end_progress()
+    return doc_pairs
+
+def _get_docs_from_pyobject(obj, options, progress_estimator):
+    progress_estimator.complete += 1
+    log.progress(progress_estimator.progress(), repr(obj))
+    
+    if not options.introspect:
+        log.error("Cannot get docs for Python objects without "
+                  "introspecting them.")
+            
+    introspect_doc = parse_doc = None
+    introspect_error = parse_error = None
+    try:
+        introspect_doc = introspect_docs(value=obj)
+    except ImportError, e:
+        log.error(e)
+        return (None, None)
+    if options.parse:
+        if introspect_doc.canonical_name is not None:
+            prev_introspect = options.introspect
+            options.introspect = False
+            try:
+                _, parse_docs = _get_docs_from_pyname(
+                    str(introspect_doc.canonical_name), options,
+                    progress_estimator, suppress_warnings=True)
+            finally:
+                options.introspect = prev_introspect
+
+    # We need a name:
+    if introspect_doc.canonical_name in (None, UNKNOWN):
+        if hasattr(obj, '__name__'):
+            introspect_doc.canonical_name = DottedName(
+                DottedName.UNREACHABLE, obj.__name__)
+        else:
+            introspect_doc.canonical_name = DottedName(
+                DottedName.UNREACHABLE)
+    return (introspect_doc, parse_doc)
+
+def _get_docs_from_pyname(name, options, progress_estimator,
+                          suppress_warnings=False):
+    progress_estimator.complete += 1
+    if options.must_introspect(name) or options.must_parse(name):
+        log.progress(progress_estimator.progress(), name)
+    
+    introspect_doc = parse_doc = None
+    introspect_error = parse_error = None
+    if options.must_introspect(name):
+        try:
+            introspect_doc = introspect_docs(name=name)
+        except ImportError, e:
+            introspect_error = str(e)
+    if options.must_parse(name):
+        try:
+            parse_doc = parse_docs(name=name)
+        except ParseError, e:
+            parse_error = str(e)
+        except ImportError, e:
+            # If we get here, then there' probably no python source
+            # available; don't bother to generate a warnining.
+            pass
+        
+    # Report any errors we encountered.
+    if not suppress_warnings:
+        _report_errors(name, introspect_doc, parse_doc,
+                       introspect_error, parse_error)
+
+    # Return the docs we found.
+    return (introspect_doc, parse_doc)
+
+def _get_docs_from_pyscript(filename, options, progress_estimator):
+    # [xx] I should be careful about what names I allow as filenames,
+    # and maybe do some munging to prevent problems.
+
+    introspect_doc = parse_doc = None
+    introspect_error = parse_error = None
+    if options.introspect:
+        try:
+            introspect_doc = introspect_docs(filename=filename, is_script=True)
+            if introspect_doc.canonical_name is UNKNOWN:
+                introspect_doc.canonical_name = munge_script_name(filename)
+        except ImportError, e:
+            introspect_error = str(e)
+    if options.parse:
+        try:
+            parse_doc = parse_docs(filename=filename, is_script=True)
+        except ParseError, e:
+            parse_error = str(e)
+        except ImportError, e:
+            parse_error = str(e)
+                
+    # Report any errors we encountered.
+    _report_errors(filename, introspect_doc, parse_doc,
+                   introspect_error, parse_error)
+
+    # Return the docs we found.
+    return (introspect_doc, parse_doc)
+    
+def _get_docs_from_module_file(filename, options, progress_estimator,
+                               parent_docs=(None,None)):
+    """
+    Construct and return the API documentation for the python
+    module with the given filename.
+
+    @param parent_docs: The C{ModuleDoc} of the containing package.
+        If C{parent_docs} is not provided, then this method will
+        check if the given filename is contained in a package; and
+        if so, it will construct a stub C{ModuleDoc} for the
+        containing package(s).  C{parent_docs} is a tuple, where
+        the first element is the parent from introspection, and
+        the second element is the parent from parsing.
+    """
+    # Record our progress.
+    modulename = os.path.splitext(os.path.split(filename)[1])[0]
+    if modulename == '__init__':
+        modulename = os.path.split(os.path.split(filename)[0])[1]
+    if parent_docs[0]:
+        modulename = DottedName(parent_docs[0].canonical_name, modulename)
+    elif parent_docs[1]:
+        modulename = DottedName(parent_docs[1].canonical_name, modulename)
+    if options.must_introspect(modulename) or options.must_parse(modulename):
+        log.progress(progress_estimator.progress(),
+                     '%s (%s)' % (modulename, filename))
+    progress_estimator.complete += 1
+    
+    # Normalize the filename.
+    filename = os.path.normpath(os.path.abspath(filename))
+
+    # When possible, use the source version of the file.
+    try:
+        filename = py_src_filename(filename)
+        src_file_available = True
+    except ValueError:
+        src_file_available = False
+
+    # Get the introspected & parsed docs (as appropriate)
+    introspect_doc = parse_doc = None
+    introspect_error = parse_error = None
+    if options.must_introspect(modulename):
+        try:
+            introspect_doc = introspect_docs(
+                filename=filename, context=parent_docs[0])
+            if introspect_doc.canonical_name is UNKNOWN:
+                introspect_doc.canonical_name = modulename
+        except ImportError, e:
+            introspect_error = str(e)
+    if src_file_available and options.must_parse(modulename):
+        try:
+            parse_doc = parse_docs(
+                filename=filename, context=parent_docs[1])
+        except ParseError, e:
+            parse_error = str(e)
+        except ImportError, e:
+            parse_error = str(e)
+
+    # Report any errors we encountered.
+    _report_errors(filename, introspect_doc, parse_doc,
+                   introspect_error, parse_error)
+
+    # Return the docs we found.
+    return (introspect_doc, parse_doc)
+
+def _get_docs_from_submodules(item, pkg_docs, options, progress_estimator):
+    # Extract the package's __path__.
+    if isinstance(pkg_docs[0], ModuleDoc) and pkg_docs[0].is_package:
+        pkg_path = pkg_docs[0].path
+        package_dir = os.path.split(pkg_docs[0].filename)[0]
+    elif isinstance(pkg_docs[1], ModuleDoc) and pkg_docs[1].is_package:
+        pkg_path = pkg_docs[1].path
+        package_dir = os.path.split(pkg_docs[1].filename)[0]
+    else:
+        return []
+
+    module_filenames = {}
+    subpackage_dirs = set()
+    for subdir in pkg_path:
+        if os.path.isdir(subdir):
+            for name in os.listdir(subdir):
+                filename = os.path.join(subdir, name)
+                # Is it a valid module filename?
+                if is_module_file(filename):
+                    basename = os.path.splitext(filename)[0]
+                    if os.path.split(basename)[1] != '__init__':
+                        module_filenames[basename] = filename
+                # Is it a valid package filename?
+                if is_package_dir(filename):
+                    subpackage_dirs.add(filename)
+
+    # Update our estimate of the number of modules in this package.
+    progress_estimator.revise_estimate(item, module_filenames.items(),
+                                       subpackage_dirs)
+
+    docs = [pkg_docs]
+    for module_filename in module_filenames.values():
+        d = _get_docs_from_module_file(
+            module_filename, options, progress_estimator, pkg_docs)
+        docs.append(d)
+    for subpackage_dir in subpackage_dirs:
+        subpackage_file = os.path.join(subpackage_dir, '__init__')
+        docs.append(_get_docs_from_module_file(
+            subpackage_file, options, progress_estimator, pkg_docs))
+        docs += _get_docs_from_submodules(
+            subpackage_dir, docs[-1], options, progress_estimator)
+    return docs
+
+def _report_errors(name, introspect_doc, parse_doc,
+                   introspect_error, parse_error):
+    hdr = 'In %s:\n' % name
+    if introspect_doc == parse_doc == None:
+        log.start_block('%sNo documentation available!' % hdr)
+        if introspect_error:
+            log.error('Import failed:\n%s' % introspect_error)
+        if parse_error:
+            log.error('Source code parsing failed:\n%s' % parse_error)
+        log.end_block()
+    elif introspect_error:
+        log.start_block('%sImport failed (but source code parsing '
+                        'was successful).' % hdr)
+        log.error(introspect_error)
+        log.end_block()
+    elif parse_error:
+        log.start_block('%sSource code parsing failed (but '
+                        'introspection was successful).' % hdr)
+        log.error(parse_error)
+        log.end_block()
+
+
+#/////////////////////////////////////////////////////////////////
+# Progress Estimation (for Documentation Generation)
+#/////////////////////////////////////////////////////////////////
+
+class _ProgressEstimator:
+    """
+    Used to keep track of progress when generating the initial docs
+    for the given items.  (It is not known in advance how many items a
+    package directory will contain, since it might depend on those
+    packages' __path__ values.)
+    """
+    def __init__(self, items):
+        self.est_totals = {}
+        self.complete = 0
+        
+        for item in items:
+            if is_package_dir(item):
+                self.est_totals[item] = self._est_pkg_modules(item)
+            else:
+                self.est_totals[item] = 1
+
+    def progress(self):
+        total = sum(self.est_totals.values())
+        return float(self.complete) / total
+
+    def revise_estimate(self, pkg_item, modules, subpackages):
+        del self.est_totals[pkg_item]
+        for item in modules:
+            self.est_totals[item] = 1
+        for item in subpackages:
+            self.est_totals[item] = self._est_pkg_modules(item)
+
+    def _est_pkg_modules(self, package_dir):
+        num_items = 0
+        
+        if is_package_dir(package_dir):
+            for name in os.listdir(package_dir):
+                filename = os.path.join(package_dir, name)
+                if is_module_file(filename):
+                    num_items += 1
+                elif is_package_dir(filename):
+                    num_items += self._est_pkg_modules(filename)
+                    
+        return num_items
+        
+######################################################################
+## Doc Merger
+######################################################################
+
+MERGE_PRECEDENCE = {
+    'repr': 'parse',
+
+    # The names we get from introspection match the names that users
+    # can actually use -- i.e., they take magic into account.
+    'canonical_name': 'introspect',
+
+    # Only fall-back on the parser for is_imported if the introspecter
+    # isn't sure.  Otherwise, we can end up thinking that vars
+    # containing modules are not imported, which can cause external
+    # modules to show up in the docs (sf bug #1653486)
+    'is_imported': 'introspect',
+
+    # The parser can tell if an assignment creates an alias or not.
+    'is_alias': 'parse',
+
+    # The parser is better able to determine what text file something
+    # came from; e.g., it can't be fooled by 'covert' imports.
+    'docformat': 'parse',
+
+    # The parse should be able to tell definitively whether a module
+    # is a package or not.
+    'is_package': 'parse',
+
+    # Extract the sort spec from the order in which values are defined
+    # in the source file.
+    'sort_spec': 'parse',
+    
+    'submodules': 'introspect',
+
+    # The filename used by 'parse' is the source file.
+    'filename': 'parse',
+
+    # 'parse' is more likely to get the encoding right, but
+    # 'introspect' will handle programatically generated docstrings.
+    # Which is better?
+    'docstring': 'introspect',
+    }
+"""Indicates whether information from introspection or parsing should be
+given precedence, for specific attributes.  This dictionary maps from
+attribute names to either C{'introspect'} or C{'parse'}."""
+
+DEFAULT_MERGE_PRECEDENCE = 'introspect'
+"""Indicates whether information from introspection or parsing should be
+given precedence.  Should be either C{'introspect'} or C{'parse'}"""
+
+_attribute_mergefunc_registry = {}
+def register_attribute_mergefunc(attrib, mergefunc):
+    """
+    Register an attribute merge function.  This function will be
+    called by L{merge_docs()} when it needs to merge the attribute
+    values of two C{APIDoc}s.
+
+    @param attrib: The name of the attribute whose values are merged
+    by C{mergefunc}.
+
+    @param mergefunc: The merge function, whose sinature is:
+
+    >>> def mergefunc(introspect_val, parse_val, precedence, cyclecheck, path):
+    ...     return calculate_merged_value(introspect_val, parse_val)
+
+    Where C{introspect_val} and C{parse_val} are the two values to
+    combine; C{precedence} is a string indicating which value takes
+    precedence for this attribute (C{'introspect'} or C{'parse'});
+    C{cyclecheck} is a value used by C{merge_docs()} to make sure that
+    it only visits each pair of docs once; and C{path} is a string
+    describing the path that was taken from the root to this
+    attribute (used to generate log messages).
+
+    If the merge function needs to call C{merge_docs}, then it should
+    pass C{cyclecheck} and C{path} back in.  (When appropriate, a
+    suffix should be added to C{path} to describe the path taken to
+    the merged values.)
+    """
+    _attribute_mergefunc_registry[attrib] = mergefunc
+
+def merge_docs(introspect_doc, parse_doc, cyclecheck=None, path=None):
+    """
+    Merge the API documentation information that was obtained from
+    introspection with information that was obtained from parsing.
+    C{introspect_doc} and C{parse_doc} should be two C{APIDoc} instances
+    that describe the same object.  C{merge_docs} combines the
+    information from these two instances, and returns the merged
+    C{APIDoc}.
+
+    If C{introspect_doc} and C{parse_doc} are compatible, then they will
+    be I{merged} -- i.e., they will be coerced to a common class, and
+    their state will be stored in a shared dictionary.  Once they have
+    been merged, any change made to the attributes of one will affect
+    the other.  The value for the each of the merged C{APIDoc}'s
+    attributes is formed by combining the values of the source
+    C{APIDoc}s' attributes, as follows:
+
+      - If either of the source attributes' value is C{UNKNOWN}, then
+        use the other source attribute's value.
+      - Otherwise, if an attribute merge function has been registered
+        for the attribute, then use that function to calculate the
+        merged value from the two source attribute values.
+      - Otherwise, if L{MERGE_PRECEDENCE} is defined for the
+        attribute, then use the attribute value from the source that
+        it indicates.
+      - Otherwise, use the attribute value from the source indicated
+        by L{DEFAULT_MERGE_PRECEDENCE}.
+
+    If C{introspect_doc} and C{parse_doc} are I{not} compatible (e.g., if
+    their values have incompatible types), then C{merge_docs()} will
+    simply return either C{introspect_doc} or C{parse_doc}, depending on
+    the value of L{DEFAULT_MERGE_PRECEDENCE}.  The two input
+    C{APIDoc}s will not be merged or modified in any way.
+
+    @param cyclecheck, path: These arguments should only be provided
+        when C{merge_docs()} is called by an attribute merge
+        function.  See L{register_attribute_mergefunc()} for more
+        details.
+    """
+    assert isinstance(introspect_doc, APIDoc)
+    assert isinstance(parse_doc, APIDoc)
+
+    if cyclecheck is None:
+        cyclecheck = set()
+        if introspect_doc.canonical_name not in (None, UNKNOWN):
+            path = '%s' % introspect_doc.canonical_name
+        elif parse_doc.canonical_name not in (None, UNKNOWN):
+            path = '%s' % parse_doc.canonical_name
+        else:
+            path = '??'
+
+    # If we've already examined this pair, then there's nothing
+    # more to do.  The reason that we check id's here is that we
+    # want to avoid hashing the APIDoc objects for now, so we can
+    # use APIDoc.merge_and_overwrite() later.
+    if (id(introspect_doc), id(parse_doc)) in cyclecheck:
+        return introspect_doc
+    cyclecheck.add( (id(introspect_doc), id(parse_doc)) )
+
+    # If these two are already merged, then we're done.  (Two
+    # APIDoc's compare equal iff they are identical or have been
+    # merged.)
+    if introspect_doc == parse_doc:
+        return introspect_doc
+
+    # If both values are GenericValueDoc, then we don't want to merge
+    # them.  E.g., we don't want to merge 2+2 with 4.  So just copy
+    # the parse_doc's parse_repr to introspect_doc, & return it.
+    # (In particular, do *not* call merge_and_overwrite.)
+    if type(introspect_doc) == type(parse_doc) == GenericValueDoc:
+        if parse_doc.parse_repr is not UNKNOWN:
+            introspect_doc.parse_repr = parse_doc.parse_repr
+        introspect_doc.docs_extracted_by = 'both'
+        return introspect_doc
+
+    # Perform several sanity checks here -- if we accidentally
+    # merge values that shouldn't get merged, then bad things can
+    # happen.
+    mismatch = None
+    if (introspect_doc.__class__ != parse_doc.__class__ and
+        not (issubclass(introspect_doc.__class__, parse_doc.__class__) or
+             issubclass(parse_doc.__class__, introspect_doc.__class__))):
+        mismatch = ("value types don't match -- i=%r, p=%r." %
+                    (introspect_doc.__class__, parse_doc.__class__))
+    if (isinstance(introspect_doc, ValueDoc) and
+        isinstance(parse_doc, ValueDoc)):
+        if (introspect_doc.pyval is not UNKNOWN and
+            parse_doc.pyval is not UNKNOWN and
+            introspect_doc.pyval is not parse_doc.pyval):
+            mismatch = "values don't match."
+        elif (introspect_doc.canonical_name not in (None, UNKNOWN) and
+            parse_doc.canonical_name not in (None, UNKNOWN) and
+            introspect_doc.canonical_name != parse_doc.canonical_name):
+            mismatch = "canonical names don't match."
+    if mismatch is not None:
+        log.info("Not merging the parsed & introspected values of %s, "
+                 "since their %s" % (path, mismatch))
+        if DEFAULT_MERGE_PRECEDENCE == 'introspect':
+            return introspect_doc
+        else:
+            return parse_doc
+
+    # If one apidoc's class is a superclass of the other's, then
+    # specialize it to the more specific class.
+    if introspect_doc.__class__ is not parse_doc.__class__:
+        if issubclass(introspect_doc.__class__, parse_doc.__class__):
+            parse_doc.specialize_to(introspect_doc.__class__)
+        if issubclass(parse_doc.__class__, introspect_doc.__class__):
+            introspect_doc.specialize_to(parse_doc.__class__)
+    assert introspect_doc.__class__ is parse_doc.__class__
+
+    # The posargs and defaults are tied together -- if we merge
+    # the posargs one way, then we need to merge the defaults the
+    # same way.  So check them first.  (This is a minor hack)
+    if (isinstance(introspect_doc, RoutineDoc) and
+        isinstance(parse_doc, RoutineDoc)):
+        _merge_posargs_and_defaults(introspect_doc, parse_doc, path)
+    
+    # Merge the two api_doc's attributes.
+    for attrib in set(introspect_doc.__dict__.keys() +
+                      parse_doc.__dict__.keys()):
+        # Be sure not to merge any private attributes (especially
+        # __mergeset or __has_been_hashed!)
+        if attrib.startswith('_'): continue
+        merge_attribute(attrib, introspect_doc, parse_doc,
+                             cyclecheck, path)
+
+    # Set the dictionaries to be shared.
+    return introspect_doc.merge_and_overwrite(parse_doc)
+
+def _merge_posargs_and_defaults(introspect_doc, parse_doc, path):
+    # If either is unknown, then let merge_attrib handle it.
+    if introspect_doc.posargs is UNKNOWN or parse_doc.posargs is UNKNOWN:
+        return 
+        
+    # If the introspected doc just has '...', then trust the parsed doc.
+    if introspect_doc.posargs == ['...'] and parse_doc.posargs != ['...']:
+        introspect_doc.posargs = parse_doc.posargs
+        introspect_doc.posarg_defaults = parse_doc.posarg_defaults
+
+    # If they are incompatible, then check the precedence.
+    elif introspect_doc.posargs != parse_doc.posargs:
+        log.info("Not merging the parsed & introspected arg "
+                 "lists for %s, since they don't match (%s vs %s)"
+                  % (path, introspect_doc.posargs, parse_doc.posargs))
+        if (MERGE_PRECEDENCE.get('posargs', DEFAULT_MERGE_PRECEDENCE) ==
+            'introspect'):
+            parse_doc.posargs = introspect_doc.posargs
+            parse_doc.posarg_defaults = introspect_doc.posarg_defaults
+        else:
+            introspect_doc.posargs = parse_doc.posargs
+            introspect_doc.posarg_defaults = parse_doc.posarg_defaults
+
+def merge_attribute(attrib, introspect_doc, parse_doc, cyclecheck, path):
+    precedence = MERGE_PRECEDENCE.get(attrib, DEFAULT_MERGE_PRECEDENCE)
+    if precedence not in ('parse', 'introspect'):
+        raise ValueError('Bad precedence value %r' % precedence)
+    
+    if (getattr(introspect_doc, attrib) is UNKNOWN and
+        getattr(parse_doc, attrib) is not UNKNOWN):
+        setattr(introspect_doc, attrib, getattr(parse_doc, attrib))
+    elif (getattr(introspect_doc, attrib) is not UNKNOWN and
+          getattr(parse_doc, attrib) is UNKNOWN):
+        setattr(parse_doc, attrib, getattr(introspect_doc, attrib))
+    elif (getattr(introspect_doc, attrib) is UNKNOWN and
+          getattr(parse_doc, attrib) is UNKNOWN):
+        pass
+    else:
+        # Both APIDoc objects have values; we need to merge them.
+        introspect_val = getattr(introspect_doc, attrib)
+        parse_val = getattr(parse_doc, attrib)
+        if attrib in _attribute_mergefunc_registry:
+            handler = _attribute_mergefunc_registry[attrib]
+            merged_val = handler(introspect_val, parse_val, precedence,
+                                 cyclecheck, path)
+        elif precedence == 'introspect':
+            merged_val = introspect_val
+        elif precedence == 'parse':
+            merged_val = parse_val
+
+        setattr(introspect_doc, attrib, merged_val)
+        setattr(parse_doc, attrib, merged_val)
+
+def merge_variables(varlist1, varlist2, precedence, cyclecheck, path):
+    # Merge all variables that are in both sets.
+    for varname, var1 in varlist1.items():
+        var2 = varlist2.get(varname)
+        if var2 is not None:
+            var = merge_docs(var1, var2, cyclecheck, path+'.'+varname)
+            varlist1[varname] = var
+            varlist2[varname] = var
+
+    # Copy any variables that are not in varlist1 over.
+    for varname, var in varlist2.items():
+        varlist1.setdefault(varname, var)
+
+    return varlist1
+
+def merge_value(value1, value2, precedence, cyclecheck, path):
+    assert value1 is not None and value2 is not None
+    return merge_docs(value1, value2, cyclecheck, path)
+
+def merge_overrides(v1, v2, precedence, cyclecheck, path):
+    return merge_value(v1, v2, precedence, cyclecheck, path+'.<overrides>')
+def merge_fget(v1, v2, precedence, cyclecheck, path):
+    return merge_value(v1, v2, precedence, cyclecheck, path+'.fget')
+def merge_fset(v1, v2, precedence, cyclecheck, path):
+    return merge_value(v1, v2, precedence, cyclecheck, path+'.fset')
+def merge_fdel(v1, v2, precedence, cyclecheck, path):
+    return merge_value(v1, v2, precedence, cyclecheck, path+'.fdel')
+
+def merge_proxy_for(v1, v2, precedence, cyclecheck, path):
+    # Anything we got from introspection shouldn't have a proxy_for
+    # attribute -- it should be the actual object's documentation.
+    return v1
+
+def merge_bases(baselist1, baselist2, precedence, cyclecheck, path):
+    # Be careful here -- if we get it wrong, then we could end up
+    # merging two unrelated classes, which could lead to bad
+    # things (e.g., a class that's its own subclass).  So only
+    # merge two bases if we're quite sure they're the same class.
+    # (In particular, if they have the same canonical name.)
+
+    # If the lengths don't match up, then give up.  This is most
+    # often caused by __metaclass__.
+    if len(baselist1) != len(baselist2):
+        log.info("Not merging the introspected & parsed base lists "
+                 "for %s, since their lengths don't match (%s vs %s)" %
+                 (path, len(baselist1), len(baselist2)))
+        if precedence == 'introspect': return baselist1
+        else: return baselist2
+
+    # If any names disagree, then give up.
+    for base1, base2 in zip(baselist1, baselist2):
+        if ((base1.canonical_name not in (None, UNKNOWN) and
+             base2.canonical_name not in (None, UNKNOWN)) and
+            base1.canonical_name != base2.canonical_name):
+            log.info("Not merging the parsed & introspected base "
+                     "lists for %s, since the bases' names don't match "
+                     "(%s vs %s)" % (path, base1.canonical_name,
+                                     base2.canonical_name))
+            if precedence == 'introspect': return baselist1
+            else: return baselist2
+
+    for i, (base1, base2) in enumerate(zip(baselist1, baselist2)):
+        base = merge_docs(base1, base2, cyclecheck,
+                           '%s.__bases__[%d]' % (path, i))
+        baselist1[i] = baselist2[i] = base
+
+    return baselist1
+
+def merge_posarg_defaults(defaults1, defaults2, precedence, cyclecheck, path):
+    if len(defaults1) != len(defaults2):
+        if precedence == 'introspect': return defaults1
+        else: return defaults2
+    defaults = []
+    for i, (d1, d2) in enumerate(zip(defaults1, defaults2)):
+        if d1 is not None and d2 is not None:
+            d_path = '%s.<default-arg-val>[%d]' % (path, i)
+            defaults.append(merge_docs(d1, d2, cyclecheck, d_path))
+        elif precedence == 'introspect':
+            defaults.append(d1)
+        else:
+            defaults.append(d2)
+    return defaults
+
+def merge_docstring(docstring1, docstring2, precedence, cyclecheck, path):
+    if docstring1 is None or docstring1 is UNKNOWN or precedence=='parse':
+        return docstring2
+    else:
+        return docstring1
+
+def merge_docs_extracted_by(v1, v2, precedence, cyclecheck, path):
+    return 'both'
+
+def merge_submodules(v1, v2, precedence, cyclecheck, path):
+    n1 = sorted([m.canonical_name for m in v1])
+    n2 = sorted([m.canonical_name for m in v2])
+    if (n1 != n2) and (n2 != []):
+        log.info('Introspector & parser disagree about submodules '
+                 'for %s: (%s) vs (%s)' % (path,
+                                           ', '.join([str(n) for n in n1]),
+                                           ', '.join([str(n) for n in n2])))
+        return v1 + [m for m in v2 if m.canonical_name not in n1]
+                
+    return v1
+
+register_attribute_mergefunc('variables', merge_variables)
+register_attribute_mergefunc('value', merge_value)
+register_attribute_mergefunc('overrides', merge_overrides)
+register_attribute_mergefunc('fget', merge_fget)
+register_attribute_mergefunc('fset', merge_fset)
+register_attribute_mergefunc('fdel', merge_fdel)
+register_attribute_mergefunc('proxy_for', merge_proxy_for)
+register_attribute_mergefunc('bases', merge_bases)
+register_attribute_mergefunc('posarg_defaults', merge_posarg_defaults)
+register_attribute_mergefunc('docstring', merge_docstring)
+register_attribute_mergefunc('docs_extracted_by', merge_docs_extracted_by)
+register_attribute_mergefunc('submodules', merge_submodules)
+
+######################################################################
+## Import Linking
+######################################################################
+
+def link_imports(val_doc, docindex):
+    # Check if the ValueDoc has an unresolved proxy_for link.
+    # If so, then resolve it.
+    while val_doc.proxy_for not in (UNKNOWN, None):
+        # Find the valuedoc that the proxy_for name points to.
+        src_doc = docindex.get_valdoc(val_doc.proxy_for)
+
+        # If we don't have any valuedoc at that address, then
+        # set that address as its canonical name.
+        # [XXX] Do I really want to do this?
+        if src_doc is None:
+            val_doc.canonical_name = val_doc.proxy_for
+            return
+
+        # If we *do* have something at that address, then
+        # merge the proxy `val_doc` with it.
+        elif src_doc != val_doc:
+            # Copy any subclass information from val_doc->src_doc.
+            if (isinstance(val_doc, ClassDoc) and
+                isinstance(src_doc, ClassDoc)):
+                for subclass in val_doc.subclasses:
+                    if subclass not in src_doc.subclasses:
+                        src_doc.subclasses.append(subclass)
+            # Then overwrite val_doc with the contents of src_doc.
+            src_doc.merge_and_overwrite(val_doc, ignore_hash_conflict=True)
+
+        # If the proxy_for link points back at src_doc
+        # itself, then we most likely have a variable that's
+        # shadowing a submodule that it should be equal to.
+        # So just get rid of the variable.
+        elif src_doc == val_doc:
+            parent_name = val_doc.proxy_for[:-1]
+            var_name = val_doc.proxy_for[-1]
+            parent = docindex.get_valdoc(parent_name)
+            if parent is not None and var_name in parent.variables:
+                del parent.variables[var_name]
+            src_doc.proxy_for = None
+
+######################################################################
+## Canonical Name Assignment
+######################################################################
+
+_name_scores = {}
+"""A dictionary mapping from each C{ValueDoc} to the score that has
+been assigned to its current cannonical name.  If
+L{assign_canonical_names()} finds a canonical name with a better
+score, then it will replace the old name."""
+
+_unreachable_names = {DottedName(DottedName.UNREACHABLE):1}
+"""The set of names that have been used for unreachable objects.  This
+is used to ensure there are no duplicate cannonical names assigned.
+C{_unreachable_names} is a dictionary mapping from dotted names to
+integer ids, where the next unused unreachable name derived from
+dotted name C{n} is
+C{DottedName('%s-%s' % (n, str(_unreachable_names[n]+1))}"""
+
+def assign_canonical_names(val_doc, name, docindex, score=0):
+    """
+    Assign a canonical name to C{val_doc} (if it doesn't have one
+    already), and (recursively) to each variable in C{val_doc}.
+    In particular, C{val_doc} will be assigned the canonical name
+    C{name} iff either:
+      - C{val_doc}'s canonical name is C{UNKNOWN}; or
+      - C{val_doc}'s current canonical name was assigned by this
+        method; but the score of the new name (C{score}) is higher
+        than the score of the current name (C{score_dict[val_doc]}).
+        
+    Note that canonical names will even be assigned to values
+    like integers and C{None}; but these should be harmless.
+    """
+    # If we've already visited this node, and our new score
+    # doesn't beat our old score, then there's nothing more to do.
+    # Note that since score increases strictly monotonically, this
+    # also prevents us from going in cycles.
+    if val_doc in _name_scores and score <= _name_scores[val_doc]:
+        return
+
+    # Update val_doc's canonical name, if appropriate.
+    if (val_doc not in _name_scores and
+        val_doc.canonical_name is not UNKNOWN):
+        # If this is the first time we've seen val_doc, and it
+        # already has a name, then don't change that name.
+        _name_scores[val_doc] = sys.maxint
+        name = val_doc.canonical_name
+        score = 0
+    else:
+        # Otherwise, update the name iff the new score is better
+        # than the old one.
+        if (val_doc not in _name_scores or
+            score > _name_scores[val_doc]):
+            val_doc.canonical_name = name
+            _name_scores[val_doc] = score
+
+    # Recurse to any contained values.
+    if isinstance(val_doc, NamespaceDoc):
+        for var_doc in val_doc.variables.values():
+            # Set the variable's canonical name.
+            varname = DottedName(name, var_doc.name)
+            var_doc.canonical_name = varname
+
+            # If the value is unknown, or is a generic value doc, then
+            # the valuedoc doesn't get assigned a name; move on.
+            if (var_doc.value is UNKNOWN
+                or isinstance(var_doc.value, GenericValueDoc)):
+                continue
+            
+            # [XX] After svn commit 1644-1647, I'm not sure if this
+            # ever gets used:  This check is for cases like
+            # curses.wrapper, where an imported variable shadows its
+            # value's "real" location.
+            if _var_shadows_self(var_doc, varname):
+                _fix_self_shadowing_var(var_doc, varname, docindex)
+    
+            # Find the score for this new name.            
+            vardoc_score = score-1
+            if var_doc.is_imported is UNKNOWN: vardoc_score -= 10
+            elif var_doc.is_imported: vardoc_score -= 100
+            if var_doc.is_alias is UNKNOWN: vardoc_score -= 10
+            elif var_doc.is_alias: vardoc_score -= 1000
+            
+            assign_canonical_names(var_doc.value, varname,
+                                   docindex, vardoc_score)
+
+    # Recurse to any directly reachable values.
+    for val_doc_2 in val_doc.apidoc_links(variables=False):
+        val_name, val_score = _unreachable_name_for(val_doc_2, docindex)
+        assign_canonical_names(val_doc_2, val_name, docindex, val_score)
+
+def _var_shadows_self(var_doc, varname):
+    return (var_doc.value not in (None, UNKNOWN) and
+            var_doc.value.canonical_name not in (None, UNKNOWN) and
+            var_doc.value.canonical_name != varname and
+            varname.dominates(var_doc.value.canonical_name))
+
+def _fix_self_shadowing_var(var_doc, varname, docindex):
+    # If possible, find another name for the shadowed value.
+    cname = var_doc.value.canonical_name
+    for i in range(1, len(cname)-1):
+        new_name = cname[:i] + (cname[i]+"'") + cname[i+1:]
+        val_doc = docindex.get_valdoc(new_name)
+        if val_doc is not None:
+            log.warning("%s shadows its own value -- using %s instead" %
+                     (varname, new_name))
+            var_doc.value = val_doc
+            return
+
+    # If we couldn't find the actual value, use an unreachable name.
+    name, score = _unreachable_name_for(var_doc.value, docindex)
+    log.warning('%s shadows itself -- using %s instead' % (varname, name))
+    var_doc.value.canonical_name = name
+
+def _unreachable_name_for(val_doc, docindex):
+    assert isinstance(val_doc, ValueDoc)
+    
+    # [xx] (when) does this help?
+    if (isinstance(val_doc, ModuleDoc) and
+        len(val_doc.canonical_name)==1 and val_doc.package is None):
+        for root_val in docindex.root:
+            if root_val.canonical_name == val_doc.canonical_name:
+                if root_val != val_doc: 
+                    log.error("Name conflict: %r vs %r" %
+                              (val_doc, root_val))
+                break
+        else:
+            return val_doc.canonical_name, -1000
+
+    # Assign it an 'unreachable' name:
+    if (val_doc.pyval is not UNKNOWN and
+          hasattr(val_doc.pyval, '__name__')):
+        try:
+            name = DottedName(DottedName.UNREACHABLE,
+                              val_doc.pyval.__name__, strict=True)
+        except DottedName.InvalidDottedName:
+            name = DottedName(DottedName.UNREACHABLE)
+    else:
+        name = DottedName(DottedName.UNREACHABLE)
+
+    # Uniquify the name.
+    if name in _unreachable_names:
+        _unreachable_names[name] += 1
+        name = DottedName('%s-%s' % (name, _unreachable_names[name]-1))
+    else:
+        _unreachable_names[name] = 1
+    
+    return name, -10000
+
+######################################################################
+## Documentation Inheritance
+######################################################################
+
+def find_overrides(class_doc):
+    """
+    Set the C{overrides} attribute for all variables in C{class_doc}.
+    This needs to be done early (before docstring parsing), so we can
+    know which docstrings to suppress warnings for.
+    """
+    for base_class in list(class_doc.mro(warn_about_bad_bases=True)):
+        if base_class == class_doc: continue
+        if base_class.variables is UNKNOWN: continue
+        for name, var_doc in base_class.variables.items():
+            if ( not (name.startswith('__') and not name.endswith('__')) and
+                 base_class == var_doc.container and
+                 name in class_doc.variables and 
+                 class_doc.variables[name].container==class_doc and
+                 class_doc.variables[name].overrides is UNKNOWN ):
+                class_doc.variables[name].overrides = var_doc
+    
+    
+def inherit_docs(class_doc):
+    for base_class in list(class_doc.mro(warn_about_bad_bases=True)):
+        if base_class == class_doc: continue
+
+        # Inherit any groups.  Place them *after* this class's groups,
+        # so that any groups that are important to this class come
+        # first.
+        if base_class.group_specs not in (None, UNKNOWN):
+            class_doc.group_specs += [gs for gs in base_class.group_specs
+                                      if gs not in class_doc.group_specs]
+
+        # Inherit any variables.
+        if base_class.variables is UNKNOWN: continue
+        for name, var_doc in base_class.variables.items():
+            # If it's a __private variable, then don't inherit it.
+            if name.startswith('__') and not name.endswith('__'):
+                continue
+            
+            # Inhetit only from the defining class. Or else, in case of
+            # multiple inheritance, we may import from a grand-ancestor
+            # variables overridden by a class that follows in mro.
+            if base_class != var_doc.container:
+                continue
+            
+            # If class_doc doesn't have a variable with this name,
+            # then inherit it.
+            if name not in class_doc.variables:
+                class_doc.variables[name] = var_doc
+
+            # Otherwise, class_doc already contains a variable
+            # that shadows var_doc.  But if class_doc's var is
+            # local, then record the fact that it overrides
+            # var_doc.
+            elif class_doc.variables[name].container==class_doc:
+                class_doc.variables[name].overrides = var_doc
+                _inherit_info(class_doc.variables[name])
+
+_INHERITED_ATTRIBS = [
+    'descr', 'summary', 'metadata', 'extra_docstring_fields',
+    'type_descr', 'arg_descrs', 'arg_types', 'return_descr',
+    'return_type', 'exception_descrs']
+
+_method_descriptor = type(list.append)
+
+def _inherit_info(var_doc):
+    """
+    Copy any relevant documentation information from the variable that
+    C{var_doc} overrides into C{var_doc} itself.
+    """
+    src_var = var_doc.overrides
+    src_val = var_doc.overrides.value
+    val_doc = var_doc.value
+
+    # Special case: if the source value and target values are both c
+    # extension methods, and the target value's signature is not
+    # specified, then inherit the source value's signature.
+    if (isinstance(val_doc, RoutineDoc) and
+        isinstance(src_val, RoutineDoc) and
+        (inspect.isbuiltin(val_doc.pyval) or
+         isinstance(val_doc.pyval, _method_descriptor)) and
+        (inspect.isbuiltin(src_val.pyval) or
+         isinstance(src_val.pyval, _method_descriptor)) and
+        val_doc.all_args() in (['...'], UNKNOWN) and
+        src_val.all_args() not in (['...'], UNKNOWN)):
+        for attrib in ['posargs', 'posarg_defaults', 'vararg',
+                       'kwarg', 'return_type']:
+            setattr(val_doc, attrib, getattr(src_val, attrib))
+    
+    # If the new variable has a docstring, then don't inherit
+    # anything, even if the docstring is blank.
+    if var_doc.docstring not in (None, UNKNOWN):
+        return
+    # [xx] Do I want a check like this:?
+#     # If it's a method and the signature doesn't match well enough,
+#     # then give up.
+#     if (isinstance(src_val, RoutineDoc) and
+#         isinstance(val_doc, RoutineDoc)):
+#         if (src_val.posargs != val_doc.posargs[:len(src_val.posargs)] or
+#             src_val.vararg != None and src_val.vararg != val_doc.vararg):
+#             log.docstring_warning(
+#                 "The signature of %s does not match the signature of the "
+#                 "method it overrides (%s); not inheriting documentation." %
+#                 (var_doc.canonical_name, src_var.canonical_name))
+#             return
+
+    # Inherit attributes!
+    for attrib in _INHERITED_ATTRIBS:
+        if (hasattr(var_doc, attrib) and hasattr(src_var, attrib) and
+            getattr(src_var, attrib) not in (None, UNKNOWN)):
+            setattr(var_doc, attrib, getattr(src_var, attrib))
+        elif (src_val is not None and
+              hasattr(val_doc, attrib) and hasattr(src_val, attrib) and
+              getattr(src_val, attrib) not in (None, UNKNOWN) and
+              getattr(val_doc, attrib) in (None, UNKNOWN, [])):
+            setattr(val_doc, attrib, getattr(src_val, attrib))