# epydoc -- Documentation Builder
#
# Copyright (C) 2005 Edward Loper
# Author: Edward Loper <edloper@loper.org>
# URL: <http://epydoc.sf.net>
#
# $Id: docbuilder.py 1683 2008-01-29 22:17:39Z edloper $
"""
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))
|