+++ /dev/null
-
-:mod:`DocXMLRPCServer` --- Self-documenting XML-RPC server
-==========================================================
-
-.. module:: DocXMLRPCServer
- :synopsis: Self-documenting XML-RPC server implementation.
-.. moduleauthor:: Brian Quinlan <brianq@activestate.com>
-.. sectionauthor:: Brian Quinlan <brianq@activestate.com>
-
-
-The :mod:`DocXMLRPCServer` module extends the classes found in
-:mod:`SimpleXMLRPCServer` to serve HTML documentation in response to HTTP GET
-requests. Servers can either be free standing, using :class:`DocXMLRPCServer`,
-or embedded in a CGI environment, using :class:`DocCGIXMLRPCRequestHandler`.
-
-
-.. class:: DocXMLRPCServer(addr[, requestHandler[, logRequests[, allow_none[, encoding[, bind_and_activate]]]]])
-
- Create a new server instance. All parameters have the same meaning as for
- :class:`SimpleXMLRPCServer.SimpleXMLRPCServer`; *requestHandler* defaults to
- :class:`DocXMLRPCRequestHandler`.
-
-
-.. class:: DocCGIXMLRPCRequestHandler()
-
- Create a new instance to handle XML-RPC requests in a CGI environment.
-
-
-.. class:: DocXMLRPCRequestHandler()
-
- Create a new request handler instance. This request handler supports XML-RPC
- POST requests, documentation GET requests, and modifies logging so that the
- *logRequests* parameter to the :class:`DocXMLRPCServer` constructor parameter is
- honored.
-
-
-.. _doc-xmlrpc-servers:
-
-DocXMLRPCServer Objects
------------------------
-
-The :class:`DocXMLRPCServer` class is derived from
-:class:`SimpleXMLRPCServer.SimpleXMLRPCServer` and provides a means of creating
-self-documenting, stand alone XML-RPC servers. HTTP POST requests are handled as
-XML-RPC method calls. HTTP GET requests are handled by generating pydoc-style
-HTML documentation. This allows a server to provide its own web-based
-documentation.
-
-
-.. method:: DocXMLRPCServer.set_server_title(server_title)
-
- Set the title used in the generated HTML documentation. This title will be used
- inside the HTML "title" element.
-
-
-.. method:: DocXMLRPCServer.set_server_name(server_name)
-
- Set the name used in the generated HTML documentation. This name will appear at
- the top of the generated documentation inside a "h1" element.
-
-
-.. method:: DocXMLRPCServer.set_server_documentation(server_documentation)
-
- Set the description used in the generated HTML documentation. This description
- will appear as a paragraph, below the server name, in the documentation.
-
-
-DocCGIXMLRPCRequestHandler
---------------------------
-
-The :class:`DocCGIXMLRPCRequestHandler` class is derived from
-:class:`SimpleXMLRPCServer.CGIXMLRPCRequestHandler` and provides a means of
-creating self-documenting, XML-RPC CGI scripts. HTTP POST requests are handled
-as XML-RPC method calls. HTTP GET requests are handled by generating pydoc-style
-HTML documentation. This allows a server to provide its own web-based
-documentation.
-
-
-.. method:: DocCGIXMLRPCRequestHandler.set_server_title(server_title)
-
- Set the title used in the generated HTML documentation. This title will be used
- inside the HTML "title" element.
-
-
-.. method:: DocCGIXMLRPCRequestHandler.set_server_name(server_name)
-
- Set the name used in the generated HTML documentation. This name will appear at
- the top of the generated documentation inside a "h1" element.
-
-
-.. method:: DocCGIXMLRPCRequestHandler.set_server_documentation(server_documentation)
-
- Set the description used in the generated HTML documentation. This description
- will appear as a paragraph, below the server name, in the documentation.
-
cgihttpserver.rst
cookielib.rst
cookie.rst
- xmlrpclib.rst
- simplexmlrpcserver.rst
- docxmlrpcserver.rst
+ xmlrpc.client.rst
+ xmlrpc.server.rst
shelve.rst
marshal.rst
dbm.rst
+ bsddb.rst
sqlite3.rst
-:mod:`xmlrpclib` --- XML-RPC client access
-==========================================
+:mod:`xmlrpc.client` --- XML-RPC client access
+==============================================
-.. module:: xmlrpclib
+.. module:: xmlrpc.client
:synopsis: XML-RPC client access.
.. moduleauthor:: Fredrik Lundh <fredrik@pythonware.com>
.. sectionauthor:: Eric S. Raymond <esr@snark.thyrsus.com>
raise a special :exc:`Fault` instance, used to signal XML-RPC server errors, or
:exc:`ProtocolError` used to signal an error in the HTTP/HTTPS transport layer.
Both :exc:`Fault` and :exc:`ProtocolError` derive from a base class called
- :exc:`Error`. Note that the xmlrpclib module currently does not marshal
+ :exc:`Error`. Note that the xmlrpc client module currently does not marshal
instances of subclasses of builtin types.
When passing strings, characters special to XML such as ``<``, ``>``, and ``&``
string may contain HTML markup.
-.. _boolean-objects:
-
-Boolean Objects
----------------
-
-This class may be initialized from any Python value; the instance returned
-depends only on its truth value. It supports various Python operators through
-:meth:`__cmp__`, :meth:`__repr__`, :meth:`__int__`, and :meth:`__bool__`
-methods, all implemented in the obvious ways.
-
-It also has the following method, supported mainly for internal use by the
-unmarshalling code:
-
-
-.. method:: Boolean.encode(out)
-
- Write the XML-RPC encoding of this Boolean item to the out stream object.
-
A working example follows. The server code::
- import xmlrpclib
- from SimpleXMLRPCServer import SimpleXMLRPCServer
+ from xmlrpc.server import SimpleXMLRPCServer
def is_even(n):
return n%2 == 0
The client code for the preceding server::
- import xmlrpclib
+ import xmlrpc.client
- proxy = xmlrpclib.ServerProxy("http://localhost:8000/")
+ proxy = xmlrpc.client.ServerProxy("http://localhost:8000/")
print("3 is even: %s" % str(proxy.is_even(3)))
print("100 is even: %s" % str(proxy.is_even(100)))
A working example follows. The server code::
import datetime
- from SimpleXMLRPCServer import SimpleXMLRPCServer
- import xmlrpclib
+ from xmlrpc.server import SimpleXMLRPCServer
+ import xmlrpc.client
def today():
today = datetime.datetime.today()
- return xmlrpclib.DateTime(today)
+ return xmlrpc.client.DateTime(today)
server = SimpleXMLRPCServer(("localhost", 8000))
print("Listening on port 8000...")
The client code for the preceding server::
- import xmlrpclib
+ import xmlrpc.client
import datetime
- proxy = xmlrpclib.ServerProxy("http://localhost:8000/")
+ proxy = xmlrpc.client.ServerProxy("http://localhost:8000/")
today = proxy.today()
# convert the ISO8601 string to a datetime object
Example usage of the binary objects. We're going to transfer an image over
XMLRPC::
- from SimpleXMLRPCServer import SimpleXMLRPCServer
- import xmlrpclib
+ from xmlrpc.server import SimpleXMLRPCServer
+ import xmlrpc.client
def python_logo():
handle = open("python_logo.jpg")
- return xmlrpclib.Binary(handle.read())
+ return xmlrpc.client.Binary(handle.read())
handle.close()
server = SimpleXMLRPCServer(("localhost", 8000))
The client gets the image and saves it to a file::
- import xmlrpclib
+ import xmlrpc.client
- proxy = xmlrpclib.ServerProxy("http://localhost:8000/")
+ proxy = xmlrpc.client.ServerProxy("http://localhost:8000/")
handle = open("fetched_python_logo.jpg", "w")
handle.write(proxy.python_logo().data)
handle.close()
In the following example we're going to intentionally cause a :exc:`Fault` by
returning a complex type object. The server code::
- from SimpleXMLRPCServer import SimpleXMLRPCServer
+ from xmlrpc.server import SimpleXMLRPCServer
# A marshalling error is going to occur because we're returning a
# complex number
The client code for the preceding server::
- import xmlrpclib
+ import xmlrpc.client
- proxy = xmlrpclib.ServerProxy("http://localhost:8000/")
+ proxy = xmlrpc.client.ServerProxy("http://localhost:8000/")
try:
proxy.add(2, 5)
- except xmlrpclib.Fault, err:
+ except xmlrpc.client.Fault, err:
print("A fault occured")
print("Fault code: %d" % err.faultCode)
print("Fault string: %s" % err.faultString)
In the following example we're going to intentionally cause a :exc:`ProtocolError`
by providing an invalid URI::
- import xmlrpclib
+ import xmlrpc.client
# create a ServerProxy with an invalid URI
- proxy = xmlrpclib.ServerProxy("http://invalidaddress/")
+ proxy = xmlrpc.client.ServerProxy("http://invalidaddress/")
try:
proxy.some_method()
- except xmlrpclib.ProtocolError, err:
+ except xmlrpc.client.ProtocolError, err:
print("A protocol error occured")
print("URL: %s" % err.url)
print("HTTP/HTTPS headers: %s" % err.headers)
A usage example of this class follows. The server code ::
- from SimpleXMLRPCServer import SimpleXMLRPCServer
+ from xmlrpc.server import SimpleXMLRPCServer
def add(x,y):
return x+y
The client code for the preceding server::
- import xmlrpclib
+ import xmlrpc.client
- proxy = xmlrpclib.ServerProxy("http://localhost:8000/")
- multicall = xmlrpclib.MultiCall(proxy)
+ proxy = xmlrpc.client.ServerProxy("http://localhost:8000/")
+ multicall = xmlrpc.client.MultiCall(proxy)
multicall.add(7,3)
multicall.subtract(7,3)
multicall.multiply(7,3)
Convenience Functions
---------------------
-
-.. function:: boolean(value)
-
- Convert any Python value to one of the XML-RPC Boolean constants, ``True`` or
- ``False``.
-
-
.. function:: dumps(params[, methodname[, methodresponse[, encoding[, allow_none]]]])
Convert *params* into an XML-RPC request. or into a response if *methodresponse*
::
# simple test program (from the XML-RPC specification)
- from xmlrpclib import ServerProxy, Error
+ from xmlrpc.client import ServerProxy, Error
# server = ServerProxy("http://localhost:8000") # local server
server = ServerProxy("http://betty.userland.com")
::
- import xmlrpclib, httplib
+ import xmlrpc.client, httplib
- class ProxiedTransport(xmlrpclib.Transport):
+ class ProxiedTransport(xmlrpc.client.Transport):
def set_proxy(self, proxy):
self.proxy = proxy
def make_connection(self, host):
p = ProxiedTransport()
p.set_proxy('proxy-server:8080')
- server = xmlrpclib.Server('http://time.xmlrpc.com/RPC2', transport=p)
+ server = xmlrpc.client.Server('http://time.xmlrpc.com/RPC2', transport=p)
print(server.currentTime.getCurrentTime())
+:mod:`xmlrpc.server` --- Basic XML-RPC servers
+==============================================
-:mod:`SimpleXMLRPCServer` --- Basic XML-RPC server
-==================================================
-
-.. module:: SimpleXMLRPCServer
- :synopsis: Basic XML-RPC server implementation.
+.. module:: xmlrpc.server
+ :synopsis: Basic XML-RPC server implementations.
.. moduleauthor:: Brian Quinlan <brianq@activestate.com>
.. sectionauthor:: Fred L. Drake, Jr. <fdrake@acm.org>
-The :mod:`SimpleXMLRPCServer` module provides a basic server framework for
-XML-RPC servers written in Python. Servers can either be free standing, using
+The :mod:`xmlrpc.server` module provides a basic server framework for XML-RPC
+servers written in Python. Servers can either be free standing, using
:class:`SimpleXMLRPCServer`, or embedded in a CGI environment, using
:class:`CGIXMLRPCRequestHandler`.
are passed to the :class:`socketserver.TCPServer` constructor. If *logRequests*
is true (the default), requests will be logged; setting this parameter to false
will turn off logging. The *allow_none* and *encoding* parameters are passed
- on to :mod:`xmlrpclib` and control the XML-RPC responses that will be returned
+ on to :mod:`xmlrpc.client` and control the XML-RPC responses that will be returned
from the server. The *bind_and_activate* parameter controls whether
:meth:`server_bind` and :meth:`server_activate` are called immediately by the
constructor; it defaults to true. Setting it to false allows code to manipulate
.. class:: CGIXMLRPCRequestHandler([allow_none[, encoding]])
Create a new instance to handle XML-RPC requests in a CGI environment. The
- *allow_none* and *encoding* parameters are passed on to :mod:`xmlrpclib` and
- control the XML-RPC responses that will be returned from the server.
+ *allow_none* and *encoding* parameters are passed on to :mod:`xmlrpc.client`
+ and control the XML-RPC responses that will be returned from the server.
.. class:: SimpleXMLRPCRequestHandler()
^^^^^^^^^^^^^^^^^^^^^^^^^^
Server code::
- from SimpleXMLRPCServer import SimpleXMLRPCServer
- from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler
+ from xmlrpc.server import SimpleXMLRPCServer
+ from xmlrpc.server import SimpleXMLRPCRequestHandler
# Restrict to a particular path.
class RequestHandler(SimpleXMLRPCRequestHandler):
The following client code will call the methods made available by the preceding
server::
- import xmlrpclib
+ import xmlrpc.client
- s = xmlrpclib.ServerProxy('http://localhost:8000')
+ s = xmlrpc.client.ServerProxy('http://localhost:8000')
print(s.pow(2,3)) # Returns 2**3 = 8
print(s.add(2,3)) # Returns 5
print(s.mul(5,2)) # Returns 5*2 = 10
handler.register_instance(MyFuncs())
handler.handle_request()
+
+Documenting XMLRPC server
+-------------------------
+
+These classes extend the above classes to serve HTML documentation in response
+to HTTP GET requests. Servers can either be free standing, using
+:class:`DocXMLRPCServer`, or embedded in a CGI environment, using
+:class:`DocCGIXMLRPCRequestHandler`.
+
+
+.. class:: DocXMLRPCServer(addr[, requestHandler[, logRequests[, allow_none[, encoding[, bind_and_activate]]]]])
+
+ Create a new server instance. All parameters have the same meaning as for
+ :class:`SimpleXMLRPCServer`; *requestHandler* defaults to
+ :class:`DocXMLRPCRequestHandler`.
+
+
+.. class:: DocCGIXMLRPCRequestHandler()
+
+ Create a new instance to handle XML-RPC requests in a CGI environment.
+
+
+.. class:: DocXMLRPCRequestHandler()
+
+ Create a new request handler instance. This request handler supports XML-RPC
+ POST requests, documentation GET requests, and modifies logging so that the
+ *logRequests* parameter to the :class:`DocXMLRPCServer` constructor parameter is
+ honored.
+
+
+.. _doc-xmlrpc-servers:
+
+DocXMLRPCServer Objects
+-----------------------
+
+The :class:`DocXMLRPCServer` class is derived from :class:`SimpleXMLRPCServer`
+and provides a means of creating self-documenting, stand alone XML-RPC
+servers. HTTP POST requests are handled as XML-RPC method calls. HTTP GET
+requests are handled by generating pydoc-style HTML documentation. This allows a
+server to provide its own web-based documentation.
+
+
+.. method:: DocXMLRPCServer.set_server_title(server_title)
+
+ Set the title used in the generated HTML documentation. This title will be used
+ inside the HTML "title" element.
+
+
+.. method:: DocXMLRPCServer.set_server_name(server_name)
+
+ Set the name used in the generated HTML documentation. This name will appear at
+ the top of the generated documentation inside a "h1" element.
+
+
+.. method:: DocXMLRPCServer.set_server_documentation(server_documentation)
+
+ Set the description used in the generated HTML documentation. This description
+ will appear as a paragraph, below the server name, in the documentation.
+
+
+DocCGIXMLRPCRequestHandler
+--------------------------
+
+The :class:`DocCGIXMLRPCRequestHandler` class is derived from
+:class:`CGIXMLRPCRequestHandler` and provides a means of creating
+self-documenting, XML-RPC CGI scripts. HTTP POST requests are handled as XML-RPC
+method calls. HTTP GET requests are handled by generating pydoc-style HTML
+documentation. This allows a server to provide its own web-based documentation.
+
+
+.. method:: DocCGIXMLRPCRequestHandler.set_server_title(server_title)
+
+ Set the title used in the generated HTML documentation. This title will be used
+ inside the HTML "title" element.
+
+
+.. method:: DocCGIXMLRPCRequestHandler.set_server_name(server_name)
+
+ Set the name used in the generated HTML documentation. This name will appear at
+ the top of the generated documentation inside a "h1" element.
+
+
+.. method:: DocCGIXMLRPCRequestHandler.set_server_documentation(server_documentation)
+
+ Set the description used in the generated HTML documentation. This description
+ will appear as a paragraph, below the server name, in the documentation.
XML Remote Procedure Calls
--------------------------
-The :mod:`xmlrpclib` module contains the following notice::
+The :mod:`xmlrpc.client` module contains the following notice::
The XML-RPC client interface is
Python has a "batteries included" philosophy. This is best seen through the
sophisticated and robust capabilities of its larger packages. For example:
-* The :mod:`xmlrpclib` and :mod:`SimpleXMLRPCServer` modules make implementing
+* The :mod:`xmlrpc.client` and :mod:`xmlrpc.server` modules make implementing
remote procedure calls into an almost trivial task. Despite the modules
names, no direct knowledge or handling of XML is needed.
+++ /dev/null
-"""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)
+++ /dev/null
-#! /usr/bin/env python
-"""Test script for the dbm.open function based on testdumbdbm.py"""
-
-import os
-import unittest
-import dbm
-import glob
-import test.support
-
-_fname = test.support.TESTFN
-
-#
-# Iterates over every database module supported by dbm currently available,
-# setting dbm to use each in turn, and yielding that module
-#
-def dbm_iterator():
- old_default = dbm._defaultmod
- for module in dbm._modules.values():
- dbm._defaultmod = module
- yield module
- dbm._defaultmod = old_default
-
-#
-# Clean up all scratch databases we might have created during testing
-#
-def delete_files():
- # we don't know the precise name the underlying database uses
- # so we use glob to locate all names
- for f in glob.glob(_fname + "*"):
- test.support.unlink(f)
-
-
-class AnyDBMTestCase(unittest.TestCase):
- _dict = {'0': b'',
- 'a': b'Python:',
- 'b': b'Programming',
- 'c': b'the',
- 'd': b'way',
- 'f': b'Guido',
- 'g': b'intended',
- }
-
- def __init__(self, *args):
- unittest.TestCase.__init__(self, *args)
-
- def test_anydbm_creation(self):
- f = dbm.open(_fname, 'c')
- self.assertEqual(list(f.keys()), [])
- for key in self._dict:
- f[key.encode("ascii")] = self._dict[key]
- self.read_helper(f)
- f.close()
-
- def test_anydbm_modification(self):
- self.init_db()
- f = dbm.open(_fname, 'c')
- self._dict['g'] = f[b'g'] = b"indented"
- self.read_helper(f)
- f.close()
-
- def test_anydbm_read(self):
- self.init_db()
- f = dbm.open(_fname, 'r')
- self.read_helper(f)
- f.close()
-
- def test_anydbm_keys(self):
- self.init_db()
- f = dbm.open(_fname, 'r')
- keys = self.keys_helper(f)
- f.close()
-
- def test_anydbm_access(self):
- self.init_db()
- f = dbm.open(_fname, 'r')
- key = "a".encode("ascii")
- assert(key in f)
- assert(f[key] == b"Python:")
- f.close()
-
- def read_helper(self, f):
- keys = self.keys_helper(f)
- for key in self._dict:
- self.assertEqual(self._dict[key], f[key.encode("ascii")])
-
- def init_db(self):
- f = dbm.open(_fname, 'n')
- for k in self._dict:
- f[k.encode("ascii")] = self._dict[k]
- f.close()
-
- def keys_helper(self, f):
- keys = sorted(k.decode("ascii") for k in f.keys())
- dkeys = sorted(self._dict.keys())
- self.assertEqual(keys, dkeys)
- return keys
-
- def tearDown(self):
- delete_files()
-
- def setUp(self):
- delete_files()
-
-
-class WhichDBTestCase(unittest.TestCase):
- # Actual test methods are added to namespace after class definition.
- def __init__(self, *args):
- unittest.TestCase.__init__(self, *args)
-
- def test_whichdb(self):
- for module in dbm_iterator():
- # Check whether whichdb correctly guesses module name
- # for databases opened with "module" module.
- # Try with empty files first
- name = module.__name__
- if name == 'dbm.dumb':
- continue # whichdb can't support dbm.dumb
- test.support.unlink(_fname)
- f = module.open(_fname, 'c')
- f.close()
- self.assertEqual(name, dbm.whichdb(_fname))
- # Now add a key
- f = module.open(_fname, 'w')
- f[b"1"] = b"1"
- # and test that we can find it
- self.assertTrue(b"1" in f)
- # and read it
- self.assertTrue(f[b"1"] == b"1")
- f.close()
- self.assertEqual(name, dbm.whichdb(_fname))
-
- def tearDown(self):
- delete_files()
-
- def setUp(self):
- delete_files()
-
-
-def test_main():
- try:
- for module in dbm_iterator():
- test.support.run_unittest(AnyDBMTestCase, WhichDBTestCase)
- finally:
- delete_files()
-
-if __name__ == "__main__":
- test_main()
-from DocXMLRPCServer import DocXMLRPCServer
+from xmlrpc.server import DocXMLRPCServer
import httplib
from test import support
import threading
import time
import unittest
-import xmlrpclib
PORT = None
import sys
import time
import unittest
-import xmlrpclib
-import SimpleXMLRPCServer
+import xmlrpc.client as xmlrpclib
+import xmlrpc.server
import threading
import mimetools
import httplib
# this will raise AttirebuteError because code don't want us to use
# private methods
self.assertRaises(AttributeError,
- SimpleXMLRPCServer.resolve_dotted_attribute, str, '__add')
+ xmlrpc.server.resolve_dotted_attribute, str, '__add')
- self.assert_(SimpleXMLRPCServer.resolve_dotted_attribute(str, 'title'))
+ self.assert_(xmlrpc.server.resolve_dotted_attribute(str, 'title'))
class DateTimeTestCase(unittest.TestCase):
def test_default(self):
'''This is my function'''
return True
- class MyXMLRPCServer(SimpleXMLRPCServer.SimpleXMLRPCServer):
+ class MyXMLRPCServer(xmlrpc.server.SimpleXMLRPCServer):
def get_request(self):
# Ensure the socket is always non-blocking. On Linux, socket
# attributes are not inherited like they are on *BSD and Windows.
class SimpleServerTestCase(unittest.TestCase):
def setUp(self):
# enable traceback reporting
- SimpleXMLRPCServer.SimpleXMLRPCServer._send_traceback_header = True
+ xmlrpc.server.SimpleXMLRPCServer._send_traceback_header = True
self.evt = threading.Event()
# start server thread to handle requests
raise RuntimeError("timeout reached, test has failed")
# disable traceback reporting
- SimpleXMLRPCServer.SimpleXMLRPCServer._send_traceback_header = False
+ xmlrpc.server.SimpleXMLRPCServer._send_traceback_header = False
def test_simple1(self):
try:
def test_dotted_attribute(self):
# Raises an AttributeError because private methods are not allowed.
self.assertRaises(AttributeError,
- SimpleXMLRPCServer.resolve_dotted_attribute, str, '__add')
+ xmlrpc.server.resolve_dotted_attribute, str, '__add')
- self.assert_(SimpleXMLRPCServer.resolve_dotted_attribute(str, 'title'))
+ self.assert_(xmlrpc.server.resolve_dotted_attribute(str, 'title'))
# Get the test to run faster by sending a request with test_simple1.
# This avoids waiting for the socket timeout.
self.test_simple1()
# wait on the server thread to terminate
self.evt.wait()
# reset flag
- SimpleXMLRPCServer.SimpleXMLRPCServer._send_traceback_header = False
+ xmlrpc.server.SimpleXMLRPCServer._send_traceback_header = False
# reset message class
- SimpleXMLRPCServer.SimpleXMLRPCRequestHandler.MessageClass = mimetools.Message
+ xmlrpc.server.SimpleXMLRPCRequestHandler.MessageClass = mimetools.Message
def test_basic(self):
# check that flag is false by default
- flagval = SimpleXMLRPCServer.SimpleXMLRPCServer._send_traceback_header
+ flagval = xmlrpc.server.SimpleXMLRPCServer._send_traceback_header
self.assertEqual(flagval, False)
# enable traceback reporting
- SimpleXMLRPCServer.SimpleXMLRPCServer._send_traceback_header = True
+ xmlrpc.server.SimpleXMLRPCServer._send_traceback_header = True
# test a call that shouldn't fail just as a smoke test
try:
def test_fail_no_info(self):
# use the broken message class
- SimpleXMLRPCServer.SimpleXMLRPCRequestHandler.MessageClass = FailingMessageClass
+ xmlrpc.server.SimpleXMLRPCRequestHandler.MessageClass = FailingMessageClass
try:
p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
def test_fail_with_info(self):
# use the broken message class
- SimpleXMLRPCServer.SimpleXMLRPCRequestHandler.MessageClass = FailingMessageClass
+ xmlrpc.server.SimpleXMLRPCRequestHandler.MessageClass = FailingMessageClass
# Check that errors in the server send back exception/traceback
# info when flag is set
- SimpleXMLRPCServer.SimpleXMLRPCServer._send_traceback_header = True
+ xmlrpc.server.SimpleXMLRPCServer._send_traceback_header = True
try:
p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
class CGIHandlerTestCase(unittest.TestCase):
def setUp(self):
- self.cgi = SimpleXMLRPCServer.CGIXMLRPCRequestHandler()
+ self.cgi = xmlrpc.server.CGIXMLRPCRequestHandler()
def tearDown(self):
self.cgi = None
import unittest
from test import support
-import xmlrpclib
+import xmlrpclib.client as xmlrpclib
class CurrentTimeTest(unittest.TestCase):
--- /dev/null
+# This directory is a Python package.
ServerProxy Represents a logical connection to an XML-RPC server
MultiCall Executor of boxcared xmlrpc requests
- Boolean boolean wrapper to generate a "boolean" XML-RPC value
DateTime dateTime wrapper for an ISO 8601 string or time tuple or
localtime integer value to generate a "dateTime.iso8601"
XML-RPC value
Exported functions:
- boolean Convert any Python value to an XML-RPC boolean
getparser Create instance of the fastest available parser & attach
to an unmarshalling object
dumps Convert an argument tuple or a Fault instance to an XML-RPC
except ImportError:
datetime = None
-try:
- _bool_is_builtin = False.__class__.__name__ == "bool"
-except NameError:
- _bool_is_builtin = 0
-
def _decode(data, encoding, is8bit=re.compile("[\x80-\xff]").search):
# decode non-ascii string (if possible)
if encoding and is8bit(data):
# Special values
##
-# Wrapper for XML-RPC boolean values. Use the xmlrpclib.True and
-# xmlrpclib.False constants, or the xmlrpclib.boolean() function, to
-# generate boolean XML-RPC values.
-#
-# @param value A boolean value. Any true value is interpreted as True,
-# all other values are interpreted as False.
+# Backwards compatibility
boolean = Boolean = bool
return value
WRAPPERS = (DateTime, Binary)
-if not _bool_is_builtin:
- WRAPPERS = WRAPPERS + (Boolean,)
# --------------------------------------------------------------------
# XML parsers
-try:
- # optional xmlrpclib accelerator
- import _xmlrpclib
- FastParser = _xmlrpclib.Parser
- FastUnmarshaller = _xmlrpclib.Unmarshaller
-except (AttributeError, ImportError):
- FastParser = FastUnmarshaller = None
-
-try:
- import _xmlrpclib
- FastMarshaller = _xmlrpclib.Marshaller
-except (AttributeError, ImportError):
- FastMarshaller = None
-
#
# the SGMLOP parser is about 15x faster than Python's builtin
# XML parser. SGMLOP sources can be downloaded from:
write("</int></value>\n")
#dispatch[int] = dump_int
- if _bool_is_builtin:
- def dump_bool(self, value, write):
- write("<value><boolean>")
- write(value and "1" or "0")
- write("</boolean></value>\n")
- dispatch[bool] = dump_bool
+ def dump_bool(self, value, write):
+ write("<value><boolean>")
+ write(value and "1" or "0")
+ write("</boolean></value>\n")
+ dispatch[bool] = dump_bool
def dump_long(self, value, write):
if value > MAXINT or value < MININT:
# --------------------------------------------------------------------
# convenience functions
+FastMarshaller = FastParser = FastUnmarshaller = None
+
##
# Create a parser object, and connect it to an unmarshalling instance.
# This function picks the fastest available XML parser.
-"""Simple XML-RPC Server.
+"""XML-RPC Servers.
This module can be used to create simple XML-RPC servers
by creating a server and either installing functions, a
It can also be used to handle XML-RPC requests in a CGI
environment using CGIXMLRPCRequestHandler.
+The Doc* classes 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.
+
A list of possible usage patterns follows:
1. Install functions:
# Written by Brian Quinlan (brian@sweetapp.com).
# Based on code written by Fredrik Lundh.
-import xmlrpclib
-from xmlrpclib import Fault
+from xmlrpc.client import Fault, dumps, loads
import socketserver
import BaseHTTPServer
import sys
import os
+import re
+import pydoc
+import inspect
import traceback
try:
import fcntl
"""
try:
- params, method = xmlrpclib.loads(data)
+ params, method = loads(data)
# generate response
if dispatch_method is not None:
response = self._dispatch(method, params)
# wrap response in a singleton tuple
response = (response,)
- response = xmlrpclib.dumps(response, methodresponse=1,
- allow_none=self.allow_none, encoding=self.encoding)
+ response = dumps(response, methodresponse=1,
+ allow_none=self.allow_none, encoding=self.encoding)
except Fault as fault:
- response = xmlrpclib.dumps(fault, allow_none=self.allow_none,
- encoding=self.encoding)
+ response = dumps(fault, allow_none=self.allow_none,
+ encoding=self.encoding)
except:
# report exception back to server
exc_type, exc_value, exc_tb = sys.exc_info()
- response = xmlrpclib.dumps(
- xmlrpclib.Fault(1, "%s:%s" % (exc_type, exc_value)),
+ response = dumps(
+ Fault(1, "%s:%s" % (exc_type, exc_value)),
encoding=self.encoding, allow_none=self.allow_none,
)
self.handle_xmlrpc(request_text)
+
+# -----------------------------------------------------------------------------
+# Self documenting XML-RPC Server.
+
+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)
+
+
if __name__ == '__main__':
print('Running XML-RPC server on port 8000')
server = SimpleXMLRPCServer(("localhost", 8000))
Library
-------
+- The ``xmlrpc`` package was created; it contains the old
+ ``xmlrpclib`` module as ``xmlrpc.client`` and the content of
+ the old ``SimpleXMLRPCServer`` and ``DocXMLRPCServer`` modules
+ as ``xmlrpc.server``.
+
+- The ``dbm`` package was created, containing the old modules
+ ``anydbm`` and ``whichdb`` in its ``__init__.py``, and having
+ ``dbm.gnu`` (was ``gdbm``), ``dbm.bsd`` (was ``dbhash``),
+ ``dbm.ndbm`` (was ``dbm``) and ``dbm.dumb`` (was ``dumbdbm``)
+ as submodules.
+
- The ``repr`` module has been renamed to ``reprlib``.
- The ``statvfs`` module has been removed.
xmllib A parser for XML, using the derived class as static DTD.
xml.dom Classes for processing XML using the Document Object Model.
xml.sax Classes for processing XML using the SAX API.
-xmlrpclib Support for remote procedure calls using XML.
+xmlrpc.client Support for remote procedure calls using XML.
+xmlrpc.server Create XMLRPC servers.
zipfile Read & write PK zipped files.
projects / python / commitdiff