Create xmlrpc package. Issue #2886.

1 files changed, 0 insertions, 1429 deletions

diff --git a/Lib/xmlrpclib.py b/Lib/xmlrpclib.py
deleted file mode 100644
index 522df4d0ef..0000000000
--- a/Lib/xmlrpclib.py
+++ /dev/null
@@ -1,1429 +0,0 @@
-#
-# XML-RPC CLIENT LIBRARY
-# $Id$
-#
-# an XML-RPC client interface for Python.
-#
-# the marshalling and response parser code can also be used to
-# implement XML-RPC servers.
-#
-# Notes:
-# this version is designed to work with Python 2.1 or newer.
-#
-# History:
-# 1999-01-14 fl  Created
-# 1999-01-15 fl  Changed dateTime to use localtime
-# 1999-01-16 fl  Added Binary/base64 element, default to RPC2 service
-# 1999-01-19 fl  Fixed array data element (from Skip Montanaro)
-# 1999-01-21 fl  Fixed dateTime constructor, etc.
-# 1999-02-02 fl  Added fault handling, handle empty sequences, etc.
-# 1999-02-10 fl  Fixed problem with empty responses (from Skip Montanaro)
-# 1999-06-20 fl  Speed improvements, pluggable parsers/transports (0.9.8)
-# 2000-11-28 fl  Changed boolean to check the truth value of its argument
-# 2001-02-24 fl  Added encoding/Unicode/SafeTransport patches
-# 2001-02-26 fl  Added compare support to wrappers (0.9.9/1.0b1)
-# 2001-03-28 fl  Make sure response tuple is a singleton
-# 2001-03-29 fl  Don't require empty params element (from Nicholas Riley)
-# 2001-06-10 fl  Folded in _xmlrpclib accelerator support (1.0b2)
-# 2001-08-20 fl  Base xmlrpclib.Error on built-in Exception (from Paul Prescod)
-# 2001-09-03 fl  Allow Transport subclass to override getparser
-# 2001-09-10 fl  Lazy import of urllib, cgi, xmllib (20x import speedup)
-# 2001-10-01 fl  Remove containers from memo cache when done with them
-# 2001-10-01 fl  Use faster escape method (80% dumps speedup)
-# 2001-10-02 fl  More dumps microtuning
-# 2001-10-04 fl  Make sure import expat gets a parser (from Guido van Rossum)
-# 2001-10-10 sm  Allow long ints to be passed as ints if they don't overflow
-# 2001-10-17 sm  Test for int and long overflow (allows use on 64-bit systems)
-# 2001-11-12 fl  Use repr() to marshal doubles (from Paul Felix)
-# 2002-03-17 fl  Avoid buffered read when possible (from James Rucker)
-# 2002-04-07 fl  Added pythondoc comments
-# 2002-04-16 fl  Added __str__ methods to datetime/binary wrappers
-# 2002-05-15 fl  Added error constants (from Andrew Kuchling)
-# 2002-06-27 fl  Merged with Python CVS version
-# 2002-10-22 fl  Added basic authentication (based on code from Phillip Eby)
-# 2003-01-22 sm  Add support for the bool type
-# 2003-02-27 gvr Remove apply calls
-# 2003-04-24 sm  Use cStringIO if available
-# 2003-04-25 ak  Add support for nil
-# 2003-06-15 gn  Add support for time.struct_time
-# 2003-07-12 gp  Correct marshalling of Faults
-# 2003-10-31 mvl Add multicall support
-# 2004-08-20 mvl Bump minimum supported Python version to 2.1
-#
-# Copyright (c) 1999-2002 by Secret Labs AB.
-# Copyright (c) 1999-2002 by Fredrik Lundh.
-#
-# info@pythonware.com
-# http://www.pythonware.com
-#
-# --------------------------------------------------------------------
-# The XML-RPC client interface is
-#
-# Copyright (c) 1999-2002 by Secret Labs AB
-# Copyright (c) 1999-2002 by Fredrik Lundh
-#
-# By obtaining, using, and/or copying this software and/or its
-# associated documentation, you agree that you have read, understood,
-# and will comply with the following terms and conditions:
-#
-# Permission to use, copy, modify, and distribute this software and
-# its associated documentation for any purpose and without fee is
-# hereby granted, provided that the above copyright notice appears in
-# all copies, and that both that copyright notice and this permission
-# notice appear in supporting documentation, and that the name of
-# Secret Labs AB or the author not be used in advertising or publicity
-# pertaining to distribution of the software without specific, written
-# prior permission.
-#
-# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
-# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
-# ABILITY AND FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
-# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
-# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
-# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
-# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
-# OF THIS SOFTWARE.
-# --------------------------------------------------------------------
-
-#
-# things to look into some day:
-
-# TODO: sort out True/False/boolean issues for Python 2.3
-
-"""
-An XML-RPC client interface for Python.
-
-The marshalling and response parser code can also be used to
-implement XML-RPC servers.
-
-Exported exceptions:
-
-  Error          Base class for client errors
-  ProtocolError  Indicates an HTTP protocol error
-  ResponseError  Indicates a broken response package
-  Fault          Indicates an XML-RPC fault package
-
-Exported classes:
-
-  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
-  Binary         binary data wrapper
-
-  SlowParser     Slow but safe standard parser (based on xmllib)
-  Marshaller     Generate an XML-RPC params chunk from a Python data structure
-  Unmarshaller   Unmarshal an XML-RPC response from incoming XML event message
-  Transport      Handles an HTTP transaction to an XML-RPC server
-  SafeTransport  Handles an HTTPS transaction to an XML-RPC server
-
-Exported constants:
-
-  True
-  False
-
-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
-                 request (or response, if the methodresponse option is used).
-  loads          Convert an XML-RPC packet to unmarshalled data plus a method
-                 name (None if not present).
-"""
-
-import re, time, operator
-import httplib
-
-# --------------------------------------------------------------------
-# Internal stuff
-
-try:
-    import datetime
-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):
-        data = str(data, encoding)
-    return data
-
-def escape(s):
-    s = s.replace("&", "&")
-    s = s.replace("<", "&lt;")
-    return s.replace(">", "&gt;",)
-
-def _stringify(string):
-    # convert to 7-bit ascii if possible
-    try:
-        return string.decode("ascii")
-    except (UnicodeError, TypeError, AttributeError):
-        return string
-
-__version__ = "1.0.1"
-
-# xmlrpc integer limits
-MAXINT =  2**31-1
-MININT = -2**31
-
-# --------------------------------------------------------------------
-# Error constants (from Dan Libby's specification at
-# http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php)
-
-# Ranges of errors
-PARSE_ERROR       = -32700
-SERVER_ERROR      = -32600
-APPLICATION_ERROR = -32500
-SYSTEM_ERROR      = -32400
-TRANSPORT_ERROR   = -32300
-
-# Specific errors
-NOT_WELLFORMED_ERROR  = -32700
-UNSUPPORTED_ENCODING  = -32701
-INVALID_ENCODING_CHAR = -32702
-INVALID_XMLRPC        = -32600
-METHOD_NOT_FOUND      = -32601
-INVALID_METHOD_PARAMS = -32602
-INTERNAL_ERROR        = -32603
-
-# --------------------------------------------------------------------
-# Exceptions
-
-##
-# Base class for all kinds of client-side errors.
-
-class Error(Exception):
-    """Base class for client errors."""
-    def __str__(self):
-        return repr(self)
-
-##
-# Indicates an HTTP-level protocol error.  This is raised by the HTTP
-# transport layer, if the server returns an error code other than 200
-# (OK).
-#
-# @param url The target URL.
-# @param errcode The HTTP error code.
-# @param errmsg The HTTP error message.
-# @param headers The HTTP header dictionary.
-
-class ProtocolError(Error):
-    """Indicates an HTTP protocol error."""
-    def __init__(self, url, errcode, errmsg, headers):
-        Error.__init__(self)
-        self.url = url
-        self.errcode = errcode
-        self.errmsg = errmsg
-        self.headers = headers
-    def __repr__(self):
-        return (
-            "<ProtocolError for %s: %s %s>" %
-            (self.url, self.errcode, self.errmsg)
-            )
-
-##
-# Indicates a broken XML-RPC response package.  This exception is
-# raised by the unmarshalling layer, if the XML-RPC response is
-# malformed.
-
-class ResponseError(Error):
-    """Indicates a broken response package."""
-    pass
-
-##
-# Indicates an XML-RPC fault response package.  This exception is
-# raised by the unmarshalling layer, if the XML-RPC response contains
-# a fault string.  This exception can also used as a class, to
-# generate a fault XML-RPC message.
-#
-# @param faultCode The XML-RPC fault code.
-# @param faultString The XML-RPC fault string.
-
-class Fault(Error):
-    """Indicates an XML-RPC fault package."""
-    def __init__(self, faultCode, faultString, **extra):
-        Error.__init__(self)
-        self.faultCode = faultCode
-        self.faultString = faultString
-    def __repr__(self):
-        return (
-            "<Fault %s: %s>" %
-            (self.faultCode, repr(self.faultString))
-            )
-
-# --------------------------------------------------------------------
-# 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.
-
-boolean = Boolean = bool
-
-##
-# Wrapper for XML-RPC DateTime values.  This converts a time value to
-# the format used by XML-RPC.
-# <p>
-# The value can be given as a string in the format
-# "yyyymmddThh:mm:ss", as a 9-item time tuple (as returned by
-# time.localtime()), or an integer value (as returned by time.time()).
-# The wrapper uses time.localtime() to convert an integer to a time
-# tuple.
-#
-# @param value The time, given as an ISO 8601 string, a time
-#              tuple, or a integer time value.
-
-def _strftime(value):
-    if datetime:
-        if isinstance(value, datetime.datetime):
-            return "%04d%02d%02dT%02d:%02d:%02d" % (
-                value.year, value.month, value.day,
-                value.hour, value.minute, value.second)
-
-    if not isinstance(value, (tuple, time.struct_time)):
-        if value == 0:
-            value = time.time()
-        value = time.localtime(value)
-
-    return "%04d%02d%02dT%02d:%02d:%02d" % value[:6]
-
-class DateTime:
-    """DateTime wrapper for an ISO 8601 string or time tuple or
-    localtime integer value to generate 'dateTime.iso8601' XML-RPC
-    value.
-    """
-
-    def __init__(self, value=0):
-        if isinstance(value, str):
-            self.value = value
-        else:
-            self.value = _strftime(value)
-
-    def make_comparable(self, other):
-        if isinstance(other, DateTime):
-            s = self.value
-            o = other.value
-        elif datetime and isinstance(other, datetime.datetime):
-            s = self.value
-            o = other.strftime("%Y%m%dT%H:%M:%S")
-        elif isinstance(other, (str, unicode)):
-            s = self.value
-            o = other
-        elif hasattr(other, "timetuple"):
-            s = self.timetuple()
-            o = other.timetuple()
-        else:
-            otype = (hasattr(other, "__class__")
-                     and other.__class__.__name__
-                     or type(other))
-            raise TypeError("Can't compare %s and %s" %
-                            (self.__class__.__name__, otype))
-        return s, o
-
-    def __lt__(self, other):
-        s, o = self.make_comparable(other)
-        return s < o
-
-    def __le__(self, other):
-        s, o = self.make_comparable(other)
-        return s <= o
-
-    def __gt__(self, other):
-        s, o = self.make_comparable(other)
-        return s > o
-
-    def __ge__(self, other):
-        s, o = self.make_comparable(other)
-        return s >= o
-
-    def __eq__(self, other):
-        s, o = self.make_comparable(other)
-        return s == o
-
-    def __ne__(self, other):
-        s, o = self.make_comparable(other)
-        return s != o
-
-    def timetuple(self):
-        return time.strptime(self.value, "%Y%m%dT%H:%M:%S")
-
-    def __cmp__(self, other):
-        s, o = self.make_comparable(other)
-        return cmp(s, o)
-
-    ##
-    # Get date/time value.
-    #
-    # @return Date/time value, as an ISO 8601 string.
-
-    def __str__(self):
-        return self.value
-
-    def __repr__(self):
-        return "<DateTime %s at %x>" % (repr(self.value), id(self))
-
-    def decode(self, data):
-        self.value = str(data).strip()
-
-    def encode(self, out):
-        out.write("<value><dateTime.iso8601>")
-        out.write(self.value)
-        out.write("</dateTime.iso8601></value>\n")
-
-def _datetime(data):
-    # decode xml element contents into a DateTime structure.
-    value = DateTime()
-    value.decode(data)
-    return value
-
-def _datetime_type(data):
-    t = time.strptime(data, "%Y%m%dT%H:%M:%S")
-    return datetime.datetime(*tuple(t)[:6])
-
-##
-# Wrapper for binary data.  This can be used to transport any kind
-# of binary data over XML-RPC, using BASE64 encoding.
-#
-# @param data An 8-bit string containing arbitrary data.
-
-import base64
-import io
-
-class Binary:
-    """Wrapper for binary data."""
-
-    def __init__(self, data=None):
-        if data is None:
-            data = b""
-        else:
-            if not isinstance(data, bytes):
-                raise TypeError("expected bytes, not %s" %
-                                data.__class__.__name__)
-            data = bytes(data)  # Make a copy of the bytes!
-        self.data = data
-
-    ##
-    # Get buffer contents.
-    #
-    # @return Buffer contents, as an 8-bit string.
-
-    def __str__(self):
-        return str(self.data, "latin-1")  # XXX encoding?!
-
-    def __eq__(self, other):
-        if isinstance(other, Binary):
-            other = other.data
-        return self.data == other
-
-    def __ne__(self, other):
-        if isinstance(other, Binary):
-            other = other.data
-        return self.data != other
-
-    def decode(self, data):
-        self.data = base64.decodestring(data)
-
-    def encode(self, out):
-        out.write("<value><base64>\n")
-        encoded = base64.encodestring(self.data)
-        out.write(encoded.decode('ascii'))
-        out.write('\n')
-        out.write("</base64></value>\n")
-
-def _binary(data):
-    # decode xml element contents into a Binary structure
-    value = Binary()
-    value.decode(data)
-    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:
-#
-#     http://www.pythonware.com/products/xml/sgmlop.htm
-#
-
-try:
-    import sgmlop
-    if not hasattr(sgmlop, "XMLParser"):
-        raise ImportError
-except ImportError:
-    SgmlopParser = None # sgmlop accelerator not available
-else:
-    class SgmlopParser:
-        def __init__(self, target):
-
-            # setup callbacks
-            self.finish_starttag = target.start
-            self.finish_endtag = target.end
-            self.handle_data = target.data
-            self.handle_xml = target.xml
-
-            # activate parser
-            self.parser = sgmlop.XMLParser()
-            self.parser.register(self)
-            self.feed = self.parser.feed
-            self.entity = {
-                "amp": "&", "gt": ">", "lt": "<",
-                "apos": "'", "quot": '"'
-                }
-
-        def close(self):
-            try:
-                self.parser.close()
-            finally:
-                self.parser = self.feed = None # nuke circular reference
-
-        def handle_proc(self, tag, attr):
-            m = re.search("encoding\s*=\s*['\"]([^\"']+)[\"']", attr)
-            if m:
-                self.handle_xml(m.group(1), 1)
-
-        def handle_entityref(self, entity):
-            # <string> entity
-            try:
-                self.handle_data(self.entity[entity])
-            except KeyError:
-                self.handle_data("&%s;" % entity)
-
-try:
-    from xml.parsers import expat
-    if not hasattr(expat, "ParserCreate"):
-        raise ImportError
-except ImportError:
-    ExpatParser = None # expat not available
-else:
-    class ExpatParser:
-        # fast expat parser for Python 2.0 and later.  this is about
-        # 50% slower than sgmlop, on roundtrip testing
-        def __init__(self, target):
-            self._parser = parser = expat.ParserCreate(None, None)
-            self._target = target
-            parser.StartElementHandler = target.start
-            parser.EndElementHandler = target.end
-            parser.CharacterDataHandler = target.data
-            encoding = None
-            target.xml(encoding, None)
-
-        def feed(self, data):
-            self._parser.Parse(data, 0)
-
-        def close(self):
-            self._parser.Parse("", 1) # end of data
-            del self._target, self._parser # get rid of circular references
-
-# --------------------------------------------------------------------
-# XML-RPC marshalling and unmarshalling code
-
-##
-# XML-RPC marshaller.
-#
-# @param encoding Default encoding for 8-bit strings.  The default
-#     value is None (interpreted as UTF-8).
-# @see dumps
-
-class Marshaller:
-    """Generate an XML-RPC params chunk from a Python data structure.
-
-    Create a Marshaller instance for each set of parameters, and use
-    the "dumps" method to convert your data (represented as a tuple)
-    to an XML-RPC params chunk.  To write a fault response, pass a
-    Fault instance instead.  You may prefer to use the "dumps" module
-    function for this purpose.
-    """
-
-    # by the way, if you don't understand what's going on in here,
-    # that's perfectly ok.
-
-    def __init__(self, encoding=None, allow_none=0):
-        self.memo = {}
-        self.data = None
-        self.encoding = encoding
-        self.allow_none = allow_none
-
-    dispatch = {}
-
-    def dumps(self, values):
-        out = []
-        write = out.append
-        dump = self.__dump
-        if isinstance(values, Fault):
-            # fault instance
-            write("<fault>\n")
-            dump({'faultCode': values.faultCode,
-                  'faultString': values.faultString},
-                 write)
-            write("</fault>\n")
-        else:
-            # parameter block
-            # FIXME: the xml-rpc specification allows us to leave out
-            # the entire <params> block if there are no parameters.
-            # however, changing this may break older code (including
-            # old versions of xmlrpclib.py), so this is better left as
-            # is for now.  See @XMLRPC3 for more information. /F
-            write("<params>\n")
-            for v in values:
-                write("<param>\n")
-                dump(v, write)
-                write("</param>\n")
-            write("</params>\n")
-        result = "".join(out)
-        return result
-
-    def __dump(self, value, write):
-        try:
-            f = self.dispatch[type(value)]
-        except KeyError:
-            # check if this object can be marshalled as a structure
-            try:
-                value.__dict__
-            except:
-                raise TypeError("cannot marshal %s objects" % type(value))
-            # check if this class is a sub-class of a basic type,
-            # because we don't know how to marshal these types
-            # (e.g. a string sub-class)
-            for type_ in type(value).__mro__:
-                if type_ in self.dispatch.keys():
-                    raise TypeError("cannot marshal %s objects" % type(value))
-            # XXX(twouters): using "_arbitrary_instance" as key as a quick-fix
-            # for the p3yk merge, this should probably be fixed more neatly.
-            f = self.dispatch["_arbitrary_instance"]
-        f(self, value, write)
-
-    def dump_nil (self, value, write):
-        if not self.allow_none:
-            raise TypeError("cannot marshal None unless allow_none is enabled")
-        write("<value><nil/></value>")
-    dispatch[type(None)] = dump_nil
-
-    def dump_int(self, value, write):
-        # in case ints are > 32 bits
-        if value > MAXINT or value < MININT:
-            raise OverflowError("int exceeds XML-RPC limits")
-        write("<value><int>")
-        write(str(value))
-        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_long(self, value, write):
-        if value > MAXINT or value < MININT:
-            raise OverflowError("long int exceeds XML-RPC limits")
-        write("<value><int>")
-        write(str(int(value)))
-        write("</int></value>\n")
-    dispatch[int] = dump_long
-
-    def dump_double(self, value, write):
-        write("<value><double>")
-        write(repr(value))
-        write("</double></value>\n")
-    dispatch[float] = dump_double
-
-    def dump_string(self, value, write, escape=escape):
-        write("<value><string>")
-        write(escape(value))
-        write("</string></value>\n")
-    dispatch[bytes] = dump_string
-
-    def dump_unicode(self, value, write, escape=escape):
-        write("<value><string>")
-        write(escape(value))
-        write("</string></value>\n")
-    dispatch[str] = dump_unicode
-
-    def dump_array(self, value, write):
-        i = id(value)
-        if i in self.memo:
-            raise TypeError("cannot marshal recursive sequences")
-        self.memo[i] = None
-        dump = self.__dump
-        write("<value><array><data>\n")
-        for v in value:
-            dump(v, write)
-        write("</data></array></value>\n")
-        del self.memo[i]
-    dispatch[tuple] = dump_array
-    dispatch[list] = dump_array
-
-    def dump_struct(self, value, write, escape=escape):
-        i = id(value)
-        if i in self.memo:
-            raise TypeError("cannot marshal recursive dictionaries")
-        self.memo[i] = None
-        dump = self.__dump
-        write("<value><struct>\n")
-        for k, v in value.items():
-            write("<member>\n")
-            if not isinstance(k, str):
-                raise TypeError("dictionary key must be string")
-            write("<name>%s</name>\n" % escape(k))
-            dump(v, write)
-            write("</member>\n")
-        write("</struct></value>\n")
-        del self.memo[i]
-    dispatch[dict] = dump_struct
-
-    if datetime:
-        def dump_datetime(self, value, write):
-            write("<value><dateTime.iso8601>")
-            write(_strftime(value))
-            write("</dateTime.iso8601></value>\n")
-        dispatch[datetime.datetime] = dump_datetime
-
-    def dump_instance(self, value, write):
-        # check for special wrappers
-        if value.__class__ in WRAPPERS:
-            self.write = write
-            value.encode(self)
-            del self.write
-        else:
-            # store instance attributes as a struct (really?)
-            self.dump_struct(value.__dict__, write)
-    dispatch[DateTime] = dump_instance
-    dispatch[Binary] = dump_instance
-    # XXX(twouters): using "_arbitrary_instance" as key as a quick-fix
-    # for the p3yk merge, this should probably be fixed more neatly.
-    dispatch["_arbitrary_instance"] = dump_instance
-
-##
-# XML-RPC unmarshaller.
-#
-# @see loads
-
-class Unmarshaller:
-    """Unmarshal an XML-RPC response, based on incoming XML event
-    messages (start, data, end).  Call close() to get the resulting
-    data structure.
-
-    Note that this reader is fairly tolerant, and gladly accepts bogus
-    XML-RPC data without complaining (but not bogus XML).
-    """
-
-    # and again, if you don't understand what's going on in here,
-    # that's perfectly ok.
-
-    def __init__(self, use_datetime=0):
-        self._type = None
-        self._stack = []
-        self._marks = []
-        self._data = []
-        self._methodname = None
-        self._encoding = "utf-8"
-        self.append = self._stack.append
-        self._use_datetime = use_datetime
-        if use_datetime and not datetime:
-            raise ValueError("the datetime module is not available")
-
-    def close(self):
-        # return response tuple and target method
-        if self._type is None or self._marks:
-            raise ResponseError()
-        if self._type == "fault":
-            raise Fault(**self._stack[0])
-        return tuple(self._stack)
-
-    def getmethodname(self):
-        return self._methodname
-
-    #
-    # event handlers
-
-    def xml(self, encoding, standalone):
-        self._encoding = encoding
-        # FIXME: assert standalone == 1 ???
-
-    def start(self, tag, attrs):
-        # prepare to handle this element
-        if tag == "array" or tag == "struct":
-            self._marks.append(len(self._stack))
-        self._data = []
-        self._value = (tag == "value")
-
-    def data(self, text):
-        self._data.append(text)
-
-    def end(self, tag):
-        # call the appropriate end tag handler
-        try:
-            f = self.dispatch[tag]
-        except KeyError:
-            pass # unknown tag ?
-        else:
-            return f(self, "".join(self._data))
-
-    #
-    # accelerator support
-
-    def end_dispatch(self, tag, data):
-        # dispatch data
-        try:
-            f = self.dispatch[tag]
-        except KeyError:
-            pass # unknown tag ?
-        else:
-            return f(self, data)
-
-    #
-    # element decoders
-
-    dispatch = {}
-
-    def end_nil (self, data):
-        self.append(None)
-        self._value = 0
-    dispatch["nil"] = end_nil
-
-    def end_boolean(self, data):
-        if data == "0":
-            self.append(False)
-        elif data == "1":
-            self.append(True)
-        else:
-            raise TypeError("bad boolean value")
-        self._value = 0
-    dispatch["boolean"] = end_boolean
-
-    def end_int(self, data):
-        self.append(int(data))
-        self._value = 0
-    dispatch["i4"] = end_int
-    dispatch["int"] = end_int
-
-    def end_double(self, data):
-        self.append(float(data))
-        self._value = 0
-    dispatch["double"] = end_double
-
-    def end_string(self, data):
-        if self._encoding:
-            data = _decode(data, self._encoding)
-        self.append(_stringify(data))
-        self._value = 0
-    dispatch["string"] = end_string
-    dispatch["name"] = end_string # struct keys are always strings
-
-    def end_array(self, data):
-        mark = self._marks.pop()
-        # map arrays to Python lists
-        self._stack[mark:] = [self._stack[mark:]]
-        self._value = 0
-    dispatch["array"] = end_array
-
-    def end_struct(self, data):
-        mark = self._marks.pop()
-        # map structs to Python dictionaries
-        dict = {}
-        items = self._stack[mark:]
-        for i in range(0, len(items), 2):
-            dict[_stringify(items[i])] = items[i+1]
-        self._stack[mark:] = [dict]
-        self._value = 0
-    dispatch["struct"] = end_struct
-
-    def end_base64(self, data):
-        value = Binary()
-        value.decode(data.encode("ascii"))
-        self.append(value)
-        self._value = 0
-    dispatch["base64"] = end_base64
-
-    def end_dateTime(self, data):
-        value = DateTime()
-        value.decode(data)
-        if self._use_datetime:
-            value = _datetime_type(data)
-        self.append(value)
-    dispatch["dateTime.iso8601"] = end_dateTime
-
-    def end_value(self, data):
-        # if we stumble upon a value element with no internal
-        # elements, treat it as a string element
-        if self._value:
-            self.end_string(data)
-    dispatch["value"] = end_value
-
-    def end_params(self, data):
-        self._type = "params"
-    dispatch["params"] = end_params
-
-    def end_fault(self, data):
-        self._type = "fault"
-    dispatch["fault"] = end_fault
-
-    def end_methodName(self, data):
-        if self._encoding:
-            data = _decode(data, self._encoding)
-        self._methodname = data
-        self._type = "methodName" # no params
-    dispatch["methodName"] = end_methodName
-
-## Multicall support
-#
-
-class _MultiCallMethod:
-    # some lesser magic to store calls made to a MultiCall object
-    # for batch execution
-    def __init__(self, call_list, name):
-        self.__call_list = call_list
-        self.__name = name
-    def __getattr__(self, name):
-        return _MultiCallMethod(self.__call_list, "%s.%s" % (self.__name, name))
-    def __call__(self, *args):
-        self.__call_list.append((self.__name, args))
-
-class MultiCallIterator:
-    """Iterates over the results of a multicall. Exceptions are
-    thrown in response to xmlrpc faults."""
-
-    def __init__(self, results):
-        self.results = results
-
-    def __getitem__(self, i):
-        item = self.results[i]
-        if type(item) == type({}):
-            raise Fault(item['faultCode'], item['faultString'])
-        elif type(item) == type([]):
-            return item[0]
-        else:
-            raise ValueError("unexpected type in multicall result")
-
-class MultiCall:
-    """server -> a object used to boxcar method calls
-
-    server should be a ServerProxy object.
-
-    Methods can be added to the MultiCall using normal
-    method call syntax e.g.:
-
-    multicall = MultiCall(server_proxy)
-    multicall.add(2,3)
-    multicall.get_address("Guido")
-
-    To execute the multicall, call the MultiCall object e.g.:
-
-    add_result, address = multicall()
-    """
-
-    def __init__(self, server):
-        self.__server = server
-        self.__call_list = []
-
-    def __repr__(self):
-        return "<MultiCall at %x>" % id(self)
-
-    __str__ = __repr__
-
-    def __getattr__(self, name):
-        return _MultiCallMethod(self.__call_list, name)
-
-    def __call__(self):
-        marshalled_list = []
-        for name, args in self.__call_list:
-            marshalled_list.append({'methodName' : name, 'params' : args})
-
-        return MultiCallIterator(self.__server.system.multicall(marshalled_list))
-
-# --------------------------------------------------------------------
-# convenience functions
-
-##
-# Create a parser object, and connect it to an unmarshalling instance.
-# This function picks the fastest available XML parser.
-#
-# return A (parser, unmarshaller) tuple.
-
-def getparser(use_datetime=0):
-    """getparser() -> parser, unmarshaller
-
-    Create an instance of the fastest available parser, and attach it
-    to an unmarshalling object.  Return both objects.
-    """
-    if use_datetime and not datetime:
-        raise ValueError("the datetime module is not available")
-    if FastParser and FastUnmarshaller:
-        if use_datetime:
-            mkdatetime = _datetime_type
-        else:
-            mkdatetime = _datetime
-        target = FastUnmarshaller(True, False, _binary, mkdatetime, Fault)
-        parser = FastParser(target)
-    else:
-        target = Unmarshaller(use_datetime=use_datetime)
-        if FastParser:
-            parser = FastParser(target)
-        elif SgmlopParser:
-            parser = SgmlopParser(target)
-        elif ExpatParser:
-            parser = ExpatParser(target)
-        else:
-            parser = SlowParser(target)
-    return parser, target
-
-##
-# Convert a Python tuple or a Fault instance to an XML-RPC packet.
-#
-# @def dumps(params, **options)
-# @param params A tuple or Fault instance.
-# @keyparam methodname If given, create a methodCall request for
-#     this method name.
-# @keyparam methodresponse If given, create a methodResponse packet.
-#     If used with a tuple, the tuple must be a singleton (that is,
-#     it must contain exactly one element).
-# @keyparam encoding The packet encoding.
-# @return A string containing marshalled data.
-
-def dumps(params, methodname=None, methodresponse=None, encoding=None,
-          allow_none=0):
-    """data [,options] -> marshalled data
-
-    Convert an argument tuple or a Fault instance to an XML-RPC
-    request (or response, if the methodresponse option is used).
-
-    In addition to the data object, the following options can be given
-    as keyword arguments:
-
-        methodname: the method name for a methodCall packet
-
-        methodresponse: true to create a methodResponse packet.
-        If this option is used with a tuple, the tuple must be
-        a singleton (i.e. it can contain only one element).
-
-        encoding: the packet encoding (default is UTF-8)
-
-    All 8-bit strings in the data structure are assumed to use the
-    packet encoding.  Unicode strings are automatically converted,
-    where necessary.
-    """
-
-    assert isinstance(params, (tuple, Fault)), "argument must be tuple or Fault instance"
-    if isinstance(params, Fault):
-        methodresponse = 1
-    elif methodresponse and isinstance(params, tuple):
-        assert len(params) == 1, "response tuple must be a singleton"
-
-    if not encoding:
-        encoding = "utf-8"
-
-    if FastMarshaller:
-        m = FastMarshaller(encoding)
-    else:
-        m = Marshaller(encoding, allow_none)
-
-    data = m.dumps(params)
-
-    if encoding != "utf-8":
-        xmlheader = "<?xml version='1.0' encoding='%s'?>\n" % str(encoding)
-    else:
-        xmlheader = "<?xml version='1.0'?>\n" # utf-8 is default
-
-    # standard XML-RPC wrappings
-    if methodname:
-        # a method call
-        if not isinstance(methodname, str):
-            methodname = methodname.encode(encoding)
-        data = (
-            xmlheader,
-            "<methodCall>\n"
-            "<methodName>", methodname, "</methodName>\n",
-            data,
-            "</methodCall>\n"
-            )
-    elif methodresponse:
-        # a method response, or a fault structure
-        data = (
-            xmlheader,
-            "<methodResponse>\n",
-            data,
-            "</methodResponse>\n"
-            )
-    else:
-        return data # return as is
-    return "".join(data)
-
-##
-# Convert an XML-RPC packet to a Python object.  If the XML-RPC packet
-# represents a fault condition, this function raises a Fault exception.
-#
-# @param data An XML-RPC packet, given as an 8-bit string.
-# @return A tuple containing the unpacked data, and the method name
-#     (None if not present).
-# @see Fault
-
-def loads(data, use_datetime=0):
-    """data -> unmarshalled data, method name
-
-    Convert an XML-RPC packet to unmarshalled data plus a method
-    name (None if not present).
-
-    If the XML-RPC packet represents a fault condition, this function
-    raises a Fault exception.
-    """
-    p, u = getparser(use_datetime=use_datetime)
-    p.feed(data)
-    p.close()
-    return u.close(), u.getmethodname()
-
-
-# --------------------------------------------------------------------
-# request dispatcher
-
-class _Method:
-    # some magic to bind an XML-RPC method to an RPC server.
-    # supports "nested" methods (e.g. examples.getStateName)
-    def __init__(self, send, name):
-        self.__send = send
-        self.__name = name
-    def __getattr__(self, name):
-        return _Method(self.__send, "%s.%s" % (self.__name, name))
-    def __call__(self, *args):
-        return self.__send(self.__name, args)
-
-##
-# Standard transport class for XML-RPC over HTTP.
-# <p>
-# You can create custom transports by subclassing this method, and
-# overriding selected methods.
-
-class Transport:
-    """Handles an HTTP transaction to an XML-RPC server."""
-
-    # client identifier (may be overridden)
-    user_agent = "xmlrpclib.py/%s (by www.pythonware.com)" % __version__
-
-    def __init__(self, use_datetime=0):
-        self._use_datetime = use_datetime
-
-    ##
-    # Send a complete request, and parse the response.
-    #
-    # @param host Target host.
-    # @param handler Target PRC handler.
-    # @param request_body XML-RPC request body.
-    # @param verbose Debugging flag.
-    # @return Parsed response.
-
-    def request(self, host, handler, request_body, verbose=0):
-        # issue XML-RPC request
-
-        http_conn = self.send_request(host, handler, request_body, verbose)
-        resp = http_conn.getresponse()
-
-        if resp.status != 200:
-            raise ProtocolError(
-                host + handler,
-                resp.status, resp.reason,
-                dict(resp.getheaders())
-                )
-
-        self.verbose = verbose
-
-        return self._parse_response(resp, None)
-
-    ##
-    # Create parser.
-    #
-    # @return A 2-tuple containing a parser and a unmarshaller.
-
-    def getparser(self):
-        # get parser and unmarshaller
-        return getparser(use_datetime=self._use_datetime)
-
-    ##
-    # Get authorization info from host parameter
-    # Host may be a string, or a (host, x509-dict) tuple; if a string,
-    # it is checked for a "user:pw@host" format, and a "Basic
-    # Authentication" header is added if appropriate.
-    #
-    # @param host Host descriptor (URL or (URL, x509 info) tuple).
-    # @return A 3-tuple containing (actual host, extra headers,
-    #     x509 info).  The header and x509 fields may be None.
-
-    def get_host_info(self, host):
-
-        x509 = {}
-        if isinstance(host, tuple):
-            host, x509 = host
-
-        import urllib
-        auth, host = urllib.splituser(host)
-
-        if auth:
-            import base64
-            auth = base64.encodestring(urllib.unquote(auth))
-            auth = "".join(auth.split()) # get rid of whitespace
-            extra_headers = [
-                ("Authorization", "Basic " + auth)
-                ]
-        else:
-            extra_headers = None
-
-        return host, extra_headers, x509
-
-    ##
-    # Connect to server.
-    #
-    # @param host Target host.
-    # @return An HTTPConnection object
-
-    def make_connection(self, host):
-        # create a HTTP connection object from a host descriptor
-        host, extra_headers, x509 = self.get_host_info(host)
-
-
-    ##
-    # Send HTTP request.
-    #
-    # @param host Host descriptor (URL or (URL, x509 info) tuple).
-    # @param handler Targer RPC handler (a path relative to host)
-    # @param request_body The XML-RPC request body
-    # @param debug Enable debugging if debug is true.
-    # @return An HTTPConnection.
-
-    def send_request(self, host, handler, request_body, debug):
-        host, extra_headers, x509 = self.get_host_info(host)
-        connection = httplib.HTTPConnection(host)
-        if debug:
-            connection.set_debuglevel(1)
-        headers = {}
-        if extra_headers:
-            for key, val in extra_headers:
-                header[key] = val
-        headers["Content-Type"] = "text/xml"
-        headers["User-Agent"] = self.user_agent
-        connection.request("POST", handler, request_body, headers)
-        return connection
-
-    ##
-    # Parse response.
-    #
-    # @param file Stream.
-    # @return Response tuple and target method.
-
-    def parse_response(self, file):
-        # compatibility interface
-        return self._parse_response(file, None)
-
-    ##
-    # Parse response (alternate interface).  This is similar to the
-    # parse_response method, but also provides direct access to the
-    # underlying socket object (where available).
-    #
-    # @param file Stream.
-    # @param sock Socket handle (or None, if the socket object
-    #    could not be accessed).
-    # @return Response tuple and target method.
-
-    def _parse_response(self, file, sock):
-        # read response from input file/socket, and parse it
-
-        p, u = self.getparser()
-
-        while 1:
-            if sock:
-                response = sock.recv(1024)
-            else:
-                response = file.read(1024)
-            if not response:
-                break
-            if self.verbose:
-                print("body:", repr(response))
-            p.feed(response)
-
-        file.close()
-        p.close()
-
-        return u.close()
-
-##
-# Standard transport class for XML-RPC over HTTPS.
-
-class SafeTransport(Transport):
-    """Handles an HTTPS transaction to an XML-RPC server."""
-
-    # FIXME: mostly untested
-
-    def send_request(self, host, handler, request_body, debug):
-        import socket
-        if not hasattr(socket, "ssl"):
-            raise NotImplementedError(
-                "your version of httplib doesn't support HTTPS")
-
-        host, extra_headers, x509 = self.get_host_info(host)
-        connection = httplib.HTTPSConnection(host, None, **(x509 or {}))
-        if debug:
-            connection.set_debuglevel(1)
-        headers = {}
-        if extra_headers:
-            for key, val in extra_headers:
-                header[key] = val
-        headers["Content-Type"] = "text/xml"
-        headers["User-Agent"] = self.user_agent
-        connection.request("POST", handler, request_body, headers)
-        return connection
-
-##
-# Standard server proxy.  This class establishes a virtual connection
-# to an XML-RPC server.
-# <p>
-# This class is available as ServerProxy and Server.  New code should
-# use ServerProxy, to avoid confusion.
-#
-# @def ServerProxy(uri, **options)
-# @param uri The connection point on the server.
-# @keyparam transport A transport factory, compatible with the
-#    standard transport class.
-# @keyparam encoding The default encoding used for 8-bit strings
-#    (default is UTF-8).
-# @keyparam verbose Use a true value to enable debugging output.
-#    (printed to standard output).
-# @see Transport
-
-class ServerProxy:
-    """uri [,options] -> a logical connection to an XML-RPC server
-
-    uri is the connection point on the server, given as
-    scheme://host/target.
-
-    The standard implementation always supports the "http" scheme.  If
-    SSL socket support is available (Python 2.0), it also supports
-    "https".
-
-    If the target part and the slash preceding it are both omitted,
-    "/RPC2" is assumed.
-
-    The following options can be given as keyword arguments:
-
-        transport: a transport factory
-        encoding: the request encoding (default is UTF-8)
-
-    All 8-bit strings passed to the server proxy are assumed to use
-    the given encoding.
-    """
-
-    def __init__(self, uri, transport=None, encoding=None, verbose=0,
-                 allow_none=0, use_datetime=0):
-        # establish a "logical" server connection
-
-        # get the url
-        import urllib
-        type, uri = urllib.splittype(uri)
-        if type not in ("http", "https"):
-            raise IOError("unsupported XML-RPC protocol")
-        self.__host, self.__handler = urllib.splithost(uri)
-        if not self.__handler:
-            self.__handler = "/RPC2"
-
-        if transport is None:
-            if type == "https":
-                transport = SafeTransport(use_datetime=use_datetime)
-            else:
-                transport = Transport(use_datetime=use_datetime)
-        self.__transport = transport
-
-        self.__encoding = encoding
-        self.__verbose = verbose
-        self.__allow_none = allow_none
-
-    def __request(self, methodname, params):
-        # call a method on the remote server
-
-        request = dumps(params, methodname, encoding=self.__encoding,
-                        allow_none=self.__allow_none)
-
-        response = self.__transport.request(
-            self.__host,
-            self.__handler,
-            request,
-            verbose=self.__verbose
-            )
-
-        if len(response) == 1:
-            response = response[0]
-
-        return response
-
-    def __repr__(self):
-        return (
-            "<ServerProxy for %s%s>" %
-            (self.__host, self.__handler)
-            )
-
-    __str__ = __repr__
-
-    def __getattr__(self, name):
-        # magic method dispatcher
-        return _Method(self.__request, name)
-
-    # note: to call a remote object with an non-standard name, use
-    # result getattr(server, "strange-python-name")(args)
-
-# compatibility
-
-Server = ServerProxy
-
-# --------------------------------------------------------------------
-# test code
-
-if __name__ == "__main__":
-
-    # simple test program (from the XML-RPC specification)
-
-    # server = ServerProxy("http://localhost:8000") # local server
-    server = ServerProxy("http://time.xmlrpc.com/RPC2")
-
-    try:
-        print(server.currentTime.getCurrentTime())
-    except Error as v:
-        print("ERROR", v)
-
-    # The server at xmlrpc.com doesn't seem to support multicall anymore.
-    multi = MultiCall(server)
-    multi.currentTime.getCurrentTime()
-    multi.currentTime.getCurrentTime()
-    try:
-        for response in multi():
-            print(response)
-    except Error as v:
-        print("ERROR", v)