path: root/devdocs/python~3.12/library%2Fxmlrpc.server.html

 <span id="xmlrpc-server-basic-xml-rpc-servers"></span><h1>xmlrpc.server — Basic XML-RPC servers</h1> <p><strong>Source code:</strong> <a class="reference external" href="https://github.com/python/cpython/tree/3.12/Lib/xmlrpc/server.py">Lib/xmlrpc/server.py</a></p>  <p>The <a class="reference internal" href="#module-xmlrpc.server" title="xmlrpc.server: Basic XML-RPC server implementations."><code>xmlrpc.server</code></a> module provides a basic server framework for XML-RPC servers written in Python. Servers can either be free standing, using <a class="reference internal" href="#xmlrpc.server.SimpleXMLRPCServer" title="xmlrpc.server.SimpleXMLRPCServer"><code>SimpleXMLRPCServer</code></a>, or embedded in a CGI environment, using <a class="reference internal" href="#xmlrpc.server.CGIXMLRPCRequestHandler" title="xmlrpc.server.CGIXMLRPCRequestHandler"><code>CGIXMLRPCRequestHandler</code></a>.</p> <div class="admonition warning"> <p class="admonition-title">Warning</p> <p>The <a class="reference internal" href="#module-xmlrpc.server" title="xmlrpc.server: Basic XML-RPC server implementations."><code>xmlrpc.server</code></a> module is not secure against maliciously constructed data. If you need to parse untrusted or unauthenticated data see <a class="reference internal" href="xml#xml-vulnerabilities"><span class="std std-ref">XML vulnerabilities</span></a>.</p> </div> <div class="availability docutils container"> <p><a class="reference internal" href="https://docs.python.org/3.12/library/intro.html#availability"><span class="std std-ref">Availability</span></a>: not Emscripten, not WASI.</p> <p>This module does not work or is not available on WebAssembly platforms <code>wasm32-emscripten</code> and <code>wasm32-wasi</code>. See <a class="reference internal" href="https://docs.python.org/3.12/library/intro.html#wasm-availability"><span class="std std-ref">WebAssembly platforms</span></a> for more information.</p> </div> <dl class="py class"> <dt class="sig sig-object py" id="xmlrpc.server.SimpleXMLRPCServer">
<code>class xmlrpc.server.SimpleXMLRPCServer(addr, requestHandler=SimpleXMLRPCRequestHandler, logRequests=True, allow_none=False, encoding=None, bind_and_activate=True, use_builtin_types=False)</code> </dt> <dd>
<p>Create a new server instance. This class provides methods for registration of functions that can be called by the XML-RPC protocol. The <em>requestHandler</em> parameter should be a factory for request handler instances; it defaults to <a class="reference internal" href="#xmlrpc.server.SimpleXMLRPCRequestHandler" title="xmlrpc.server.SimpleXMLRPCRequestHandler"><code>SimpleXMLRPCRequestHandler</code></a>. The <em>addr</em> and <em>requestHandler</em> parameters are passed to the <a class="reference internal" href="socketserver#socketserver.TCPServer" title="socketserver.TCPServer"><code>socketserver.TCPServer</code></a> constructor. If <em>logRequests</em> is true (the default), requests will be logged; setting this parameter to false will turn off logging. The <em>allow_none</em> and <em>encoding</em> parameters are passed on to <a class="reference internal" href="xmlrpc.client#module-xmlrpc.client" title="xmlrpc.client: XML-RPC client access."><code>xmlrpc.client</code></a> and control the XML-RPC responses that will be returned from the server. The <em>bind_and_activate</em> parameter controls whether <code>server_bind()</code> and <code>server_activate()</code> are called immediately by the constructor; it defaults to true. Setting it to false allows code to manipulate the <em>allow_reuse_address</em> class variable before the address is bound. The <em>use_builtin_types</em> parameter is passed to the <a class="reference internal" href="xmlrpc.client#xmlrpc.client.loads" title="xmlrpc.client.loads"><code>loads()</code></a> function and controls which types are processed when date/times values or binary data are received; it defaults to false.</p> <div class="versionchanged"> <p><span class="versionmodified changed">Changed in version 3.3: </span>The <em>use_builtin_types</em> flag was added.</p> </div> </dd>
</dl> <dl class="py class"> <dt class="sig sig-object py" id="xmlrpc.server.CGIXMLRPCRequestHandler">
<code>class xmlrpc.server.CGIXMLRPCRequestHandler(allow_none=False, encoding=None, use_builtin_types=False)</code> </dt> <dd>
<p>Create a new instance to handle XML-RPC requests in a CGI environment. The <em>allow_none</em> and <em>encoding</em> parameters are passed on to <a class="reference internal" href="xmlrpc.client#module-xmlrpc.client" title="xmlrpc.client: XML-RPC client access."><code>xmlrpc.client</code></a> and control the XML-RPC responses that will be returned from the server. The <em>use_builtin_types</em> parameter is passed to the <a class="reference internal" href="xmlrpc.client#xmlrpc.client.loads" title="xmlrpc.client.loads"><code>loads()</code></a> function and controls which types are processed when date/times values or binary data are received; it defaults to false.</p> <div class="versionchanged"> <p><span class="versionmodified changed">Changed in version 3.3: </span>The <em>use_builtin_types</em> flag was added.</p> </div> </dd>
</dl> <dl class="py class"> <dt class="sig sig-object py" id="xmlrpc.server.SimpleXMLRPCRequestHandler">
<code>class xmlrpc.server.SimpleXMLRPCRequestHandler</code> </dt> <dd>
<p>Create a new request handler instance. This request handler supports <code>POST</code> requests and modifies logging so that the <em>logRequests</em> parameter to the <a class="reference internal" href="#xmlrpc.server.SimpleXMLRPCServer" title="xmlrpc.server.SimpleXMLRPCServer"><code>SimpleXMLRPCServer</code></a> constructor parameter is honored.</p> </dd>
</dl> <section id="simplexmlrpcserver-objects"> <span id="simple-xmlrpc-servers"></span><h2>SimpleXMLRPCServer Objects</h2> <p>The <a class="reference internal" href="#xmlrpc.server.SimpleXMLRPCServer" title="xmlrpc.server.SimpleXMLRPCServer"><code>SimpleXMLRPCServer</code></a> class is based on <a class="reference internal" href="socketserver#socketserver.TCPServer" title="socketserver.TCPServer"><code>socketserver.TCPServer</code></a> and provides a means of creating simple, stand alone XML-RPC servers.</p> <dl class="py method"> <dt class="sig sig-object py" id="xmlrpc.server.SimpleXMLRPCServer.register_function">
<code>SimpleXMLRPCServer.register_function(function=None, name=None)</code> </dt> <dd>
<p>Register a function that can respond to XML-RPC requests. If <em>name</em> is given, it will be the method name associated with <em>function</em>, otherwise <a class="reference internal" href="../reference/datamodel#function.__name__" title="function.__name__"><code>function.__name__</code></a> will be used. <em>name</em> is a string, and may contain characters not legal in Python identifiers, including the period character.</p> <p>This method can also be used as a decorator. When used as a decorator, <em>name</em> can only be given as a keyword argument to register <em>function</em> under <em>name</em>. If no <em>name</em> is given, <a class="reference internal" href="../reference/datamodel#function.__name__" title="function.__name__"><code>function.__name__</code></a> will be used.</p> <div class="versionchanged"> <p><span class="versionmodified changed">Changed in version 3.7: </span><a class="reference internal" href="#xmlrpc.server.SimpleXMLRPCServer.register_function" title="xmlrpc.server.SimpleXMLRPCServer.register_function"><code>register_function()</code></a> can be used as a decorator.</p> </div> </dd>
</dl> <dl class="py method"> <dt class="sig sig-object py" id="xmlrpc.server.SimpleXMLRPCServer.register_instance">
<code>SimpleXMLRPCServer.register_instance(instance, allow_dotted_names=False)</code> </dt> <dd>
<p>Register an object which is used to expose method names which have not been registered using <a class="reference internal" href="#xmlrpc.server.SimpleXMLRPCServer.register_function" title="xmlrpc.server.SimpleXMLRPCServer.register_function"><code>register_function()</code></a>. If <em>instance</em> contains a <code>_dispatch()</code> method, it is called with the requested method name and the parameters from the request. Its API is <code>def _dispatch(self, method, params)</code> (note that <em>params</em> does not represent a variable argument list). If it calls an underlying function to perform its task, that function is called as <code>func(*params)</code>, expanding the parameter list. The return value from <code>_dispatch()</code> is returned to the client as the result. If <em>instance</em> does not have a <code>_dispatch()</code> method, it is searched for an attribute matching the name of the requested method.</p> <p>If the optional <em>allow_dotted_names</em> argument is true and the instance does not have a <code>_dispatch()</code> method, then if the requested method name contains periods, each component of the method name is searched for individually, with the effect that a simple hierarchical search is performed. The value found from this search is then called with the parameters from the request, and the return value is passed back to the client.</p> <div class="admonition warning"> <p class="admonition-title">Warning</p> <p>Enabling the <em>allow_dotted_names</em> option allows intruders to access your module’s global variables and may allow intruders to execute arbitrary code on your machine. Only use this option on a secure, closed network.</p> </div> </dd>
</dl> <dl class="py method"> <dt class="sig sig-object py" id="xmlrpc.server.SimpleXMLRPCServer.register_introspection_functions">
<code>SimpleXMLRPCServer.register_introspection_functions()</code> </dt> <dd>
<p>Registers the XML-RPC introspection functions <code>system.listMethods</code>, <code>system.methodHelp</code> and <code>system.methodSignature</code>.</p> </dd>
</dl> <dl class="py method"> <dt class="sig sig-object py" id="xmlrpc.server.SimpleXMLRPCServer.register_multicall_functions">
<code>SimpleXMLRPCServer.register_multicall_functions()</code> </dt> <dd>
<p>Registers the XML-RPC multicall function system.multicall.</p> </dd>
</dl> <dl class="py attribute"> <dt class="sig sig-object py" id="xmlrpc.server.SimpleXMLRPCRequestHandler.rpc_paths">
<code>SimpleXMLRPCRequestHandler.rpc_paths</code> </dt> <dd>
<p>An attribute value that must be a tuple listing valid path portions of the URL for receiving XML-RPC requests. Requests posted to other paths will result in a 404 “no such page” HTTP error. If this tuple is empty, all paths will be considered valid. The default value is <code>('/', '/RPC2')</code>.</p> </dd>
</dl> <section id="simplexmlrpcserver-example"> <span id="id1"></span><h3>SimpleXMLRPCServer Example</h3> <p>Server code:</p> <pre data-language="python">from xmlrpc.server import SimpleXMLRPCServer
from xmlrpc.server import SimpleXMLRPCRequestHandler

# Restrict to a particular path.
class RequestHandler(SimpleXMLRPCRequestHandler):
    rpc_paths = ('/RPC2',)

# Create server
with SimpleXMLRPCServer(('localhost', 8000),
                        requestHandler=RequestHandler) as server:
    server.register_introspection_functions()

    # Register pow() function; this will use the value of
    # pow.__name__ as the name, which is just 'pow'.
    server.register_function(pow)

    # Register a function under a different name
    def adder_function(x, y):
        return x + y
    server.register_function(adder_function, 'add')

    # Register an instance; all the methods of the instance are
    # published as XML-RPC methods (in this case, just 'mul').
    class MyFuncs:
        def mul(self, x, y):
            return x * y

    server.register_instance(MyFuncs())

    # Run the server's main loop
    server.serve_forever()
</pre> <p>The following client code will call the methods made available by the preceding server:</p> <pre data-language="python">import xmlrpc.client

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

# Print list of available methods
print(s.system.listMethods())
</pre> <p><code>register_function()</code> can also be used as a decorator. The previous server example can register functions in a decorator way:</p> <pre data-language="python">from xmlrpc.server import SimpleXMLRPCServer
from xmlrpc.server import SimpleXMLRPCRequestHandler

class RequestHandler(SimpleXMLRPCRequestHandler):
    rpc_paths = ('/RPC2',)

with SimpleXMLRPCServer(('localhost', 8000),
                        requestHandler=RequestHandler) as server:
    server.register_introspection_functions()

    # Register pow() function; this will use the value of
    # pow.__name__ as the name, which is just 'pow'.
    server.register_function(pow)

    # Register a function under a different name, using
    # register_function as a decorator. *name* can only be given
    # as a keyword argument.
    @server.register_function(name='add')
    def adder_function(x, y):
        return x + y

    # Register a function under function.__name__.
    @server.register_function
    def mul(x, y):
        return x * y

    server.serve_forever()
</pre> <p>The following example included in the <code>Lib/xmlrpc/server.py</code> module shows a server allowing dotted names and registering a multicall function.</p> <div class="admonition warning"> <p class="admonition-title">Warning</p> <p>Enabling the <em>allow_dotted_names</em> option allows intruders to access your module’s global variables and may allow intruders to execute arbitrary code on your machine. Only use this example only within a secure, closed network.</p> </div> <pre data-language="python">import datetime

class ExampleService:
    def getData(self):
        return '42'

    class currentTime:
        @staticmethod
        def getCurrentTime():
            return datetime.datetime.now()

with SimpleXMLRPCServer(("localhost", 8000)) as server:
    server.register_function(pow)
    server.register_function(lambda x,y: x+y, 'add')
    server.register_instance(ExampleService(), allow_dotted_names=True)
    server.register_multicall_functions()
    print('Serving XML-RPC on localhost port 8000')
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        print("\nKeyboard interrupt received, exiting.")
        sys.exit(0)
</pre> <p>This ExampleService demo can be invoked from the command line:</p> <pre data-language="python">python -m xmlrpc.server
</pre> <p>The client that interacts with the above server is included in <code>Lib/xmlrpc/client.py</code>:</p> <pre data-language="python">server = ServerProxy("http://localhost:8000")

try:
    print(server.currentTime.getCurrentTime())
except Error as v:
    print("ERROR", v)

multi = MultiCall(server)
multi.getData()
multi.pow(2,9)
multi.add(1,2)
try:
    for response in multi():
        print(response)
except Error as v:
    print("ERROR", v)
</pre> <p>This client which interacts with the demo XMLRPC server can be invoked as:</p> <pre data-language="python">python -m xmlrpc.client
</pre> </section> </section> <section id="cgixmlrpcrequesthandler"> <h2>CGIXMLRPCRequestHandler</h2> <p>The <a class="reference internal" href="#xmlrpc.server.CGIXMLRPCRequestHandler" title="xmlrpc.server.CGIXMLRPCRequestHandler"><code>CGIXMLRPCRequestHandler</code></a> class can be used to handle XML-RPC requests sent to Python CGI scripts.</p> <dl class="py method"> <dt class="sig sig-object py" id="xmlrpc.server.CGIXMLRPCRequestHandler.register_function">
<code>CGIXMLRPCRequestHandler.register_function(function=None, name=None)</code> </dt> <dd>
<p>Register a function that can respond to XML-RPC requests. If <em>name</em> is given, it will be the method name associated with <em>function</em>, otherwise <a class="reference internal" href="../reference/datamodel#function.__name__" title="function.__name__"><code>function.__name__</code></a> will be used. <em>name</em> is a string, and may contain characters not legal in Python identifiers, including the period character.</p> <p>This method can also be used as a decorator. When used as a decorator, <em>name</em> can only be given as a keyword argument to register <em>function</em> under <em>name</em>. If no <em>name</em> is given, <a class="reference internal" href="../reference/datamodel#function.__name__" title="function.__name__"><code>function.__name__</code></a> will be used.</p> <div class="versionchanged"> <p><span class="versionmodified changed">Changed in version 3.7: </span><a class="reference internal" href="#xmlrpc.server.CGIXMLRPCRequestHandler.register_function" title="xmlrpc.server.CGIXMLRPCRequestHandler.register_function"><code>register_function()</code></a> can be used as a decorator.</p> </div> </dd>
</dl> <dl class="py method"> <dt class="sig sig-object py" id="xmlrpc.server.CGIXMLRPCRequestHandler.register_instance">
<code>CGIXMLRPCRequestHandler.register_instance(instance)</code> </dt> <dd>
<p>Register an object which is used to expose method names which have not been registered using <a class="reference internal" href="#xmlrpc.server.CGIXMLRPCRequestHandler.register_function" title="xmlrpc.server.CGIXMLRPCRequestHandler.register_function"><code>register_function()</code></a>. If instance contains a <code>_dispatch()</code> method, it is called with the requested method name and the parameters from the request; the return value is returned to the client as the result. If instance does not have a <code>_dispatch()</code> method, it is searched for an attribute matching the name of the requested method; if the requested method name contains periods, each component of the method name is searched for individually, with the effect that a simple hierarchical search is performed. The value found from this search is then called with the parameters from the request, and the return value is passed back to the client.</p> </dd>
</dl> <dl class="py method"> <dt class="sig sig-object py" id="xmlrpc.server.CGIXMLRPCRequestHandler.register_introspection_functions">
<code>CGIXMLRPCRequestHandler.register_introspection_functions()</code> </dt> <dd>
<p>Register the XML-RPC introspection functions <code>system.listMethods</code>, <code>system.methodHelp</code> and <code>system.methodSignature</code>.</p> </dd>
</dl> <dl class="py method"> <dt class="sig sig-object py" id="xmlrpc.server.CGIXMLRPCRequestHandler.register_multicall_functions">
<code>CGIXMLRPCRequestHandler.register_multicall_functions()</code> </dt> <dd>
<p>Register the XML-RPC multicall function <code>system.multicall</code>.</p> </dd>
</dl> <dl class="py method"> <dt class="sig sig-object py" id="xmlrpc.server.CGIXMLRPCRequestHandler.handle_request">
<code>CGIXMLRPCRequestHandler.handle_request(request_text=None)</code> </dt> <dd>
<p>Handle an XML-RPC request. If <em>request_text</em> is given, it should be the POST data provided by the HTTP server, otherwise the contents of stdin will be used.</p> </dd>
</dl> <p>Example:</p> <pre data-language="python">class MyFuncs:
    def mul(self, x, y):
        return x * y


handler = CGIXMLRPCRequestHandler()
handler.register_function(pow)
handler.register_function(lambda x,y: x+y, 'add')
handler.register_introspection_functions()
handler.register_instance(MyFuncs())
handler.handle_request()
</pre> </section> <section id="documenting-xmlrpc-server"> <h2>Documenting XMLRPC server</h2> <p>These classes extend the above classes to serve HTML documentation in response to HTTP GET requests. Servers can either be free standing, using <a class="reference internal" href="#xmlrpc.server.DocXMLRPCServer" title="xmlrpc.server.DocXMLRPCServer"><code>DocXMLRPCServer</code></a>, or embedded in a CGI environment, using <a class="reference internal" href="#xmlrpc.server.DocCGIXMLRPCRequestHandler" title="xmlrpc.server.DocCGIXMLRPCRequestHandler"><code>DocCGIXMLRPCRequestHandler</code></a>.</p> <dl class="py class"> <dt class="sig sig-object py" id="xmlrpc.server.DocXMLRPCServer">
<code>class xmlrpc.server.DocXMLRPCServer(addr, requestHandler=DocXMLRPCRequestHandler, logRequests=True, allow_none=False, encoding=None, bind_and_activate=True, use_builtin_types=True)</code> </dt> <dd>
<p>Create a new server instance. All parameters have the same meaning as for <a class="reference internal" href="#xmlrpc.server.SimpleXMLRPCServer" title="xmlrpc.server.SimpleXMLRPCServer"><code>SimpleXMLRPCServer</code></a>; <em>requestHandler</em> defaults to <a class="reference internal" href="#xmlrpc.server.DocXMLRPCRequestHandler" title="xmlrpc.server.DocXMLRPCRequestHandler"><code>DocXMLRPCRequestHandler</code></a>.</p> <div class="versionchanged"> <p><span class="versionmodified changed">Changed in version 3.3: </span>The <em>use_builtin_types</em> flag was added.</p> </div> </dd>
</dl> <dl class="py class"> <dt class="sig sig-object py" id="xmlrpc.server.DocCGIXMLRPCRequestHandler">
<code>class xmlrpc.server.DocCGIXMLRPCRequestHandler</code> </dt> <dd>
<p>Create a new instance to handle XML-RPC requests in a CGI environment.</p> </dd>
</dl> <dl class="py class"> <dt class="sig sig-object py" id="xmlrpc.server.DocXMLRPCRequestHandler">
<code>class xmlrpc.server.DocXMLRPCRequestHandler</code> </dt> <dd>
<p>Create a new request handler instance. This request handler supports XML-RPC POST requests, documentation GET requests, and modifies logging so that the <em>logRequests</em> parameter to the <a class="reference internal" href="#xmlrpc.server.DocXMLRPCServer" title="xmlrpc.server.DocXMLRPCServer"><code>DocXMLRPCServer</code></a> constructor parameter is honored.</p> </dd>
</dl> </section> <section id="docxmlrpcserver-objects"> <span id="doc-xmlrpc-servers"></span><h2>DocXMLRPCServer Objects</h2> <p>The <a class="reference internal" href="#xmlrpc.server.DocXMLRPCServer" title="xmlrpc.server.DocXMLRPCServer"><code>DocXMLRPCServer</code></a> class is derived from <a class="reference internal" href="#xmlrpc.server.SimpleXMLRPCServer" title="xmlrpc.server.SimpleXMLRPCServer"><code>SimpleXMLRPCServer</code></a> 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.</p> <dl class="py method"> <dt class="sig sig-object py" id="xmlrpc.server.DocXMLRPCServer.set_server_title">
<code>DocXMLRPCServer.set_server_title(server_title)</code> </dt> <dd>
<p>Set the title used in the generated HTML documentation. This title will be used inside the HTML “title” element.</p> </dd>
</dl> <dl class="py method"> <dt class="sig sig-object py" id="xmlrpc.server.DocXMLRPCServer.set_server_name">
<code>DocXMLRPCServer.set_server_name(server_name)</code> </dt> <dd>
<p>Set the name used in the generated HTML documentation. This name will appear at the top of the generated documentation inside a “h1” element.</p> </dd>
</dl> <dl class="py method"> <dt class="sig sig-object py" id="xmlrpc.server.DocXMLRPCServer.set_server_documentation">
<code>DocXMLRPCServer.set_server_documentation(server_documentation)</code> </dt> <dd>
<p>Set the description used in the generated HTML documentation. This description will appear as a paragraph, below the server name, in the documentation.</p> </dd>
</dl> </section> <section id="doccgixmlrpcrequesthandler"> <h2>DocCGIXMLRPCRequestHandler</h2> <p>The <a class="reference internal" href="#xmlrpc.server.DocCGIXMLRPCRequestHandler" title="xmlrpc.server.DocCGIXMLRPCRequestHandler"><code>DocCGIXMLRPCRequestHandler</code></a> class is derived from <a class="reference internal" href="#xmlrpc.server.CGIXMLRPCRequestHandler" title="xmlrpc.server.CGIXMLRPCRequestHandler"><code>CGIXMLRPCRequestHandler</code></a> 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.</p> <dl class="py method"> <dt class="sig sig-object py" id="xmlrpc.server.DocCGIXMLRPCRequestHandler.set_server_title">
<code>DocCGIXMLRPCRequestHandler.set_server_title(server_title)</code> </dt> <dd>
<p>Set the title used in the generated HTML documentation. This title will be used inside the HTML “title” element.</p> </dd>
</dl> <dl class="py method"> <dt class="sig sig-object py" id="xmlrpc.server.DocCGIXMLRPCRequestHandler.set_server_name">
<code>DocCGIXMLRPCRequestHandler.set_server_name(server_name)</code> </dt> <dd>
<p>Set the name used in the generated HTML documentation. This name will appear at the top of the generated documentation inside a “h1” element.</p> </dd>
</dl> <dl class="py method"> <dt class="sig sig-object py" id="xmlrpc.server.DocCGIXMLRPCRequestHandler.set_server_documentation">
<code>DocCGIXMLRPCRequestHandler.set_server_documentation(server_documentation)</code> </dt> <dd>
<p>Set the description used in the generated HTML documentation. This description will appear as a paragraph, below the server name, in the documentation.</p> </dd>
</dl> </section> <div class="_attribution">
  <p class="_attribution-p">
    &copy; 2001&ndash;2023 Python Software Foundation<br>Licensed under the PSF License.<br>
    <a href="https://docs.python.org/3.12/library/xmlrpc.server.html" class="_attribution-link">https://docs.python.org/3.12/library/xmlrpc.server.html</a>
  </p>
</div>