blob: 6fb6c68db51819ae1d7344701285e23bceb5cd20 [file] [log] [blame]
Fredrik Lundhb9056332001-07-11 17:42:21 +00001#
2# XML-RPC CLIENT LIBRARY
3# $Id$
4#
Fredrik Lundhc4c062f2001-09-10 19:45:02 +00005# 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:
Martin v. Löwis37af9862004-08-20 07:31:37 +000011# this version is designed to work with Python 2.1 or newer.
Fredrik Lundhc4c062f2001-09-10 19:45:02 +000012#
Fredrik Lundhb9056332001-07-11 17:42:21 +000013# 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)
Fredrik Lundh78eedce2001-08-23 20:04:33 +000027# 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)
Fredrik Lundhc4c062f2001-09-10 19:45:02 +000029# 2001-09-03 fl Allow Transport subclass to override getparser
30# 2001-09-10 fl Lazy import of urllib, cgi, xmllib (20x import speedup)
Fredrik Lundh1538c232001-10-01 19:42:03 +000031# 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)
Fredrik Lundh3d9addd2002-06-27 21:36:21 +000033# 2001-10-02 fl More dumps microtuning
34# 2001-10-04 fl Make sure import expat gets a parser (from Guido van Rossum)
Skip Montanaro5e9c71b2001-10-10 15:56:34 +000035# 2001-10-10 sm Allow long ints to be passed as ints if they don't overflow
Fredrik Lundh3d9addd2002-06-27 21:36:21 +000036# 2001-10-17 sm Test for int and long overflow (allows use on 64-bit systems)
Fredrik Lundhb6ab93f2001-12-19 21:40:04 +000037# 2001-11-12 fl Use repr() to marshal doubles (from Paul Felix)
Fredrik Lundh3d9addd2002-06-27 21:36:21 +000038# 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
Fredrik Lundh1303c7c2002-10-22 18:23:00 +000043# 2002-10-22 fl Added basic authentication (based on code from Phillip Eby)
Martin v. Löwis541342f2003-07-12 07:53:04 +000044# 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
Martin v. Löwis45394c22003-10-31 13:49:36 +000050# 2003-10-31 mvl Add multicall support
Martin v. Löwis37af9862004-08-20 07:31:37 +000051# 2004-08-20 mvl Bump minimum supported Python version to 2.1
Fredrik Lundhb9056332001-07-11 17:42:21 +000052#
Fredrik Lundh3d9addd2002-06-27 21:36:21 +000053# Copyright (c) 1999-2002 by Secret Labs AB.
54# Copyright (c) 1999-2002 by Fredrik Lundh.
Fredrik Lundhb9056332001-07-11 17:42:21 +000055#
56# info@pythonware.com
57# http://www.pythonware.com
58#
59# --------------------------------------------------------------------
60# The XML-RPC client interface is
61#
Fredrik Lundh3d9addd2002-06-27 21:36:21 +000062# Copyright (c) 1999-2002 by Secret Labs AB
63# Copyright (c) 1999-2002 by Fredrik Lundh
Fredrik Lundhb9056332001-07-11 17:42:21 +000064#
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#
Fredrik Lundh3d9addd2002-06-27 21:36:21 +000089# things to look into some day:
Fredrik Lundhb9056332001-07-11 17:42:21 +000090
Fredrik Lundh3d9addd2002-06-27 21:36:21 +000091# TODO: sort out True/False/boolean issues for Python 2.3
Fredrik Lundhb9056332001-07-11 17:42:21 +000092
Fred Drake1b410792001-09-04 18:55:03 +000093"""
94An XML-RPC client interface for Python.
95
96The marshalling and response parser code can also be used to
97implement XML-RPC servers.
98
Fred Drake1b410792001-09-04 18:55:03 +000099Exported exceptions:
100
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000101 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
Fred Drake1b410792001-09-04 18:55:03 +0000105
106Exported classes:
107
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000108 ServerProxy Represents a logical connection to an XML-RPC server
Fred Drake1b410792001-09-04 18:55:03 +0000109
Raymond Hettingercc523fc2003-11-02 09:47:05 +0000110 MultiCall Executor of boxcared xmlrpc requests
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000111 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
Fred Drake1b410792001-09-04 18:55:03 +0000116
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000117 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
Fred Drake1b410792001-09-04 18:55:03 +0000122
123Exported constants:
124
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000125 True
126 False
Fred Drake1b410792001-09-04 18:55:03 +0000127
128Exported functions:
129
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000130 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).
Fred Drake1b410792001-09-04 18:55:03 +0000137"""
138
Fred Drake2a2d9702001-10-17 01:51:04 +0000139import re, string, time, operator
Fredrik Lundh1538c232001-10-01 19:42:03 +0000140
Raymond Hettingerfe59dc12005-02-07 15:28:45 +0000141from types import *
Fredrik Lundhb9056332001-07-11 17:42:21 +0000142
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000143# --------------------------------------------------------------------
144# Internal stuff
145
Fredrik Lundhb9056332001-07-11 17:42:21 +0000146try:
147 unicode
148except NameError:
149 unicode = None # unicode support not available
150
Skip Montanaro9a7c96a2003-01-22 18:17:25 +0000151try:
Fred Drakeba613c32005-02-10 18:33:30 +0000152 import datetime
153except ImportError:
154 datetime = None
155
156try:
Skip Montanaro9a7c96a2003-01-22 18:17:25 +0000157 _bool_is_builtin = False.__class__.__name__ == "bool"
158except NameError:
159 _bool_is_builtin = 0
160
Fredrik Lundhb9056332001-07-11 17:42:21 +0000161def _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
Fredrik Lundh1538c232001-10-01 19:42:03 +0000167def escape(s, replace=string.replace):
168 s = replace(s, "&", "&")
169 s = replace(s, "<", "&lt;")
170 return replace(s, ">", "&gt;",)
171
Fredrik Lundhb9056332001-07-11 17:42:21 +0000172if unicode:
173 def _stringify(string):
174 # convert to 7-bit ascii if possible
175 try:
Fred Drake22c07062005-02-11 17:59:08 +0000176 return string.encode("ascii")
Fredrik Lundhb9056332001-07-11 17:42:21 +0000177 except UnicodeError:
178 return string
179else:
180 def _stringify(string):
181 return string
182
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000183__version__ = "1.0.1"
184
185# xmlrpc integer limits
186MAXINT = 2L**31-1
187MININT = -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
194PARSE_ERROR = -32700
195SERVER_ERROR = -32600
196APPLICATION_ERROR = -32500
197SYSTEM_ERROR = -32400
198TRANSPORT_ERROR = -32300
199
200# Specific errors
201NOT_WELLFORMED_ERROR = -32700
202UNSUPPORTED_ENCODING = -32701
203INVALID_ENCODING_CHAR = -32702
204INVALID_XMLRPC = -32600
205METHOD_NOT_FOUND = -32601
206INVALID_METHOD_PARAMS = -32602
207INTERNAL_ERROR = -32603
Fredrik Lundhb9056332001-07-11 17:42:21 +0000208
209# --------------------------------------------------------------------
210# Exceptions
211
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000212##
213# Base class for all kinds of client-side errors.
214
Fredrik Lundh78eedce2001-08-23 20:04:33 +0000215class Error(Exception):
Fred Drake1b410792001-09-04 18:55:03 +0000216 """Base class for client errors."""
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +0000217 def __str__(self):
218 return repr(self)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000219
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000220##
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
Fredrik Lundhb9056332001-07-11 17:42:21 +0000230class ProtocolError(Error):
Fred Drake1b410792001-09-04 18:55:03 +0000231 """Indicates an HTTP protocol error."""
Fredrik Lundhb9056332001-07-11 17:42:21 +0000232 def __init__(self, url, errcode, errmsg, headers):
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +0000233 Error.__init__(self)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000234 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
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000244##
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
Fredrik Lundhb9056332001-07-11 17:42:21 +0000249class ResponseError(Error):
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000250 """Indicates a broken response package."""
Fredrik Lundhb9056332001-07-11 17:42:21 +0000251 pass
252
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000253##
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
Fredrik Lundhb9056332001-07-11 17:42:21 +0000262class Fault(Error):
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000263 """Indicates an XML-RPC fault package."""
Fredrik Lundhb9056332001-07-11 17:42:21 +0000264 def __init__(self, faultCode, faultString, **extra):
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +0000265 Error.__init__(self)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000266 self.faultCode = faultCode
267 self.faultString = faultString
268 def __repr__(self):
269 return (
270 "<Fault %s: %s>" %
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +0000271 (self.faultCode, repr(self.faultString))
Fredrik Lundhb9056332001-07-11 17:42:21 +0000272 )
273
274# --------------------------------------------------------------------
275# Special values
276
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000277##
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
Skip Montanaro9a7c96a2003-01-22 18:17:25 +0000285if _bool_is_builtin:
286 boolean = Boolean = bool
287 # to avoid breaking code which references xmlrpclib.{True,False}
288 True, False = True, False
289else:
290 class Boolean:
291 """Boolean-value wrapper.
Fred Drake1b410792001-09-04 18:55:03 +0000292
Skip Montanaro9a7c96a2003-01-22 18:17:25 +0000293 Use True or False to generate a "boolean" XML-RPC value.
294 """
Fredrik Lundhb9056332001-07-11 17:42:21 +0000295
Skip Montanaro9a7c96a2003-01-22 18:17:25 +0000296 def __init__(self, value = 0):
297 self.value = operator.truth(value)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000298
Skip Montanaro9a7c96a2003-01-22 18:17:25 +0000299 def encode(self, out):
300 out.write("<value><boolean>%d</boolean></value>\n" % self.value)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000301
Skip Montanaro9a7c96a2003-01-22 18:17:25 +0000302 def __cmp__(self, other):
303 if isinstance(other, Boolean):
304 other = other.value
305 return cmp(self.value, other)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000306
Skip Montanaro9a7c96a2003-01-22 18:17:25 +0000307 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)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000312
Skip Montanaro9a7c96a2003-01-22 18:17:25 +0000313 def __int__(self):
314 return self.value
Fredrik Lundhb9056332001-07-11 17:42:21 +0000315
Skip Montanaro9a7c96a2003-01-22 18:17:25 +0000316 def __nonzero__(self):
317 return self.value
Fredrik Lundhb9056332001-07-11 17:42:21 +0000318
Skip Montanaro9a7c96a2003-01-22 18:17:25 +0000319 True, False = Boolean(1), Boolean(0)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000320
Skip Montanaro9a7c96a2003-01-22 18:17:25 +0000321 ##
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
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000331
Skip Montanaro9a7c96a2003-01-22 18:17:25 +0000332 def boolean(value, _truefalse=(False, True)):
333 """Convert any Python value to XML-RPC 'boolean'."""
334 return _truefalse[operator.truth(value)]
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000335
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.
Fredrik Lundhb9056332001-07-11 17:42:21 +0000348
Fredrik Lundhb9056332001-07-11 17:42:21 +0000349class DateTime:
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000350 """DateTime wrapper for an ISO 8601 string or time tuple or
351 localtime integer value to generate 'dateTime.iso8601' XML-RPC
352 value.
353 """
Fredrik Lundhb9056332001-07-11 17:42:21 +0000354
355 def __init__(self, value=0):
Raymond Hettingerfe59dc12005-02-07 15:28:45 +0000356 if not isinstance(value, StringType):
Fred Drakeba613c32005-02-10 18:33:30 +0000357 if datetime and isinstance(value, datetime.datetime):
358 self.value = value.strftime("%Y%m%dT%H:%M:%S")
359 return
Skip Montanaro174dd222005-05-14 20:54:16 +0000360 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)):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000368 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
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000379 ##
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
Fredrik Lundhb9056332001-07-11 17:42:21 +0000387 def __repr__(self):
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000388 return "<DateTime %s at %x>" % (repr(self.value), id(self))
Fredrik Lundhb9056332001-07-11 17:42:21 +0000389
390 def decode(self, data):
Andrew M. Kuchlingbdb39012005-12-04 19:11:17 +0000391 data = str(data)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000392 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
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000399def _datetime(data):
400 # decode xml element contents into a DateTime structure.
Fredrik Lundhb9056332001-07-11 17:42:21 +0000401 value = DateTime()
402 value.decode(data)
403 return value
404
Skip Montanaro174dd222005-05-14 20:54:16 +0000405def _datetime_type(data):
406 t = time.strptime(data, "%Y%m%dT%H:%M:%S")
407 return datetime.datetime(*tuple(t)[:6])
408
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000409##
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
Skip Montanarobfcbfa72003-04-24 19:51:31 +0000415import base64
416try:
417 import cStringIO as StringIO
418except ImportError:
419 import StringIO
420
Fredrik Lundhb9056332001-07-11 17:42:21 +0000421class Binary:
Fred Drake1b410792001-09-04 18:55:03 +0000422 """Wrapper for binary data."""
Fredrik Lundhb9056332001-07-11 17:42:21 +0000423
424 def __init__(self, data=None):
425 self.data = data
426
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000427 ##
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
Fredrik Lundhb9056332001-07-11 17:42:21 +0000435 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):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000441 self.data = base64.decodestring(data)
442
443 def encode(self, out):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000444 out.write("<value><base64>\n")
445 base64.encode(StringIO.StringIO(self.data), out)
446 out.write("</base64></value>\n")
447
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000448def _binary(data):
449 # decode xml element contents into a Binary structure
Fredrik Lundhb9056332001-07-11 17:42:21 +0000450 value = Binary()
451 value.decode(data)
452 return value
453
Skip Montanaro9a7c96a2003-01-22 18:17:25 +0000454WRAPPERS = (DateTime, Binary)
455if not _bool_is_builtin:
456 WRAPPERS = WRAPPERS + (Boolean,)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000457
458# --------------------------------------------------------------------
459# XML parsers
460
461try:
Fredrik Lundh7069c312004-10-13 06:48:37 +0000462 # optional xmlrpclib accelerator
Fredrik Lundhb9056332001-07-11 17:42:21 +0000463 import _xmlrpclib
464 FastParser = _xmlrpclib.Parser
465 FastUnmarshaller = _xmlrpclib.Unmarshaller
466except (AttributeError, ImportError):
467 FastParser = FastUnmarshaller = None
468
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000469try:
470 import _xmlrpclib
471 FastMarshaller = _xmlrpclib.Marshaller
472except (AttributeError, ImportError):
473 FastMarshaller = None
474
Fredrik Lundhb9056332001-07-11 17:42:21 +0000475#
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
482try:
483 import sgmlop
484 if not hasattr(sgmlop, "XMLParser"):
485 raise ImportError
486except ImportError:
487 SgmlopParser = None # sgmlop accelerator not available
488else:
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
525try:
526 from xml.parsers import expat
Guido van Rossumb8551342001-10-02 18:33:11 +0000527 if not hasattr(expat, "ParserCreate"):
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000528 raise ImportError
Fredrik Lundhb9056332001-07-11 17:42:21 +0000529except ImportError:
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000530 ExpatParser = None # expat not available
Fredrik Lundhb9056332001-07-11 17:42:21 +0000531else:
532 class ExpatParser:
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000533 # fast expat parser for Python 2.0 and later. this is about
534 # 50% slower than sgmlop, on roundtrip testing
Fredrik Lundhb9056332001-07-11 17:42:21 +0000535 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
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000553class SlowParser:
554 """Default XML parser (based on xmllib.XMLParser)."""
555 # this is about 10 times slower than sgmlop, on roundtrip
556 # testing.
Fredrik Lundhb9056332001-07-11 17:42:21 +0000557 def __init__(self, target):
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000558 import xmllib # lazy subclassing (!)
559 if xmllib.XMLParser not in SlowParser.__bases__:
560 SlowParser.__bases__ = (xmllib.XMLParser,)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000561 self.handle_xml = target.xml
562 self.unknown_starttag = target.start
563 self.handle_data = target.data
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000564 self.handle_cdata = target.data
Fredrik Lundhb9056332001-07-11 17:42:21 +0000565 self.unknown_endtag = target.end
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +0000566 try:
567 xmllib.XMLParser.__init__(self, accept_utf8=1)
568 except TypeError:
569 xmllib.XMLParser.__init__(self) # pre-2.0
Fredrik Lundhb9056332001-07-11 17:42:21 +0000570
571# --------------------------------------------------------------------
572# XML-RPC marshalling and unmarshalling code
573
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000574##
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
Fredrik Lundhb9056332001-07-11 17:42:21 +0000581class Marshaller:
Fred Drake1b410792001-09-04 18:55:03 +0000582 """Generate an XML-RPC params chunk from a Python data structure.
Fredrik Lundhb9056332001-07-11 17:42:21 +0000583
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000584 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.
Fred Drake1b410792001-09-04 18:55:03 +0000589 """
Fredrik Lundhb9056332001-07-11 17:42:21 +0000590
591 # by the way, if you don't understand what's going on in here,
592 # that's perfectly ok.
593
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +0000594 def __init__(self, encoding=None, allow_none=0):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000595 self.memo = {}
596 self.data = None
597 self.encoding = encoding
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +0000598 self.allow_none = allow_none
Tim Petersc2659cf2003-05-12 20:19:37 +0000599
Fredrik Lundhb9056332001-07-11 17:42:21 +0000600 dispatch = {}
601
602 def dumps(self, values):
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000603 out = []
604 write = out.append
605 dump = self.__dump
Fredrik Lundhb9056332001-07-11 17:42:21 +0000606 if isinstance(values, Fault):
607 # fault instance
608 write("<fault>\n")
Martin v. Löwis541342f2003-07-12 07:53:04 +0000609 dump({'faultCode': values.faultCode,
610 'faultString': values.faultString},
611 write)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000612 write("</fault>\n")
613 else:
614 # parameter block
Fredrik Lundhc266bb02001-08-23 20:13:08 +0000615 # 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
Fredrik Lundhb9056332001-07-11 17:42:21 +0000620 write("<params>\n")
621 for v in values:
622 write("<param>\n")
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000623 dump(v, write)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000624 write("</param>\n")
625 write("</params>\n")
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000626 result = string.join(out, "")
Fredrik Lundhb9056332001-07-11 17:42:21 +0000627 return result
628
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000629 def __dump(self, value, write):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000630 try:
631 f = self.dispatch[type(value)]
632 except KeyError:
633 raise TypeError, "cannot marshal %s objects" % type(value)
634 else:
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000635 f(self, value, write)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000636
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +0000637 def dump_nil (self, value, write):
638 if not self.allow_none:
639 raise TypeError, "cannot marshal None unless allow_none is enabled"
640 write("<value><nil/></value>")
Raymond Hettingerfe59dc12005-02-07 15:28:45 +0000641 dispatch[NoneType] = dump_nil
Tim Petersc2659cf2003-05-12 20:19:37 +0000642
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000643 def dump_int(self, value, write):
Skip Montanaro5449e082001-10-17 22:53:33 +0000644 # in case ints are > 32 bits
645 if value > MAXINT or value < MININT:
646 raise OverflowError, "int exceeds XML-RPC limits"
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000647 write("<value><int>")
648 write(str(value))
649 write("</int></value>\n")
Raymond Hettingerfe59dc12005-02-07 15:28:45 +0000650 dispatch[IntType] = dump_int
Fredrik Lundhb9056332001-07-11 17:42:21 +0000651
Skip Montanaro9a7c96a2003-01-22 18:17:25 +0000652 if _bool_is_builtin:
653 def dump_bool(self, value, write):
654 write("<value><boolean>")
655 write(value and "1" or "0")
656 write("</boolean></value>\n")
657 dispatch[bool] = dump_bool
658
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000659 def dump_long(self, value, write):
Skip Montanaro5449e082001-10-17 22:53:33 +0000660 if value > MAXINT or value < MININT:
661 raise OverflowError, "long int exceeds XML-RPC limits"
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000662 write("<value><int>")
663 write(str(int(value)))
664 write("</int></value>\n")
Raymond Hettingerfe59dc12005-02-07 15:28:45 +0000665 dispatch[LongType] = dump_long
Skip Montanaro5e9c71b2001-10-10 15:56:34 +0000666
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000667 def dump_double(self, value, write):
668 write("<value><double>")
669 write(repr(value))
670 write("</double></value>\n")
Raymond Hettingerfe59dc12005-02-07 15:28:45 +0000671 dispatch[FloatType] = dump_double
Fredrik Lundhb9056332001-07-11 17:42:21 +0000672
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000673 def dump_string(self, value, write, escape=escape):
674 write("<value><string>")
675 write(escape(value))
676 write("</string></value>\n")
Raymond Hettingerfe59dc12005-02-07 15:28:45 +0000677 dispatch[StringType] = dump_string
Fredrik Lundhb9056332001-07-11 17:42:21 +0000678
679 if unicode:
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000680 def dump_unicode(self, value, write, escape=escape):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000681 value = value.encode(self.encoding)
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000682 write("<value><string>")
683 write(escape(value))
684 write("</string></value>\n")
Raymond Hettingerfe59dc12005-02-07 15:28:45 +0000685 dispatch[UnicodeType] = dump_unicode
Fredrik Lundhb9056332001-07-11 17:42:21 +0000686
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000687 def dump_array(self, value, write):
688 i = id(value)
689 if self.memo.has_key(i):
690 raise TypeError, "cannot marshal recursive sequences"
691 self.memo[i] = None
Fredrik Lundh1538c232001-10-01 19:42:03 +0000692 dump = self.__dump
Fredrik Lundhb9056332001-07-11 17:42:21 +0000693 write("<value><array><data>\n")
694 for v in value:
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000695 dump(v, write)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000696 write("</data></array></value>\n")
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000697 del self.memo[i]
Raymond Hettingerfe59dc12005-02-07 15:28:45 +0000698 dispatch[TupleType] = dump_array
699 dispatch[ListType] = dump_array
Fredrik Lundhb9056332001-07-11 17:42:21 +0000700
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000701 def dump_struct(self, value, write, escape=escape):
702 i = id(value)
703 if self.memo.has_key(i):
704 raise TypeError, "cannot marshal recursive dictionaries"
705 self.memo[i] = None
Fredrik Lundh1538c232001-10-01 19:42:03 +0000706 dump = self.__dump
Fredrik Lundhb9056332001-07-11 17:42:21 +0000707 write("<value><struct>\n")
Andrew M. Kuchling5962f452004-06-05 12:35:58 +0000708 for k, v in value.items():
Fredrik Lundhb9056332001-07-11 17:42:21 +0000709 write("<member>\n")
Raymond Hettingerfe59dc12005-02-07 15:28:45 +0000710 if type(k) is not StringType:
711 if unicode and type(k) is UnicodeType:
Andrew M. Kuchling5962f452004-06-05 12:35:58 +0000712 k = k.encode(self.encoding)
713 else:
714 raise TypeError, "dictionary key must be string"
Fredrik Lundh1538c232001-10-01 19:42:03 +0000715 write("<name>%s</name>\n" % escape(k))
Andrew M. Kuchling5962f452004-06-05 12:35:58 +0000716 dump(v, write)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000717 write("</member>\n")
718 write("</struct></value>\n")
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000719 del self.memo[i]
Raymond Hettingerfe59dc12005-02-07 15:28:45 +0000720 dispatch[DictType] = dump_struct
Fredrik Lundhb9056332001-07-11 17:42:21 +0000721
Fred Drakeba613c32005-02-10 18:33:30 +0000722 if datetime:
723 def dump_datetime(self, value, write):
724 write("<value><dateTime.iso8601>")
725 write(value.strftime("%Y%m%dT%H:%M:%S"))
726 write("</dateTime.iso8601></value>\n")
727 dispatch[datetime.datetime] = dump_datetime
728
Skip Montanaro174dd222005-05-14 20:54:16 +0000729 def dump_date(self, value, write):
730 write("<value><dateTime.iso8601>")
731 write(value.strftime("%Y%m%dT00:00:00"))
732 write("</dateTime.iso8601></value>\n")
733 dispatch[datetime.date] = dump_date
734
735 def dump_time(self, value, write):
736 write("<value><dateTime.iso8601>")
737 write(datetime.datetime.now().date().strftime("%Y%m%dT"))
738 write(value.strftime("%H:%M:%S"))
739 write("</dateTime.iso8601></value>\n")
740 dispatch[datetime.time] = dump_time
741
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000742 def dump_instance(self, value, write):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000743 # check for special wrappers
744 if value.__class__ in WRAPPERS:
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000745 self.write = write
Fredrik Lundhb9056332001-07-11 17:42:21 +0000746 value.encode(self)
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000747 del self.write
Fredrik Lundhb9056332001-07-11 17:42:21 +0000748 else:
749 # store instance attributes as a struct (really?)
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000750 self.dump_struct(value.__dict__, write)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000751 dispatch[InstanceType] = dump_instance
752
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000753##
754# XML-RPC unmarshaller.
755#
756# @see loads
757
Fredrik Lundhb9056332001-07-11 17:42:21 +0000758class Unmarshaller:
Fred Drake1b410792001-09-04 18:55:03 +0000759 """Unmarshal an XML-RPC response, based on incoming XML event
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +0000760 messages (start, data, end). Call close() to get the resulting
Fred Drake1b410792001-09-04 18:55:03 +0000761 data structure.
Fredrik Lundhb9056332001-07-11 17:42:21 +0000762
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +0000763 Note that this reader is fairly tolerant, and gladly accepts bogus
764 XML-RPC data without complaining (but not bogus XML).
Fred Drake1b410792001-09-04 18:55:03 +0000765 """
Fredrik Lundhb9056332001-07-11 17:42:21 +0000766
767 # and again, if you don't understand what's going on in here,
768 # that's perfectly ok.
769
Skip Montanaro174dd222005-05-14 20:54:16 +0000770 def __init__(self, use_datetime=0):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000771 self._type = None
772 self._stack = []
773 self._marks = []
774 self._data = []
775 self._methodname = None
776 self._encoding = "utf-8"
777 self.append = self._stack.append
Skip Montanaro174dd222005-05-14 20:54:16 +0000778 self._use_datetime = use_datetime
779 if use_datetime and not datetime:
780 raise ValueError, "the datetime module is not available"
Fredrik Lundhb9056332001-07-11 17:42:21 +0000781
782 def close(self):
783 # return response tuple and target method
784 if self._type is None or self._marks:
785 raise ResponseError()
786 if self._type == "fault":
Guido van Rossum68468eb2003-02-27 20:14:51 +0000787 raise Fault(**self._stack[0])
Fredrik Lundhb9056332001-07-11 17:42:21 +0000788 return tuple(self._stack)
789
790 def getmethodname(self):
791 return self._methodname
792
793 #
794 # event handlers
795
796 def xml(self, encoding, standalone):
797 self._encoding = encoding
798 # FIXME: assert standalone == 1 ???
799
800 def start(self, tag, attrs):
801 # prepare to handle this element
802 if tag == "array" or tag == "struct":
803 self._marks.append(len(self._stack))
804 self._data = []
805 self._value = (tag == "value")
806
807 def data(self, text):
808 self._data.append(text)
809
Fredrik Lundh1538c232001-10-01 19:42:03 +0000810 def end(self, tag, join=string.join):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000811 # call the appropriate end tag handler
812 try:
813 f = self.dispatch[tag]
814 except KeyError:
815 pass # unknown tag ?
816 else:
Fredrik Lundh1538c232001-10-01 19:42:03 +0000817 return f(self, join(self._data, ""))
Fredrik Lundhb9056332001-07-11 17:42:21 +0000818
819 #
820 # accelerator support
821
822 def end_dispatch(self, tag, data):
823 # dispatch data
824 try:
825 f = self.dispatch[tag]
826 except KeyError:
827 pass # unknown tag ?
828 else:
829 return f(self, data)
830
831 #
832 # element decoders
833
834 dispatch = {}
835
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +0000836 def end_nil (self, data):
837 self.append(None)
838 self._value = 0
839 dispatch["nil"] = end_nil
Tim Petersc2659cf2003-05-12 20:19:37 +0000840
Fredrik Lundh1538c232001-10-01 19:42:03 +0000841 def end_boolean(self, data):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000842 if data == "0":
843 self.append(False)
844 elif data == "1":
845 self.append(True)
846 else:
847 raise TypeError, "bad boolean value"
848 self._value = 0
849 dispatch["boolean"] = end_boolean
850
Fredrik Lundh1538c232001-10-01 19:42:03 +0000851 def end_int(self, data):
852 self.append(int(data))
Fredrik Lundhb9056332001-07-11 17:42:21 +0000853 self._value = 0
854 dispatch["i4"] = end_int
855 dispatch["int"] = end_int
856
Fredrik Lundh1538c232001-10-01 19:42:03 +0000857 def end_double(self, data):
858 self.append(float(data))
Fredrik Lundhb9056332001-07-11 17:42:21 +0000859 self._value = 0
860 dispatch["double"] = end_double
861
Fredrik Lundh1538c232001-10-01 19:42:03 +0000862 def end_string(self, data):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000863 if self._encoding:
864 data = _decode(data, self._encoding)
865 self.append(_stringify(data))
866 self._value = 0
867 dispatch["string"] = end_string
868 dispatch["name"] = end_string # struct keys are always strings
869
870 def end_array(self, data):
Raymond Hettinger46ac8eb2002-06-30 03:39:14 +0000871 mark = self._marks.pop()
Fredrik Lundhb9056332001-07-11 17:42:21 +0000872 # map arrays to Python lists
873 self._stack[mark:] = [self._stack[mark:]]
874 self._value = 0
875 dispatch["array"] = end_array
876
877 def end_struct(self, data):
Raymond Hettinger46ac8eb2002-06-30 03:39:14 +0000878 mark = self._marks.pop()
Fredrik Lundhb9056332001-07-11 17:42:21 +0000879 # map structs to Python dictionaries
880 dict = {}
881 items = self._stack[mark:]
882 for i in range(0, len(items), 2):
883 dict[_stringify(items[i])] = items[i+1]
884 self._stack[mark:] = [dict]
885 self._value = 0
886 dispatch["struct"] = end_struct
887
Fredrik Lundh1538c232001-10-01 19:42:03 +0000888 def end_base64(self, data):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000889 value = Binary()
Fredrik Lundh1538c232001-10-01 19:42:03 +0000890 value.decode(data)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000891 self.append(value)
892 self._value = 0
893 dispatch["base64"] = end_base64
894
Fredrik Lundh1538c232001-10-01 19:42:03 +0000895 def end_dateTime(self, data):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000896 value = DateTime()
Fredrik Lundh1538c232001-10-01 19:42:03 +0000897 value.decode(data)
Skip Montanaro174dd222005-05-14 20:54:16 +0000898 if self._use_datetime:
899 value = _datetime_type(data)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000900 self.append(value)
901 dispatch["dateTime.iso8601"] = end_dateTime
902
903 def end_value(self, data):
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000904 # if we stumble upon a value element with no internal
Fredrik Lundhb9056332001-07-11 17:42:21 +0000905 # elements, treat it as a string element
906 if self._value:
907 self.end_string(data)
908 dispatch["value"] = end_value
909
910 def end_params(self, data):
911 self._type = "params"
912 dispatch["params"] = end_params
913
914 def end_fault(self, data):
915 self._type = "fault"
916 dispatch["fault"] = end_fault
917
Fredrik Lundh1538c232001-10-01 19:42:03 +0000918 def end_methodName(self, data):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000919 if self._encoding:
920 data = _decode(data, self._encoding)
921 self._methodname = data
922 self._type = "methodName" # no params
923 dispatch["methodName"] = end_methodName
924
Martin v. Löwis45394c22003-10-31 13:49:36 +0000925## Multicall support
926#
Fredrik Lundhb9056332001-07-11 17:42:21 +0000927
Martin v. Löwis45394c22003-10-31 13:49:36 +0000928class _MultiCallMethod:
929 # some lesser magic to store calls made to a MultiCall object
930 # for batch execution
931 def __init__(self, call_list, name):
932 self.__call_list = call_list
933 self.__name = name
934 def __getattr__(self, name):
935 return _MultiCallMethod(self.__call_list, "%s.%s" % (self.__name, name))
936 def __call__(self, *args):
937 self.__call_list.append((self.__name, args))
938
Martin v. Löwis12237b32004-08-22 16:04:50 +0000939class MultiCallIterator:
Martin v. Löwis45394c22003-10-31 13:49:36 +0000940 """Iterates over the results of a multicall. Exceptions are
941 thrown in response to xmlrpc faults."""
Raymond Hettingercc523fc2003-11-02 09:47:05 +0000942
Martin v. Löwis12237b32004-08-22 16:04:50 +0000943 def __init__(self, results):
944 self.results = results
945
946 def __getitem__(self, i):
947 item = self.results[i]
948 if type(item) == type({}):
949 raise Fault(item['faultCode'], item['faultString'])
950 elif type(item) == type([]):
951 return item[0]
Martin v. Löwis45394c22003-10-31 13:49:36 +0000952 else:
953 raise ValueError,\
954 "unexpected type in multicall result"
Raymond Hettingercc523fc2003-11-02 09:47:05 +0000955
Martin v. Löwis45394c22003-10-31 13:49:36 +0000956class MultiCall:
957 """server -> a object used to boxcar method calls
958
959 server should be a ServerProxy object.
960
961 Methods can be added to the MultiCall using normal
962 method call syntax e.g.:
963
964 multicall = MultiCall(server_proxy)
965 multicall.add(2,3)
966 multicall.get_address("Guido")
967
968 To execute the multicall, call the MultiCall object e.g.:
969
970 add_result, address = multicall()
971 """
Raymond Hettingercc523fc2003-11-02 09:47:05 +0000972
Martin v. Löwis45394c22003-10-31 13:49:36 +0000973 def __init__(self, server):
974 self.__server = server
975 self.__call_list = []
Raymond Hettingercc523fc2003-11-02 09:47:05 +0000976
Martin v. Löwis45394c22003-10-31 13:49:36 +0000977 def __repr__(self):
978 return "<MultiCall at %x>" % id(self)
Raymond Hettingercc523fc2003-11-02 09:47:05 +0000979
Martin v. Löwis45394c22003-10-31 13:49:36 +0000980 __str__ = __repr__
981
982 def __getattr__(self, name):
983 return _MultiCallMethod(self.__call_list, name)
984
985 def __call__(self):
986 marshalled_list = []
987 for name, args in self.__call_list:
988 marshalled_list.append({'methodName' : name, 'params' : args})
989
990 return MultiCallIterator(self.__server.system.multicall(marshalled_list))
Raymond Hettingercc523fc2003-11-02 09:47:05 +0000991
Fredrik Lundhb9056332001-07-11 17:42:21 +0000992# --------------------------------------------------------------------
993# convenience functions
994
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000995##
996# Create a parser object, and connect it to an unmarshalling instance.
997# This function picks the fastest available XML parser.
998#
999# return A (parser, unmarshaller) tuple.
1000
Skip Montanaro174dd222005-05-14 20:54:16 +00001001def getparser(use_datetime=0):
Fredrik Lundhb9056332001-07-11 17:42:21 +00001002 """getparser() -> parser, unmarshaller
1003
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +00001004 Create an instance of the fastest available parser, and attach it
1005 to an unmarshalling object. Return both objects.
Fredrik Lundhb9056332001-07-11 17:42:21 +00001006 """
Skip Montanaro174dd222005-05-14 20:54:16 +00001007 if use_datetime and not datetime:
1008 raise ValueError, "the datetime module is not available"
Fredrik Lundhb9056332001-07-11 17:42:21 +00001009 if FastParser and FastUnmarshaller:
Skip Montanaro174dd222005-05-14 20:54:16 +00001010 if use_datetime:
1011 mkdatetime = _datetime_type
1012 else:
1013 mkdatetime = _datetime
1014 target = FastUnmarshaller(True, False, _binary, mkdatetime, Fault)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001015 parser = FastParser(target)
1016 else:
Skip Montanaro174dd222005-05-14 20:54:16 +00001017 target = Unmarshaller(use_datetime=use_datetime)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001018 if FastParser:
1019 parser = FastParser(target)
1020 elif SgmlopParser:
1021 parser = SgmlopParser(target)
1022 elif ExpatParser:
1023 parser = ExpatParser(target)
1024 else:
1025 parser = SlowParser(target)
1026 return parser, target
1027
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001028##
1029# Convert a Python tuple or a Fault instance to an XML-RPC packet.
1030#
1031# @def dumps(params, **options)
1032# @param params A tuple or Fault instance.
1033# @keyparam methodname If given, create a methodCall request for
1034# this method name.
1035# @keyparam methodresponse If given, create a methodResponse packet.
1036# If used with a tuple, the tuple must be a singleton (that is,
1037# it must contain exactly one element).
1038# @keyparam encoding The packet encoding.
1039# @return A string containing marshalled data.
1040
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +00001041def dumps(params, methodname=None, methodresponse=None, encoding=None,
1042 allow_none=0):
Fredrik Lundhb9056332001-07-11 17:42:21 +00001043 """data [,options] -> marshalled data
1044
1045 Convert an argument tuple or a Fault instance to an XML-RPC
1046 request (or response, if the methodresponse option is used).
1047
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +00001048 In addition to the data object, the following options can be given
1049 as keyword arguments:
Fredrik Lundhb9056332001-07-11 17:42:21 +00001050
1051 methodname: the method name for a methodCall packet
1052
1053 methodresponse: true to create a methodResponse packet.
1054 If this option is used with a tuple, the tuple must be
1055 a singleton (i.e. it can contain only one element).
1056
1057 encoding: the packet encoding (default is UTF-8)
1058
1059 All 8-bit strings in the data structure are assumed to use the
1060 packet encoding. Unicode strings are automatically converted,
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +00001061 where necessary.
Fredrik Lundhb9056332001-07-11 17:42:21 +00001062 """
1063
Raymond Hettingerfe59dc12005-02-07 15:28:45 +00001064 assert isinstance(params, TupleType) or isinstance(params, Fault),\
Fredrik Lundhb9056332001-07-11 17:42:21 +00001065 "argument must be tuple or Fault instance"
1066
1067 if isinstance(params, Fault):
1068 methodresponse = 1
Raymond Hettingerfe59dc12005-02-07 15:28:45 +00001069 elif methodresponse and isinstance(params, TupleType):
Fredrik Lundhb9056332001-07-11 17:42:21 +00001070 assert len(params) == 1, "response tuple must be a singleton"
1071
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001072 if not encoding:
Fredrik Lundhb9056332001-07-11 17:42:21 +00001073 encoding = "utf-8"
1074
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001075 if FastMarshaller:
1076 m = FastMarshaller(encoding)
1077 else:
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +00001078 m = Marshaller(encoding, allow_none)
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001079
Fredrik Lundhb9056332001-07-11 17:42:21 +00001080 data = m.dumps(params)
1081
1082 if encoding != "utf-8":
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001083 xmlheader = "<?xml version='1.0' encoding='%s'?>\n" % str(encoding)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001084 else:
1085 xmlheader = "<?xml version='1.0'?>\n" # utf-8 is default
1086
1087 # standard XML-RPC wrappings
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001088 if methodname:
Fredrik Lundhb9056332001-07-11 17:42:21 +00001089 # a method call
Raymond Hettingerfe59dc12005-02-07 15:28:45 +00001090 if not isinstance(methodname, StringType):
Fredrik Lundhb9056332001-07-11 17:42:21 +00001091 methodname = methodname.encode(encoding)
1092 data = (
1093 xmlheader,
1094 "<methodCall>\n"
1095 "<methodName>", methodname, "</methodName>\n",
1096 data,
1097 "</methodCall>\n"
1098 )
1099 elif methodresponse:
1100 # a method response, or a fault structure
1101 data = (
1102 xmlheader,
1103 "<methodResponse>\n",
1104 data,
1105 "</methodResponse>\n"
1106 )
1107 else:
1108 return data # return as is
1109 return string.join(data, "")
1110
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001111##
1112# Convert an XML-RPC packet to a Python object. If the XML-RPC packet
1113# represents a fault condition, this function raises a Fault exception.
1114#
1115# @param data An XML-RPC packet, given as an 8-bit string.
Walter Dörwaldf0dfc7a2003-10-20 14:01:56 +00001116# @return A tuple containing the unpacked data, and the method name
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001117# (None if not present).
1118# @see Fault
1119
Skip Montanaro174dd222005-05-14 20:54:16 +00001120def loads(data, use_datetime=0):
Fredrik Lundhb9056332001-07-11 17:42:21 +00001121 """data -> unmarshalled data, method name
1122
1123 Convert an XML-RPC packet to unmarshalled data plus a method
1124 name (None if not present).
1125
1126 If the XML-RPC packet represents a fault condition, this function
1127 raises a Fault exception.
1128 """
Skip Montanaro174dd222005-05-14 20:54:16 +00001129 p, u = getparser(use_datetime=use_datetime)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001130 p.feed(data)
1131 p.close()
1132 return u.close(), u.getmethodname()
1133
1134
1135# --------------------------------------------------------------------
1136# request dispatcher
1137
1138class _Method:
1139 # some magic to bind an XML-RPC method to an RPC server.
1140 # supports "nested" methods (e.g. examples.getStateName)
1141 def __init__(self, send, name):
1142 self.__send = send
1143 self.__name = name
1144 def __getattr__(self, name):
1145 return _Method(self.__send, "%s.%s" % (self.__name, name))
1146 def __call__(self, *args):
1147 return self.__send(self.__name, args)
1148
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001149##
1150# Standard transport class for XML-RPC over HTTP.
1151# <p>
1152# You can create custom transports by subclassing this method, and
1153# overriding selected methods.
Fredrik Lundhb9056332001-07-11 17:42:21 +00001154
1155class Transport:
Fredrik Lundhc4c062f2001-09-10 19:45:02 +00001156 """Handles an HTTP transaction to an XML-RPC server."""
Fredrik Lundhb9056332001-07-11 17:42:21 +00001157
1158 # client identifier (may be overridden)
1159 user_agent = "xmlrpclib.py/%s (by www.pythonware.com)" % __version__
1160
Skip Montanaro174dd222005-05-14 20:54:16 +00001161 def __init__(self, use_datetime=0):
1162 self._use_datetime = use_datetime
1163
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001164 ##
1165 # Send a complete request, and parse the response.
1166 #
1167 # @param host Target host.
1168 # @param handler Target PRC handler.
1169 # @param request_body XML-RPC request body.
1170 # @param verbose Debugging flag.
1171 # @return Parsed response.
1172
Fredrik Lundhb9056332001-07-11 17:42:21 +00001173 def request(self, host, handler, request_body, verbose=0):
1174 # issue XML-RPC request
1175
1176 h = self.make_connection(host)
1177 if verbose:
1178 h.set_debuglevel(1)
1179
1180 self.send_request(h, handler, request_body)
1181 self.send_host(h, host)
1182 self.send_user_agent(h)
1183 self.send_content(h, request_body)
1184
1185 errcode, errmsg, headers = h.getreply()
1186
1187 if errcode != 200:
1188 raise ProtocolError(
1189 host + handler,
1190 errcode, errmsg,
1191 headers
1192 )
1193
1194 self.verbose = verbose
1195
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001196 try:
1197 sock = h._conn.sock
1198 except AttributeError:
1199 sock = None
1200
1201 return self._parse_response(h.getfile(), sock)
1202
1203 ##
1204 # Create parser.
1205 #
1206 # @return A 2-tuple containing a parser and a unmarshaller.
Fredrik Lundhb9056332001-07-11 17:42:21 +00001207
Fredrik Lundhc4c062f2001-09-10 19:45:02 +00001208 def getparser(self):
1209 # get parser and unmarshaller
Skip Montanaro174dd222005-05-14 20:54:16 +00001210 return getparser(use_datetime=self._use_datetime)
Fredrik Lundhc4c062f2001-09-10 19:45:02 +00001211
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001212 ##
Fredrik Lundh1303c7c2002-10-22 18:23:00 +00001213 # Get authorization info from host parameter
1214 # Host may be a string, or a (host, x509-dict) tuple; if a string,
1215 # it is checked for a "user:pw@host" format, and a "Basic
1216 # Authentication" header is added if appropriate.
1217 #
1218 # @param host Host descriptor (URL or (URL, x509 info) tuple).
1219 # @return A 3-tuple containing (actual host, extra headers,
1220 # x509 info). The header and x509 fields may be None.
1221
1222 def get_host_info(self, host):
1223
1224 x509 = {}
Raymond Hettingerfe59dc12005-02-07 15:28:45 +00001225 if isinstance(host, TupleType):
Fredrik Lundh1303c7c2002-10-22 18:23:00 +00001226 host, x509 = host
1227
1228 import urllib
1229 auth, host = urllib.splituser(host)
1230
1231 if auth:
1232 import base64
Fredrik Lundh768c98b2002-11-01 17:14:16 +00001233 auth = base64.encodestring(urllib.unquote(auth))
Fredrik Lundh1303c7c2002-10-22 18:23:00 +00001234 auth = string.join(string.split(auth), "") # get rid of whitespace
1235 extra_headers = [
1236 ("Authorization", "Basic " + auth)
1237 ]
1238 else:
1239 extra_headers = None
1240
1241 return host, extra_headers, x509
1242
1243 ##
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001244 # Connect to server.
1245 #
1246 # @param host Target host.
1247 # @return A connection handle.
1248
Fredrik Lundhb9056332001-07-11 17:42:21 +00001249 def make_connection(self, host):
1250 # create a HTTP connection object from a host descriptor
1251 import httplib
Fredrik Lundh1303c7c2002-10-22 18:23:00 +00001252 host, extra_headers, x509 = self.get_host_info(host)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001253 return httplib.HTTP(host)
1254
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001255 ##
1256 # Send request header.
1257 #
1258 # @param connection Connection handle.
1259 # @param handler Target RPC handler.
1260 # @param request_body XML-RPC body.
1261
Fredrik Lundhb9056332001-07-11 17:42:21 +00001262 def send_request(self, connection, handler, request_body):
1263 connection.putrequest("POST", handler)
1264
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001265 ##
1266 # Send host name.
1267 #
1268 # @param connection Connection handle.
1269 # @param host Host name.
1270
Fredrik Lundhb9056332001-07-11 17:42:21 +00001271 def send_host(self, connection, host):
Fredrik Lundh1303c7c2002-10-22 18:23:00 +00001272 host, extra_headers, x509 = self.get_host_info(host)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001273 connection.putheader("Host", host)
Fredrik Lundh1303c7c2002-10-22 18:23:00 +00001274 if extra_headers:
Raymond Hettingerfe59dc12005-02-07 15:28:45 +00001275 if isinstance(extra_headers, DictType):
Fredrik Lundh1303c7c2002-10-22 18:23:00 +00001276 extra_headers = extra_headers.items()
1277 for key, value in extra_headers:
1278 connection.putheader(key, value)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001279
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001280 ##
1281 # Send user-agent identifier.
1282 #
1283 # @param connection Connection handle.
1284
Fredrik Lundhb9056332001-07-11 17:42:21 +00001285 def send_user_agent(self, connection):
1286 connection.putheader("User-Agent", self.user_agent)
1287
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001288 ##
1289 # Send request body.
1290 #
1291 # @param connection Connection handle.
1292 # @param request_body XML-RPC request body.
1293
Fredrik Lundhb9056332001-07-11 17:42:21 +00001294 def send_content(self, connection, request_body):
1295 connection.putheader("Content-Type", "text/xml")
1296 connection.putheader("Content-Length", str(len(request_body)))
1297 connection.endheaders()
1298 if request_body:
1299 connection.send(request_body)
1300
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001301 ##
1302 # Parse response.
1303 #
1304 # @param file Stream.
1305 # @return Response tuple and target method.
1306
1307 def parse_response(self, file):
1308 # compatibility interface
1309 return self._parse_response(file, None)
1310
1311 ##
1312 # Parse response (alternate interface). This is similar to the
1313 # parse_response method, but also provides direct access to the
1314 # underlying socket object (where available).
1315 #
1316 # @param file Stream.
1317 # @param sock Socket handle (or None, if the socket object
1318 # could not be accessed).
1319 # @return Response tuple and target method.
1320
1321 def _parse_response(self, file, sock):
1322 # read response from input file/socket, and parse it
Fredrik Lundhb9056332001-07-11 17:42:21 +00001323
Fredrik Lundhc4c062f2001-09-10 19:45:02 +00001324 p, u = self.getparser()
Fredrik Lundhb9056332001-07-11 17:42:21 +00001325
1326 while 1:
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001327 if sock:
1328 response = sock.recv(1024)
1329 else:
1330 response = file.read(1024)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001331 if not response:
1332 break
1333 if self.verbose:
1334 print "body:", repr(response)
1335 p.feed(response)
1336
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001337 file.close()
Fredrik Lundhb9056332001-07-11 17:42:21 +00001338 p.close()
1339
1340 return u.close()
1341
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001342##
1343# Standard transport class for XML-RPC over HTTPS.
1344
Fredrik Lundhb9056332001-07-11 17:42:21 +00001345class SafeTransport(Transport):
Fredrik Lundhc4c062f2001-09-10 19:45:02 +00001346 """Handles an HTTPS transaction to an XML-RPC server."""
Fredrik Lundhb9056332001-07-11 17:42:21 +00001347
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001348 # FIXME: mostly untested
1349
Fredrik Lundhb9056332001-07-11 17:42:21 +00001350 def make_connection(self, host):
1351 # create a HTTPS connection object from a host descriptor
1352 # host may be a string, or a (host, x509-dict) tuple
1353 import httplib
Fredrik Lundh1303c7c2002-10-22 18:23:00 +00001354 host, extra_headers, x509 = self.get_host_info(host)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001355 try:
1356 HTTPS = httplib.HTTPS
1357 except AttributeError:
Fredrik Lundh1303c7c2002-10-22 18:23:00 +00001358 raise NotImplementedError(
1359 "your version of httplib doesn't support HTTPS"
1360 )
Fredrik Lundhb9056332001-07-11 17:42:21 +00001361 else:
Guido van Rossum68468eb2003-02-27 20:14:51 +00001362 return HTTPS(host, None, **(x509 or {}))
Fredrik Lundhb9056332001-07-11 17:42:21 +00001363
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001364##
1365# Standard server proxy. This class establishes a virtual connection
1366# to an XML-RPC server.
1367# <p>
1368# This class is available as ServerProxy and Server. New code should
1369# use ServerProxy, to avoid confusion.
1370#
1371# @def ServerProxy(uri, **options)
1372# @param uri The connection point on the server.
1373# @keyparam transport A transport factory, compatible with the
1374# standard transport class.
1375# @keyparam encoding The default encoding used for 8-bit strings
1376# (default is UTF-8).
1377# @keyparam verbose Use a true value to enable debugging output.
1378# (printed to standard output).
1379# @see Transport
1380
Fredrik Lundhb9056332001-07-11 17:42:21 +00001381class ServerProxy:
1382 """uri [,options] -> a logical connection to an XML-RPC server
1383
1384 uri is the connection point on the server, given as
1385 scheme://host/target.
1386
1387 The standard implementation always supports the "http" scheme. If
1388 SSL socket support is available (Python 2.0), it also supports
1389 "https".
1390
1391 If the target part and the slash preceding it are both omitted,
1392 "/RPC2" is assumed.
1393
1394 The following options can be given as keyword arguments:
1395
1396 transport: a transport factory
1397 encoding: the request encoding (default is UTF-8)
1398
1399 All 8-bit strings passed to the server proxy are assumed to use
1400 the given encoding.
1401 """
1402
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +00001403 def __init__(self, uri, transport=None, encoding=None, verbose=0,
Skip Montanaro174dd222005-05-14 20:54:16 +00001404 allow_none=0, use_datetime=0):
Fredrik Lundhb9056332001-07-11 17:42:21 +00001405 # establish a "logical" server connection
1406
1407 # get the url
Fredrik Lundhc4c062f2001-09-10 19:45:02 +00001408 import urllib
Fredrik Lundhb9056332001-07-11 17:42:21 +00001409 type, uri = urllib.splittype(uri)
1410 if type not in ("http", "https"):
1411 raise IOError, "unsupported XML-RPC protocol"
1412 self.__host, self.__handler = urllib.splithost(uri)
1413 if not self.__handler:
1414 self.__handler = "/RPC2"
1415
1416 if transport is None:
1417 if type == "https":
Skip Montanaro174dd222005-05-14 20:54:16 +00001418 transport = SafeTransport(use_datetime=use_datetime)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001419 else:
Skip Montanaro174dd222005-05-14 20:54:16 +00001420 transport = Transport(use_datetime=use_datetime)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001421 self.__transport = transport
1422
1423 self.__encoding = encoding
1424 self.__verbose = verbose
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +00001425 self.__allow_none = allow_none
Tim Petersc2659cf2003-05-12 20:19:37 +00001426
Fredrik Lundhb9056332001-07-11 17:42:21 +00001427 def __request(self, methodname, params):
1428 # call a method on the remote server
1429
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +00001430 request = dumps(params, methodname, encoding=self.__encoding,
1431 allow_none=self.__allow_none)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001432
1433 response = self.__transport.request(
1434 self.__host,
1435 self.__handler,
1436 request,
1437 verbose=self.__verbose
1438 )
1439
1440 if len(response) == 1:
1441 response = response[0]
1442
1443 return response
1444
1445 def __repr__(self):
1446 return (
Fredrik Lundh78eedce2001-08-23 20:04:33 +00001447 "<ServerProxy for %s%s>" %
Fredrik Lundhb9056332001-07-11 17:42:21 +00001448 (self.__host, self.__handler)
1449 )
1450
1451 __str__ = __repr__
Raymond Hettingercc523fc2003-11-02 09:47:05 +00001452
Fredrik Lundhb9056332001-07-11 17:42:21 +00001453 def __getattr__(self, name):
1454 # magic method dispatcher
1455 return _Method(self.__request, name)
1456
1457 # note: to call a remote object with an non-standard name, use
1458 # result getattr(server, "strange-python-name")(args)
1459
Fredrik Lundh78eedce2001-08-23 20:04:33 +00001460# compatibility
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001461
Fredrik Lundhb9056332001-07-11 17:42:21 +00001462Server = ServerProxy
1463
1464# --------------------------------------------------------------------
1465# test code
1466
1467if __name__ == "__main__":
1468
1469 # simple test program (from the XML-RPC specification)
1470
Fredrik Lundh78eedce2001-08-23 20:04:33 +00001471 # server = ServerProxy("http://localhost:8000") # local server
Martin v. Löwis12237b32004-08-22 16:04:50 +00001472 server = ServerProxy("http://time.xmlrpc.com/RPC2")
Fredrik Lundhb9056332001-07-11 17:42:21 +00001473
1474 print server
1475
1476 try:
Martin v. Löwis12237b32004-08-22 16:04:50 +00001477 print server.currentTime.getCurrentTime()
1478 except Error, v:
1479 print "ERROR", v
1480
1481 multi = MultiCall(server)
1482 multi.currentTime.getCurrentTime()
1483 multi.currentTime.getCurrentTime()
1484 try:
1485 for response in multi():
1486 print response
Fredrik Lundhb9056332001-07-11 17:42:21 +00001487 except Error, v:
1488 print "ERROR", v