Lib/xmlrpclib.py

   1 #
   2 # XML-RPC CLIENT LIBRARY
   3 # $Id$
   4 #
   5 # an XML-RPC client interface for Python.
   6 #
   7 # the marshalling and response parser code can also be used to
   8 # implement XML-RPC servers.
   9 #
  10 # Notes:
  11 # this version is designed to work with Python 2.1 or newer.
  12 #
  13 # History:
  14 # 1999-01-14 fl  Created
  15 # 1999-01-15 fl  Changed dateTime to use localtime
  16 # 1999-01-16 fl  Added Binary/base64 element, default to RPC2 service
  17 # 1999-01-19 fl  Fixed array data element (from Skip Montanaro)
  18 # 1999-01-21 fl  Fixed dateTime constructor, etc.
  19 # 1999-02-02 fl  Added fault handling, handle empty sequences, etc.
  20 # 1999-02-10 fl  Fixed problem with empty responses (from Skip Montanaro)
  21 # 1999-06-20 fl  Speed improvements, pluggable parsers/transports (0.9.8)
  22 # 2000-11-28 fl  Changed boolean to check the truth value of its argument
  23 # 2001-02-24 fl  Added encoding/Unicode/SafeTransport patches
  24 # 2001-02-26 fl  Added compare support to wrappers (0.9.9/1.0b1)
  25 # 2001-03-28 fl  Make sure response tuple is a singleton
  26 # 2001-03-29 fl  Don't require empty params element (from Nicholas Riley)
  27 # 2001-06-10 fl  Folded in _xmlrpclib accelerator support (1.0b2)
  28 # 2001-08-20 fl  Base xmlrpclib.Error on built-in Exception (from Paul Prescod)
  29 # 2001-09-03 fl  Allow Transport subclass to override getparser
  30 # 2001-09-10 fl  Lazy import of urllib, cgi, xmllib (20x import speedup)
  31 # 2001-10-01 fl  Remove containers from memo cache when done with them
  32 # 2001-10-01 fl  Use faster escape method (80% dumps speedup)
  33 # 2001-10-02 fl  More dumps microtuning
  34 # 2001-10-04 fl  Make sure import expat gets a parser (from Guido van Rossum)
  35 # 2001-10-10 sm  Allow long ints to be passed as ints if they don't overflow
  36 # 2001-10-17 sm  Test for int and long overflow (allows use on 64-bit systems)
  37 # 2001-11-12 fl  Use repr() to marshal doubles (from Paul Felix)
  38 # 2002-03-17 fl  Avoid buffered read when possible (from James Rucker)
  39 # 2002-04-07 fl  Added pythondoc comments
  40 # 2002-04-16 fl  Added __str__ methods to datetime/binary wrappers
  41 # 2002-05-15 fl  Added error constants (from Andrew Kuchling)
  42 # 2002-06-27 fl  Merged with Python CVS version
  43 # 2002-10-22 fl  Added basic authentication (based on code from Phillip Eby)
  44 # 2003-01-22 sm  Add support for the bool type
  45 # 2003-02-27 gvr Remove apply calls
  46 # 2003-04-24 sm  Use cStringIO if available
  47 # 2003-04-25 ak  Add support for nil
  48 # 2003-06-15 gn  Add support for time.struct_time
  49 # 2003-07-12 gp  Correct marshalling of Faults
  50 # 2003-10-31 mvl Add multicall support
  51 # 2004-08-20 mvl Bump minimum supported Python version to 2.1
  52 #
  53 # Copyright (c) 1999-2002 by Secret Labs AB.
  54 # Copyright (c) 1999-2002 by Fredrik Lundh.
  55 #
  56 # info@pythonware.com
  57 # http://www.pythonware.com
  58 #
  59 # --------------------------------------------------------------------
  60 # The XML-RPC client interface is
  61 #
  62 # Copyright (c) 1999-2002 by Secret Labs AB
  63 # Copyright (c) 1999-2002 by Fredrik Lundh
  64 #
  65 # By obtaining, using, and/or copying this software and/or its
  66 # associated documentation, you agree that you have read, understood,
  67 # and will comply with the following terms and conditions:
  68 #
  69 # Permission to use, copy, modify, and distribute this software and
  70 # its associated documentation for any purpose and without fee is
  71 # hereby granted, provided that the above copyright notice appears in
  72 # all copies, and that both that copyright notice and this permission
  73 # notice appear in supporting documentation, and that the name of
  74 # Secret Labs AB or the author not be used in advertising or publicity
  75 # pertaining to distribution of the software without specific, written
  76 # prior permission.
  77 #
  78 # SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
  79 # TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
  80 # ABILITY AND FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
  81 # BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
  82 # DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  83 # WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  84 # ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  85 # OF THIS SOFTWARE.
  86 # --------------------------------------------------------------------
  87
  88 #
  89 # things to look into some day:
  90
  91 # TODO: sort out True/False/boolean issues for Python 2.3
  92
  93 """
  94 An XML-RPC client interface for Python.
  95
  96 The marshalling and response parser code can also be used to
  97 implement XML-RPC servers.
  98
  99 Exported exceptions:
 100
 101   Error          Base class for client errors
 102   ProtocolError  Indicates an HTTP protocol error
 103   ResponseError  Indicates a broken response package
 104   Fault          Indicates an XML-RPC fault package
 105
 106 Exported classes:
 107
 108   ServerProxy    Represents a logical connection to an XML-RPC server
 109
 110   MultiCall      Executor of boxcared xmlrpc requests
 111   Boolean        boolean wrapper to generate a "boolean" XML-RPC value
 112   DateTime       dateTime wrapper for an ISO 8601 string or time tuple or
 113                  localtime integer value to generate a "dateTime.iso8601"
 114                  XML-RPC value
 115   Binary         binary data wrapper
 116
 117   SlowParser     Slow but safe standard parser (based on xmllib)
 118   Marshaller     Generate an XML-RPC params chunk from a Python data structure
 119   Unmarshaller   Unmarshal an XML-RPC response from incoming XML event message
 120   Transport      Handles an HTTP transaction to an XML-RPC server
 121   SafeTransport  Handles an HTTPS transaction to an XML-RPC server
 122
 123 Exported constants:
 124
 125   True
 126   False
 127
 128 Exported functions:
 129
 130   boolean        Convert any Python value to an XML-RPC boolean
 131   getparser      Create instance of the fastest available parser & attach
 132                  to an unmarshalling object
 133   dumps          Convert an argument tuple or a Fault instance to an XML-RPC
 134                  request (or response, if the methodresponse option is used).
 135   loads          Convert an XML-RPC packet to unmarshalled data plus a method
 136                  name (None if not present).
 137 """
 138
 139 import re, string, time, operator
 140
 141 from types import *
 142
 143 # --------------------------------------------------------------------
 144 # Internal stuff
 145
 146 try:
 147     unicode
 148 except NameError:
 149     unicode = None # unicode support not available
 150
 151 try:
 152     import datetime
 153 except ImportError:
 154     datetime = None
 155
 156 try:
 157     _bool_is_builtin = False.__class__.__name__ == "bool"
 158 except NameError:
 159     _bool_is_builtin = 0
 160
 161 def _decode(data, encoding, is8bit=re.compile("[\x80-\xff]").search):
 162     # decode non-ascii string (if possible)
 163     if unicode and encoding and is8bit(data):
 164         data = unicode(data, encoding)
 165     return data
 166
 167 def escape(s, replace=string.replace):
 168     s = replace(s, "&", "&amp;")
 169     s = replace(s, "<", "&lt;")
 170     return replace(s, ">", "&gt;",)
 171
 172 if unicode:
 173     def _stringify(string):
 174         # convert to 7-bit ascii if possible
 175         try:
 176             return string.encode("ascii")
 177         except UnicodeError:
 178             return string
 179 else:
 180     def _stringify(string):
 181         return string
 182
 183 __version__ = "1.0.1"
 184
 185 # xmlrpc integer limits
 186 MAXINT =  2L**31-1
 187 MININT = -2L**31
 188
 189 # --------------------------------------------------------------------
 190 # Error constants (from Dan Libby's specification at
 191 # http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php)
 192
 193 # Ranges of errors
 194 PARSE_ERROR       = -32700
 195 SERVER_ERROR      = -32600
 196 APPLICATION_ERROR = -32500
 197 SYSTEM_ERROR      = -32400
 198 TRANSPORT_ERROR   = -32300
 199
 200 # Specific errors
 201 NOT_WELLFORMED_ERROR  = -32700
 202 UNSUPPORTED_ENCODING  = -32701
 203 INVALID_ENCODING_CHAR = -32702
 204 INVALID_XMLRPC        = -32600
 205 METHOD_NOT_FOUND      = -32601
 206 INVALID_METHOD_PARAMS = -32602
 207 INTERNAL_ERROR        = -32603
 208
 209 # --------------------------------------------------------------------
 210 # Exceptions
 211
 212 ##
 213 # Base class for all kinds of client-side errors.
 214
 215 class Error(Exception):
 216     """Base class for client errors."""
 217     def __str__(self):
 218         return repr(self)
 219
 220 ##
 221 # Indicates an HTTP-level protocol error.  This is raised by the HTTP
 222 # transport layer, if the server returns an error code other than 200
 223 # (OK).
 224 #
 225 # @param url The target URL.
 226 # @param errcode The HTTP error code.
 227 # @param errmsg The HTTP error message.
 228 # @param headers The HTTP header dictionary.
 229
 230 class ProtocolError(Error):
 231     """Indicates an HTTP protocol error."""
 232     def __init__(self, url, errcode, errmsg, headers):
 233         Error.__init__(self)
 234         self.url = url
 235         self.errcode = errcode
 236         self.errmsg = errmsg
 237         self.headers = headers
 238     def __repr__(self):
 239         return (
 240             "<ProtocolError for %s: %s %s>" %
 241             (self.url, self.errcode, self.errmsg)
 242             )
 243
 244 ##
 245 # Indicates a broken XML-RPC response package.  This exception is
 246 # raised by the unmarshalling layer, if the XML-RPC response is
 247 # malformed.
 248
 249 class ResponseError(Error):
 250     """Indicates a broken response package."""
 251     pass
 252
 253 ##
 254 # Indicates an XML-RPC fault response package.  This exception is
 255 # raised by the unmarshalling layer, if the XML-RPC response contains
 256 # a fault string.  This exception can also used as a class, to
 257 # generate a fault XML-RPC message.
 258 #
 259 # @param faultCode The XML-RPC fault code.
 260 # @param faultString The XML-RPC fault string.
 261
 262 class Fault(Error):
 263     """Indicates an XML-RPC fault package."""
 264     def __init__(self, faultCode, faultString, **extra):
 265         Error.__init__(self)
 266         self.faultCode = faultCode
 267         self.faultString = faultString
 268     def __repr__(self):
 269         return (
 270             "<Fault %s: %s>" %
 271             (self.faultCode, repr(self.faultString))
 272             )
 273
 274 # --------------------------------------------------------------------
 275 # Special values
 276
 277 ##
 278 # Wrapper for XML-RPC boolean values.  Use the xmlrpclib.True and
 279 # xmlrpclib.False constants, or the xmlrpclib.boolean() function, to
 280 # generate boolean XML-RPC values.
 281 #
 282 # @param value A boolean value.  Any true value is interpreted as True,
 283 #              all other values are interpreted as False.
 284
 285 if _bool_is_builtin:
 286     boolean = Boolean = bool
 287     # to avoid breaking code which references xmlrpclib.{True,False}
 288     True, False = True, False
 289 else:
 290     class Boolean:
 291         """Boolean-value wrapper.
 292
 293         Use True or False to generate a "boolean" XML-RPC value.
 294         """
 295
 296         def __init__(self, value = 0):
 297             self.value = operator.truth(value)
 298
 299         def encode(self, out):
 300             out.write("<value><boolean>%d</boolean></value>\n" % self.value)
 301
 302         def __cmp__(self, other):
 303             if isinstance(other, Boolean):
 304                 other = other.value
 305             return cmp(self.value, other)
 306
 307         def __repr__(self):
 308             if self.value:
 309                 return "<Boolean True at %x>" % id(self)
 310             else:
 311                 return "<Boolean False at %x>" % id(self)
 312
 313         def __int__(self):
 314             return self.value
 315
 316         def __nonzero__(self):
 317             return self.value
 318
 319     True, False = Boolean(1), Boolean(0)
 320
 321     ##
 322     # Map true or false value to XML-RPC boolean values.
 323     #
 324     # @def boolean(value)
 325     # @param value A boolean value.  Any true value is mapped to True,
 326     #              all other values are mapped to False.
 327     # @return xmlrpclib.True or xmlrpclib.False.
 328     # @see Boolean
 329     # @see True
 330     # @see False
 331
 332     def boolean(value, _truefalse=(False, True)):
 333         """Convert any Python value to XML-RPC 'boolean'."""
 334         return _truefalse[operator.truth(value)]
 335
 336 ##
 337 # Wrapper for XML-RPC DateTime values.  This converts a time value to
 338 # the format used by XML-RPC.
 339 # <p>
 340 # The value can be given as a string in the format
 341 # "yyyymmddThh:mm:ss", as a 9-item time tuple (as returned by
 342 # time.localtime()), or an integer value (as returned by time.time()).
 343 # The wrapper uses time.localtime() to convert an integer to a time
 344 # tuple.
 345 #
 346 # @param value The time, given as an ISO 8601 string, a time
 347 #              tuple, or a integer time value.
 348
 349 class DateTime:
 350     """DateTime wrapper for an ISO 8601 string or time tuple or
 351     localtime integer value to generate 'dateTime.iso8601' XML-RPC
 352     value.
 353     """
 354
 355     def __init__(self, value=0):
 356         if not isinstance(value, StringType):
 357             if datetime and isinstance(value, datetime.datetime):
 358                 self.value = value.strftime("%Y%m%dT%H:%M:%S")
 359                 return
 360             if datetime and isinstance(value, datetime.date):
 361                 self.value = value.strftime("%Y%m%dT%H:%M:%S")
 362                 return
 363             if datetime and isinstance(value, datetime.time):
 364                 today = datetime.datetime.now().strftime("%Y%m%d")
 365                 self.value = value.strftime(today+"T%H:%M:%S")
 366                 return
 367             if not isinstance(value, (TupleType, time.struct_time)):
 368                 if value == 0:
 369                     value = time.time()
 370                 value = time.localtime(value)
 371             value = time.strftime("%Y%m%dT%H:%M:%S", value)
 372         self.value = value
 373
 374     def __cmp__(self, other):
 375         if isinstance(other, DateTime):
 376             other = other.value
 377         return cmp(self.value, other)
 378
 379     ##
 380     # Get date/time value.
 381     #
 382     # @return Date/time value, as an ISO 8601 string.
 383
 384     def __str__(self):
 385         return self.value
 386
 387     def __repr__(self):
 388         return "<DateTime %s at %x>" % (repr(self.value), id(self))
 389
 390     def decode(self, data):
 391         data = str(data)
 392         self.value = string.strip(data)
 393
 394     def encode(self, out):
 395         out.write("<value><dateTime.iso8601>")
 396         out.write(self.value)
 397         out.write("</dateTime.iso8601></value>\n")
 398
 399 def _datetime(data):
 400     # decode xml element contents into a DateTime structure.
 401     value = DateTime()
 402     value.decode(data)
 403     return value
 404
 405 def _datetime_type(data):
 406     t = time.strptime(data, "%Y%m%dT%H:%M:%S")
 407     return datetime.datetime(*tuple(t)[:6])
 408
 409 ##
 410 # Wrapper for binary data.  This can be used to transport any kind
 411 # of binary data over XML-RPC, using BASE64 encoding.
 412 #
 413 # @param data An 8-bit string containing arbitrary data.
 414
 415 import base64
 416 try:
 417     import cStringIO as StringIO
 418 except ImportError:
 419     import StringIO
 420
 421 class Binary:
 422     """Wrapper for binary data."""
 423
 424     def __init__(self, data=None):
 425         self.data = data
 426
 427     ##
 428     # Get buffer contents.
 429     #
 430     # @return Buffer contents, as an 8-bit string.
 431
 432     def __str__(self):
 433         return self.data or ""
 434
 435     def __cmp__(self, other):
 436         if isinstance(other, Binary):
 437             other = other.data
 438         return cmp(self.data, other)
 439
 440     def decode(self, data):
 441         self.data = base64.decodestring(data)
 442
 443     def encode(self, out):
 444         out.write("<value><base64>\n")
 445         base64.encode(StringIO.StringIO(self.data), out)
 446         out.write("</base64></value>\n")
 447
 448 def _binary(data):
 449     # decode xml element contents into a Binary structure
 450     value = Binary()
 451     value.decode(data)
 452     return value
 453
 454 WRAPPERS = (DateTime, Binary)
 455 if not _bool_is_builtin:
 456     WRAPPERS = WRAPPERS + (Boolean,)
 457
 458 # --------------------------------------------------------------------
 459 # XML parsers
 460
 461 try:
 462     # optional xmlrpclib accelerator
 463     import _xmlrpclib
 464     FastParser = _xmlrpclib.Parser
 465     FastUnmarshaller = _xmlrpclib.Unmarshaller
 466 except (AttributeError, ImportError):
 467     FastParser = FastUnmarshaller = None
 468
 469 try:
 470     import _xmlrpclib
 471     FastMarshaller = _xmlrpclib.Marshaller
 472 except (AttributeError, ImportError):
 473     FastMarshaller = None
 474
 475 #
 476 # the SGMLOP parser is about 15x faster than Python's builtin
 477 # XML parser.  SGMLOP sources can be downloaded from:
 478 #
 479 #     http://www.pythonware.com/products/xml/sgmlop.htm
 480 #
 481
 482 try:
 483     import sgmlop
 484     if not hasattr(sgmlop, "XMLParser"):
 485         raise ImportError
 486 except ImportError:
 487     SgmlopParser = None # sgmlop accelerator not available
 488 else:
 489     class SgmlopParser:
 490         def __init__(self, target):
 491
 492             # setup callbacks
 493             self.finish_starttag = target.start
 494             self.finish_endtag = target.end
 495             self.handle_data = target.data
 496             self.handle_xml = target.xml
 497
 498             # activate parser
 499             self.parser = sgmlop.XMLParser()
 500             self.parser.register(self)
 501             self.feed = self.parser.feed
 502             self.entity = {
 503                 "amp": "&", "gt": ">", "lt": "<",
 504                 "apos": "'", "quot": '"'
 505                 }
 506
 507         def close(self):
 508             try:
 509                 self.parser.close()
 510             finally:
 511                 self.parser = self.feed = None # nuke circular reference
 512
 513         def handle_proc(self, tag, attr):
 514             m = re.search("encoding\s*=\s*['\"]([^\"']+)[\"']", attr)
 515             if m:
 516                 self.handle_xml(m.group(1), 1)
 517
 518         def handle_entityref(self, entity):
 519             # <string> entity
 520             try:
 521                 self.handle_data(self.entity[entity])
 522             except KeyError:
 523                 self.handle_data("&%s;" % entity)
 524
 525 try:
 526     from xml.parsers import expat
 527     if not hasattr(expat, "ParserCreate"):
 528         raise ImportError
 529 except ImportError:
 530     ExpatParser = None # expat not available
 531 else:
 532     class ExpatParser:
 533         # fast expat parser for Python 2.0 and later.  this is about
 534         # 50% slower than sgmlop, on roundtrip testing
 535         def __init__(self, target):
 536             self._parser = parser = expat.ParserCreate(None, None)
 537             self._target = target
 538             parser.StartElementHandler = target.start
 539             parser.EndElementHandler = target.end
 540             parser.CharacterDataHandler = target.data
 541             encoding = None
 542             if not parser.returns_unicode:
 543                 encoding = "utf-8"
 544             target.xml(encoding, None)
 545
 546         def feed(self, data):
 547             self._parser.Parse(data, 0)
 548
 549         def close(self):
 550             self._parser.Parse("", 1) # end of data
 551             del self._target, self._parser # get rid of circular references
 552
 553 class SlowParser:
 554     """Default XML parser (based on xmllib.XMLParser)."""
 555     # this is about 10 times slower than sgmlop, on roundtrip
 556     # testing.
 557     def __init__(self, target):
 558         import xmllib # lazy subclassing (!)
 559         if xmllib.XMLParser not in SlowParser.__bases__:
 560             SlowParser.__bases__ = (xmllib.XMLParser,)
 561         self.handle_xml = target.xml
 562         self.unknown_starttag = target.start
 563         self.handle_data = target.data
 564         self.handle_cdata = target.data
 565         self.unknown_endtag = target.end
 566         try:
 567             xmllib.XMLParser.__init__(self, accept_utf8=1)
 568         except TypeError:
 569             xmllib.XMLParser.__init__(self) # pre-2.0
 570
 571 # --------------------------------------------------------------------
 572 # XML-RPC marshalling and unmarshalling code
 573
 574 ##
 575 # XML-RPC marshaller.
 576 #
 577 # @param encoding Default encoding for 8-bit strings.  The default
 578 #     value is None (interpreted as UTF-8).
 579 # @see dumps
 580
 581 class Marshaller:
 582     """Generate an XML-RPC params chunk from a Python data structure.
 583
 584     Create a Marshaller instance for each set of parameters, and use
 585     the "dumps" method to convert your data (represented as a tuple)
 586     to an XML-RPC params chunk.  To write a fault response, pass a
 587     Fault instance instead.  You may prefer to use the "dumps" module
 588     function for this purpose.
 589     """
 590
 591     # by the way, if you don't understand what's going on in here,
 592     # that's perfectly ok.
 593
 594     def __init__(self, encoding=None, allow_none=0):
 595         self.memo = {}
 596         self.data = None
 597         self.encoding = encoding
 598         self.allow_none = allow_none
 599
 600     dispatch = {}
 601
 602     def dumps(self, values):
 603         out = []
 604         write = out.append
 605         dump = self.__dump
 606         if isinstance(values, Fault):
 607             # fault instance
 608             write("<fault>\n")
 609             dump({'faultCode': values.faultCode,
 610                   'faultString': values.faultString},
 611                  write)
 612             write("</fault>\n")
 613         else:
 614             # parameter block
 615             # FIXME: the xml-rpc specification allows us to leave out
 616             # the entire <params> block if there are no parameters.
 617             # however, changing this may break older code (including
 618             # old versions of xmlrpclib.py), so this is better left as
 619             # is for now.  See @XMLRPC3 for more information. /F
 620             write("<params>\n")
 621             for v in values:
 622                 write("<param>\n")
 623                 dump(v, write)
 624                 write("</param>\n")
 625             write("</params>\n")
 626         result = string.join(out, "")
 627         return result
 628
 629     def __dump(self, value, write):
 630         try:
 631             f = self.dispatch[type(value)]
 632         except KeyError:
 633             # check if this object can be marshalled as a structure
 634             try:
 635                 value.__dict__
 636             except:
 637                 raise TypeError, "cannot marshal %s objects" % type(value)
 638             # check if this class is a sub-class of a basic type,
 639             # because we don't know how to marshal these types
 640             # (e.g. a string sub-class)
 641             for type_ in type(value).__mro__:
 642                 if type_ in self.dispatch.keys():
 643                     raise TypeError, "cannot marshal %s objects" % type(value)
 644             f = self.dispatch[InstanceType]
 645         f(self, value, write)
 646
 647     def dump_nil (self, value, write):
 648         if not self.allow_none:
 649             raise TypeError, "cannot marshal None unless allow_none is enabled"
 650         write("<value><nil/></value>")
 651     dispatch[NoneType] = dump_nil
 652
 653     def dump_int(self, value, write):
 654         # in case ints are > 32 bits
 655         if value > MAXINT or value < MININT:
 656             raise OverflowError, "int exceeds XML-RPC limits"
 657         write("<value><int>")
 658         write(str(value))
 659         write("</int></value>\n")
 660     dispatch[IntType] = dump_int
 661
 662     if _bool_is_builtin:
 663         def dump_bool(self, value, write):
 664             write("<value><boolean>")
 665             write(value and "1" or "0")
 666             write("</boolean></value>\n")
 667         dispatch[bool] = dump_bool
 668
 669     def dump_long(self, value, write):
 670         if value > MAXINT or value < MININT:
 671             raise OverflowError, "long int exceeds XML-RPC limits"
 672         write("<value><int>")
 673         write(str(int(value)))
 674         write("</int></value>\n")
 675     dispatch[LongType] = dump_long
 676
 677     def dump_double(self, value, write):
 678         write("<value><double>")
 679         write(repr(value))
 680         write("</double></value>\n")
 681     dispatch[FloatType] = dump_double
 682
 683     def dump_string(self, value, write, escape=escape):
 684         write("<value><string>")
 685         write(escape(value))
 686         write("</string></value>\n")
 687     dispatch[StringType] = dump_string
 688
 689     if unicode:
 690         def dump_unicode(self, value, write, escape=escape):
 691             value = value.encode(self.encoding)
 692             write("<value><string>")
 693             write(escape(value))
 694             write("</string></value>\n")
 695         dispatch[UnicodeType] = dump_unicode
 696
 697     def dump_array(self, value, write):
 698         i = id(value)
 699         if self.memo.has_key(i):
 700             raise TypeError, "cannot marshal recursive sequences"
 701         self.memo[i] = None
 702         dump = self.__dump
 703         write("<value><array><data>\n")
 704         for v in value:
 705             dump(v, write)
 706         write("</data></array></value>\n")
 707         del self.memo[i]
 708     dispatch[TupleType] = dump_array
 709     dispatch[ListType] = dump_array
 710
 711     def dump_struct(self, value, write, escape=escape):
 712         i = id(value)
 713         if self.memo.has_key(i):
 714             raise TypeError, "cannot marshal recursive dictionaries"
 715         self.memo[i] = None
 716         dump = self.__dump
 717         write("<value><struct>\n")
 718         for k, v in value.items():
 719             write("<member>\n")
 720             if type(k) is not StringType:
 721                 if unicode and type(k) is UnicodeType:
 722                     k = k.encode(self.encoding)
 723                 else:
 724                     raise TypeError, "dictionary key must be string"
 725             write("<name>%s</name>\n" % escape(k))
 726             dump(v, write)
 727             write("</member>\n")
 728         write("</struct></value>\n")
 729         del self.memo[i]
 730     dispatch[DictType] = dump_struct
 731
 732     if datetime:
 733         def dump_datetime(self, value, write):
 734             write("<value><dateTime.iso8601>")
 735             write(value.strftime("%Y%m%dT%H:%M:%S"))
 736             write("</dateTime.iso8601></value>\n")
 737         dispatch[datetime.datetime] = dump_datetime
 738
 739         def dump_date(self, value, write):
 740             write("<value><dateTime.iso8601>")
 741             write(value.strftime("%Y%m%dT00:00:00"))
 742             write("</dateTime.iso8601></value>\n")
 743         dispatch[datetime.date] = dump_date
 744
 745         def dump_time(self, value, write):
 746             write("<value><dateTime.iso8601>")
 747             write(datetime.datetime.now().date().strftime("%Y%m%dT"))
 748             write(value.strftime("%H:%M:%S"))
 749             write("</dateTime.iso8601></value>\n")
 750         dispatch[datetime.time] = dump_time
 751
 752     def dump_instance(self, value, write):
 753         # check for special wrappers
 754         if value.__class__ in WRAPPERS:
 755             self.write = write
 756             value.encode(self)
 757             del self.write
 758         else:
 759             # store instance attributes as a struct (really?)
 760             self.dump_struct(value.__dict__, write)
 761     dispatch[InstanceType] = dump_instance
 762
 763 ##
 764 # XML-RPC unmarshaller.
 765 #
 766 # @see loads
 767
 768 class Unmarshaller:
 769     """Unmarshal an XML-RPC response, based on incoming XML event
 770     messages (start, data, end).  Call close() to get the resulting
 771     data structure.
 772
 773     Note that this reader is fairly tolerant, and gladly accepts bogus
 774     XML-RPC data without complaining (but not bogus XML).
 775     """
 776
 777     # and again, if you don't understand what's going on in here,
 778     # that's perfectly ok.
 779
 780     def __init__(self, use_datetime=0):
 781         self._type = None
 782         self._stack = []
 783         self._marks = []
 784         self._data = []
 785         self._methodname = None
 786         self._encoding = "utf-8"
 787         self.append = self._stack.append
 788         self._use_datetime = use_datetime
 789         if use_datetime and not datetime:
 790             raise ValueError, "the datetime module is not available"
 791
 792     def close(self):
 793         # return response tuple and target method
 794         if self._type is None or self._marks:
 795             raise ResponseError()
 796         if self._type == "fault":
 797             raise Fault(**self._stack[0])
 798         return tuple(self._stack)
 799
 800     def getmethodname(self):
 801         return self._methodname
 802
 803     #
 804     # event handlers
 805
 806     def xml(self, encoding, standalone):
 807         self._encoding = encoding
 808         # FIXME: assert standalone == 1 ???
 809
 810     def start(self, tag, attrs):
 811         # prepare to handle this element
 812         if tag == "array" or tag == "struct":
 813             self._marks.append(len(self._stack))
 814         self._data = []
 815         self._value = (tag == "value")
 816
 817     def data(self, text):
 818         self._data.append(text)
 819
 820     def end(self, tag, join=string.join):
 821         # call the appropriate end tag handler
 822         try:
 823             f = self.dispatch[tag]
 824         except KeyError:
 825             pass # unknown tag ?
 826         else:
 827             return f(self, join(self._data, ""))
 828
 829     #
 830     # accelerator support
 831
 832     def end_dispatch(self, tag, data):
 833         # dispatch data
 834         try:
 835             f = self.dispatch[tag]
 836         except KeyError:
 837             pass # unknown tag ?
 838         else:
 839             return f(self, data)
 840
 841     #
 842     # element decoders
 843
 844     dispatch = {}
 845
 846     def end_nil (self, data):
 847         self.append(None)
 848         self._value = 0
 849     dispatch["nil"] = end_nil
 850
 851     def end_boolean(self, data):
 852         if data == "0":
 853             self.append(False)
 854         elif data == "1":
 855             self.append(True)
 856         else:
 857             raise TypeError, "bad boolean value"
 858         self._value = 0
 859     dispatch["boolean"] = end_boolean
 860
 861     def end_int(self, data):
 862         self.append(int(data))
 863         self._value = 0
 864     dispatch["i4"] = end_int
 865     dispatch["int"] = end_int
 866
 867     def end_double(self, data):
 868         self.append(float(data))
 869         self._value = 0
 870     dispatch["double"] = end_double
 871
 872     def end_string(self, data):
 873         if self._encoding:
 874             data = _decode(data, self._encoding)
 875         self.append(_stringify(data))
 876         self._value = 0
 877     dispatch["string"] = end_string
 878     dispatch["name"] = end_string # struct keys are always strings
 879
 880     def end_array(self, data):
 881         mark = self._marks.pop()
 882         # map arrays to Python lists
 883         self._stack[mark:] = [self._stack[mark:]]
 884         self._value = 0
 885     dispatch["array"] = end_array
 886
 887     def end_struct(self, data):
 888         mark = self._marks.pop()
 889         # map structs to Python dictionaries
 890         dict = {}
 891         items = self._stack[mark:]
 892         for i in range(0, len(items), 2):
 893             dict[_stringify(items[i])] = items[i+1]
 894         self._stack[mark:] = [dict]
 895         self._value = 0
 896     dispatch["struct"] = end_struct
 897
 898     def end_base64(self, data):
 899         value = Binary()
 900         value.decode(data)
 901         self.append(value)
 902         self._value = 0
 903     dispatch["base64"] = end_base64
 904
 905     def end_dateTime(self, data):
 906         value = DateTime()
 907         value.decode(data)
 908         if self._use_datetime:
 909             value = _datetime_type(data)
 910         self.append(value)
 911     dispatch["dateTime.iso8601"] = end_dateTime
 912
 913     def end_value(self, data):
 914         # if we stumble upon a value element with no internal
 915         # elements, treat it as a string element
 916         if self._value:
 917             self.end_string(data)
 918     dispatch["value"] = end_value
 919
 920     def end_params(self, data):
 921         self._type = "params"
 922     dispatch["params"] = end_params
 923
 924     def end_fault(self, data):
 925         self._type = "fault"
 926     dispatch["fault"] = end_fault
 927
 928     def end_methodName(self, data):
 929         if self._encoding:
 930             data = _decode(data, self._encoding)
 931         self._methodname = data
 932         self._type = "methodName" # no params
 933     dispatch["methodName"] = end_methodName
 934
 935 ## Multicall support
 936 #
 937
 938 class _MultiCallMethod:
 939     # some lesser magic to store calls made to a MultiCall object
 940     # for batch execution
 941     def __init__(self, call_list, name):
 942         self.__call_list = call_list
 943         self.__name = name
 944     def __getattr__(self, name):
 945         return _MultiCallMethod(self.__call_list, "%s.%s" % (self.__name, name))
 946     def __call__(self, *args):
 947         self.__call_list.append((self.__name, args))
 948
 949 class MultiCallIterator:
 950     """Iterates over the results of a multicall. Exceptions are
 951     thrown in response to xmlrpc faults."""
 952
 953     def __init__(self, results):
 954         self.results = results
 955
 956     def __getitem__(self, i):
 957         item = self.results[i]
 958         if type(item) == type({}):
 959             raise Fault(item['faultCode'], item['faultString'])
 960         elif type(item) == type([]):
 961             return item[0]
 962         else:
 963             raise ValueError,\
 964                   "unexpected type in multicall result"
 965
 966 class MultiCall:
 967     """server -> a object used to boxcar method calls
 968
 969     server should be a ServerProxy object.
 970
 971     Methods can be added to the MultiCall using normal
 972     method call syntax e.g.:
 973
 974     multicall = MultiCall(server_proxy)
 975     multicall.add(2,3)
 976     multicall.get_address("Guido")
 977
 978     To execute the multicall, call the MultiCall object e.g.:
 979
 980     add_result, address = multicall()
 981     """
 982
 983     def __init__(self, server):
 984         self.__server = server
 985         self.__call_list = []
 986
 987     def __repr__(self):
 988         return "<MultiCall at %x>" % id(self)
 989
 990     __str__ = __repr__
 991
 992     def __getattr__(self, name):
 993         return _MultiCallMethod(self.__call_list, name)
 994
 995     def __call__(self):
 996         marshalled_list = []
 997         for name, args in self.__call_list:
 998             marshalled_list.append({'methodName' : name, 'params' : args})
 999
1000         return MultiCallIterator(self.__server.system.multicall(marshalled_list))
1001
1002 # --------------------------------------------------------------------
1003 # convenience functions
1004
1005 ##
1006 # Create a parser object, and connect it to an unmarshalling instance.
1007 # This function picks the fastest available XML parser.
1008 #
1009 # return A (parser, unmarshaller) tuple.
1010
1011 def getparser(use_datetime=0):
1012     """getparser() -> parser, unmarshaller
1013
1014     Create an instance of the fastest available parser, and attach it
1015     to an unmarshalling object.  Return both objects.
1016     """
1017     if use_datetime and not datetime:
1018         raise ValueError, "the datetime module is not available"
1019     if FastParser and FastUnmarshaller:
1020         if use_datetime:
1021             mkdatetime = _datetime_type
1022         else:
1023             mkdatetime = _datetime
1024         target = FastUnmarshaller(True, False, _binary, mkdatetime, Fault)
1025         parser = FastParser(target)
1026     else:
1027         target = Unmarshaller(use_datetime=use_datetime)
1028         if FastParser:
1029             parser = FastParser(target)
1030         elif SgmlopParser:
1031             parser = SgmlopParser(target)
1032         elif ExpatParser:
1033             parser = ExpatParser(target)
1034         else:
1035             parser = SlowParser(target)
1036     return parser, target
1037
1038 ##
1039 # Convert a Python tuple or a Fault instance to an XML-RPC packet.
1040 #
1041 # @def dumps(params, **options)
1042 # @param params A tuple or Fault instance.
1043 # @keyparam methodname If given, create a methodCall request for
1044 #     this method name.
1045 # @keyparam methodresponse If given, create a methodResponse packet.
1046 #     If used with a tuple, the tuple must be a singleton (that is,
1047 #     it must contain exactly one element).
1048 # @keyparam encoding The packet encoding.
1049 # @return A string containing marshalled data.
1050
1051 def dumps(params, methodname=None, methodresponse=None, encoding=None,
1052           allow_none=0):
1053     """data [,options] -> marshalled data
1054
1055     Convert an argument tuple or a Fault instance to an XML-RPC
1056     request (or response, if the methodresponse option is used).
1057
1058     In addition to the data object, the following options can be given
1059     as keyword arguments:
1060
1061         methodname: the method name for a methodCall packet
1062
1063         methodresponse: true to create a methodResponse packet.
1064         If this option is used with a tuple, the tuple must be
1065         a singleton (i.e. it can contain only one element).
1066
1067         encoding: the packet encoding (default is UTF-8)
1068
1069     All 8-bit strings in the data structure are assumed to use the
1070     packet encoding.  Unicode strings are automatically converted,
1071     where necessary.
1072     """
1073
1074     assert isinstance(params, TupleType) or isinstance(params, Fault),\
1075            "argument must be tuple or Fault instance"
1076
1077     if isinstance(params, Fault):
1078         methodresponse = 1
1079     elif methodresponse and isinstance(params, TupleType):
1080         assert len(params) == 1, "response tuple must be a singleton"
1081
1082     if not encoding:
1083         encoding = "utf-8"
1084
1085     if FastMarshaller:
1086         m = FastMarshaller(encoding)
1087     else:
1088         m = Marshaller(encoding, allow_none)
1089
1090     data = m.dumps(params)
1091
1092     if encoding != "utf-8":
1093         xmlheader = "<?xml version='1.0' encoding='%s'?>\n" % str(encoding)
1094     else:
1095         xmlheader = "<?xml version='1.0'?>\n" # utf-8 is default
1096
1097     # standard XML-RPC wrappings
1098     if methodname:
1099         # a method call
1100         if not isinstance(methodname, StringType):
1101             methodname = methodname.encode(encoding)
1102         data = (
1103             xmlheader,
1104             "<methodCall>\n"
1105             "<methodName>", methodname, "</methodName>\n",
1106             data,
1107             "</methodCall>\n"
1108             )
1109     elif methodresponse:
1110         # a method response, or a fault structure
1111         data = (
1112             xmlheader,
1113             "<methodResponse>\n",
1114             data,
1115             "</methodResponse>\n"
1116             )
1117     else:
1118         return data # return as is
1119     return string.join(data, "")
1120
1121 ##
1122 # Convert an XML-RPC packet to a Python object.  If the XML-RPC packet
1123 # represents a fault condition, this function raises a Fault exception.
1124 #
1125 # @param data An XML-RPC packet, given as an 8-bit string.
1126 # @return A tuple containing the unpacked data, and the method name
1127 #     (None if not present).
1128 # @see Fault
1129
1130 def loads(data, use_datetime=0):
1131     """data -> unmarshalled data, method name
1132
1133     Convert an XML-RPC packet to unmarshalled data plus a method
1134     name (None if not present).
1135
1136     If the XML-RPC packet represents a fault condition, this function
1137     raises a Fault exception.
1138     """
1139     p, u = getparser(use_datetime=use_datetime)
1140     p.feed(data)
1141     p.close()
1142     return u.close(), u.getmethodname()
1143
1144
1145 # --------------------------------------------------------------------
1146 # request dispatcher
1147
1148 class _Method:
1149     # some magic to bind an XML-RPC method to an RPC server.
1150     # supports "nested" methods (e.g. examples.getStateName)
1151     def __init__(self, send, name):
1152         self.__send = send
1153         self.__name = name
1154     def __getattr__(self, name):
1155         return _Method(self.__send, "%s.%s" % (self.__name, name))
1156     def __call__(self, *args):
1157         return self.__send(self.__name, args)
1158
1159 ##
1160 # Standard transport class for XML-RPC over HTTP.
1161 # <p>
1162 # You can create custom transports by subclassing this method, and
1163 # overriding selected methods.
1164
1165 class Transport:
1166     """Handles an HTTP transaction to an XML-RPC server."""
1167
1168     # client identifier (may be overridden)
1169     user_agent = "xmlrpclib.py/%s (by www.pythonware.com)" % __version__
1170
1171     def __init__(self, use_datetime=0):
1172         self._use_datetime = use_datetime
1173
1174     ##
1175     # Send a complete request, and parse the response.
1176     #
1177     # @param host Target host.
1178     # @param handler Target PRC handler.
1179     # @param request_body XML-RPC request body.
1180     # @param verbose Debugging flag.
1181     # @return Parsed response.
1182
1183     def request(self, host, handler, request_body, verbose=0):
1184         # issue XML-RPC request
1185
1186         h = self.make_connection(host)
1187         if verbose:
1188             h.set_debuglevel(1)
1189
1190         self.send_request(h, handler, request_body)
1191         self.send_host(h, host)
1192         self.send_user_agent(h)
1193         self.send_content(h, request_body)
1194
1195         errcode, errmsg, headers = h.getreply()
1196
1197         if errcode != 200:
1198             raise ProtocolError(
1199                 host + handler,
1200                 errcode, errmsg,
1201                 headers
1202                 )
1203
1204         self.verbose = verbose
1205
1206         try:
1207             sock = h._conn.sock
1208         except AttributeError:
1209             sock = None
1210
1211         return self._parse_response(h.getfile(), sock)
1212
1213     ##
1214     # Create parser.
1215     #
1216     # @return A 2-tuple containing a parser and a unmarshaller.
1217
1218     def getparser(self):
1219         # get parser and unmarshaller
1220         return getparser(use_datetime=self._use_datetime)
1221
1222     ##
1223     # Get authorization info from host parameter
1224     # Host may be a string, or a (host, x509-dict) tuple; if a string,
1225     # it is checked for a "user:pw@host" format, and a "Basic
1226     # Authentication" header is added if appropriate.
1227     #
1228     # @param host Host descriptor (URL or (URL, x509 info) tuple).
1229     # @return A 3-tuple containing (actual host, extra headers,
1230     #     x509 info).  The header and x509 fields may be None.
1231
1232     def get_host_info(self, host):
1233
1234         x509 = {}
1235         if isinstance(host, TupleType):
1236             host, x509 = host
1237
1238         import urllib
1239         auth, host = urllib.splituser(host)
1240
1241         if auth:
1242             import base64
1243             auth = base64.encodestring(urllib.unquote(auth))
1244             auth = string.join(string.split(auth), "") # get rid of whitespace
1245             extra_headers = [
1246                 ("Authorization", "Basic " + auth)
1247                 ]
1248         else:
1249             extra_headers = None
1250
1251         return host, extra_headers, x509
1252
1253     ##
1254     # Connect to server.
1255     #
1256     # @param host Target host.
1257     # @return A connection handle.
1258
1259     def make_connection(self, host):
1260         # create a HTTP connection object from a host descriptor
1261         import httplib
1262         host, extra_headers, x509 = self.get_host_info(host)
1263         return httplib.HTTP(host)
1264
1265     ##
1266     # Send request header.
1267     #
1268     # @param connection Connection handle.
1269     # @param handler Target RPC handler.
1270     # @param request_body XML-RPC body.
1271
1272     def send_request(self, connection, handler, request_body):
1273         connection.putrequest("POST", handler)
1274
1275     ##
1276     # Send host name.
1277     #
1278     # @param connection Connection handle.
1279     # @param host Host name.
1280
1281     def send_host(self, connection, host):
1282         host, extra_headers, x509 = self.get_host_info(host)
1283         connection.putheader("Host", host)
1284         if extra_headers:
1285             if isinstance(extra_headers, DictType):
1286                 extra_headers = extra_headers.items()
1287             for key, value in extra_headers:
1288                 connection.putheader(key, value)
1289
1290     ##
1291     # Send user-agent identifier.
1292     #
1293     # @param connection Connection handle.
1294
1295     def send_user_agent(self, connection):
1296         connection.putheader("User-Agent", self.user_agent)
1297
1298     ##
1299     # Send request body.
1300     #
1301     # @param connection Connection handle.
1302     # @param request_body XML-RPC request body.
1303
1304     def send_content(self, connection, request_body):
1305         connection.putheader("Content-Type", "text/xml")
1306         connection.putheader("Content-Length", str(len(request_body)))
1307         connection.endheaders()
1308         if request_body:
1309             connection.send(request_body)
1310
1311     ##
1312     # Parse response.
1313     #
1314     # @param file Stream.
1315     # @return Response tuple and target method.
1316
1317     def parse_response(self, file):
1318         # compatibility interface
1319         return self._parse_response(file, None)
1320
1321     ##
1322     # Parse response (alternate interface).  This is similar to the
1323     # parse_response method, but also provides direct access to the
1324     # underlying socket object (where available).
1325     #
1326     # @param file Stream.
1327     # @param sock Socket handle (or None, if the socket object
1328     #    could not be accessed).
1329     # @return Response tuple and target method.
1330
1331     def _parse_response(self, file, sock):
1332         # read response from input file/socket, and parse it
1333
1334         p, u = self.getparser()
1335
1336         while 1:
1337             if sock:
1338                 response = sock.recv(1024)
1339             else:
1340                 response = file.read(1024)
1341             if not response:
1342                 break
1343             if self.verbose:
1344                 print "body:", repr(response)
1345             p.feed(response)
1346
1347         file.close()
1348         p.close()
1349
1350         return u.close()
1351
1352 ##
1353 # Standard transport class for XML-RPC over HTTPS.
1354
1355 class SafeTransport(Transport):
1356     """Handles an HTTPS transaction to an XML-RPC server."""
1357
1358     # FIXME: mostly untested
1359
1360     def make_connection(self, host):
1361         # create a HTTPS connection object from a host descriptor
1362         # host may be a string, or a (host, x509-dict) tuple
1363         import httplib
1364         host, extra_headers, x509 = self.get_host_info(host)
1365         try:
1366             HTTPS = httplib.HTTPS
1367         except AttributeError:
1368             raise NotImplementedError(
1369                 "your version of httplib doesn't support HTTPS"
1370                 )
1371         else:
1372             return HTTPS(host, None, **(x509 or {}))
1373
1374 ##
1375 # Standard server proxy.  This class establishes a virtual connection
1376 # to an XML-RPC server.
1377 # <p>
1378 # This class is available as ServerProxy and Server.  New code should
1379 # use ServerProxy, to avoid confusion.
1380 #
1381 # @def ServerProxy(uri, **options)
1382 # @param uri The connection point on the server.
1383 # @keyparam transport A transport factory, compatible with the
1384 #    standard transport class.
1385 # @keyparam encoding The default encoding used for 8-bit strings
1386 #    (default is UTF-8).
1387 # @keyparam verbose Use a true value to enable debugging output.
1388 #    (printed to standard output).
1389 # @see Transport
1390
1391 class ServerProxy:
1392     """uri [,options] -> a logical connection to an XML-RPC server
1393
1394     uri is the connection point on the server, given as
1395     scheme://host/target.
1396
1397     The standard implementation always supports the "http" scheme.  If
1398     SSL socket support is available (Python 2.0), it also supports
1399     "https".
1400
1401     If the target part and the slash preceding it are both omitted,
1402     "/RPC2" is assumed.
1403
1404     The following options can be given as keyword arguments:
1405
1406         transport: a transport factory
1407         encoding: the request encoding (default is UTF-8)
1408
1409     All 8-bit strings passed to the server proxy are assumed to use
1410     the given encoding.
1411     """
1412
1413     def __init__(self, uri, transport=None, encoding=None, verbose=0,
1414                  allow_none=0, use_datetime=0):
1415         # establish a "logical" server connection
1416
1417         # get the url
1418         import urllib
1419         type, uri = urllib.splittype(uri)
1420         if type not in ("http", "https"):
1421             raise IOError, "unsupported XML-RPC protocol"
1422         self.__host, self.__handler = urllib.splithost(uri)
1423         if not self.__handler:
1424             self.__handler = "/RPC2"
1425
1426         if transport is None:
1427             if type == "https":
1428                 transport = SafeTransport(use_datetime=use_datetime)
1429             else:
1430                 transport = Transport(use_datetime=use_datetime)
1431         self.__transport = transport
1432
1433         self.__encoding = encoding
1434         self.__verbose = verbose
1435         self.__allow_none = allow_none
1436
1437     def __request(self, methodname, params):
1438         # call a method on the remote server
1439
1440         request = dumps(params, methodname, encoding=self.__encoding,
1441                         allow_none=self.__allow_none)
1442
1443         response = self.__transport.request(
1444             self.__host,
1445             self.__handler,
1446             request,
1447             verbose=self.__verbose
1448             )
1449
1450         if len(response) == 1:
1451             response = response[0]
1452
1453         return response
1454
1455     def __repr__(self):
1456         return (
1457             "<ServerProxy for %s%s>" %
1458             (self.__host, self.__handler)
1459             )
1460
1461     __str__ = __repr__
1462
1463     def __getattr__(self, name):
1464         # magic method dispatcher
1465         return _Method(self.__request, name)
1466
1467     # note: to call a remote object with an non-standard name, use
1468     # result getattr(server, "strange-python-name")(args)
1469
1470 # compatibility
1471
1472 Server = ServerProxy
1473
1474 # --------------------------------------------------------------------
1475 # test code
1476
1477 if __name__ == "__main__":
1478
1479     # simple test program (from the XML-RPC specification)
1480
1481     # server = ServerProxy("http://localhost:8000") # local server
1482     server = ServerProxy("http://time.xmlrpc.com/RPC2")
1483
1484     print server
1485
1486     try:
1487         print server.currentTime.getCurrentTime()
1488     except Error, v:
1489         print "ERROR", v
1490
1491     multi = MultiCall(server)
1492     multi.currentTime.getCurrentTime()
1493     multi.currentTime.getCurrentTime()
1494     try:
1495         for response in multi():
1496             print response
1497     except Error, v:
1498         print "ERROR", v