Fixes for various issues reported and discovered since Python 9:
Factor description of import errors into DocImportError.__str__.
Add "docother" and "fail" methods to Doc class.
Factor formatting of constants into "docother".
Increase max string repr limit to 100 characters.
Factor page generation into HTMLDoc.page.
Handle aliasing of names (objects appearing under an attribute
name different from their intrinsic __name__) by passing the
attribute name into each doc* method.
Handle methods at top level of modules (e.g. in random).
Try to do reloading efficiently.
Important fixes still to do:
Module reloading is broken by the unfortunate property that
failed imports leave an incomplete module in sys. Still
need to think of a good solution.
Can't document modules in the current directory, due to the
other unfortunate property that sys.path gets '.' when
you run 'python' but it gets the script directory when
you run a script. Need to ponder to find a solution.
The synopsis() routine does not work on .so modules.
Aliases cause duplicate copies of documentation to appear.
This is easy to fix, just more work.
Classes appear as their intrinsic name, not their attribute name,
in the class hierarchy. This should be fixed.
Inherited methods should be listed in class descriptions.
diff --git a/Lib/pydoc.py b/Lib/pydoc.py
index b64e78e..baa1985 100755
--- a/Lib/pydoc.py
+++ b/Lib/pydoc.py
@@ -4,24 +4,25 @@
In the Python interpreter, do "from pydoc import help" to provide online
help. Calling help(thing) on a Python object documents the object.
-At the shell command line outside of Python:
- Run "pydoc <name>" to show documentation on something. <name> may be
- the name of a function, module, package, or a dotted reference to a
- class or function within a module or module in a package. If the
- argument contains a path segment delimiter (e.g. slash on Unix,
- backslash on Windows) it is treated as the path to a Python source file.
+Or, at the shell command line outside of Python:
- Run "pydoc -k <keyword>" to search for a keyword in the synopsis lines
- of all available modules.
+Run "pydoc <name>" to show documentation on something. <name> may be
+the name of a function, module, package, or a dotted reference to a
+class or function within a module or module in a package. If the
+argument contains a path segment delimiter (e.g. slash on Unix,
+backslash on Windows) it is treated as the path to a Python source file.
- Run "pydoc -p <port>" to start an HTTP server on a given port on the
- local machine to generate documentation web pages.
+Run "pydoc -k <keyword>" to search for a keyword in the synopsis lines
+of all available modules.
- For platforms without a command line, "pydoc -g" starts the HTTP server
- and also pops up a little window for controlling it.
+Run "pydoc -p <port>" to start an HTTP server on a given port on the
+local machine to generate documentation web pages.
- Run "pydoc -w <name>" to write out the HTML documentation for a module
- to a file named "<name>.html".
+For platforms without a command line, "pydoc -g" starts the HTTP server
+and also pops up a little window for controlling it.
+
+Run "pydoc -w <name>" to write out the HTML documentation for a module
+to a file named "<name>.html".
"""
__author__ = "Ka-Ping Yee <ping@lfw.org>"
@@ -48,6 +49,7 @@
"""Get the one-line summary out of a module file."""
mtime = os.stat(filename)[stat.ST_MTIME]
lastupdate, result = cache.get(filename, (0, None))
+ # XXX what if ext is 'rb' type in imp_getsuffixes?
if lastupdate < mtime:
file = open(filename)
line = file.readline()
@@ -137,13 +139,17 @@
class DocImportError(Exception):
"""Class for errors while trying to import something to document it."""
- def __init__(self, filename, etype, evalue):
+ def __init__(self, filename, (type, value, tb)):
self.filename = filename
- self.etype = etype
- self.evalue = evalue
- if type(etype) is types.ClassType:
- etype = etype.__name__
- self.args = '%s: %s' % (etype, evalue)
+ self.type = type
+ self.value = value
+ self.tb = tb
+
+ def __str__(self):
+ t = self.type
+ if type(t) is types.ClassType:
+ t = t.__name__
+ return 'problem in %s - %s: %s' % (self.filename, t, self.value)
def importfile(path):
"""Import a Python source file or compiled file given its path."""
@@ -160,29 +166,35 @@
try:
module = imp.load_module(name, file, path, (ext, 'r', kind))
except:
- raise DocImportError(path, sys.exc_type, sys.exc_value)
+ raise DocImportError(path, sys.exc_info())
file.close()
return module
def ispackage(path):
"""Guess whether a path refers to a package directory."""
if os.path.isdir(path):
- init = os.path.join(path, '__init__.py')
- initc = os.path.join(path, '__init__.pyc')
- if os.path.isfile(init) or os.path.isfile(initc):
- return 1
+ for ext in ['.py', '.pyc', '.pyo']:
+ if os.path.isfile(os.path.join(path, '__init__' + ext)):
+ return 1
# ---------------------------------------------------- formatter base class
class Doc:
- def document(self, object, *args):
+ def document(self, object, name=None, *args):
"""Generate documentation for an object."""
- args = (object,) + args
+ args = (object, name) + args
if inspect.ismodule(object): return apply(self.docmodule, args)
if inspect.isclass(object): return apply(self.docclass, args)
if inspect.isroutine(object): return apply(self.docroutine, args)
- raise TypeError, "don't know how to document objects of type " + \
- type(object).__name__
+ return apply(self.docother, args)
+
+ def fail(self, object, name=None, *args):
+ """Raise an exception for unimplemented types."""
+ message = "don't know how to document object%s of type %s" % (
+ name and ' ' + repr(name), type(object).__name__)
+ raise TypeError, message
+
+ docmodule = docclass = docroutine = docother = fail
# -------------------------------------------- HTML documentation generator
@@ -191,14 +203,13 @@
def __init__(self):
Repr.__init__(self)
self.maxlist = self.maxtuple = self.maxdict = 10
- self.maxstring = self.maxother = 50
+ self.maxstring = self.maxother = 100
def escape(self, text):
return replace(text, ('&', '&'), ('<', '<'), ('>', '>'))
def repr(self, object):
- result = Repr.repr(self, object)
- return result
+ return Repr.repr(self, object)
def repr1(self, x, level):
methodname = 'repr_' + join(split(type(x).__name__), '_')
@@ -220,7 +231,7 @@
def repr_instance(self, x, level):
try:
- return cram(stripid(repr(x)), self.maxstring)
+ return self.escape(cram(stripid(repr(x)), self.maxstring))
except:
return self.escape('<%s instance>' % x.__class__.__name__)
@@ -235,6 +246,52 @@
repr = _repr_instance.repr
escape = _repr_instance.escape
+ def page(self, title, contents):
+ """Format an HTML page."""
+ return '''
+<!doctype html public "-//W3C//DTD HTML 4.0 Transitional//EN">
+<html><title>Python: %s</title><body bgcolor="#f0f0f8">
+%s
+</body></html>''' % (title, contents)
+
+ def heading(self, title, fgcol, bgcol, extras=''):
+ """Format a page heading."""
+ return '''
+<table width="100%%" cellspacing=0 cellpadding=2 border=0>
+<tr bgcolor="%s">
+<td valign=bottom><small> <br></small
+><font color="%s" face="helvetica"> <br>%s</font></td
+><td align=right valign=bottom
+><font color="%s" face="helvetica">%s</font></td></tr></table>
+ ''' % (bgcol, fgcol, title, fgcol, extras or ' ')
+
+ def section(self, title, fgcol, bgcol, contents, width=20,
+ prelude='', marginalia=None, gap=' '):
+ """Format a section with a heading."""
+ if marginalia is None:
+ marginalia = ' ' * width
+ result = '''
+<p><table width="100%%" cellspacing=0 cellpadding=2 border=0>
+<tr bgcolor="%s">
+<td colspan=3 valign=bottom><small><small> <br></small></small
+><font color="%s" face="helvetica, arial">%s</font></td></tr>
+ ''' % (bgcol, fgcol, title)
+ if prelude:
+ result = result + '''
+<tr bgcolor="%s"><td>%s</td>
+<td colspan=2>%s</td></tr>
+ ''' % (bgcol, marginalia, prelude)
+ result = result + '''
+<tr><td bgcolor="%s">%s</td><td>%s</td>
+ ''' % (bgcol, marginalia, gap)
+
+ return result + '<td width="100%%">%s</td></tr></table>' % contents
+
+ def bigsection(self, title, *args):
+ """Format a section with a big heading."""
+ title = '<big><strong>%s</strong></big>' % title
+ return apply(self.section, (title,) + args)
+
def preformat(self, text):
"""Format literal preformatted text."""
text = self.escape(expandtabs(text))
@@ -245,7 +302,6 @@
"""Format a list of items into a multi-column list."""
result = ''
rows = (len(list)+cols-1)/cols
-
for col in range(cols):
result = result + '<td width="%d%%" valign=top>' % (100/cols)
for i in range(rows*col, rows*col+rows):
@@ -254,44 +310,8 @@
result = result + '</td>'
return '<table width="100%%"><tr>%s</tr></table>' % result
- def heading(self, title, fgcol, bgcol, extras=''):
- """Format a page heading."""
- return """
-<p><table width="100%%" cellspacing=0 cellpadding=0 border=0>
-<tr bgcolor="%s"><td> </td>
-<td valign=bottom><small><small><br></small></small
-><font color="%s" face="helvetica"><br> %s</font></td
-><td align=right valign=bottom
-><font color="%s" face="helvetica">%s</font></td><td> </td></tr></table>
- """ % (bgcol, fgcol, title, fgcol, extras or ' ')
-
- def section(self, title, fgcol, bgcol, contents, width=20,
- prelude='', marginalia=None, gap=' '):
- """Format a section with a heading."""
- if marginalia is None:
- marginalia = ' ' * width
- result = """
-<p><table width="100%%" cellspacing=0 cellpadding=0 border=0>
-<tr bgcolor="%s"><td rowspan=2> </td>
-<td colspan=3 valign=bottom><small><small><br></small></small
-><font color="%s" face="helvetica, arial"> %s</font></td></tr>
- """ % (bgcol, fgcol, title)
- if prelude:
- result = result + """
-<tr><td bgcolor="%s">%s</td>
-<td bgcolor="%s" colspan=2>%s</td></tr>
- """ % (bgcol, marginalia, bgcol, prelude)
- result = result + """
-<tr><td bgcolor="%s">%s</td><td>%s</td>
- """ % (bgcol, marginalia, gap)
-
- result = result + '<td width="100%%">%s</td></tr></table>' % contents
- return result
-
- def bigsection(self, title, *args):
- """Format a section with a big heading."""
- title = '<big><strong>%s</strong></big>' % title
- return apply(self.section, (title,) + args)
+ def small(self, text): return '<small>%s</small>' % text
+ def grey(self, text): return '<font color="#909090">%s</font>' % text
def namelink(self, name, *dicts):
"""Make a link for an identifier, given name-to-URL mappings."""
@@ -317,7 +337,7 @@
def modpkglink(self, (name, path, ispackage, shadowed)):
"""Make a link for a module or package to display in an index."""
if shadowed:
- return '<font color="#909090">%s</font>' % name
+ return self.grey(name)
if path:
url = '%s.%s.html' % (path, name)
else:
@@ -362,7 +382,7 @@
# ---------------------------------------------- type-specific routines
- def doctree(self, tree, modname, classes={}, parent=None):
+ def formattree(self, tree, modname, classes={}, parent=None):
"""Produce HTML for a class tree as given by inspect.getclasstree()."""
result = ''
for entry in tree:
@@ -377,13 +397,13 @@
result = result + '(' + join(parents, ', ') + ')'
result = result + '\n</small></font></dt>'
elif type(entry) is type([]):
- result = result + \
- '<dd>\n%s</dd>\n' % self.doctree(entry, modname, classes, c)
+ result = result + '<dd>\n%s</dd>\n' % self.formattree(
+ entry, modname, classes, c)
return '<dl>\n%s</dl>\n' % result
- def docmodule(self, object):
+ def docmodule(self, object, name=None):
"""Produce HTML documentation for a module object."""
- name = object.__name__
+ name = object.__name__ # ignore the passed-in name
parts = split(name, '.')
links = []
for i in range(len(parts)-1):
@@ -410,36 +430,42 @@
result = self.heading(
head, '#ffffff', '#7799ee', '<a href=".">index</a><br>' + filelink)
- second = lambda list: list[1]
- modules = map(second, inspect.getmembers(object, inspect.ismodule))
+ modules = inspect.getmembers(object, inspect.ismodule)
+
+ if 0 and hasattr(object, '__all__'):
+ visible = lambda key, all=object.__all__: key in all
+ else:
+ visible = lambda key: key[:1] != '_'
classes, cdict = [], {}
for key, value in inspect.getmembers(object, inspect.isclass):
- if (inspect.getmodule(value) or object) is object:
- classes.append(value)
+ if visible(key) and (
+ inspect.getmodule(value) or object) is object:
+ classes.append((key, value))
cdict[key] = cdict[value] = '#' + key
- funcs, fdict = [], {}
- for key, value in inspect.getmembers(object, inspect.isroutine):
- if inspect.isbuiltin(value) or inspect.getmodule(value) is object:
- funcs.append(value)
- fdict[key] = '#-' + key
- if inspect.isfunction(value): fdict[value] = fdict[key]
- for c in classes:
- for base in c.__bases__:
+ for key, value in classes:
+ for base in value.__bases__:
key, modname = base.__name__, base.__module__
- if modname != name and sys.modules.has_key(modname):
- module = sys.modules[modname]
- if hasattr(module, key) and getattr(module, key) is base:
+ module = sys.modules.get(modname)
+ if modname != name and module and hasattr(module, key):
+ if getattr(module, key) is base:
if not cdict.has_key(key):
cdict[key] = cdict[base] = modname + '.html#' + key
+ funcs, fdict = [], {}
+ for key, value in inspect.getmembers(object, inspect.isroutine):
+ if visible(key) and (inspect.isbuiltin(value) or
+ inspect.getmodule(value) is object):
+ funcs.append((key, value))
+ fdict[key] = '#-' + key
+ if inspect.isfunction(value): fdict[value] = fdict[key]
constants = []
for key, value in inspect.getmembers(object, isconstant):
- if key[:1] != '_':
+ if visible(key):
constants.append((key, value))
doc = self.markup(getdoc(object), self.preformat, fdict, cdict)
doc = doc and '<tt>%s</tt>' % doc
- result = result + '<p><small>%s</small></p>\n' % doc
+ result = result + '<p>%s\n' % self.small(doc)
if hasattr(object, '__path__'):
modpkgs = []
@@ -457,39 +483,36 @@
contents = self.multicolumn(modpkgs, self.modpkglink)
result = result + self.bigsection(
'Package Contents', '#ffffff', '#aa55cc', contents)
-
elif modules:
- contents = self.multicolumn(modules, self.modulelink)
+ contents = self.multicolumn(
+ modules, lambda (key, value), s=self: s.modulelink(value))
result = result + self.bigsection(
'Modules', '#fffff', '#aa55cc', contents)
if classes:
- contents = self.doctree(
- inspect.getclasstree(classes, 1), name, cdict)
- for item in classes:
- contents = contents + self.document(item, fdict, cdict)
+ classlist = map(lambda (key, value): value, classes)
+ contents = [self.formattree(
+ inspect.getclasstree(classlist, 1), name, cdict)]
+ for key, value in classes:
+ contents.append(self.document(value, key, fdict, cdict))
result = result + self.bigsection(
- 'Classes', '#ffffff', '#ee77aa', contents)
+ 'Classes', '#ffffff', '#ee77aa', join(contents))
if funcs:
- contents = ''
- for item in funcs:
- contents = contents + self.document(item, fdict, cdict)
+ contents = []
+ for key, value in funcs:
+ contents.append(self.document(value, key, fdict, cdict))
result = result + self.bigsection(
- 'Functions', '#ffffff', '#eeaa77', contents)
-
+ 'Functions', '#ffffff', '#eeaa77', join(contents))
if constants:
- contents = ''
+ contents = []
for key, value in constants:
- contents = contents + ('<br><strong>%s</strong> = %s' %
- (key, self.repr(value)))
+ contents.append(self.document(value, key))
result = result + self.bigsection(
- 'Constants', '#ffffff', '#55aa55', contents)
-
+ 'Constants', '#ffffff', '#55aa55', join(contents, '<br>'))
if hasattr(object, '__author__'):
contents = self.markup(str(object.__author__), self.preformat)
result = result + self.bigsection(
'Author', '#ffffff', '#7799ee', contents)
-
if hasattr(object, '__credits__'):
contents = self.markup(str(object.__credits__), self.preformat)
result = result + self.bigsection(
@@ -497,67 +520,84 @@
return result
- def docclass(self, object, funcs={}, classes={}):
+ def docclass(self, object, name=None, funcs={}, classes={}):
"""Produce HTML documentation for a class object."""
- name = object.__name__
+ realname = object.__name__
+ name = name or realname
bases = object.__bases__
contents = ''
methods, mdict = [], {}
for key, value in inspect.getmembers(object, inspect.ismethod):
- methods.append(value)
+ methods.append((key, value))
mdict[key] = mdict[value] = '#' + name + '-' + key
- for item in methods:
+ for key, value in methods:
contents = contents + self.document(
- item, funcs, classes, mdict, name)
+ value, key, funcs, classes, mdict, name)
- title = '<a name="%s">class <strong>%s</strong></a>' % (name, name)
+ if name == realname:
+ title = '<a name="%s">class <strong>%s</strong></a>' % (
+ name, realname)
+ else:
+ title = '<strong>%s</strong> = <a name="%s">class %s</a>' % (
+ name, name, realname)
+
if bases:
parents = []
for base in bases:
- parents.append(self.classlink(base, object.__module__, classes))
+ parents.append(
+ self.classlink(base, object.__module__, classes))
title = title + '(%s)' % join(parents, ', ')
- doc = self.markup(getdoc(object), self.preformat,
- funcs, classes, mdict)
- if doc: doc = '<small><tt>' + doc + '</tt></small>'
+ doc = self.markup(
+ getdoc(object), self.preformat, funcs, classes, mdict)
+ if doc: doc = self.small('<tt>%s</tt>' % doc)
return self.section(title, '#000000', '#ffc8d8', contents, 10, doc)
def formatvalue(self, object):
"""Format an argument default value as text."""
- return ('<small><font color="#909090">=%s</font></small>' %
- self.repr(object))
+ return self.small(self.grey('=' + self.repr(object)))
- def docroutine(self, object, funcs={}, classes={}, methods={}, clname=''):
+ def docroutine(self, object, name=None,
+ funcs={}, classes={}, methods={}, clname=''):
"""Produce HTML documentation for a function or method object."""
- if inspect.ismethod(object): object = object.im_func
+ realname = object.__name__
+ name = name or realname
+ anchor = clname + '-' + realname
+ note = ''
+ if inspect.ismethod(object):
+ if not clname:
+ note = self.small(self.grey(
+ object.im_self and
+ 'method of ' + self.repr(object.im_self) or
+ ' unbound %s method' % object.im_class.__name__))
+ object = object.im_func
+
+ if name == realname:
+ title = '<a name="%s"><strong>%s</strong></a>' % (anchor, realname)
+ else:
+ title = '<strong>%s</strong> = <a name="%s">%s</a>' % (
+ name, anchor, realname)
if inspect.isbuiltin(object):
- decl = '<a name="%s"><strong>%s</strong>(...)</a>\n' % (
- clname + '-' + object.__name__, object.__name__)
+ argspec = '(...)'
else:
args, varargs, varkw, defaults = inspect.getargspec(object)
argspec = inspect.formatargspec(
args, varargs, varkw, defaults, formatvalue=self.formatvalue)
+ if realname == '<lambda>':
+ decl = '<em>lambda</em>'
+ argspec = argspec[1:-1] # remove parentheses
- if object.__name__ == '<lambda>':
- decl = '<em>lambda</em> ' + argspec[1:-1]
- else:
- anchor = clname + '-' + object.__name__
- decl = '<a name="%s"\n><strong>%s</strong>%s</a>\n' % (
- anchor, object.__name__, argspec)
- doc = self.markup(getdoc(object), self.preformat,
- funcs, classes, methods)
+ decl = title + argspec + note
+
+ doc = self.markup(
+ getdoc(object), self.preformat, funcs, classes, methods)
doc = replace(doc, ('<br>\n', '</tt></small\n><dd><small><tt>'))
doc = doc and '<tt>%s</tt>' % doc
- return '<dl><dt>%s<dd><small>%s</small></dl>' % (decl, doc)
+ return '<dl><dt>%s<dd>%s</dl>' % (decl, self.small(doc))
- def page(self, object):
- """Produce a complete HTML page of documentation for an object."""
- return '''
-<!doctype html public "-//W3C//DTD HTML 4.0 Transitional//EN">
-<html><title>Python: %s</title><body bgcolor="#ffffff">
-%s
-</body></html>
-''' % (describe(object), self.document(object))
+ def docother(self, object, name=None):
+ """Produce HTML documentation for a data object."""
+ return '<strong>%s</strong> = %s' % (name, self.repr(object))
def index(self, dir, shadowed=None):
"""Generate an HTML index for a directory of modules."""
@@ -594,7 +634,7 @@
def __init__(self):
Repr.__init__(self)
self.maxlist = self.maxtuple = self.maxdict = 10
- self.maxstring = self.maxother = 50
+ self.maxstring = self.maxother = 100
def repr1(self, x, level):
methodname = 'repr_' + join(split(type(x).__name__), '_')
@@ -644,27 +684,25 @@
# ---------------------------------------------- type-specific routines
- def doctree(self, tree, modname, parent=None, prefix=''):
+ def formattree(self, tree, modname, parent=None, prefix=''):
"""Render in text a class tree as returned by inspect.getclasstree()."""
result = ''
for entry in tree:
if type(entry) is type(()):
- cl, bases = entry
- result = result + prefix + classname(cl, modname)
+ c, bases = entry
+ result = result + prefix + classname(c, modname)
if bases and bases != (parent,):
- parents = map(lambda cl, m=modname: classname(cl, m), bases)
+ parents = map(lambda c, m=modname: classname(c, m), bases)
result = result + '(%s)' % join(parents, ', ')
result = result + '\n'
elif type(entry) is type([]):
- result = result + self.doctree(
- entry, modname, cl, prefix + ' ')
+ result = result + self.formattree(
+ entry, modname, c, prefix + ' ')
return result
- def docmodule(self, object):
+ def docmodule(self, object, name=None):
"""Produce text documentation for a given module object."""
- result = ''
-
- name = object.__name__
+ name = object.__name__ # ignore the passed-in name
lines = split(strip(getdoc(object)), '\n')
if len(lines) == 1:
if lines[0]: name = name + ' - ' + lines[0]
@@ -672,9 +710,12 @@
elif len(lines) >= 2 and not rstrip(lines[1]):
if lines[0]: name = name + ' - ' + lines[0]
lines = lines[2:]
- result = result + self.section('NAME', name)
- try: file = inspect.getabsfile(object)
- except TypeError: file = '(built-in)'
+ result = self.section('NAME', name)
+
+ try:
+ file = inspect.getabsfile(object)
+ except TypeError:
+ file = '(built-in)'
result = result + self.section('FILE', file)
if lines:
result = result + self.section('DESCRIPTION', join(lines, '\n'))
@@ -682,11 +723,11 @@
classes = []
for key, value in inspect.getmembers(object, inspect.isclass):
if (inspect.getmodule(value) or object) is object:
- classes.append(value)
+ classes.append((key, value))
funcs = []
for key, value in inspect.getmembers(object, inspect.isroutine):
if inspect.isbuiltin(value) or inspect.getmodule(value) is object:
- funcs.append(value)
+ funcs.append((key, value))
constants = []
for key, value in inspect.getmembers(object, isconstant):
if key[:1] != '_':
@@ -707,27 +748,24 @@
'PACKAGE CONTENTS', join(modpkgs, '\n'))
if classes:
- contents = self.doctree(
- inspect.getclasstree(classes, 1), object.__name__) + '\n'
- for item in classes:
- contents = contents + self.document(item) + '\n'
- result = result + self.section('CLASSES', contents)
+ classlist = map(lambda (key, value): value, classes)
+ contents = [self.formattree(
+ inspect.getclasstree(classlist, 1), name)]
+ for key, value in classes:
+ contents.append(self.document(value, key))
+ result = result + self.section('CLASSES', join(contents, '\n'))
if funcs:
- contents = ''
- for item in funcs:
- contents = contents + self.document(item) + '\n'
- result = result + self.section('FUNCTIONS', contents)
+ contents = []
+ for key, value in funcs:
+ contents.append(self.document(value, key))
+ result = result + self.section('FUNCTIONS', join(contents, '\n'))
if constants:
- contents = ''
+ contents = []
for key, value in constants:
- line = key + ' = ' + self.repr(value)
- chop = 70 - len(line)
- line = self.bold(key) + ' = ' + self.repr(value)
- if chop < 0: line = line[:chop] + '...'
- contents = contents + line + '\n'
- result = result + self.section('CONSTANTS', contents)
+ contents.append(self.docother(value, key, 70))
+ result = result + self.section('CONSTANTS', join(contents, '\n'))
if hasattr(object, '__version__'):
version = str(object.__version__)
@@ -742,22 +780,24 @@
result = result + self.section('CREDITS', str(object.__credits__))
return result
- def docclass(self, object):
+ def docclass(self, object, name=None):
"""Produce text documentation for a given class object."""
- name = object.__name__
+ realname = object.__name__
+ name = name or realname
bases = object.__bases__
- title = 'class ' + self.bold(name)
+ if name == realname:
+ title = 'class ' + self.bold(realname)
+ else:
+ title = self.bold(name) + ' = class ' + realname
if bases:
parents = map(lambda c, m=object.__module__: classname(c, m), bases)
title = title + '(%s)' % join(parents, ', ')
doc = getdoc(object)
contents = doc and doc + '\n'
- methods = map(lambda (key, value): value,
- inspect.getmembers(object, inspect.ismethod))
- for item in methods:
- contents = contents + '\n' + self.document(item)
+ for key, value in inspect.getmembers(object, inspect.ismethod):
+ contents = contents + '\n' + self.document(value, key, name)
if not contents: return title + '\n'
return title + '\n' + self.indent(rstrip(contents), ' | ') + '\n'
@@ -766,25 +806,50 @@
"""Format an argument default value as text."""
return '=' + self.repr(object)
- def docroutine(self, object):
+ def docroutine(self, object, name=None, clname=None):
"""Produce text documentation for a function or method object."""
- if inspect.ismethod(object): object = object.im_func
+ realname = object.__name__
+ name = name or realname
+ note = ''
+ if inspect.ismethod(object):
+ if not clname:
+ if object.im_self:
+ note = ' method of %s' % self.repr(object.im_self)
+ else:
+ note = ' unbound %s method' % object.im_class.__name__
+ object = object.im_func
+
+ if name == realname:
+ title = self.bold(realname)
+ else:
+ title = self.bold(name) + ' = ' + realname
if inspect.isbuiltin(object):
- decl = self.bold(object.__name__) + '(...)'
+ argspec = '(...)'
else:
args, varargs, varkw, defaults = inspect.getargspec(object)
argspec = inspect.formatargspec(
args, varargs, varkw, defaults, formatvalue=self.formatvalue)
- if object.__name__ == '<lambda>':
- decl = '<lambda> ' + argspec[1:-1]
- else:
- decl = self.bold(object.__name__) + argspec
+ if realname == '<lambda>':
+ title = 'lambda'
+ argspec = argspec[1:-1] # remove parentheses
+ decl = title + argspec + note
+
doc = getdoc(object)
if doc:
return decl + '\n' + rstrip(self.indent(doc)) + '\n'
else:
return decl + '\n'
+ def docother(self, object, name=None, maxlen=None):
+ """Produce text documentation for a data object."""
+ repr = self.repr(object)
+ if maxlen:
+ line = name + ' = ' + repr
+ chop = maxlen - len(line)
+ if chop < 0: repr = repr[:chop] + '...'
+ line = self.bold(name) + ' = ' + repr
+ return line
+
# --------------------------------------------------------- user interfaces
def pager(text):
@@ -902,7 +967,21 @@
return 'function ' + thing.__name__
if inspect.ismethod(thing):
return 'method ' + thing.__name__
- return repr(thing)
+ if type(thing) is types.InstanceType:
+ return 'instance of ' + thing.__class__.__name__
+ return type(thing).__name__
+
+def freshimp(path, cache={}):
+ """Import a module, reloading it if the source file has changed."""
+ module = __import__(path)
+ if hasattr(module, '__file__'):
+ file = module.__file__
+ info = (file, os.path.getmtime(file), os.path.getsize(file))
+ if cache.has_key(path):
+ if cache[path] != info:
+ module = reload(module)
+ cache[path] = info
+ return module
def locate(path):
"""Locate an object by name (or dotted path), importing as necessary."""
@@ -915,8 +994,7 @@
while n <= len(parts):
path = join(parts[:n], '.')
try:
- module = __import__(path)
- module = reload(module)
+ module = freshimp(path)
except:
# determine if error occurred before or after module was found
if sys.modules.has_key(path):
@@ -927,7 +1005,7 @@
# module not found, so stop looking
break
# error occurred in the imported module, so report it
- raise DocImportError(filename, sys.exc_type, sys.exc_value)
+ raise DocImportError(filename, sys.exc_info())
try:
x = module
for p in parts[1:]:
@@ -951,12 +1029,12 @@
try:
path, x = locate(thing)
except DocImportError, value:
- print 'Problem in %s - %s' % (value.filename, value.args)
+ print value
return
if x:
thing = x
else:
- print 'No Python documentation found for %s.' % repr(thing)
+ print 'no Python documentation found for %s' % repr(thing)
return
desc = describe(thing)
@@ -967,18 +1045,40 @@
def writedoc(key):
"""Write HTML documentation to a file in the current directory."""
- path, object = locate(key)
- if object:
- file = open(key + '.html', 'w')
- file.write(html.page(object))
- file.close()
- print 'wrote', key + '.html'
+ try:
+ path, object = locate(key)
+ except DocImportError, value:
+ print value
+ else:
+ if object:
+ page = html.page('Python: ' + describe(object),
+ html.document(object, object.__name__))
+ file = open(key + '.html', 'w')
+ file.write(page)
+ file.close()
+ print 'wrote', key + '.html'
+ else:
+ print 'no Python documentation found for %s' % repr(key)
+
+def writedocs(dir, pkgpath='', done={}):
+ """Write out HTML documentation for all modules in a directory tree."""
+ for file in os.listdir(dir):
+ path = os.path.join(dir, file)
+ if ispackage(path):
+ writedocs(path, pkgpath + file + '.')
+ elif os.path.isfile(path):
+ modname = modulename(path)
+ if modname:
+ modname = pkgpath + modname
+ if not done.has_key(modname):
+ done[modname] = 1
+ writedoc(modname)
class Helper:
def __repr__(self):
- return """To get help on a Python object, call help(object).
+ return '''To get help on a Python object, call help(object).
To get help on a module or package, either import it before calling
-help(module) or call help('modulename')."""
+help(module) or call help('modulename').'''
def __call__(self, *args):
if args:
@@ -994,10 +1094,10 @@
if object:
title = 'Python Library Documentation: ' + describe(object)
if path: title = title + ' in ' + path
- pager('\n' + title + '\n\n' + text.document(object))
+ pager('\n' + title + '\n\n' + text.document(object, key))
found = 1
else:
- print 'No Python documentation found for %s.' % repr(key)
+ print 'no Python documentation found for %s' % repr(key)
class Scanner:
"""A generic tree iterator."""
@@ -1049,7 +1149,7 @@
for modname in sys.builtin_module_names:
if modname != '__main__':
seen[modname] = 1
- desc = split(__import__(modname).__doc__ or '', '\n')[0]
+ desc = split(freshimp(modname).__doc__ or '', '\n')[0]
if find(lower(modname + ' - ' + desc), lower(key)) >= 0:
callback(None, modname, desc)
@@ -1096,11 +1196,7 @@
self.send_response(200)
self.send_header('Content-Type', 'text/html')
self.end_headers()
- self.wfile.write('''
-<!doctype html public "-//W3C//DTD HTML 4.0 Transitional//EN">
-<html><title>Python: %s</title><body bgcolor="#ffffff">
-%s
-</body></html>''' % (title, contents))
+ self.wfile.write(html.page(title, contents))
except IOError: pass
def do_GET(self):
@@ -1111,14 +1207,13 @@
try:
p, x = locate(path)
except DocImportError, value:
- self.send_document(path, html.escape(
- 'Problem in %s - %s' % (value.filename, value.args)))
+ self.send_document(path, html.escape(str(value)))
return
if x:
- self.send_document(describe(x), html.document(x))
+ self.send_document(describe(x), html.document(x, path))
else:
self.send_document(path,
-'No Python documentation found for %s.' % repr(path))
+'no Python documentation found for %s' % repr(path))
else:
heading = html.heading(
'<big><big><strong>Python: Index of Modules</strong></big></big>',
@@ -1130,12 +1225,14 @@
indices = ['<p>' + html.bigsection(
'Built-in Modules', '#ffffff', '#ee77aa', contents)]
+ # for skip in ['', '.', os.getcwd(), os.path.dirname(sys.argv[0])]:
+ # if skip in sys.path: sys.path.remove(skip)
seen = {}
for dir in pathdirs():
indices.append(html.index(dir, seen))
- contents = heading + join(indices) + """<p align=right>
+ contents = heading + join(indices) + '''<p align=right>
<small><small><font color="#909090" face="helvetica, arial"><strong>
-pydoc</strong> by Ka-Ping Yee <ping@lfw.org></font></small></small>"""
+pydoc</strong> by Ka-Ping Yee <ping@lfw.org></font></small></small>'''
self.send_document('Index of Modules', contents)
def log_message(self, *args): pass
@@ -1143,7 +1240,7 @@
class DocServer(BaseHTTPServer.HTTPServer):
def __init__(self, port, callback):
host = (sys.platform == 'mac') and '127.0.0.1' or 'localhost'
- self.address = (host, port)
+ self.address = ('', port)
self.url = 'http://%s:%d/' % (host, port)
self.callback = callback
self.base.__init__(self, self.address, self.handler)
@@ -1348,6 +1445,9 @@
# -------------------------------------------------- command-line interface
+def ispath(x):
+ return type(x) is types.StringType and find(x, os.sep) >= 0
+
def cli():
"""Command-line interface (looks at sys.argv to decide what to do)."""
import getopt
@@ -1384,12 +1484,17 @@
if not args: raise BadUsage
for arg in args:
try:
- if find(arg, os.sep) >= 0 and os.path.isfile(arg):
+ if ispath(arg) and os.path.isfile(arg):
arg = importfile(arg)
- if writing: writedoc(arg)
- else: man(arg)
+ if writing:
+ if ispath(arg) and os.path.isdir(arg):
+ writedocs(arg)
+ else:
+ writedoc(arg)
+ else:
+ man(arg)
except DocImportError, value:
- print 'Problem in %s - %s' % (value.filename, value.args)
+ print value
except (getopt.error, BadUsage):
cmd = sys.argv[0]