Permalink
Cannot retrieve contributors at this time
279 lines (226 sloc)
10.3 KB
Name already in use
A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
cpython/Lib/DocXMLRPCServer.py /
Go to fileThis commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| """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.im_func) | |
| # 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', pydoc.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) | |
| 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) | |
| sys.stdout.write(response) | |
| def __init__(self): | |
| CGIXMLRPCRequestHandler.__init__(self) | |
| XMLRPCDocGenerator.__init__(self) |