blob: ac36b62ca328e5fdf024bdc2360d52cac3a5c306 [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
Neal Norwitzff113342007-04-17 08:42:15 +0000139import re, time, operator
Jeremy Hylton5d8a88a2007-08-14 16:47:39 +0000140import httplib
Fredrik Lundh1538c232001-10-01 19:42:03 +0000141
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000142# --------------------------------------------------------------------
143# Internal stuff
144
Fredrik Lundhb9056332001-07-11 17:42:21 +0000145try:
Fred Drakeba613c32005-02-10 18:33:30 +0000146 import datetime
147except ImportError:
148 datetime = None
149
150try:
Skip Montanaro9a7c96a2003-01-22 18:17:25 +0000151 _bool_is_builtin = False.__class__.__name__ == "bool"
152except NameError:
153 _bool_is_builtin = 0
154
Fredrik Lundhb9056332001-07-11 17:42:21 +0000155def _decode(data, encoding, is8bit=re.compile("[\x80-\xff]").search):
156 # decode non-ascii string (if possible)
Guido van Rossum54ad5232007-05-27 09:17:48 +0000157 if encoding and is8bit(data):
Guido van Rossumef87d6e2007-05-02 19:09:54 +0000158 data = str(data, encoding)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000159 return data
160
Neal Norwitzff113342007-04-17 08:42:15 +0000161def escape(s):
162 s = s.replace("&", "&")
163 s = s.replace("<", "&lt;")
164 return s.replace(">", "&gt;",)
Fredrik Lundh1538c232001-10-01 19:42:03 +0000165
Guido van Rossum54ad5232007-05-27 09:17:48 +0000166def _stringify(string):
167 # convert to 7-bit ascii if possible
168 try:
Brett Cannon2dbde5e2007-07-30 03:50:35 +0000169 return string.decode("ascii")
Guido van Rossum25a29a92007-08-27 22:31:36 +0000170 except (UnicodeError, TypeError):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000171 return string
172
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000173__version__ = "1.0.1"
174
175# xmlrpc integer limits
Guido van Rossume2a383d2007-01-15 16:59:06 +0000176MAXINT = 2**31-1
177MININT = -2**31
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000178
179# --------------------------------------------------------------------
180# Error constants (from Dan Libby's specification at
181# http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php)
182
183# Ranges of errors
184PARSE_ERROR = -32700
185SERVER_ERROR = -32600
186APPLICATION_ERROR = -32500
187SYSTEM_ERROR = -32400
188TRANSPORT_ERROR = -32300
189
190# Specific errors
191NOT_WELLFORMED_ERROR = -32700
192UNSUPPORTED_ENCODING = -32701
193INVALID_ENCODING_CHAR = -32702
194INVALID_XMLRPC = -32600
195METHOD_NOT_FOUND = -32601
196INVALID_METHOD_PARAMS = -32602
197INTERNAL_ERROR = -32603
Fredrik Lundhb9056332001-07-11 17:42:21 +0000198
199# --------------------------------------------------------------------
200# Exceptions
201
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000202##
203# Base class for all kinds of client-side errors.
204
Fredrik Lundh78eedce2001-08-23 20:04:33 +0000205class Error(Exception):
Fred Drake1b410792001-09-04 18:55:03 +0000206 """Base class for client errors."""
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +0000207 def __str__(self):
208 return repr(self)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000209
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000210##
211# Indicates an HTTP-level protocol error. This is raised by the HTTP
212# transport layer, if the server returns an error code other than 200
213# (OK).
214#
215# @param url The target URL.
216# @param errcode The HTTP error code.
217# @param errmsg The HTTP error message.
218# @param headers The HTTP header dictionary.
219
Fredrik Lundhb9056332001-07-11 17:42:21 +0000220class ProtocolError(Error):
Fred Drake1b410792001-09-04 18:55:03 +0000221 """Indicates an HTTP protocol error."""
Fredrik Lundhb9056332001-07-11 17:42:21 +0000222 def __init__(self, url, errcode, errmsg, headers):
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +0000223 Error.__init__(self)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000224 self.url = url
225 self.errcode = errcode
226 self.errmsg = errmsg
227 self.headers = headers
228 def __repr__(self):
229 return (
230 "<ProtocolError for %s: %s %s>" %
231 (self.url, self.errcode, self.errmsg)
232 )
233
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000234##
235# Indicates a broken XML-RPC response package. This exception is
236# raised by the unmarshalling layer, if the XML-RPC response is
237# malformed.
238
Fredrik Lundhb9056332001-07-11 17:42:21 +0000239class ResponseError(Error):
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000240 """Indicates a broken response package."""
Fredrik Lundhb9056332001-07-11 17:42:21 +0000241 pass
242
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000243##
244# Indicates an XML-RPC fault response package. This exception is
245# raised by the unmarshalling layer, if the XML-RPC response contains
246# a fault string. This exception can also used as a class, to
247# generate a fault XML-RPC message.
248#
249# @param faultCode The XML-RPC fault code.
250# @param faultString The XML-RPC fault string.
251
Fredrik Lundhb9056332001-07-11 17:42:21 +0000252class Fault(Error):
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000253 """Indicates an XML-RPC fault package."""
Fredrik Lundhb9056332001-07-11 17:42:21 +0000254 def __init__(self, faultCode, faultString, **extra):
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +0000255 Error.__init__(self)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000256 self.faultCode = faultCode
257 self.faultString = faultString
258 def __repr__(self):
259 return (
260 "<Fault %s: %s>" %
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +0000261 (self.faultCode, repr(self.faultString))
Fredrik Lundhb9056332001-07-11 17:42:21 +0000262 )
263
264# --------------------------------------------------------------------
265# Special values
266
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000267##
268# Wrapper for XML-RPC boolean values. Use the xmlrpclib.True and
269# xmlrpclib.False constants, or the xmlrpclib.boolean() function, to
270# generate boolean XML-RPC values.
271#
272# @param value A boolean value. Any true value is interpreted as True,
273# all other values are interpreted as False.
274
Guido van Rossum47b9ff62006-08-24 00:41:19 +0000275boolean = Boolean = bool
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000276
277##
278# Wrapper for XML-RPC DateTime values. This converts a time value to
279# the format used by XML-RPC.
280# <p>
281# The value can be given as a string in the format
282# "yyyymmddThh:mm:ss", as a 9-item time tuple (as returned by
283# time.localtime()), or an integer value (as returned by time.time()).
284# The wrapper uses time.localtime() to convert an integer to a time
285# tuple.
286#
287# @param value The time, given as an ISO 8601 string, a time
288# tuple, or a integer time value.
Fredrik Lundhb9056332001-07-11 17:42:21 +0000289
Fredrik Lundhb9056332001-07-11 17:42:21 +0000290class DateTime:
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000291 """DateTime wrapper for an ISO 8601 string or time tuple or
292 localtime integer value to generate 'dateTime.iso8601' XML-RPC
293 value.
294 """
Fredrik Lundhb9056332001-07-11 17:42:21 +0000295
296 def __init__(self, value=0):
Guido van Rossum54ad5232007-05-27 09:17:48 +0000297 if not isinstance(value, basestring):
Fred Drakeba613c32005-02-10 18:33:30 +0000298 if datetime and isinstance(value, datetime.datetime):
299 self.value = value.strftime("%Y%m%dT%H:%M:%S")
300 return
Skip Montanaro174dd222005-05-14 20:54:16 +0000301 if datetime and isinstance(value, datetime.date):
302 self.value = value.strftime("%Y%m%dT%H:%M:%S")
303 return
304 if datetime and isinstance(value, datetime.time):
305 today = datetime.datetime.now().strftime("%Y%m%d")
306 self.value = value.strftime(today+"T%H:%M:%S")
307 return
Guido van Rossum13257902007-06-07 23:15:56 +0000308 if not isinstance(value, (tuple, time.struct_time)):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000309 if value == 0:
310 value = time.time()
311 value = time.localtime(value)
312 value = time.strftime("%Y%m%dT%H:%M:%S", value)
313 self.value = value
314
Guido van Rossum47b9ff62006-08-24 00:41:19 +0000315 def __eq__(self, other):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000316 if isinstance(other, DateTime):
317 other = other.value
Guido van Rossum47b9ff62006-08-24 00:41:19 +0000318 return self.value == other
319
320 def __ne__(self, other):
321 if isinstance(other, DateTime):
322 other = other.value
323 return self.value != other
Fredrik Lundhb9056332001-07-11 17:42:21 +0000324
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000325 ##
326 # Get date/time value.
327 #
328 # @return Date/time value, as an ISO 8601 string.
329
330 def __str__(self):
331 return self.value
332
Fredrik Lundhb9056332001-07-11 17:42:21 +0000333 def __repr__(self):
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000334 return "<DateTime %s at %x>" % (repr(self.value), id(self))
Fredrik Lundhb9056332001-07-11 17:42:21 +0000335
336 def decode(self, data):
Neal Norwitzff113342007-04-17 08:42:15 +0000337 self.value = str(data).strip()
Fredrik Lundhb9056332001-07-11 17:42:21 +0000338
339 def encode(self, out):
340 out.write("<value><dateTime.iso8601>")
341 out.write(self.value)
342 out.write("</dateTime.iso8601></value>\n")
343
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000344def _datetime(data):
345 # decode xml element contents into a DateTime structure.
Fredrik Lundhb9056332001-07-11 17:42:21 +0000346 value = DateTime()
347 value.decode(data)
348 return value
349
Skip Montanaro174dd222005-05-14 20:54:16 +0000350def _datetime_type(data):
351 t = time.strptime(data, "%Y%m%dT%H:%M:%S")
352 return datetime.datetime(*tuple(t)[:6])
353
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000354##
355# Wrapper for binary data. This can be used to transport any kind
356# of binary data over XML-RPC, using BASE64 encoding.
357#
358# @param data An 8-bit string containing arbitrary data.
359
Skip Montanarobfcbfa72003-04-24 19:51:31 +0000360import base64
Guido van Rossum68937b42007-05-18 00:51:22 +0000361import io
Skip Montanarobfcbfa72003-04-24 19:51:31 +0000362
Fredrik Lundhb9056332001-07-11 17:42:21 +0000363class Binary:
Fred Drake1b410792001-09-04 18:55:03 +0000364 """Wrapper for binary data."""
Fredrik Lundhb9056332001-07-11 17:42:21 +0000365
366 def __init__(self, data=None):
Guido van Rossum54a40cb2007-08-27 22:27:41 +0000367 if data is None:
368 data = b""
369 else:
370 if not isinstance(data, bytes):
371 raise TypeError("expected bytes, not %s" %
372 data.__class__.__name__)
373 data = bytes(data) # Make a copy of the bytes!
Fredrik Lundhb9056332001-07-11 17:42:21 +0000374 self.data = data
375
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000376 ##
377 # Get buffer contents.
378 #
379 # @return Buffer contents, as an 8-bit string.
380
381 def __str__(self):
Guido van Rossum54a40cb2007-08-27 22:27:41 +0000382 return str(self.data, "latin-1") # XXX encoding?!
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000383
Guido van Rossum47b9ff62006-08-24 00:41:19 +0000384 def __eq__(self, other):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000385 if isinstance(other, Binary):
386 other = other.data
Guido van Rossum47b9ff62006-08-24 00:41:19 +0000387 return self.data == other
388
389 def __ne__(self, other):
390 if isinstance(other, Binary):
391 other = other.data
392 return self.data != other
Fredrik Lundhb9056332001-07-11 17:42:21 +0000393
394 def decode(self, data):
Guido van Rossum54a40cb2007-08-27 22:27:41 +0000395 self.data = base64.decodestring(data)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000396
397 def encode(self, out):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000398 out.write("<value><base64>\n")
Brett Cannon2dbde5e2007-07-30 03:50:35 +0000399 encoded = base64.encodestring(self.data)
400 out.write(encoded.decode('ascii'))
401 out.write('\n')
Fredrik Lundhb9056332001-07-11 17:42:21 +0000402 out.write("</base64></value>\n")
403
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000404def _binary(data):
405 # decode xml element contents into a Binary structure
Fredrik Lundhb9056332001-07-11 17:42:21 +0000406 value = Binary()
407 value.decode(data)
408 return value
409
Skip Montanaro9a7c96a2003-01-22 18:17:25 +0000410WRAPPERS = (DateTime, Binary)
411if not _bool_is_builtin:
412 WRAPPERS = WRAPPERS + (Boolean,)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000413
414# --------------------------------------------------------------------
415# XML parsers
416
417try:
Fredrik Lundh7069c312004-10-13 06:48:37 +0000418 # optional xmlrpclib accelerator
Fredrik Lundhb9056332001-07-11 17:42:21 +0000419 import _xmlrpclib
420 FastParser = _xmlrpclib.Parser
421 FastUnmarshaller = _xmlrpclib.Unmarshaller
422except (AttributeError, ImportError):
423 FastParser = FastUnmarshaller = None
424
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000425try:
426 import _xmlrpclib
427 FastMarshaller = _xmlrpclib.Marshaller
428except (AttributeError, ImportError):
429 FastMarshaller = None
430
Fredrik Lundhb9056332001-07-11 17:42:21 +0000431#
432# the SGMLOP parser is about 15x faster than Python's builtin
433# XML parser. SGMLOP sources can be downloaded from:
434#
435# http://www.pythonware.com/products/xml/sgmlop.htm
436#
437
438try:
439 import sgmlop
440 if not hasattr(sgmlop, "XMLParser"):
441 raise ImportError
442except ImportError:
443 SgmlopParser = None # sgmlop accelerator not available
444else:
445 class SgmlopParser:
446 def __init__(self, target):
447
448 # setup callbacks
449 self.finish_starttag = target.start
450 self.finish_endtag = target.end
451 self.handle_data = target.data
452 self.handle_xml = target.xml
453
454 # activate parser
455 self.parser = sgmlop.XMLParser()
456 self.parser.register(self)
457 self.feed = self.parser.feed
458 self.entity = {
459 "amp": "&", "gt": ">", "lt": "<",
460 "apos": "'", "quot": '"'
461 }
462
463 def close(self):
464 try:
465 self.parser.close()
466 finally:
467 self.parser = self.feed = None # nuke circular reference
468
469 def handle_proc(self, tag, attr):
470 m = re.search("encoding\s*=\s*['\"]([^\"']+)[\"']", attr)
471 if m:
472 self.handle_xml(m.group(1), 1)
473
474 def handle_entityref(self, entity):
475 # <string> entity
476 try:
477 self.handle_data(self.entity[entity])
478 except KeyError:
479 self.handle_data("&%s;" % entity)
480
481try:
482 from xml.parsers import expat
Guido van Rossumb8551342001-10-02 18:33:11 +0000483 if not hasattr(expat, "ParserCreate"):
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000484 raise ImportError
Fredrik Lundhb9056332001-07-11 17:42:21 +0000485except ImportError:
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000486 ExpatParser = None # expat not available
Fredrik Lundhb9056332001-07-11 17:42:21 +0000487else:
488 class ExpatParser:
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000489 # fast expat parser for Python 2.0 and later. this is about
490 # 50% slower than sgmlop, on roundtrip testing
Fredrik Lundhb9056332001-07-11 17:42:21 +0000491 def __init__(self, target):
492 self._parser = parser = expat.ParserCreate(None, None)
493 self._target = target
494 parser.StartElementHandler = target.start
495 parser.EndElementHandler = target.end
496 parser.CharacterDataHandler = target.data
497 encoding = None
Fredrik Lundhb9056332001-07-11 17:42:21 +0000498 target.xml(encoding, None)
499
500 def feed(self, data):
501 self._parser.Parse(data, 0)
502
503 def close(self):
504 self._parser.Parse("", 1) # end of data
505 del self._target, self._parser # get rid of circular references
506
Fredrik Lundhb9056332001-07-11 17:42:21 +0000507# --------------------------------------------------------------------
508# XML-RPC marshalling and unmarshalling code
509
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000510##
511# XML-RPC marshaller.
512#
513# @param encoding Default encoding for 8-bit strings. The default
514# value is None (interpreted as UTF-8).
515# @see dumps
516
Fredrik Lundhb9056332001-07-11 17:42:21 +0000517class Marshaller:
Fred Drake1b410792001-09-04 18:55:03 +0000518 """Generate an XML-RPC params chunk from a Python data structure.
Fredrik Lundhb9056332001-07-11 17:42:21 +0000519
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000520 Create a Marshaller instance for each set of parameters, and use
521 the "dumps" method to convert your data (represented as a tuple)
522 to an XML-RPC params chunk. To write a fault response, pass a
523 Fault instance instead. You may prefer to use the "dumps" module
524 function for this purpose.
Fred Drake1b410792001-09-04 18:55:03 +0000525 """
Fredrik Lundhb9056332001-07-11 17:42:21 +0000526
527 # by the way, if you don't understand what's going on in here,
528 # that's perfectly ok.
529
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +0000530 def __init__(self, encoding=None, allow_none=0):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000531 self.memo = {}
532 self.data = None
533 self.encoding = encoding
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +0000534 self.allow_none = allow_none
Tim Petersc2659cf2003-05-12 20:19:37 +0000535
Fredrik Lundhb9056332001-07-11 17:42:21 +0000536 dispatch = {}
537
538 def dumps(self, values):
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000539 out = []
540 write = out.append
541 dump = self.__dump
Fredrik Lundhb9056332001-07-11 17:42:21 +0000542 if isinstance(values, Fault):
543 # fault instance
544 write("<fault>\n")
Martin v. Löwis541342f2003-07-12 07:53:04 +0000545 dump({'faultCode': values.faultCode,
546 'faultString': values.faultString},
547 write)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000548 write("</fault>\n")
549 else:
550 # parameter block
Fredrik Lundhc266bb02001-08-23 20:13:08 +0000551 # FIXME: the xml-rpc specification allows us to leave out
552 # the entire <params> block if there are no parameters.
553 # however, changing this may break older code (including
554 # old versions of xmlrpclib.py), so this is better left as
555 # is for now. See @XMLRPC3 for more information. /F
Fredrik Lundhb9056332001-07-11 17:42:21 +0000556 write("<params>\n")
557 for v in values:
558 write("<param>\n")
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000559 dump(v, write)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000560 write("</param>\n")
561 write("</params>\n")
Neal Norwitzff113342007-04-17 08:42:15 +0000562 result = "".join(out)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000563 return result
564
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000565 def __dump(self, value, write):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000566 try:
567 f = self.dispatch[type(value)]
568 except KeyError:
Thomas Wouters89f507f2006-12-13 04:49:30 +0000569 # check if this object can be marshalled as a structure
570 try:
571 value.__dict__
572 except:
573 raise TypeError, "cannot marshal %s objects" % type(value)
574 # check if this class is a sub-class of a basic type,
575 # because we don't know how to marshal these types
576 # (e.g. a string sub-class)
577 for type_ in type(value).__mro__:
578 if type_ in self.dispatch.keys():
579 raise TypeError, "cannot marshal %s objects" % type(value)
580 # XXX(twouters): using "_arbitrary_instance" as key as a quick-fix
581 # for the p3yk merge, this should probably be fixed more neatly.
582 f = self.dispatch["_arbitrary_instance"]
583 f(self, value, write)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000584
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +0000585 def dump_nil (self, value, write):
586 if not self.allow_none:
587 raise TypeError, "cannot marshal None unless allow_none is enabled"
588 write("<value><nil/></value>")
Guido van Rossum13257902007-06-07 23:15:56 +0000589 dispatch[type(None)] = dump_nil
Tim Petersc2659cf2003-05-12 20:19:37 +0000590
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000591 def dump_int(self, value, write):
Skip Montanaro5449e082001-10-17 22:53:33 +0000592 # in case ints are > 32 bits
593 if value > MAXINT or value < MININT:
594 raise OverflowError, "int exceeds XML-RPC limits"
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000595 write("<value><int>")
596 write(str(value))
597 write("</int></value>\n")
Guido van Rossum13257902007-06-07 23:15:56 +0000598 #dispatch[int] = dump_int
Fredrik Lundhb9056332001-07-11 17:42:21 +0000599
Skip Montanaro9a7c96a2003-01-22 18:17:25 +0000600 if _bool_is_builtin:
601 def dump_bool(self, value, write):
602 write("<value><boolean>")
603 write(value and "1" or "0")
604 write("</boolean></value>\n")
605 dispatch[bool] = dump_bool
606
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000607 def dump_long(self, value, write):
Skip Montanaro5449e082001-10-17 22:53:33 +0000608 if value > MAXINT or value < MININT:
609 raise OverflowError, "long int exceeds XML-RPC limits"
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000610 write("<value><int>")
611 write(str(int(value)))
612 write("</int></value>\n")
Guido van Rossum13257902007-06-07 23:15:56 +0000613 dispatch[int] = dump_long
Skip Montanaro5e9c71b2001-10-10 15:56:34 +0000614
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000615 def dump_double(self, value, write):
616 write("<value><double>")
617 write(repr(value))
618 write("</double></value>\n")
Guido van Rossum13257902007-06-07 23:15:56 +0000619 dispatch[float] = dump_double
Fredrik Lundhb9056332001-07-11 17:42:21 +0000620
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000621 def dump_string(self, value, write, escape=escape):
622 write("<value><string>")
623 write(escape(value))
624 write("</string></value>\n")
Guido van Rossum54ad5232007-05-27 09:17:48 +0000625 dispatch[str8] = dump_string
Fredrik Lundhb9056332001-07-11 17:42:21 +0000626
Guido van Rossum54ad5232007-05-27 09:17:48 +0000627 def dump_unicode(self, value, write, escape=escape):
Guido van Rossum54ad5232007-05-27 09:17:48 +0000628 write("<value><string>")
629 write(escape(value))
630 write("</string></value>\n")
631 dispatch[str] = dump_unicode
Fredrik Lundhb9056332001-07-11 17:42:21 +0000632
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000633 def dump_array(self, value, write):
634 i = id(value)
Guido van Rossume2b70bc2006-08-18 22:13:04 +0000635 if i in self.memo:
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000636 raise TypeError, "cannot marshal recursive sequences"
637 self.memo[i] = None
Fredrik Lundh1538c232001-10-01 19:42:03 +0000638 dump = self.__dump
Fredrik Lundhb9056332001-07-11 17:42:21 +0000639 write("<value><array><data>\n")
640 for v in value:
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000641 dump(v, write)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000642 write("</data></array></value>\n")
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000643 del self.memo[i]
Guido van Rossum13257902007-06-07 23:15:56 +0000644 dispatch[tuple] = dump_array
645 dispatch[list] = dump_array
Fredrik Lundhb9056332001-07-11 17:42:21 +0000646
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000647 def dump_struct(self, value, write, escape=escape):
648 i = id(value)
Guido van Rossume2b70bc2006-08-18 22:13:04 +0000649 if i in self.memo:
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000650 raise TypeError, "cannot marshal recursive dictionaries"
651 self.memo[i] = None
Fredrik Lundh1538c232001-10-01 19:42:03 +0000652 dump = self.__dump
Fredrik Lundhb9056332001-07-11 17:42:21 +0000653 write("<value><struct>\n")
Andrew M. Kuchling5962f452004-06-05 12:35:58 +0000654 for k, v in value.items():
Fredrik Lundhb9056332001-07-11 17:42:21 +0000655 write("<member>\n")
Brett Cannon2dbde5e2007-07-30 03:50:35 +0000656 if not isinstance(k, basestring):
Guido van Rossum54ad5232007-05-27 09:17:48 +0000657 raise TypeError, "dictionary key must be string"
Fredrik Lundh1538c232001-10-01 19:42:03 +0000658 write("<name>%s</name>\n" % escape(k))
Andrew M. Kuchling5962f452004-06-05 12:35:58 +0000659 dump(v, write)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000660 write("</member>\n")
661 write("</struct></value>\n")
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000662 del self.memo[i]
Guido van Rossum13257902007-06-07 23:15:56 +0000663 dispatch[dict] = dump_struct
Fredrik Lundhb9056332001-07-11 17:42:21 +0000664
Fred Drakeba613c32005-02-10 18:33:30 +0000665 if datetime:
666 def dump_datetime(self, value, write):
667 write("<value><dateTime.iso8601>")
668 write(value.strftime("%Y%m%dT%H:%M:%S"))
669 write("</dateTime.iso8601></value>\n")
670 dispatch[datetime.datetime] = dump_datetime
671
Skip Montanaro174dd222005-05-14 20:54:16 +0000672 def dump_date(self, value, write):
673 write("<value><dateTime.iso8601>")
674 write(value.strftime("%Y%m%dT00:00:00"))
675 write("</dateTime.iso8601></value>\n")
676 dispatch[datetime.date] = dump_date
677
678 def dump_time(self, value, write):
679 write("<value><dateTime.iso8601>")
680 write(datetime.datetime.now().date().strftime("%Y%m%dT"))
681 write(value.strftime("%H:%M:%S"))
682 write("</dateTime.iso8601></value>\n")
683 dispatch[datetime.time] = dump_time
684
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000685 def dump_instance(self, value, write):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000686 # check for special wrappers
687 if value.__class__ in WRAPPERS:
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000688 self.write = write
Fredrik Lundhb9056332001-07-11 17:42:21 +0000689 value.encode(self)
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000690 del self.write
Fredrik Lundhb9056332001-07-11 17:42:21 +0000691 else:
692 # store instance attributes as a struct (really?)
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000693 self.dump_struct(value.__dict__, write)
Guido van Rossume4dea982006-04-21 13:45:00 +0000694 dispatch[DateTime] = dump_instance
695 dispatch[Binary] = dump_instance
Thomas Wouters89f507f2006-12-13 04:49:30 +0000696 # XXX(twouters): using "_arbitrary_instance" as key as a quick-fix
697 # for the p3yk merge, this should probably be fixed more neatly.
698 dispatch["_arbitrary_instance"] = dump_instance
Fredrik Lundhb9056332001-07-11 17:42:21 +0000699
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000700##
701# XML-RPC unmarshaller.
702#
703# @see loads
704
Fredrik Lundhb9056332001-07-11 17:42:21 +0000705class Unmarshaller:
Fred Drake1b410792001-09-04 18:55:03 +0000706 """Unmarshal an XML-RPC response, based on incoming XML event
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +0000707 messages (start, data, end). Call close() to get the resulting
Fred Drake1b410792001-09-04 18:55:03 +0000708 data structure.
Fredrik Lundhb9056332001-07-11 17:42:21 +0000709
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +0000710 Note that this reader is fairly tolerant, and gladly accepts bogus
711 XML-RPC data without complaining (but not bogus XML).
Fred Drake1b410792001-09-04 18:55:03 +0000712 """
Fredrik Lundhb9056332001-07-11 17:42:21 +0000713
714 # and again, if you don't understand what's going on in here,
715 # that's perfectly ok.
716
Skip Montanaro174dd222005-05-14 20:54:16 +0000717 def __init__(self, use_datetime=0):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000718 self._type = None
719 self._stack = []
720 self._marks = []
721 self._data = []
722 self._methodname = None
723 self._encoding = "utf-8"
724 self.append = self._stack.append
Skip Montanaro174dd222005-05-14 20:54:16 +0000725 self._use_datetime = use_datetime
726 if use_datetime and not datetime:
727 raise ValueError, "the datetime module is not available"
Fredrik Lundhb9056332001-07-11 17:42:21 +0000728
729 def close(self):
730 # return response tuple and target method
731 if self._type is None or self._marks:
732 raise ResponseError()
733 if self._type == "fault":
Guido van Rossum68468eb2003-02-27 20:14:51 +0000734 raise Fault(**self._stack[0])
Fredrik Lundhb9056332001-07-11 17:42:21 +0000735 return tuple(self._stack)
736
737 def getmethodname(self):
738 return self._methodname
739
740 #
741 # event handlers
742
743 def xml(self, encoding, standalone):
744 self._encoding = encoding
745 # FIXME: assert standalone == 1 ???
746
747 def start(self, tag, attrs):
748 # prepare to handle this element
749 if tag == "array" or tag == "struct":
750 self._marks.append(len(self._stack))
751 self._data = []
752 self._value = (tag == "value")
753
754 def data(self, text):
755 self._data.append(text)
756
Neal Norwitzff113342007-04-17 08:42:15 +0000757 def end(self, tag):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000758 # call the appropriate end tag handler
759 try:
760 f = self.dispatch[tag]
761 except KeyError:
762 pass # unknown tag ?
763 else:
Neal Norwitzff113342007-04-17 08:42:15 +0000764 return f(self, "".join(self._data))
Fredrik Lundhb9056332001-07-11 17:42:21 +0000765
766 #
767 # accelerator support
768
769 def end_dispatch(self, tag, data):
770 # dispatch data
771 try:
772 f = self.dispatch[tag]
773 except KeyError:
774 pass # unknown tag ?
775 else:
776 return f(self, data)
777
778 #
779 # element decoders
780
781 dispatch = {}
782
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +0000783 def end_nil (self, data):
784 self.append(None)
785 self._value = 0
786 dispatch["nil"] = end_nil
Tim Petersc2659cf2003-05-12 20:19:37 +0000787
Fredrik Lundh1538c232001-10-01 19:42:03 +0000788 def end_boolean(self, data):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000789 if data == "0":
790 self.append(False)
791 elif data == "1":
792 self.append(True)
793 else:
794 raise TypeError, "bad boolean value"
795 self._value = 0
796 dispatch["boolean"] = end_boolean
797
Fredrik Lundh1538c232001-10-01 19:42:03 +0000798 def end_int(self, data):
799 self.append(int(data))
Fredrik Lundhb9056332001-07-11 17:42:21 +0000800 self._value = 0
801 dispatch["i4"] = end_int
802 dispatch["int"] = end_int
803
Fredrik Lundh1538c232001-10-01 19:42:03 +0000804 def end_double(self, data):
805 self.append(float(data))
Fredrik Lundhb9056332001-07-11 17:42:21 +0000806 self._value = 0
807 dispatch["double"] = end_double
808
Fredrik Lundh1538c232001-10-01 19:42:03 +0000809 def end_string(self, data):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000810 if self._encoding:
811 data = _decode(data, self._encoding)
812 self.append(_stringify(data))
813 self._value = 0
814 dispatch["string"] = end_string
815 dispatch["name"] = end_string # struct keys are always strings
816
817 def end_array(self, data):
Raymond Hettinger46ac8eb2002-06-30 03:39:14 +0000818 mark = self._marks.pop()
Fredrik Lundhb9056332001-07-11 17:42:21 +0000819 # map arrays to Python lists
820 self._stack[mark:] = [self._stack[mark:]]
821 self._value = 0
822 dispatch["array"] = end_array
823
824 def end_struct(self, data):
Raymond Hettinger46ac8eb2002-06-30 03:39:14 +0000825 mark = self._marks.pop()
Fredrik Lundhb9056332001-07-11 17:42:21 +0000826 # map structs to Python dictionaries
827 dict = {}
828 items = self._stack[mark:]
829 for i in range(0, len(items), 2):
830 dict[_stringify(items[i])] = items[i+1]
831 self._stack[mark:] = [dict]
832 self._value = 0
833 dispatch["struct"] = end_struct
834
Fredrik Lundh1538c232001-10-01 19:42:03 +0000835 def end_base64(self, data):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000836 value = Binary()
Guido van Rossum54a40cb2007-08-27 22:27:41 +0000837 value.decode(data.encode("ascii"))
Fredrik Lundhb9056332001-07-11 17:42:21 +0000838 self.append(value)
839 self._value = 0
840 dispatch["base64"] = end_base64
841
Fredrik Lundh1538c232001-10-01 19:42:03 +0000842 def end_dateTime(self, data):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000843 value = DateTime()
Fredrik Lundh1538c232001-10-01 19:42:03 +0000844 value.decode(data)
Skip Montanaro174dd222005-05-14 20:54:16 +0000845 if self._use_datetime:
846 value = _datetime_type(data)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000847 self.append(value)
848 dispatch["dateTime.iso8601"] = end_dateTime
849
850 def end_value(self, data):
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000851 # if we stumble upon a value element with no internal
Fredrik Lundhb9056332001-07-11 17:42:21 +0000852 # elements, treat it as a string element
853 if self._value:
854 self.end_string(data)
855 dispatch["value"] = end_value
856
857 def end_params(self, data):
858 self._type = "params"
859 dispatch["params"] = end_params
860
861 def end_fault(self, data):
862 self._type = "fault"
863 dispatch["fault"] = end_fault
864
Fredrik Lundh1538c232001-10-01 19:42:03 +0000865 def end_methodName(self, data):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000866 if self._encoding:
867 data = _decode(data, self._encoding)
868 self._methodname = data
869 self._type = "methodName" # no params
870 dispatch["methodName"] = end_methodName
871
Martin v. Löwis45394c22003-10-31 13:49:36 +0000872## Multicall support
873#
Fredrik Lundhb9056332001-07-11 17:42:21 +0000874
Martin v. Löwis45394c22003-10-31 13:49:36 +0000875class _MultiCallMethod:
876 # some lesser magic to store calls made to a MultiCall object
877 # for batch execution
878 def __init__(self, call_list, name):
879 self.__call_list = call_list
880 self.__name = name
881 def __getattr__(self, name):
882 return _MultiCallMethod(self.__call_list, "%s.%s" % (self.__name, name))
883 def __call__(self, *args):
884 self.__call_list.append((self.__name, args))
885
Martin v. Löwis12237b32004-08-22 16:04:50 +0000886class MultiCallIterator:
Martin v. Löwis45394c22003-10-31 13:49:36 +0000887 """Iterates over the results of a multicall. Exceptions are
888 thrown in response to xmlrpc faults."""
Raymond Hettingercc523fc2003-11-02 09:47:05 +0000889
Martin v. Löwis12237b32004-08-22 16:04:50 +0000890 def __init__(self, results):
891 self.results = results
892
893 def __getitem__(self, i):
894 item = self.results[i]
895 if type(item) == type({}):
896 raise Fault(item['faultCode'], item['faultString'])
897 elif type(item) == type([]):
898 return item[0]
Martin v. Löwis45394c22003-10-31 13:49:36 +0000899 else:
900 raise ValueError,\
901 "unexpected type in multicall result"
Raymond Hettingercc523fc2003-11-02 09:47:05 +0000902
Martin v. Löwis45394c22003-10-31 13:49:36 +0000903class MultiCall:
904 """server -> a object used to boxcar method calls
905
906 server should be a ServerProxy object.
907
908 Methods can be added to the MultiCall using normal
909 method call syntax e.g.:
910
911 multicall = MultiCall(server_proxy)
912 multicall.add(2,3)
913 multicall.get_address("Guido")
914
915 To execute the multicall, call the MultiCall object e.g.:
916
917 add_result, address = multicall()
918 """
Raymond Hettingercc523fc2003-11-02 09:47:05 +0000919
Martin v. Löwis45394c22003-10-31 13:49:36 +0000920 def __init__(self, server):
921 self.__server = server
922 self.__call_list = []
Raymond Hettingercc523fc2003-11-02 09:47:05 +0000923
Martin v. Löwis45394c22003-10-31 13:49:36 +0000924 def __repr__(self):
925 return "<MultiCall at %x>" % id(self)
Raymond Hettingercc523fc2003-11-02 09:47:05 +0000926
Martin v. Löwis45394c22003-10-31 13:49:36 +0000927 __str__ = __repr__
928
929 def __getattr__(self, name):
930 return _MultiCallMethod(self.__call_list, name)
931
932 def __call__(self):
933 marshalled_list = []
934 for name, args in self.__call_list:
935 marshalled_list.append({'methodName' : name, 'params' : args})
936
937 return MultiCallIterator(self.__server.system.multicall(marshalled_list))
Raymond Hettingercc523fc2003-11-02 09:47:05 +0000938
Fredrik Lundhb9056332001-07-11 17:42:21 +0000939# --------------------------------------------------------------------
940# convenience functions
941
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000942##
943# Create a parser object, and connect it to an unmarshalling instance.
944# This function picks the fastest available XML parser.
945#
946# return A (parser, unmarshaller) tuple.
947
Skip Montanaro174dd222005-05-14 20:54:16 +0000948def getparser(use_datetime=0):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000949 """getparser() -> parser, unmarshaller
950
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +0000951 Create an instance of the fastest available parser, and attach it
952 to an unmarshalling object. Return both objects.
Fredrik Lundhb9056332001-07-11 17:42:21 +0000953 """
Skip Montanaro174dd222005-05-14 20:54:16 +0000954 if use_datetime and not datetime:
955 raise ValueError, "the datetime module is not available"
Fredrik Lundhb9056332001-07-11 17:42:21 +0000956 if FastParser and FastUnmarshaller:
Skip Montanaro174dd222005-05-14 20:54:16 +0000957 if use_datetime:
958 mkdatetime = _datetime_type
959 else:
960 mkdatetime = _datetime
961 target = FastUnmarshaller(True, False, _binary, mkdatetime, Fault)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000962 parser = FastParser(target)
963 else:
Skip Montanaro174dd222005-05-14 20:54:16 +0000964 target = Unmarshaller(use_datetime=use_datetime)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000965 if FastParser:
966 parser = FastParser(target)
967 elif SgmlopParser:
968 parser = SgmlopParser(target)
969 elif ExpatParser:
970 parser = ExpatParser(target)
971 else:
972 parser = SlowParser(target)
973 return parser, target
974
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000975##
976# Convert a Python tuple or a Fault instance to an XML-RPC packet.
977#
978# @def dumps(params, **options)
979# @param params A tuple or Fault instance.
980# @keyparam methodname If given, create a methodCall request for
981# this method name.
982# @keyparam methodresponse If given, create a methodResponse packet.
983# If used with a tuple, the tuple must be a singleton (that is,
984# it must contain exactly one element).
985# @keyparam encoding The packet encoding.
986# @return A string containing marshalled data.
987
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +0000988def dumps(params, methodname=None, methodresponse=None, encoding=None,
989 allow_none=0):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000990 """data [,options] -> marshalled data
991
992 Convert an argument tuple or a Fault instance to an XML-RPC
993 request (or response, if the methodresponse option is used).
994
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +0000995 In addition to the data object, the following options can be given
996 as keyword arguments:
Fredrik Lundhb9056332001-07-11 17:42:21 +0000997
998 methodname: the method name for a methodCall packet
999
1000 methodresponse: true to create a methodResponse packet.
1001 If this option is used with a tuple, the tuple must be
1002 a singleton (i.e. it can contain only one element).
1003
1004 encoding: the packet encoding (default is UTF-8)
1005
1006 All 8-bit strings in the data structure are assumed to use the
1007 packet encoding. Unicode strings are automatically converted,
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +00001008 where necessary.
Fredrik Lundhb9056332001-07-11 17:42:21 +00001009 """
1010
Guido van Rossum13257902007-06-07 23:15:56 +00001011 assert isinstance(params, (tuple, Fault)), "argument must be tuple or Fault instance"
Fredrik Lundhb9056332001-07-11 17:42:21 +00001012 if isinstance(params, Fault):
1013 methodresponse = 1
Guido van Rossum13257902007-06-07 23:15:56 +00001014 elif methodresponse and isinstance(params, tuple):
Fredrik Lundhb9056332001-07-11 17:42:21 +00001015 assert len(params) == 1, "response tuple must be a singleton"
1016
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001017 if not encoding:
Fredrik Lundhb9056332001-07-11 17:42:21 +00001018 encoding = "utf-8"
1019
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001020 if FastMarshaller:
1021 m = FastMarshaller(encoding)
1022 else:
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +00001023 m = Marshaller(encoding, allow_none)
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001024
Fredrik Lundhb9056332001-07-11 17:42:21 +00001025 data = m.dumps(params)
1026
1027 if encoding != "utf-8":
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001028 xmlheader = "<?xml version='1.0' encoding='%s'?>\n" % str(encoding)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001029 else:
1030 xmlheader = "<?xml version='1.0'?>\n" # utf-8 is default
1031
1032 # standard XML-RPC wrappings
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001033 if methodname:
Fredrik Lundhb9056332001-07-11 17:42:21 +00001034 # a method call
Guido van Rossum54ad5232007-05-27 09:17:48 +00001035 if not isinstance(methodname, basestring):
Fredrik Lundhb9056332001-07-11 17:42:21 +00001036 methodname = methodname.encode(encoding)
1037 data = (
1038 xmlheader,
1039 "<methodCall>\n"
1040 "<methodName>", methodname, "</methodName>\n",
1041 data,
1042 "</methodCall>\n"
1043 )
1044 elif methodresponse:
1045 # a method response, or a fault structure
1046 data = (
1047 xmlheader,
1048 "<methodResponse>\n",
1049 data,
1050 "</methodResponse>\n"
1051 )
1052 else:
1053 return data # return as is
Neal Norwitzff113342007-04-17 08:42:15 +00001054 return "".join(data)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001055
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001056##
1057# Convert an XML-RPC packet to a Python object. If the XML-RPC packet
1058# represents a fault condition, this function raises a Fault exception.
1059#
1060# @param data An XML-RPC packet, given as an 8-bit string.
Walter Dörwaldf0dfc7a2003-10-20 14:01:56 +00001061# @return A tuple containing the unpacked data, and the method name
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001062# (None if not present).
1063# @see Fault
1064
Skip Montanaro174dd222005-05-14 20:54:16 +00001065def loads(data, use_datetime=0):
Fredrik Lundhb9056332001-07-11 17:42:21 +00001066 """data -> unmarshalled data, method name
1067
1068 Convert an XML-RPC packet to unmarshalled data plus a method
1069 name (None if not present).
1070
1071 If the XML-RPC packet represents a fault condition, this function
1072 raises a Fault exception.
1073 """
Skip Montanaro174dd222005-05-14 20:54:16 +00001074 p, u = getparser(use_datetime=use_datetime)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001075 p.feed(data)
1076 p.close()
1077 return u.close(), u.getmethodname()
1078
1079
1080# --------------------------------------------------------------------
1081# request dispatcher
1082
1083class _Method:
1084 # some magic to bind an XML-RPC method to an RPC server.
1085 # supports "nested" methods (e.g. examples.getStateName)
1086 def __init__(self, send, name):
1087 self.__send = send
1088 self.__name = name
1089 def __getattr__(self, name):
1090 return _Method(self.__send, "%s.%s" % (self.__name, name))
1091 def __call__(self, *args):
1092 return self.__send(self.__name, args)
1093
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001094##
1095# Standard transport class for XML-RPC over HTTP.
1096# <p>
1097# You can create custom transports by subclassing this method, and
1098# overriding selected methods.
Fredrik Lundhb9056332001-07-11 17:42:21 +00001099
1100class Transport:
Fredrik Lundhc4c062f2001-09-10 19:45:02 +00001101 """Handles an HTTP transaction to an XML-RPC server."""
Fredrik Lundhb9056332001-07-11 17:42:21 +00001102
1103 # client identifier (may be overridden)
1104 user_agent = "xmlrpclib.py/%s (by www.pythonware.com)" % __version__
1105
Skip Montanaro174dd222005-05-14 20:54:16 +00001106 def __init__(self, use_datetime=0):
1107 self._use_datetime = use_datetime
1108
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001109 ##
1110 # Send a complete request, and parse the response.
1111 #
1112 # @param host Target host.
1113 # @param handler Target PRC handler.
1114 # @param request_body XML-RPC request body.
1115 # @param verbose Debugging flag.
1116 # @return Parsed response.
1117
Fredrik Lundhb9056332001-07-11 17:42:21 +00001118 def request(self, host, handler, request_body, verbose=0):
1119 # issue XML-RPC request
1120
Jeremy Hylton5d8a88a2007-08-14 16:47:39 +00001121 http_conn = self.send_request(host, handler, request_body, verbose)
1122 resp = http_conn.getresponse()
Fredrik Lundhb9056332001-07-11 17:42:21 +00001123
Jeremy Hylton5d8a88a2007-08-14 16:47:39 +00001124 if resp.status != 200:
Fredrik Lundhb9056332001-07-11 17:42:21 +00001125 raise ProtocolError(
1126 host + handler,
Hye-Shik Chang96042862007-08-19 10:49:11 +00001127 resp.status, resp.reason,
Guido van Rossumcfe02a42007-08-22 23:45:42 +00001128 dict(resp.getheaders())
Fredrik Lundhb9056332001-07-11 17:42:21 +00001129 )
1130
1131 self.verbose = verbose
1132
Jeremy Hylton5d8a88a2007-08-14 16:47:39 +00001133 return self._parse_response(resp, None)
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001134
1135 ##
1136 # Create parser.
1137 #
1138 # @return A 2-tuple containing a parser and a unmarshaller.
Fredrik Lundhb9056332001-07-11 17:42:21 +00001139
Fredrik Lundhc4c062f2001-09-10 19:45:02 +00001140 def getparser(self):
1141 # get parser and unmarshaller
Skip Montanaro174dd222005-05-14 20:54:16 +00001142 return getparser(use_datetime=self._use_datetime)
Fredrik Lundhc4c062f2001-09-10 19:45:02 +00001143
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001144 ##
Fredrik Lundh1303c7c2002-10-22 18:23:00 +00001145 # Get authorization info from host parameter
1146 # Host may be a string, or a (host, x509-dict) tuple; if a string,
1147 # it is checked for a "user:pw@host" format, and a "Basic
1148 # Authentication" header is added if appropriate.
1149 #
1150 # @param host Host descriptor (URL or (URL, x509 info) tuple).
1151 # @return A 3-tuple containing (actual host, extra headers,
1152 # x509 info). The header and x509 fields may be None.
1153
1154 def get_host_info(self, host):
1155
1156 x509 = {}
Guido van Rossum13257902007-06-07 23:15:56 +00001157 if isinstance(host, tuple):
Fredrik Lundh1303c7c2002-10-22 18:23:00 +00001158 host, x509 = host
1159
1160 import urllib
1161 auth, host = urllib.splituser(host)
1162
1163 if auth:
1164 import base64
Fredrik Lundh768c98b2002-11-01 17:14:16 +00001165 auth = base64.encodestring(urllib.unquote(auth))
Neal Norwitzff113342007-04-17 08:42:15 +00001166 auth = "".join(auth.split()) # get rid of whitespace
Fredrik Lundh1303c7c2002-10-22 18:23:00 +00001167 extra_headers = [
1168 ("Authorization", "Basic " + auth)
1169 ]
1170 else:
1171 extra_headers = None
1172
1173 return host, extra_headers, x509
1174
1175 ##
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001176 # Connect to server.
1177 #
1178 # @param host Target host.
Jeremy Hylton5d8a88a2007-08-14 16:47:39 +00001179 # @return An HTTPConnection object
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001180
Fredrik Lundhb9056332001-07-11 17:42:21 +00001181 def make_connection(self, host):
1182 # create a HTTP connection object from a host descriptor
Fredrik Lundh1303c7c2002-10-22 18:23:00 +00001183 host, extra_headers, x509 = self.get_host_info(host)
Jeremy Hylton5d8a88a2007-08-14 16:47:39 +00001184
Fredrik Lundhb9056332001-07-11 17:42:21 +00001185
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001186 ##
Jeremy Hylton5d8a88a2007-08-14 16:47:39 +00001187 # Send HTTP request.
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001188 #
Jeremy Hylton5d8a88a2007-08-14 16:47:39 +00001189 # @param host Host descriptor (URL or (URL, x509 info) tuple).
1190 # @param handler Targer RPC handler (a path relative to host)
1191 # @param request_body The XML-RPC request body
1192 # @param debug Enable debugging if debug is true.
1193 # @return An HTTPConnection.
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001194
Jeremy Hylton5d8a88a2007-08-14 16:47:39 +00001195 def send_request(self, host, handler, request_body, debug):
Fredrik Lundh1303c7c2002-10-22 18:23:00 +00001196 host, extra_headers, x509 = self.get_host_info(host)
Jeremy Hylton5d8a88a2007-08-14 16:47:39 +00001197 connection = httplib.HTTPConnection(host)
1198 if debug:
1199 connection.set_debuglevel(1)
1200 headers = {}
Fredrik Lundh1303c7c2002-10-22 18:23:00 +00001201 if extra_headers:
Jeremy Hylton5d8a88a2007-08-14 16:47:39 +00001202 for key, val in extra_headers:
1203 header[key] = val
1204 headers["Content-Type"] = "text/xml"
1205 headers["User-Agent"] = self.user_agent
1206 connection.request("POST", handler, request_body, headers)
1207 return connection
Fredrik Lundhb9056332001-07-11 17:42:21 +00001208
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001209 ##
1210 # Parse response.
1211 #
1212 # @param file Stream.
1213 # @return Response tuple and target method.
1214
1215 def parse_response(self, file):
1216 # compatibility interface
1217 return self._parse_response(file, None)
1218
1219 ##
1220 # Parse response (alternate interface). This is similar to the
1221 # parse_response method, but also provides direct access to the
1222 # underlying socket object (where available).
1223 #
1224 # @param file Stream.
1225 # @param sock Socket handle (or None, if the socket object
1226 # could not be accessed).
1227 # @return Response tuple and target method.
1228
1229 def _parse_response(self, file, sock):
1230 # read response from input file/socket, and parse it
Fredrik Lundhb9056332001-07-11 17:42:21 +00001231
Fredrik Lundhc4c062f2001-09-10 19:45:02 +00001232 p, u = self.getparser()
Fredrik Lundhb9056332001-07-11 17:42:21 +00001233
1234 while 1:
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001235 if sock:
1236 response = sock.recv(1024)
1237 else:
1238 response = file.read(1024)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001239 if not response:
1240 break
1241 if self.verbose:
Guido van Rossumbe19ed72007-02-09 05:37:30 +00001242 print("body:", repr(response))
Fredrik Lundhb9056332001-07-11 17:42:21 +00001243 p.feed(response)
1244
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001245 file.close()
Fredrik Lundhb9056332001-07-11 17:42:21 +00001246 p.close()
1247
1248 return u.close()
1249
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001250##
1251# Standard transport class for XML-RPC over HTTPS.
1252
Fredrik Lundhb9056332001-07-11 17:42:21 +00001253class SafeTransport(Transport):
Fredrik Lundhc4c062f2001-09-10 19:45:02 +00001254 """Handles an HTTPS transaction to an XML-RPC server."""
Fredrik Lundhb9056332001-07-11 17:42:21 +00001255
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001256 # FIXME: mostly untested
1257
Jeremy Hylton5d8a88a2007-08-14 16:47:39 +00001258 def send_request(self, host, handler, request_body, debug):
1259 import socket
1260 if not hasattr(socket, "ssl"):
Fredrik Lundh1303c7c2002-10-22 18:23:00 +00001261 raise NotImplementedError(
Jeremy Hylton5d8a88a2007-08-14 16:47:39 +00001262 "your version of httplib doesn't support HTTPS")
1263
1264 host, extra_headers, x509 = self.get_host_info(host)
1265 connection = httplib.HTTPSConnection(host, None, **(x509 or {}))
1266 if debug:
1267 connection.set_debuglevel(1)
1268 headers = {}
1269 if extra_headers:
1270 for key, val in extra_headers:
1271 header[key] = val
1272 headers["Content-Type"] = "text/xml"
1273 headers["User-Agent"] = self.user_agent
1274 connection.request("POST", handler, request_body, headers)
1275 return connection
Fredrik Lundhb9056332001-07-11 17:42:21 +00001276
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001277##
1278# Standard server proxy. This class establishes a virtual connection
1279# to an XML-RPC server.
1280# <p>
1281# This class is available as ServerProxy and Server. New code should
1282# use ServerProxy, to avoid confusion.
1283#
1284# @def ServerProxy(uri, **options)
1285# @param uri The connection point on the server.
1286# @keyparam transport A transport factory, compatible with the
1287# standard transport class.
1288# @keyparam encoding The default encoding used for 8-bit strings
1289# (default is UTF-8).
1290# @keyparam verbose Use a true value to enable debugging output.
1291# (printed to standard output).
1292# @see Transport
1293
Fredrik Lundhb9056332001-07-11 17:42:21 +00001294class ServerProxy:
1295 """uri [,options] -> a logical connection to an XML-RPC server
1296
1297 uri is the connection point on the server, given as
1298 scheme://host/target.
1299
1300 The standard implementation always supports the "http" scheme. If
1301 SSL socket support is available (Python 2.0), it also supports
1302 "https".
1303
1304 If the target part and the slash preceding it are both omitted,
1305 "/RPC2" is assumed.
1306
1307 The following options can be given as keyword arguments:
1308
1309 transport: a transport factory
1310 encoding: the request encoding (default is UTF-8)
1311
1312 All 8-bit strings passed to the server proxy are assumed to use
1313 the given encoding.
1314 """
1315
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +00001316 def __init__(self, uri, transport=None, encoding=None, verbose=0,
Skip Montanaro174dd222005-05-14 20:54:16 +00001317 allow_none=0, use_datetime=0):
Fredrik Lundhb9056332001-07-11 17:42:21 +00001318 # establish a "logical" server connection
1319
1320 # get the url
Fredrik Lundhc4c062f2001-09-10 19:45:02 +00001321 import urllib
Fredrik Lundhb9056332001-07-11 17:42:21 +00001322 type, uri = urllib.splittype(uri)
1323 if type not in ("http", "https"):
1324 raise IOError, "unsupported XML-RPC protocol"
1325 self.__host, self.__handler = urllib.splithost(uri)
1326 if not self.__handler:
1327 self.__handler = "/RPC2"
1328
1329 if transport is None:
1330 if type == "https":
Skip Montanaro174dd222005-05-14 20:54:16 +00001331 transport = SafeTransport(use_datetime=use_datetime)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001332 else:
Skip Montanaro174dd222005-05-14 20:54:16 +00001333 transport = Transport(use_datetime=use_datetime)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001334 self.__transport = transport
1335
1336 self.__encoding = encoding
1337 self.__verbose = verbose
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +00001338 self.__allow_none = allow_none
Tim Petersc2659cf2003-05-12 20:19:37 +00001339
Fredrik Lundhb9056332001-07-11 17:42:21 +00001340 def __request(self, methodname, params):
1341 # call a method on the remote server
1342
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +00001343 request = dumps(params, methodname, encoding=self.__encoding,
1344 allow_none=self.__allow_none)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001345
1346 response = self.__transport.request(
1347 self.__host,
1348 self.__handler,
1349 request,
1350 verbose=self.__verbose
1351 )
1352
1353 if len(response) == 1:
1354 response = response[0]
1355
1356 return response
1357
1358 def __repr__(self):
1359 return (
Fredrik Lundh78eedce2001-08-23 20:04:33 +00001360 "<ServerProxy for %s%s>" %
Fredrik Lundhb9056332001-07-11 17:42:21 +00001361 (self.__host, self.__handler)
1362 )
1363
1364 __str__ = __repr__
Raymond Hettingercc523fc2003-11-02 09:47:05 +00001365
Fredrik Lundhb9056332001-07-11 17:42:21 +00001366 def __getattr__(self, name):
1367 # magic method dispatcher
1368 return _Method(self.__request, name)
1369
1370 # note: to call a remote object with an non-standard name, use
1371 # result getattr(server, "strange-python-name")(args)
1372
Fredrik Lundh78eedce2001-08-23 20:04:33 +00001373# compatibility
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001374
Fredrik Lundhb9056332001-07-11 17:42:21 +00001375Server = ServerProxy
1376
1377# --------------------------------------------------------------------
1378# test code
1379
1380if __name__ == "__main__":
1381
1382 # simple test program (from the XML-RPC specification)
1383
Fredrik Lundh78eedce2001-08-23 20:04:33 +00001384 # server = ServerProxy("http://localhost:8000") # local server
Martin v. Löwis12237b32004-08-22 16:04:50 +00001385 server = ServerProxy("http://time.xmlrpc.com/RPC2")
Fredrik Lundhb9056332001-07-11 17:42:21 +00001386
Fredrik Lundhb9056332001-07-11 17:42:21 +00001387 try:
Guido van Rossumbe19ed72007-02-09 05:37:30 +00001388 print(server.currentTime.getCurrentTime())
Guido van Rossumb940e112007-01-10 16:19:56 +00001389 except Error as v:
Guido van Rossumbe19ed72007-02-09 05:37:30 +00001390 print("ERROR", v)
Martin v. Löwis12237b32004-08-22 16:04:50 +00001391
Jeremy Hylton5d8a88a2007-08-14 16:47:39 +00001392 # The server at xmlrpc.com doesn't seem to support multicall anymore.
Martin v. Löwis12237b32004-08-22 16:04:50 +00001393 multi = MultiCall(server)
1394 multi.currentTime.getCurrentTime()
1395 multi.currentTime.getCurrentTime()
1396 try:
1397 for response in multi():
Guido van Rossumbe19ed72007-02-09 05:37:30 +00001398 print(response)
Guido van Rossumb940e112007-01-10 16:19:56 +00001399 except Error as v:
Guido van Rossumbe19ed72007-02-09 05:37:30 +00001400 print("ERROR", v)