mirror of
https://github.com/python/cpython
synced 2024-09-04 15:56:13 +00:00
![Christian Heimes](/assets/img/avatar_default.png)
svn+ssh://pythondev@svn.python.org/python/trunk ........ r60568 | christian.heimes | 2008-02-04 19:48:38 +0100 (Mon, 04 Feb 2008) | 1 line Increase debugging to investige failing tests on some build bots ........ r60570 | christian.heimes | 2008-02-04 20:30:05 +0100 (Mon, 04 Feb 2008) | 1 line Small adjustments for test compact freelist test. It's no passing on Windows as well. ........ r60573 | amaury.forgeotdarc | 2008-02-04 21:53:14 +0100 (Mon, 04 Feb 2008) | 2 lines Correct quotes in NEWS file ........ r60575 | amaury.forgeotdarc | 2008-02-04 22:45:05 +0100 (Mon, 04 Feb 2008) | 13 lines #1750076: Debugger did not step on every iteration of a while statement. The mapping between bytecode offsets and source lines (lnotab) did not contain an entry for the beginning of the loop. Now it does, and the lnotab can be a bit larger: in particular, several statements on the same line generate several entries. However, this does not bother the settrace function, which will trigger only one 'line' event. The lnotab seems to be exactly the same as with python2.4. ........ r60584 | amaury.forgeotdarc | 2008-02-05 01:26:21 +0100 (Tue, 05 Feb 2008) | 3 lines Change r60575 broke test_compile: there is no need to emit co_lnotab item when both offsets are zeros. ........ r60587 | skip.montanaro | 2008-02-05 03:32:16 +0100 (Tue, 05 Feb 2008) | 1 line sync with most recent version from python-mode sf project ........ r60588 | lars.gustaebel | 2008-02-05 12:51:40 +0100 (Tue, 05 Feb 2008) | 5 lines Issue #2004: Use mode 0700 for temporary directories and default permissions for missing directories. (will backport to 2.5) ........ r60590 | georg.brandl | 2008-02-05 13:01:24 +0100 (Tue, 05 Feb 2008) | 2 lines Convert external links to internal links. Fixes #2010. ........ r60592 | marc-andre.lemburg | 2008-02-05 15:50:40 +0100 (Tue, 05 Feb 2008) | 3 lines Keep distutils Python 2.1 compatible (or even Python 2.4 in this case). ........ r60593 | andrew.kuchling | 2008-02-05 17:06:57 +0100 (Tue, 05 Feb 2008) | 5 lines Update PEP URL. (This code is duplicated between pydoc and DocXMLRPCServer; maybe it should be refactored as a GHOP project.) 2.5.2 backport candidate. ........ r60596 | guido.van.rossum | 2008-02-05 18:32:15 +0100 (Tue, 05 Feb 2008) | 2 lines In the experimental 'Scanner' feature, the group count was set wrong. ........ r60602 | facundo.batista | 2008-02-05 20:03:32 +0100 (Tue, 05 Feb 2008) | 3 lines Issue 1951. Converts wave test cases to unittest. ........ r60603 | georg.brandl | 2008-02-05 20:07:10 +0100 (Tue, 05 Feb 2008) | 2 lines Actually run the test. ........ r60604 | skip.montanaro | 2008-02-05 20:24:30 +0100 (Tue, 05 Feb 2008) | 2 lines correct object name ........ r60605 | georg.brandl | 2008-02-05 20:58:17 +0100 (Tue, 05 Feb 2008) | 7 lines * Use the same code to profile for test_profile and test_cprofile. * Convert both to unittest. * Use the same unit testing code. * Include the expected output in both test files. * Make it possible to regenerate the expected output by running the file as a script with an '-r' argument. ........ r60613 | raymond.hettinger | 2008-02-06 02:49:00 +0100 (Wed, 06 Feb 2008) | 1 line Sync-up with Py3k work. ........ r60614 | christian.heimes | 2008-02-06 13:44:34 +0100 (Wed, 06 Feb 2008) | 1 line Limit free list of method and builtin function objects to 256 entries each. ........ r60616 | christian.heimes | 2008-02-06 14:33:44 +0100 (Wed, 06 Feb 2008) | 7 lines Unified naming convention for free lists and their limits. All free lists in Object/ are named ``free_list``, the counter ``numfree`` and the upper limit is a macro ``PyName_MAXFREELIST`` inside an #ifndef block. The chances should make it easier to adjust Python for platforms with less memory, e.g. mobile phones. ........
284 lines
10 KiB
Python
284 lines
10 KiB
Python
"""Self documenting XML-RPC Server.
|
|
|
|
This module can be used to create XML-RPC servers that
|
|
serve pydoc-style documentation in response to HTTP
|
|
GET requests. This documentation is dynamically generated
|
|
based on the functions and methods registered with the
|
|
server.
|
|
|
|
This module is built upon the pydoc and SimpleXMLRPCServer
|
|
modules.
|
|
"""
|
|
|
|
import pydoc
|
|
import inspect
|
|
import re
|
|
import sys
|
|
|
|
from SimpleXMLRPCServer import (SimpleXMLRPCServer,
|
|
SimpleXMLRPCRequestHandler,
|
|
CGIXMLRPCRequestHandler,
|
|
resolve_dotted_attribute)
|
|
|
|
class ServerHTMLDoc(pydoc.HTMLDoc):
|
|
"""Class used to generate pydoc HTML document for a server"""
|
|
|
|
def markup(self, text, escape=None, funcs={}, classes={}, methods={}):
|
|
"""Mark up some plain text, given a context of symbols to look for.
|
|
Each context dictionary maps object names to anchor names."""
|
|
escape = escape or self.escape
|
|
results = []
|
|
here = 0
|
|
|
|
# XXX Note that this regular expression does not allow for the
|
|
# hyperlinking of arbitrary strings being used as method
|
|
# names. Only methods with names consisting of word characters
|
|
# and '.'s are hyperlinked.
|
|
pattern = re.compile(r'\b((http|ftp)://\S+[\w/]|'
|
|
r'RFC[- ]?(\d+)|'
|
|
r'PEP[- ]?(\d+)|'
|
|
r'(self\.)?((?:\w|\.)+))\b')
|
|
while 1:
|
|
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('"', '"')
|
|
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 text[end:end+1] == '(':
|
|
results.append(self.namelink(name, methods, funcs, classes))
|
|
elif selfdot:
|
|
results.append('self.<strong>%s</strong>' % name)
|
|
else:
|
|
results.append(self.namelink(name, classes))
|
|
here = end
|
|
results.append(escape(text[here:]))
|
|
return ''.join(results)
|
|
|
|
def docroutine(self, object, name, mod=None,
|
|
funcs={}, classes={}, methods={}, cl=None):
|
|
"""Produce HTML documentation for a function or method object."""
|
|
|
|
anchor = (cl and cl.__name__ or '') + '-' + name
|
|
note = ''
|
|
|
|
title = '<a name="%s"><strong>%s</strong></a>' % (
|
|
self.escape(anchor), self.escape(name))
|
|
|
|
if inspect.ismethod(object):
|
|
args, varargs, varkw, defaults = inspect.getargspec(object)
|
|
# exclude the argument bound to the instance, it will be
|
|
# confusing to the non-Python user
|
|
argspec = inspect.formatargspec (
|
|
args[1:],
|
|
varargs,
|
|
varkw,
|
|
defaults,
|
|
formatvalue=self.formatvalue
|
|
)
|
|
elif inspect.isfunction(object):
|
|
args, varargs, varkw, defaults = inspect.getargspec(object)
|
|
argspec = inspect.formatargspec(
|
|
args, varargs, varkw, defaults, formatvalue=self.formatvalue)
|
|
else:
|
|
argspec = '(...)'
|
|
|
|
if isinstance(object, tuple):
|
|
argspec = object[0] or argspec
|
|
docstring = object[1] or ""
|
|
else:
|
|
docstring = pydoc.getdoc(object)
|
|
|
|
decl = title + argspec + (note and self.grey(
|
|
'<font face="helvetica, arial">%s</font>' % note))
|
|
|
|
doc = self.markup(
|
|
docstring, self.preformat, funcs, classes, methods)
|
|
doc = doc and '<dd><tt>%s</tt></dd>' % doc
|
|
return '<dl><dt>%s</dt>%s</dl>\n' % (decl, doc)
|
|
|
|
def docserver(self, server_name, package_documentation, methods):
|
|
"""Produce HTML documentation for an XML-RPC server."""
|
|
|
|
fdict = {}
|
|
for key, value in methods.items():
|
|
fdict[key] = '#-' + key
|
|
fdict[value] = fdict[key]
|
|
|
|
server_name = self.escape(server_name)
|
|
head = '<big><big><strong>%s</strong></big></big>' % server_name
|
|
result = self.heading(head, '#ffffff', '#7799ee')
|
|
|
|
doc = self.markup(package_documentation, self.preformat, fdict)
|
|
doc = doc and '<tt>%s</tt>' % doc
|
|
result = result + '<p>%s</p>\n' % doc
|
|
|
|
contents = []
|
|
method_items = sorted(methods.items())
|
|
for key, value in method_items:
|
|
contents.append(self.docroutine(value, key, funcs=fdict))
|
|
result = result + self.bigsection(
|
|
'Methods', '#ffffff', '#eeaa77', ''.join(contents))
|
|
|
|
return result
|
|
|
|
class XMLRPCDocGenerator:
|
|
"""Generates documentation for an XML-RPC server.
|
|
|
|
This class is designed as mix-in and should not
|
|
be constructed directly.
|
|
"""
|
|
|
|
def __init__(self):
|
|
# setup variables used for HTML documentation
|
|
self.server_name = 'XML-RPC Server Documentation'
|
|
self.server_documentation = \
|
|
"This server exports the following methods through the XML-RPC "\
|
|
"protocol."
|
|
self.server_title = 'XML-RPC Server Documentation'
|
|
|
|
def set_server_title(self, server_title):
|
|
"""Set the HTML title of the generated server documentation"""
|
|
|
|
self.server_title = server_title
|
|
|
|
def set_server_name(self, server_name):
|
|
"""Set the name of the generated HTML server documentation"""
|
|
|
|
self.server_name = server_name
|
|
|
|
def set_server_documentation(self, server_documentation):
|
|
"""Set the documentation string for the entire server."""
|
|
|
|
self.server_documentation = server_documentation
|
|
|
|
def generate_html_documentation(self):
|
|
"""generate_html_documentation() => html documentation for the server
|
|
|
|
Generates HTML documentation for the server using introspection for
|
|
installed functions and instances that do not implement the
|
|
_dispatch method. Alternatively, instances can choose to implement
|
|
the _get_method_argstring(method_name) method to provide the
|
|
argument string used in the documentation and the
|
|
_methodHelp(method_name) method to provide the help text used
|
|
in the documentation."""
|
|
|
|
methods = {}
|
|
|
|
for method_name in self.system_listMethods():
|
|
if method_name in self.funcs:
|
|
method = self.funcs[method_name]
|
|
elif self.instance is not None:
|
|
method_info = [None, None] # argspec, documentation
|
|
if hasattr(self.instance, '_get_method_argstring'):
|
|
method_info[0] = self.instance._get_method_argstring(method_name)
|
|
if hasattr(self.instance, '_methodHelp'):
|
|
method_info[1] = self.instance._methodHelp(method_name)
|
|
|
|
method_info = tuple(method_info)
|
|
if method_info != (None, None):
|
|
method = method_info
|
|
elif not hasattr(self.instance, '_dispatch'):
|
|
try:
|
|
method = resolve_dotted_attribute(
|
|
self.instance,
|
|
method_name
|
|
)
|
|
except AttributeError:
|
|
method = method_info
|
|
else:
|
|
method = method_info
|
|
else:
|
|
assert 0, "Could not find method in self.functions and no "\
|
|
"instance installed"
|
|
|
|
methods[method_name] = method
|
|
|
|
documenter = ServerHTMLDoc()
|
|
documentation = documenter.docserver(
|
|
self.server_name,
|
|
self.server_documentation,
|
|
methods
|
|
)
|
|
|
|
return documenter.page(self.server_title, documentation)
|
|
|
|
class DocXMLRPCRequestHandler(SimpleXMLRPCRequestHandler):
|
|
"""XML-RPC and documentation request handler class.
|
|
|
|
Handles all HTTP POST requests and attempts to decode them as
|
|
XML-RPC requests.
|
|
|
|
Handles all HTTP GET requests and interprets them as requests
|
|
for documentation.
|
|
"""
|
|
|
|
def do_GET(self):
|
|
"""Handles the HTTP GET request.
|
|
|
|
Interpret all HTTP GET requests as requests for server
|
|
documentation.
|
|
"""
|
|
# Check that the path is legal
|
|
if not self.is_rpc_path_valid():
|
|
self.report_404()
|
|
return
|
|
|
|
response = self.server.generate_html_documentation()
|
|
self.send_response(200)
|
|
self.send_header("Content-type", "text/html")
|
|
self.send_header("Content-length", str(len(response)))
|
|
self.end_headers()
|
|
self.wfile.write(response.encode())
|
|
|
|
# shut down the connection
|
|
self.wfile.flush()
|
|
self.connection.shutdown(1)
|
|
|
|
class DocXMLRPCServer( SimpleXMLRPCServer,
|
|
XMLRPCDocGenerator):
|
|
"""XML-RPC and HTML documentation server.
|
|
|
|
Adds the ability to serve server documentation to the capabilities
|
|
of SimpleXMLRPCServer.
|
|
"""
|
|
|
|
def __init__(self, addr, requestHandler=DocXMLRPCRequestHandler,
|
|
logRequests=1, allow_none=False, encoding=None,
|
|
bind_and_activate=True):
|
|
SimpleXMLRPCServer.__init__(self, addr, requestHandler, logRequests,
|
|
allow_none, encoding, bind_and_activate)
|
|
XMLRPCDocGenerator.__init__(self)
|
|
|
|
class DocCGIXMLRPCRequestHandler( CGIXMLRPCRequestHandler,
|
|
XMLRPCDocGenerator):
|
|
"""Handler for XML-RPC data and documentation requests passed through
|
|
CGI"""
|
|
|
|
def handle_get(self):
|
|
"""Handles the HTTP GET request.
|
|
|
|
Interpret all HTTP GET requests as requests for server
|
|
documentation.
|
|
"""
|
|
|
|
response = self.generate_html_documentation()
|
|
|
|
print('Content-Type: text/html')
|
|
print('Content-Length: %d' % len(response))
|
|
print()
|
|
sys.stdout.write(response)
|
|
|
|
def __init__(self):
|
|
CGIXMLRPCRequestHandler.__init__(self)
|
|
XMLRPCDocGenerator.__init__(self)
|