"""Convert sys.path into a list of absolute, existing, unique paths."""

dirs = []

normdirs = []

for dir in sys.path:

dir = os.path.abspath(dir or '.')

normdir = os.path.normcase(dir)

if normdir not in normdirs and os.path.isdir(dir):

dirs.append(dir)

normdirs.append(normdir)

"""Split a doc string into a synopsis line (if any) and the rest."""

lines = doc.strip().split('\n')

if len(lines) == 1:

return lines[0], ''

elif len(lines) >= 2 and not lines[1].rstrip():

return lines[0], '\n'.join(lines[2:])

"""Get a class name and qualify it with a module name if necessary."""

name = object.__name__

if object.__module__ != modname:

name = object.__module__ + '.' + name

"""Check if an object is of a type that probably means it's data."""

return not (inspect.ismodule(object) or inspect.isclass(object) or

inspect.isroutine(object) or inspect.isframe(object) or

"""Do a series of global replacements on a string."""

while pairs:

text = pairs[1].join(text.split(pairs[0]))

pairs = pairs[2:]

"""Omit part of a string if needed to make it fit in a maximum length."""

if len(text) > maxlen:

pre = max(0, (maxlen-3)//2)

post = max(0, maxlen-3-pre)

return text[:pre] + '...' + text[len(text)-post:]

"""

if inspect.ismethod(fn):

return True

if inspect.isbuiltin(fn):

self = getattr(fn, '__self__', None)

return not (inspect.ismodule(self) or (self is None))

methods = {}

for key, value in inspect.getmembers(cl, inspect.isroutine):

methods[key] = 1

for base in cl.__bases__:

methods.update(allmethods(base)) # all your base are belong to us

for key in methods.keys():

methods[key] = getattr(cl, key)

"""Split sequence s via predicate, and return pair ([true], [false]).

yes = []

no = []

for x in s:

if predicate(x):

yes.append(x)

else:

no.append(x)

"""Decide whether to show documentation on a variable."""

# Certain special names are redundant or internal.

# XXX Remove __initializing__?

if name in {'__author__', '__builtins__', '__cached__', '__credits__',

'__date__', '__doc__', '__file__', '__spec__',

'__loader__', '__module__', '__name__', '__package__',

'__path__', '__qualname__', '__slots__', '__version__'}:

return 0

# Private names are hidden, but special names are displayed.

if name.startswith('__') and name.endswith('__'): return 1

# Namedtuples have public fields and methods with a single leading underscore

if name.startswith('_') and hasattr(obj, '_fields'):

return True

if all is not None:

# only document that which the programmer exported in __all__

return name in all

else:

"""Wrap inspect.classify_class_attrs, with fixup for data descriptors."""

results = []

for (name, kind, cls, value) in inspect.classify_class_attrs(object):

if inspect.isdatadescriptor(value):

kind = 'data descriptor'

if isinstance(value, property) and value.fset is None:

kind = 'readonly property'

results.append((name, kind, cls, value))

'Sort the attrs list in-place by _fields and then alphabetically by name'

# This allows data descriptors to be ordered according

# to a _fields attribute if present.

fields = getattr(object, '_fields', [])

try:

field_order = {name : i-len(fields) for (i, name) in enumerate(fields)}

except TypeError:

field_order = {}

keyfunc = lambda attr: (field_order.get(attr[0], 0), attr[0])

"""Guess whether a path refers to a package directory."""

if os.path.isdir(path):

for ext in ('.py', '.pyc'):

if os.path.isfile(os.path.join(path, '__init__' + ext)):

return True

line = file.readline()

while line[:1] == '#' or not line.strip():

line = file.readline()

if not line: break

line = line.strip()

if line[:4] == 'r"""': line = line[1:]

if line[:3] == '"""':

line = line[3:]

if line[-1:] == '\\': line = line[:-1]

while not line.strip():

line = file.readline()

if not line: break

result = line.split('"""')[0].strip()

else: result = None

"""Get the one-line summary out of a module file."""

mtime = os.stat(filename).st_mtime

lastupdate, result = cache.get(filename, (None, None))

if lastupdate is None or lastupdate < mtime:

# Look for binary suffixes first, falling back to source.

if filename.endswith(tuple(importlib.machinery.BYTECODE_SUFFIXES)):

loader_cls = importlib.machinery.SourcelessFileLoader

elif filename.endswith(tuple(importlib.machinery.EXTENSION_SUFFIXES)):

loader_cls = importlib.machinery.ExtensionFileLoader

else:

loader_cls = None

# Now handle the choice.

if loader_cls is None:

# Must be a source file.

try:

file = tokenize.open(filename)

except OSError:

# module can't be opened, so skip it

return None

# text modules can be directly examined

with file:

result = source_synopsis(file)

else:

# Must be a binary module, which has to be imported.

loader = loader_cls('__temp__', filename)

# XXX We probably don't need to pass in the loader here.

spec = importlib.util.spec_from_file_location('__temp__', filename,

loader=loader)

try:

module = importlib._bootstrap._load(spec)

except:

return None

del sys.modules['__temp__']

result = module.__doc__.splitlines()[0] if module.__doc__ else None

# Cache the result.

cache[filename] = (mtime, result)

"""Errors that occurred while trying to import something to document it."""

def __init__(self, filename, exc_info):

self.filename = filename

self.exc, self.value, self.tb = exc_info

def __str__(self):

exc = self.exc.__name__

"""Import a Python source file or compiled file given its path."""

magic = importlib.util.MAGIC_NUMBER

with open(path, 'rb') as file:

is_bytecode = magic == file.read(len(magic))

filename = os.path.basename(path)

name, ext = os.path.splitext(filename)

if is_bytecode:

loader = importlib._bootstrap_external.SourcelessFileLoader(name, path)

else:

loader = importlib._bootstrap_external.SourceFileLoader(name, path)

# XXX We probably don't need to pass in the loader here.

spec = importlib.util.spec_from_file_location(name, path, loader=loader)

try:

return importlib._bootstrap._load(spec)

except:

"""Import a module; handle errors; return None if the module isn't found.

try:

# If forceload is 1 and the module has been previously loaded from

# disk, we always have to reload the module. Checking the file's

# mtime isn't good enough (e.g. the module could contain a class

# that inherits from another module that has changed).

if forceload and path in sys.modules:

if path not in sys.builtin_module_names:

# Remove the module from sys.modules and re-import to try

# and avoid problems with partially loaded modules.

# Also remove any submodules because they won't appear

# in the newly loaded module's namespace if they're already

# in sys.modules.

subs = [m for m in sys.modules if m.startswith(path + '.')]

for key in [path] + subs:

# Prevent garbage collection.

cache[key] = sys.modules[key]

del sys.modules[key]

module = __import__(path)

except:

# Did the error occur before or after the module was found?

(exc, value, tb) = info = sys.exc_info()

if path in sys.modules:

# An error occurred while executing the imported module.

raise ErrorDuringImport(sys.modules[path].__file__, info)

elif exc is SyntaxError:

# A SyntaxError occurred before we could execute the module.

raise ErrorDuringImport(value.filename, info)

elif issubclass(exc, ImportError) and value.name == path:

# No such module in the path.

return None

else:

# Some other error occurred during the importing process.

raise ErrorDuringImport(path, sys.exc_info())

for part in path.split('.')[1:]:

try: module = getattr(module, part)

except AttributeError: return None

PYTHONDOCS = os.environ.get("PYTHONDOCS",

"https://docs.python.org/%d.%d/library"

% sys.version_info[:2])

def document(self, object, name=None, *args):

"""Generate documentation for an object."""

args = (object, name) + args

# 'try' clause is to attempt to handle the possibility that inspect

# identifies something in a way that pydoc itself has issues handling;

# think 'super' and how it is a descriptor (which raises the exception

# by lacking a __name__ attribute) and an instance.

try:

if inspect.ismodule(object): return self.docmodule(*args)

if inspect.isclass(object): return self.docclass(*args)

if inspect.isroutine(object): return self.docroutine(*args)

except AttributeError:

pass

if inspect.isdatadescriptor(object): return self.docdata(*args)

return 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 = docproperty = docdata = fail

def getdocloc(self, object, basedir=sysconfig.get_path('stdlib')):

"""Return the location of module docs or None"""

try:

file = inspect.getabsfile(object)

except TypeError:

file = '(built-in)'

docloc = os.environ.get("PYTHONDOCS", self.PYTHONDOCS)

basedir = os.path.normcase(basedir)

if (isinstance(object, type(os)) and

(object.__name__ in ('errno', 'exceptions', 'gc', 'imp',

'marshal', 'posix', 'signal', 'sys',

'_thread', 'zipimport') or

(file.startswith(basedir) and

not file.startswith(os.path.join(basedir, 'site-packages')))) and

object.__name__ not in ('xml.etree', 'test.pydoc_mod')):

if docloc.startswith(("http://", "https://")):

docloc = "%s/%s" % (docloc.rstrip("/"), object.__name__.lower())

else:

docloc = os.path.join(docloc, object.__name__.lower() + ".html")

else:

docloc = None

"""Class for safely making an HTML representation of a Python object."""

def __init__(self):

Repr.__init__(self)

self.maxlist = self.maxtuple = 20

self.maxdict = 10

self.maxstring = self.maxother = 100

def escape(self, text):

return replace(text, '&', '&amp;', '<', '&lt;', '>', '&gt;')

def repr(self, object):

return Repr.repr(self, object)

def repr1(self, x, level):

if hasattr(type(x), '__name__'):

methodname = 'repr_' + '_'.join(type(x).__name__.split())

if hasattr(self, methodname):

return getattr(self, methodname)(x, level)

return self.escape(cram(stripid(repr(x)), self.maxother))

def repr_string(self, x, level):

test = cram(x, self.maxstring)

testrepr = repr(test)

if '\\' in test and '\\' not in replace(testrepr, r'\\', ''):

# Backslashes are only literal in the string and are never

# needed to make any special characters, so show a raw string.

return 'r' + testrepr[0] + self.escape(test) + testrepr[0]

return re.sub(r'((\\[\\abfnrtv\'"]|\\[0-9]..|\\x..|\\u....)+)',

r'<font color="#c040c0">\1</font>',

self.escape(testrepr))

repr_str = repr_string

def repr_instance(self, x, level):

try:

return self.escape(cram(stripid(repr(x)), self.maxstring))

except:

return self.escape('<%s instance>' % x.__class__.__name__)

"""Formatter class for HTML documentation."""

# ------------------------------------------- HTML formatting utilities

_repr_instance = HTMLRepr()

repr = _repr_instance.repr

escape = _repr_instance.escape

def page(self, title, contents):

"""Format an HTML page."""

return '''\

</body></html>''' % (title, contents)

def heading(self, title, fgcol, bgcol, extras=''):

"""Format a page heading."""

return '''

''' % (bgcol, fgcol, title, fgcol, extras or '&nbsp;')

def section(self, title, fgcol, bgcol, contents, width=6,

prelude='', marginalia=None, gap='&nbsp;'):

"""Format a section with a heading."""

if marginalia is None:

marginalia = '<tt>' + '&nbsp;' * width + '</tt>'

result = '''<p>

''' % (bgcol, fgcol, title)

if prelude:

result = result + '''

<tr><td>%s</td>''' % (bgcol, marginalia, prelude, gap)

else:

result = result + '''

<tr><td bgcolor="%s">%s</td><td>%s</td>''' % (bgcol, marginalia, gap)

return result + '\n<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 self.section(title, *args)

def preformat(self, text):

"""Format literal preformatted text."""

text = self.escape(text.expandtabs())

return replace(text, '\n\n', '\n \n', '\n\n', '\n \n',

' ', '&nbsp;', '\n', '<br>\n')

def multicolumn(self, list, format, cols=4):

"""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):

if i < len(list):

result = result + format(list[i]) + '<br>\n'

result = result + '</td>'

return '<table width="100%%" summary="list"><tr>%s</tr></table>' % result

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."""

for dict in dicts:

if name in dict:

return '<a href="%s">%s</a>' % (dict[name], name)

return name

def classlink(self, object, modname):

"""Make a link for a class."""

name, module = object.__name__, sys.modules.get(object.__module__)

if hasattr(module, name) and getattr(module, name) is object:

return '<a href="%s.html#%s">%s</a>' % (

module.__name__, name, classname(object, modname))

return classname(object, modname)

def modulelink(self, object):

"""Make a link for a module."""

return '<a href="%s.html">%s</a>' % (object.__name__, object.__name__)

def modpkglink(self, modpkginfo):

"""Make a link for a module or package to display in an index."""

name, path, ispackage, shadowed = modpkginfo

if shadowed:

return self.grey(name)

if path:

url = '%s.%s.html' % (path, name)

else:

url = '%s.html' % name

if ispackage:

text = '<strong>%s</strong>&nbsp;(package)' % name

else:

text = name

return '<a href="%s">%s</a>' % (url, text)

def filelink(self, url, path):

"""Make a link to source file."""

return '<a href="file:%s">%s</a>' % (url, path)

def markup(self, text, escape=None, funcs={}, classes={}, methods={}):

"""Mark up some plain text, given a context of symbols to look for.

escape = escape or self.escape

results = []

here = 0

pattern = re.compile(r'\b((http|ftp)://\S+[\w/]|'

r'RFC[- ]?(\d+)|'

r'PEP[- ]?(\d+)|'

r'(self\.)?(\w+))')

while True:

match = pattern.search(text, here)

if not match: break

start, end = match.span()

results.append(escape(text[here:start]))

all, scheme, rfc, pep, selfdot, name = match.groups()

if scheme:

url = escape(all).replace('"', '&quot;')

results.append('<a href="%s">%s</a>' % (url, url))

elif rfc:

url = 'http://www.rfc-editor.org/rfc/rfc%d.txt' % int(rfc)

results.append('<a href="%s">%s</a>' % (url, escape(all)))

elif pep:

url = 'http://www.python.org/dev/peps/pep-%04d/' % int(pep)

results.append('<a href="%s">%s</a>' % (url, escape(all)))

elif selfdot:

# Create a link for methods like 'self.method(...)'

# and use <strong> for attributes like 'self.attr'

if text[end:end+1] == '(':

results.append('self.' + self.namelink(name, methods))

else:

results.append('self.<strong>%s</strong>' % name)

elif text[end:end+1] == '(':

results.append(self.namelink(name, methods, funcs, classes))

else:

results.append(self.namelink(name, classes))

here = end

results.append(escape(text[here:]))

return ''.join(results)

# ---------------------------------------------- type-specific routines

def formattree(self, tree, modname, parent=None):

"""Produce HTML for a class tree as given by inspect.getclasstree()."""

result = ''

for entry in tree:

if type(entry) is type(()):

c, bases = entry

result = result + '<dt><font face="helvetica, arial">'

result = result + self.classlink(c, modname)

if bases and bases != (parent,):

parents = []

for base in bases:

parents.append(self.classlink(base, modname))

result = result + '(' + ', '.join(parents) + ')'

result = result + '\n</font></dt>'

elif type(entry) is type([]):

result = result + '<dd>\n%s</dd>\n' % self.formattree(

entry, modname, c)

return '<dl>\n%s</dl>\n' % result

def docmodule(self, object, name=None, mod=None, *ignored):

"""Produce HTML documentation for a module object."""

name = object.__name__ # ignore the passed-in name

try:

all = object.__all__

except AttributeError:

all = None

parts = name.split('.')

links = []

for i in range(len(parts)-1):

links.append(

'<a href="%s.html"><font color="#ffffff">%s</font></a>' %

('.'.join(parts[:i+1]), parts[i]))

linkedname = '.'.join(links + parts[-1:])

head = '<big><big><strong>%s</strong></big></big>' % linkedname

try:

path = inspect.getabsfile(object)

url = urllib.parse.quote(path)

filelink = self.filelink(url, path)

except TypeError:

filelink = '(built-in)'

info = []

if hasattr(object, '__version__'):

version = str(object.__version__)

if version[:11] == '$' + 'Revision: ' and version[-1:] == '$':

version = version[11:-1].strip()

info.append('version %s' % self.escape(version))

if hasattr(object, '__date__'):

info.append(self.escape(str(object.__date__)))

if info:

head = head + ' (%s)' % ', '.join(info)

docloc = self.getdocloc(object)

if docloc is not None:

docloc = '<br><a href="%(docloc)s">Module Reference</a>' % locals()

else:

docloc = ''

result = self.heading(

head, '#ffffff', '#7799ee',

'<a href=".">index</a><br>' + filelink + docloc)

modules = inspect.getmembers(object, inspect.ismodule)

classes, cdict = [], {}

for key, value in inspect.getmembers(object, inspect.isclass):

# if __all__ exists, believe it. Otherwise use old heuristic.

if (all is not None or

(inspect.getmodule(value) or object) is object):

if visiblename(key, all, object):

classes.append((key, value))

cdict[key] = cdict[value] = '#' + key

for key, value in classes:

for base in value.__bases__:

key, modname = base.__name__, base.__module__

module = sys.modules.get(modname)

if modname != name and module and hasattr(module, key):

if getattr(module, key) is base:

if not key in cdict:

cdict[key] = cdict[base] = modname + '.html#' + key

funcs, fdict = [], {}

for key, value in inspect.getmembers(object, inspect.isroutine):

# if __all__ exists, believe it. Otherwise use old heuristic.

if (all is not None or

inspect.isbuiltin(value) or inspect.getmodule(value) is object):

if visiblename(key, all, object):

funcs.append((key, value))

fdict[key] = '#-' + key

if inspect.isfunction(value): fdict[value] = fdict[key]

data = []

for key, value in inspect.getmembers(object, isdata):

if visiblename(key, all, object):

data.append((key, value))

doc = self.markup(getdoc(object), self.preformat, fdict, cdict)

doc = doc and '<tt>%s</tt>' % doc

result = result + '<p>%s</p>\n' % doc

if hasattr(object, '__path__'):

modpkgs = []

for importer, modname, ispkg in pkgutil.iter_modules(object.__path__):

modpkgs.append((modname, name, ispkg, 0))

modpkgs.sort()

contents = self.multicolumn(modpkgs, self.modpkglink)

result = result + self.bigsection(

'Package Contents', '#ffffff', '#aa55cc', contents)

elif modules:

contents = self.multicolumn(

modules, lambda t: self.modulelink(t[1]))

result = result + self.bigsection(

'Modules', '#ffffff', '#aa55cc', contents)

if classes:

classlist = [value for (key, value) in classes]

contents = [

self.formattree(inspect.getclasstree(classlist, 1), name)]

for key, value in classes:

contents.append(self.document(value, key, name, fdict, cdict))

result = result + self.bigsection(

'Classes', '#ffffff', '#ee77aa', ' '.join(contents))

if funcs:

contents = []

for key, value in funcs:

contents.append(self.document(value, key, name, fdict, cdict))

result = result + self.bigsection(

'Functions', '#ffffff', '#eeaa77', ' '.join(contents))

if data:

contents = []

for key, value in data:

contents.append(self.document(value, key))

result = result + self.bigsection(

'Data', '#ffffff', '#55aa55', '<br>\n'.join(contents))

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(

'Credits', '#ffffff', '#7799ee', contents)

return result

def docclass(self, object, name=None, mod=None, funcs={}, classes={},

*ignored):

"""Produce HTML documentation for a class object."""

realname = object.__name__

name = name or realname

bases = object.__bases__

contents = []

push = contents.append

# Cute little class to pump out a horizontal rule between sections.

class HorizontalRule:

def __init__(self):

self.needone = 0

def maybe(self):

if self.needone:

push('<hr>\n')

self.needone = 1

hr = HorizontalRule()

# List the mro, if non-trivial.

mro = deque(inspect.getmro(object))

if len(mro) > 2:

hr.maybe()

push('<dl><dt>Method resolution order:</dt>\n')

for base in mro:

push('<dd>%s</dd>\n' % self.classlink(base,

object.__module__))

push('</dl>\n')

def spill(msg, attrs, predicate):

ok, attrs = _split_list(attrs, predicate)

if ok:

hr.maybe()

push(msg)

for name, kind, homecls, value in ok:

try:

value = getattr(object, name)

except Exception:

# Some descriptors may meet a failure in their __get__.

# (bug #1785)

push(self.docdata(value, name, mod))

else:

push(self.document(value, name, mod,

funcs, classes, mdict, object))

push('\n')

return attrs

def spilldescriptors(msg, attrs, predicate):

ok, attrs = _split_list(attrs, predicate)

if ok:

hr.maybe()

push(msg)

for name, kind, homecls, value in ok:

push(self.docdata(value, name, mod))

return attrs

def spilldata(msg, attrs, predicate):

ok, attrs = _split_list(attrs, predicate)

if ok:

hr.maybe()

push(msg)

for name, kind, homecls, value in ok:

base = self.docother(getattr(object, name), name, mod)

if callable(value) or inspect.isdatadescriptor(value):

doc = getattr(value, "__doc__", None)

else:

doc = None

if doc is None:

push('<dl><dt>%s</dl>\n' % base)

else:

doc = self.markup(getdoc(value), self.preformat,

funcs, classes, mdict)

doc = '<dd><tt>%s</tt>' % doc

push('<dl><dt>%s%s</dl>\n' % (base, doc))

push('\n')

return attrs

attrs = [(name, kind, cls, value)

for name, kind, cls, value in classify_class_attrs(object)

if visiblename(name, obj=object)]

mdict = {}

for key, kind, homecls, value in attrs:

mdict[key] = anchor = '#' + name + '-' + key

try:

value = getattr(object, name)

except Exception:

# Some descriptors may meet a failure in their __get__.

# (bug #1785)

pass

try:

# The value may not be hashable (e.g., a data attr with

# a dict or list value).

mdict[value] = anchor

except TypeError:

pass

while attrs:

if mro:

thisclass = mro.popleft()

else:

thisclass = attrs[0][2]

attrs, inherited = _split_list(attrs, lambda t: t[2] is thisclass)

if object is not builtins.object and thisclass is builtins.object:

attrs = inherited

continue

elif thisclass is object:

tag = 'defined here'

else:

tag = 'inherited from %s' % self.classlink(thisclass,

object.__module__)

tag += ':<br>\n'

sort_attributes(attrs, object)

# Pump out the attrs, segregated by kind.

attrs = spill('Methods %s' % tag, attrs,

lambda t: t[1] == 'method')

attrs = spill('Class methods %s' % tag, attrs,

lambda t: t[1] == 'class method')

attrs = spill('Static methods %s' % tag, attrs,

lambda t: t[1] == 'static method')

attrs = spilldescriptors("Readonly properties %s" % tag, attrs,

lambda t: t[1] == 'readonly property')

attrs = spilldescriptors('Data descriptors %s' % tag, attrs,

lambda t: t[1] == 'data descriptor')

attrs = spilldata('Data and other attributes %s' % tag, attrs,

lambda t: t[1] == 'data')

assert attrs == []

attrs = inherited

contents = ''.join(contents)

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__))

title = title + '(%s)' % ', '.join(parents)

decl = ''

try:

signature = inspect.signature(object)

except (ValueError, TypeError):

signature = None

if signature:

argspec = str(signature)

if argspec and argspec != '()':

decl = name + self.escape(argspec) + '\n\n'

doc = getdoc(object)

if decl:

doc = decl + (doc or '')

doc = self.markup(doc, self.preformat, funcs, classes, mdict)

doc = doc and '<tt>%s<br>&nbsp;</tt>' % doc

return self.section(title, '#000000', '#ffc8d8', contents, 3, doc)

def formatvalue(self, object):

"""Format an argument default value as text."""

return self.grey('=' + self.repr(object))

def docroutine(self, object, name=None, mod=None,

funcs={}, classes={}, methods={}, cl=None):

"""Produce HTML documentation for a function or method object."""

realname = object.__name__

name = name or realname

anchor = (cl and cl.__name__ or '') + '-' + name

note = ''

skipdocs = 0

if _is_bound_method(object):

imclass = object.__self__.__class__

if cl:

if imclass is not cl:

note = ' from ' + self.classlink(imclass, mod)

else:

if object.__self__ is not None:

note = ' method of %s instance' % self.classlink(

object.__self__.__class__, mod)

else:

note = ' unbound %s method' % self.classlink(imclass,mod)

if (inspect.iscoroutinefunction(object) or

inspect.isasyncgenfunction(object)):

asyncqualifier = 'async '

else:

asyncqualifier = ''

if name == realname:

title = '<a name="%s"><strong>%s</strong></a>' % (anchor, realname)

else:

if cl and inspect.getattr_static(cl, realname, []) is object:

reallink = '<a href="#%s">%s</a>' % (

cl.__name__ + '-' + realname, realname)

skipdocs = 1

else:

reallink = realname

title = '<a name="%s"><strong>%s</strong></a> = %s' % (

anchor, name, reallink)

argspec = None

if inspect.isroutine(object):

try:

signature = inspect.signature(object)

except (ValueError, TypeError):

signature = None

if signature:

argspec = str(signature)

if realname == '<lambda>':