Python code coverage for Lib/xmlrpclib.py

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