home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2012 January / maximum-cd-2012-01.iso / DiscContents / digsby_setup.exe / lib / xmlrpclib.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-10-05  |  32.4 KB  |  1,128 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. import re
  5. import string
  6. import time
  7. import operator
  8. from types import *
  9.  
  10. try:
  11.     unicode
  12. except NameError:
  13.     unicode = None
  14.  
  15.  
  16. try:
  17.     import datetime
  18. except ImportError:
  19.     datetime = None
  20.  
  21.  
  22. try:
  23.     _bool_is_builtin = False.__class__.__name__ == 'bool'
  24. except NameError:
  25.     _bool_is_builtin = 0
  26.  
  27.  
  28. def _decode(data, encoding, is8bit = re.compile('[\x80-\xff]').search):
  29.     if unicode and encoding and is8bit(data):
  30.         data = unicode(data, encoding)
  31.     
  32.     return data
  33.  
  34.  
  35. def escape(s, replace = string.replace):
  36.     s = replace(s, '&', '&')
  37.     s = replace(s, '<', '<')
  38.     return replace(s, '>', '>')
  39.  
  40. if unicode:
  41.     
  42.     def _stringify(string):
  43.         
  44.         try:
  45.             return string.encode('ascii')
  46.         except UnicodeError:
  47.             return string
  48.  
  49.  
  50. else:
  51.     
  52.     def _stringify(string):
  53.         return string
  54.  
  55. __version__ = '1.0.1'
  56. MAXINT = 0x7FFFFFFFL
  57. MININT = -0x80000000L
  58. PARSE_ERROR = -32700
  59. SERVER_ERROR = -32600
  60. APPLICATION_ERROR = -32500
  61. SYSTEM_ERROR = -32400
  62. TRANSPORT_ERROR = -32300
  63. NOT_WELLFORMED_ERROR = -32700
  64. UNSUPPORTED_ENCODING = -32701
  65. INVALID_ENCODING_CHAR = -32702
  66. INVALID_XMLRPC = -32600
  67. METHOD_NOT_FOUND = -32601
  68. INVALID_METHOD_PARAMS = -32602
  69. INTERNAL_ERROR = -32603
  70.  
  71. class Error(Exception):
  72.     
  73.     def __str__(self):
  74.         return repr(self)
  75.  
  76.  
  77.  
  78. class ProtocolError(Error):
  79.     
  80.     def __init__(self, url, errcode, errmsg, headers):
  81.         Error.__init__(self)
  82.         self.url = url
  83.         self.errcode = errcode
  84.         self.errmsg = errmsg
  85.         self.headers = headers
  86.  
  87.     
  88.     def __repr__(self):
  89.         return '<ProtocolError for %s: %s %s>' % (self.url, self.errcode, self.errmsg)
  90.  
  91.  
  92.  
  93. class ResponseError(Error):
  94.     pass
  95.  
  96.  
  97. class Fault(Error):
  98.     
  99.     def __init__(self, faultCode, faultString, **extra):
  100.         Error.__init__(self)
  101.         self.faultCode = faultCode
  102.         self.faultString = faultString
  103.  
  104.     
  105.     def __repr__(self):
  106.         return '<Fault %s: %s>' % (self.faultCode, repr(self.faultString))
  107.  
  108.  
  109. from sys import modules
  110. mod_dict = modules[__name__].__dict__
  111. if _bool_is_builtin:
  112.     boolean = Boolean = bool
  113.     mod_dict['True'] = True
  114.     mod_dict['False'] = False
  115. else:
  116.     
  117.     class Boolean:
  118.         
  119.         def __init__(self, value = 0):
  120.             self.value = operator.truth(value)
  121.  
  122.         
  123.         def encode(self, out):
  124.             out.write('<value><boolean>%d</boolean></value>\n' % self.value)
  125.  
  126.         
  127.         def __cmp__(self, other):
  128.             if isinstance(other, Boolean):
  129.                 other = other.value
  130.             
  131.             return cmp(self.value, other)
  132.  
  133.         
  134.         def __repr__(self):
  135.             if self.value:
  136.                 return '<Boolean True at %x>' % id(self)
  137.             return '<Boolean False at %x>' % id(self)
  138.  
  139.         
  140.         def __int__(self):
  141.             return self.value
  142.  
  143.         
  144.         def __nonzero__(self):
  145.             return self.value
  146.  
  147.  
  148.     mod_dict['True'] = Boolean(1)
  149.     mod_dict['False'] = Boolean(0)
  150.     
  151.     def boolean(value, _truefalse = (False, True)):
  152.         return _truefalse[operator.truth(value)]
  153.  
  154. del modules
  155. del mod_dict
  156.  
  157. def _strftime(value):
  158.     if datetime:
  159.         if isinstance(value, datetime.datetime):
  160.             return '%04d%02d%02dT%02d:%02d:%02d' % (value.year, value.month, value.day, value.hour, value.minute, value.second)
  161.     
  162.     if not isinstance(value, (TupleType, time.struct_time)):
  163.         if value == 0:
  164.             value = time.time()
  165.         
  166.         value = time.localtime(value)
  167.     
  168.     return '%04d%02d%02dT%02d:%02d:%02d' % value[:6]
  169.  
  170.  
  171. class DateTime:
  172.     
  173.     def __init__(self, value = 0):
  174.         if isinstance(value, StringType):
  175.             self.value = value
  176.         else:
  177.             self.value = _strftime(value)
  178.  
  179.     
  180.     def make_comparable(self, other):
  181.         if isinstance(other, DateTime):
  182.             s = self.value
  183.             o = other.value
  184.         elif datetime and isinstance(other, datetime.datetime):
  185.             s = self.value
  186.             o = other.strftime('%Y%m%dT%H:%M:%S')
  187.         elif isinstance(other, (str, unicode)):
  188.             s = self.value
  189.             o = other
  190.         elif hasattr(other, 'timetuple'):
  191.             s = self.timetuple()
  192.             o = other.timetuple()
  193.         elif not hasattr(other, '__class__') or other.__class__.__name__:
  194.             pass
  195.         otype = type(other)
  196.         raise TypeError("Can't compare %s and %s" % (self.__class__.__name__, otype))
  197.         return (s, o)
  198.  
  199.     
  200.     def __lt__(self, other):
  201.         (s, o) = self.make_comparable(other)
  202.         return s < o
  203.  
  204.     
  205.     def __le__(self, other):
  206.         (s, o) = self.make_comparable(other)
  207.         return s <= o
  208.  
  209.     
  210.     def __gt__(self, other):
  211.         (s, o) = self.make_comparable(other)
  212.         return s > o
  213.  
  214.     
  215.     def __ge__(self, other):
  216.         (s, o) = self.make_comparable(other)
  217.         return s >= o
  218.  
  219.     
  220.     def __eq__(self, other):
  221.         (s, o) = self.make_comparable(other)
  222.         return s == o
  223.  
  224.     
  225.     def __ne__(self, other):
  226.         (s, o) = self.make_comparable(other)
  227.         return s != o
  228.  
  229.     
  230.     def timetuple(self):
  231.         return time.strptime(self.value, '%Y%m%dT%H:%M:%S')
  232.  
  233.     
  234.     def __cmp__(self, other):
  235.         (s, o) = self.make_comparable(other)
  236.         return cmp(s, o)
  237.  
  238.     
  239.     def __str__(self):
  240.         return self.value
  241.  
  242.     
  243.     def __repr__(self):
  244.         return '<DateTime %s at %x>' % (repr(self.value), id(self))
  245.  
  246.     
  247.     def decode(self, data):
  248.         data = str(data)
  249.         self.value = string.strip(data)
  250.  
  251.     
  252.     def encode(self, out):
  253.         out.write('<value><dateTime.iso8601>')
  254.         out.write(self.value)
  255.         out.write('</dateTime.iso8601></value>\n')
  256.  
  257.  
  258.  
  259. def _datetime(data):
  260.     value = DateTime()
  261.     value.decode(data)
  262.     return value
  263.  
  264.  
  265. def _datetime_type(data):
  266.     t = time.strptime(data, '%Y%m%dT%H:%M:%S')
  267.     return datetime.datetime(*tuple(t)[:6])
  268.  
  269. import base64
  270.  
  271. try:
  272.     import cStringIO as StringIO
  273. except ImportError:
  274.     import StringIO
  275.  
  276.  
  277. class Binary:
  278.     
  279.     def __init__(self, data = None):
  280.         self.data = data
  281.  
  282.     
  283.     def __str__(self):
  284.         if not self.data:
  285.             pass
  286.         return ''
  287.  
  288.     
  289.     def __cmp__(self, other):
  290.         if isinstance(other, Binary):
  291.             other = other.data
  292.         
  293.         return cmp(self.data, other)
  294.  
  295.     
  296.     def decode(self, data):
  297.         self.data = base64.decodestring(data)
  298.  
  299.     
  300.     def encode(self, out):
  301.         out.write('<value><base64>\n')
  302.         base64.encode(StringIO.StringIO(self.data), out)
  303.         out.write('</base64></value>\n')
  304.  
  305.  
  306.  
  307. def _binary(data):
  308.     value = Binary()
  309.     value.decode(data)
  310.     return value
  311.  
  312. WRAPPERS = (DateTime, Binary)
  313. if not _bool_is_builtin:
  314.     WRAPPERS = WRAPPERS + (Boolean,)
  315.  
  316.  
  317. try:
  318.     import _xmlrpclib
  319.     FastParser = _xmlrpclib.Parser
  320.     FastUnmarshaller = _xmlrpclib.Unmarshaller
  321. except (AttributeError, ImportError):
  322.     FastParser = None
  323.     FastUnmarshaller = None
  324.  
  325.  
  326. try:
  327.     import _xmlrpclib
  328.     FastMarshaller = _xmlrpclib.Marshaller
  329. except (AttributeError, ImportError):
  330.     FastMarshaller = None
  331.  
  332.  
  333. try:
  334.     import sgmlop
  335.     if not hasattr(sgmlop, 'XMLParser'):
  336.         raise ImportError
  337.     hasattr(sgmlop, 'XMLParser')
  338. except ImportError:
  339.     SgmlopParser = None
  340.  
  341.  
  342. class SgmlopParser:
  343.     
  344.     def __init__(self, target):
  345.         self.finish_starttag = target.start
  346.         self.finish_endtag = target.end
  347.         self.handle_data = target.data
  348.         self.handle_xml = target.xml
  349.         self.parser = sgmlop.XMLParser()
  350.         self.parser.register(self)
  351.         self.feed = self.parser.feed
  352.         self.entity = {
  353.             'amp': '&',
  354.             'gt': '>',
  355.             'lt': '<',
  356.             'apos': "'",
  357.             'quot': '"' }
  358.  
  359.     
  360.     def close(self):
  361.         
  362.         try:
  363.             self.parser.close()
  364.         finally:
  365.             self.parser = None
  366.             self.feed = None
  367.  
  368.  
  369.     
  370.     def handle_proc(self, tag, attr):
  371.         m = re.search('encoding\\s*=\\s*[\'"]([^"\']+)["\']', attr)
  372.         if m:
  373.             self.handle_xml(m.group(1), 1)
  374.         
  375.  
  376.     
  377.     def handle_entityref(self, entity):
  378.         
  379.         try:
  380.             self.handle_data(self.entity[entity])
  381.         except KeyError:
  382.             self.handle_data('&%s;' % entity)
  383.  
  384.  
  385.  
  386.  
  387. try:
  388.     from xml.parsers import expat
  389.     if not hasattr(expat, 'ParserCreate'):
  390.         raise ImportError
  391.     hasattr(expat, 'ParserCreate')
  392. except ImportError:
  393.     ExpatParser = None
  394.  
  395.  
  396. class ExpatParser:
  397.     
  398.     def __init__(self, target):
  399.         self._parser = parser = expat.ParserCreate(None, None)
  400.         self._target = target
  401.         parser.StartElementHandler = target.start
  402.         parser.EndElementHandler = target.end
  403.         parser.CharacterDataHandler = target.data
  404.         encoding = None
  405.         if not parser.returns_unicode:
  406.             encoding = 'utf-8'
  407.         
  408.         target.xml(encoding, None)
  409.  
  410.     
  411.     def feed(self, data):
  412.         self._parser.Parse(data, 0)
  413.  
  414.     
  415.     def close(self):
  416.         self._parser.Parse('', 1)
  417.         del self._target
  418.         del self._parser
  419.  
  420.  
  421.  
  422. class SlowParser:
  423.     
  424.     def __init__(self, target):
  425.         import xmllib
  426.         if xmllib.XMLParser not in SlowParser.__bases__:
  427.             SlowParser.__bases__ = (xmllib.XMLParser,)
  428.         
  429.         self.handle_xml = target.xml
  430.         self.unknown_starttag = target.start
  431.         self.handle_data = target.data
  432.         self.handle_cdata = target.data
  433.         self.unknown_endtag = target.end
  434.         
  435.         try:
  436.             xmllib.XMLParser.__init__(self, accept_utf8 = 1)
  437.         except TypeError:
  438.             xmllib.XMLParser.__init__(self)
  439.  
  440.  
  441.  
  442.  
  443. class Marshaller:
  444.     
  445.     def __init__(self, encoding = None, allow_none = 0):
  446.         self.memo = { }
  447.         self.data = None
  448.         self.encoding = encoding
  449.         self.allow_none = allow_none
  450.  
  451.     dispatch = { }
  452.     
  453.     def dumps(self, values):
  454.         out = []
  455.         write = out.append
  456.         dump = self._Marshaller__dump
  457.         if isinstance(values, Fault):
  458.             write('<fault>\n')
  459.             dump({
  460.                 'faultCode': values.faultCode,
  461.                 'faultString': values.faultString }, write)
  462.             write('</fault>\n')
  463.         else:
  464.             write('<params>\n')
  465.             for v in values:
  466.                 write('<param>\n')
  467.                 dump(v, write)
  468.                 write('</param>\n')
  469.             
  470.             write('</params>\n')
  471.         result = string.join(out, '')
  472.         return result
  473.  
  474.     
  475.     def __dump(self, value, write):
  476.         
  477.         try:
  478.             f = self.dispatch[type(value)]
  479.         except KeyError:
  480.             
  481.             try:
  482.                 value.__dict__
  483.             except:
  484.                 raise TypeError, 'cannot marshal %s objects' % type(value)
  485.  
  486.             for type_ in type(value).__mro__:
  487.                 if type_ in self.dispatch.keys():
  488.                     raise TypeError, 'cannot marshal %s objects' % type(value)
  489.                 type_ in self.dispatch.keys()
  490.             
  491.             f = self.dispatch[InstanceType]
  492.  
  493.         f(self, value, write)
  494.  
  495.     
  496.     def dump_nil(self, value, write):
  497.         if not self.allow_none:
  498.             raise TypeError, 'cannot marshal None unless allow_none is enabled'
  499.         self.allow_none
  500.         write('<value><nil/></value>')
  501.  
  502.     dispatch[NoneType] = dump_nil
  503.     
  504.     def dump_int(self, value, write):
  505.         if value > MAXINT or value < MININT:
  506.             raise OverflowError, 'int exceeds XML-RPC limits'
  507.         value < MININT
  508.         write('<value><int>')
  509.         write(str(value))
  510.         write('</int></value>\n')
  511.  
  512.     dispatch[IntType] = dump_int
  513.     if _bool_is_builtin:
  514.         
  515.         def dump_bool(self, value, write):
  516.             write('<value><boolean>')
  517.             if not value or '1':
  518.                 pass
  519.             write('0')
  520.             write('</boolean></value>\n')
  521.  
  522.         dispatch[bool] = dump_bool
  523.     
  524.     
  525.     def dump_long(self, value, write):
  526.         if value > MAXINT or value < MININT:
  527.             raise OverflowError, 'long int exceeds XML-RPC limits'
  528.         value < MININT
  529.         write('<value><int>')
  530.         write(str(int(value)))
  531.         write('</int></value>\n')
  532.  
  533.     dispatch[LongType] = dump_long
  534.     
  535.     def dump_double(self, value, write):
  536.         write('<value><double>')
  537.         write(repr(value))
  538.         write('</double></value>\n')
  539.  
  540.     dispatch[FloatType] = dump_double
  541.     
  542.     def dump_string(self, value, write, escape = escape):
  543.         write('<value><string>')
  544.         write(escape(value))
  545.         write('</string></value>\n')
  546.  
  547.     dispatch[StringType] = dump_string
  548.     if unicode:
  549.         
  550.         def dump_unicode(self, value, write, escape = escape):
  551.             value = value.encode(self.encoding)
  552.             write('<value><string>')
  553.             write(escape(value))
  554.             write('</string></value>\n')
  555.  
  556.         dispatch[UnicodeType] = dump_unicode
  557.     
  558.     
  559.     def dump_array(self, value, write):
  560.         i = id(value)
  561.         if i in self.memo:
  562.             raise TypeError, 'cannot marshal recursive sequences'
  563.         i in self.memo
  564.         self.memo[i] = None
  565.         dump = self._Marshaller__dump
  566.         write('<value><array><data>\n')
  567.         for v in value:
  568.             dump(v, write)
  569.         
  570.         write('</data></array></value>\n')
  571.         del self.memo[i]
  572.  
  573.     dispatch[TupleType] = dump_array
  574.     dispatch[ListType] = dump_array
  575.     
  576.     def dump_struct(self, value, write, escape = escape):
  577.         i = id(value)
  578.         if i in self.memo:
  579.             raise TypeError, 'cannot marshal recursive dictionaries'
  580.         i in self.memo
  581.         self.memo[i] = None
  582.         dump = self._Marshaller__dump
  583.         write('<value><struct>\n')
  584.         for k, v in value.items():
  585.             write('<member>\n')
  586.             if type(k) is not StringType:
  587.                 if unicode and type(k) is UnicodeType:
  588.                     k = k.encode(self.encoding)
  589.                 else:
  590.                     raise TypeError, 'dictionary key must be string'
  591.             type(k) is UnicodeType
  592.             write('<name>%s</name>\n' % escape(k))
  593.             dump(v, write)
  594.             write('</member>\n')
  595.         
  596.         write('</struct></value>\n')
  597.         del self.memo[i]
  598.  
  599.     dispatch[DictType] = dump_struct
  600.     if datetime:
  601.         
  602.         def dump_datetime(self, value, write):
  603.             write('<value><dateTime.iso8601>')
  604.             write(_strftime(value))
  605.             write('</dateTime.iso8601></value>\n')
  606.  
  607.         dispatch[datetime.datetime] = dump_datetime
  608.     
  609.     
  610.     def dump_instance(self, value, write):
  611.         if value.__class__ in WRAPPERS:
  612.             self.write = write
  613.             value.encode(self)
  614.             del self.write
  615.         else:
  616.             self.dump_struct(value.__dict__, write)
  617.  
  618.     dispatch[InstanceType] = dump_instance
  619.  
  620.  
  621. class Unmarshaller:
  622.     
  623.     def __init__(self, use_datetime = 0):
  624.         self._type = None
  625.         self._stack = []
  626.         self._marks = []
  627.         self._data = []
  628.         self._methodname = None
  629.         self._encoding = 'utf-8'
  630.         self.append = self._stack.append
  631.         self._use_datetime = use_datetime
  632.         if use_datetime and not datetime:
  633.             raise ValueError, 'the datetime module is not available'
  634.         not datetime
  635.  
  636.     
  637.     def close(self):
  638.         if self._type is None or self._marks:
  639.             raise ResponseError()
  640.         self._marks
  641.         if self._type == 'fault':
  642.             raise Fault(**self._stack[0])
  643.         self._type == 'fault'
  644.         return tuple(self._stack)
  645.  
  646.     
  647.     def getmethodname(self):
  648.         return self._methodname
  649.  
  650.     
  651.     def xml(self, encoding, standalone):
  652.         self._encoding = encoding
  653.  
  654.     
  655.     def start(self, tag, attrs):
  656.         if tag == 'array' or tag == 'struct':
  657.             self._marks.append(len(self._stack))
  658.         
  659.         self._data = []
  660.         self._value = tag == 'value'
  661.  
  662.     
  663.     def data(self, text):
  664.         self._data.append(text)
  665.  
  666.     
  667.     def end(self, tag, join = string.join):
  668.         
  669.         try:
  670.             f = self.dispatch[tag]
  671.         except KeyError:
  672.             pass
  673.  
  674.         return f(self, join(self._data, ''))
  675.  
  676.     
  677.     def end_dispatch(self, tag, data):
  678.         
  679.         try:
  680.             f = self.dispatch[tag]
  681.         except KeyError:
  682.             pass
  683.  
  684.         return f(self, data)
  685.  
  686.     dispatch = { }
  687.     
  688.     def end_nil(self, data):
  689.         self.append(None)
  690.         self._value = 0
  691.  
  692.     dispatch['nil'] = end_nil
  693.     
  694.     def end_boolean(self, data):
  695.         if data == '0':
  696.             self.append(False)
  697.         elif data == '1':
  698.             self.append(True)
  699.         else:
  700.             raise TypeError, 'bad boolean value'
  701.         self._value = data == '0'
  702.  
  703.     dispatch['boolean'] = end_boolean
  704.     
  705.     def end_int(self, data):
  706.         self.append(int(data))
  707.         self._value = 0
  708.  
  709.     dispatch['i4'] = end_int
  710.     dispatch['i8'] = end_int
  711.     dispatch['int'] = end_int
  712.     
  713.     def end_double(self, data):
  714.         self.append(float(data))
  715.         self._value = 0
  716.  
  717.     dispatch['double'] = end_double
  718.     
  719.     def end_string(self, data):
  720.         if self._encoding:
  721.             data = _decode(data, self._encoding)
  722.         
  723.         self.append(_stringify(data))
  724.         self._value = 0
  725.  
  726.     dispatch['string'] = end_string
  727.     dispatch['name'] = end_string
  728.     
  729.     def end_array(self, data):
  730.         mark = self._marks.pop()
  731.         self._stack[mark:] = [
  732.             self._stack[mark:]]
  733.         self._value = 0
  734.  
  735.     dispatch['array'] = end_array
  736.     
  737.     def end_struct(self, data):
  738.         mark = self._marks.pop()
  739.         dict = { }
  740.         items = self._stack[mark:]
  741.         for i in range(0, len(items), 2):
  742.             dict[_stringify(items[i])] = items[i + 1]
  743.         
  744.         self._stack[mark:] = [
  745.             dict]
  746.         self._value = 0
  747.  
  748.     dispatch['struct'] = end_struct
  749.     
  750.     def end_base64(self, data):
  751.         value = Binary()
  752.         value.decode(data)
  753.         self.append(value)
  754.         self._value = 0
  755.  
  756.     dispatch['base64'] = end_base64
  757.     
  758.     def end_dateTime(self, data):
  759.         value = DateTime()
  760.         value.decode(data)
  761.         if self._use_datetime:
  762.             value = _datetime_type(data)
  763.         
  764.         self.append(value)
  765.  
  766.     dispatch['dateTime.iso8601'] = end_dateTime
  767.     
  768.     def end_value(self, data):
  769.         if self._value:
  770.             self.end_string(data)
  771.         
  772.  
  773.     dispatch['value'] = end_value
  774.     
  775.     def end_params(self, data):
  776.         self._type = 'params'
  777.  
  778.     dispatch['params'] = end_params
  779.     
  780.     def end_fault(self, data):
  781.         self._type = 'fault'
  782.  
  783.     dispatch['fault'] = end_fault
  784.     
  785.     def end_methodName(self, data):
  786.         if self._encoding:
  787.             data = _decode(data, self._encoding)
  788.         
  789.         self._methodname = data
  790.         self._type = 'methodName'
  791.  
  792.     dispatch['methodName'] = end_methodName
  793.  
  794.  
  795. class _MultiCallMethod:
  796.     
  797.     def __init__(self, call_list, name):
  798.         self._MultiCallMethod__call_list = call_list
  799.         self._MultiCallMethod__name = name
  800.  
  801.     
  802.     def __getattr__(self, name):
  803.         return _MultiCallMethod(self._MultiCallMethod__call_list, '%s.%s' % (self._MultiCallMethod__name, name))
  804.  
  805.     
  806.     def __call__(self, *args):
  807.         self._MultiCallMethod__call_list.append((self._MultiCallMethod__name, args))
  808.  
  809.  
  810.  
  811. class MultiCallIterator:
  812.     
  813.     def __init__(self, results):
  814.         self.results = results
  815.  
  816.     
  817.     def __getitem__(self, i):
  818.         item = self.results[i]
  819.         if type(item) == type({ }):
  820.             raise Fault(item['faultCode'], item['faultString'])
  821.         type(item) == type({ })
  822.         if type(item) == type([]):
  823.             return item[0]
  824.         raise ValueError, 'unexpected type in multicall result'
  825.  
  826.  
  827.  
  828. class MultiCall:
  829.     
  830.     def __init__(self, server):
  831.         self._MultiCall__server = server
  832.         self._MultiCall__call_list = []
  833.  
  834.     
  835.     def __repr__(self):
  836.         return '<MultiCall at %x>' % id(self)
  837.  
  838.     __str__ = __repr__
  839.     
  840.     def __getattr__(self, name):
  841.         return _MultiCallMethod(self._MultiCall__call_list, name)
  842.  
  843.     
  844.     def __call__(self):
  845.         marshalled_list = []
  846.         for name, args in self._MultiCall__call_list:
  847.             marshalled_list.append({
  848.                 'methodName': name,
  849.                 'params': args })
  850.         
  851.         return MultiCallIterator(self._MultiCall__server.system.multicall(marshalled_list))
  852.  
  853.  
  854.  
  855. def getparser(use_datetime = 0):
  856.     if use_datetime and not datetime:
  857.         raise ValueError, 'the datetime module is not available'
  858.     not datetime
  859.     if FastParser and FastUnmarshaller:
  860.         if use_datetime:
  861.             mkdatetime = _datetime_type
  862.         else:
  863.             mkdatetime = _datetime
  864.         target = FastUnmarshaller(True, False, _binary, mkdatetime, Fault)
  865.         parser = FastParser(target)
  866.     else:
  867.         target = Unmarshaller(use_datetime = use_datetime)
  868.         if FastParser:
  869.             parser = FastParser(target)
  870.         elif SgmlopParser:
  871.             parser = SgmlopParser(target)
  872.         elif ExpatParser:
  873.             parser = ExpatParser(target)
  874.         else:
  875.             parser = SlowParser(target)
  876.     return (parser, target)
  877.  
  878.  
  879. def dumps(params, methodname = None, methodresponse = None, encoding = None, allow_none = 0):
  880.     if isinstance(params, Fault):
  881.         methodresponse = 1
  882.     elif methodresponse and isinstance(params, TupleType):
  883.         pass
  884.     
  885.     if not encoding:
  886.         encoding = 'utf-8'
  887.     
  888.     if FastMarshaller:
  889.         m = FastMarshaller(encoding)
  890.     else:
  891.         m = Marshaller(encoding, allow_none)
  892.     data = m.dumps(params)
  893.     if encoding != 'utf-8':
  894.         xmlheader = "<?xml version='1.0' encoding='%s'?>\n" % str(encoding)
  895.     else:
  896.         xmlheader = "<?xml version='1.0'?>\n"
  897.     if methodname:
  898.         if not isinstance(methodname, StringType):
  899.             methodname = methodname.encode(encoding)
  900.         
  901.         data = (xmlheader, '<methodCall>\n<methodName>', methodname, '</methodName>\n', data, '</methodCall>\n')
  902.     elif methodresponse:
  903.         data = (xmlheader, '<methodResponse>\n', data, '</methodResponse>\n')
  904.     else:
  905.         return data
  906.     return methodname.join(data, '')
  907.  
  908.  
  909. def loads(data, use_datetime = 0):
  910.     (p, u) = getparser(use_datetime = use_datetime)
  911.     p.feed(data)
  912.     p.close()
  913.     return (u.close(), u.getmethodname())
  914.  
  915.  
  916. class _Method:
  917.     
  918.     def __init__(self, send, name):
  919.         self._Method__send = send
  920.         self._Method__name = name
  921.  
  922.     
  923.     def __getattr__(self, name):
  924.         return _Method(self._Method__send, '%s.%s' % (self._Method__name, name))
  925.  
  926.     
  927.     def __call__(self, *args):
  928.         return self._Method__send(self._Method__name, args)
  929.  
  930.  
  931.  
  932. class Transport:
  933.     user_agent = 'xmlrpclib.py/%s (by www.pythonware.com)' % __version__
  934.     
  935.     def __init__(self, use_datetime = 0):
  936.         self._use_datetime = use_datetime
  937.  
  938.     
  939.     def request(self, host, handler, request_body, verbose = 0):
  940.         h = self.make_connection(host)
  941.         if verbose:
  942.             h.set_debuglevel(1)
  943.         
  944.         self.send_request(h, handler, request_body)
  945.         self.send_host(h, host)
  946.         self.send_user_agent(h)
  947.         self.send_content(h, request_body)
  948.         (errcode, errmsg, headers) = h.getreply()
  949.         if errcode != 200:
  950.             raise ProtocolError(host + handler, errcode, errmsg, headers)
  951.         errcode != 200
  952.         self.verbose = verbose
  953.         
  954.         try:
  955.             sock = h._conn.sock
  956.         except AttributeError:
  957.             sock = None
  958.  
  959.         return self._parse_response(h.getfile(), sock)
  960.  
  961.     
  962.     def getparser(self):
  963.         return getparser(use_datetime = self._use_datetime)
  964.  
  965.     
  966.     def get_host_info(self, host):
  967.         x509 = { }
  968.         if isinstance(host, TupleType):
  969.             (host, x509) = host
  970.         
  971.         import urllib
  972.         (auth, host) = urllib.splituser(host)
  973.         if auth:
  974.             import base64
  975.             auth = base64.encodestring(urllib.unquote(auth))
  976.             auth = string.join(string.split(auth), '')
  977.             extra_headers = [
  978.                 ('Authorization', 'Basic ' + auth)]
  979.         else:
  980.             extra_headers = None
  981.         return (host, extra_headers, x509)
  982.  
  983.     
  984.     def make_connection(self, host):
  985.         import httplib
  986.         (host, extra_headers, x509) = self.get_host_info(host)
  987.         return httplib.HTTP(host)
  988.  
  989.     
  990.     def send_request(self, connection, handler, request_body):
  991.         connection.putrequest('POST', handler)
  992.  
  993.     
  994.     def send_host(self, connection, host):
  995.         (host, extra_headers, x509) = self.get_host_info(host)
  996.         connection.putheader('Host', host)
  997.         if extra_headers:
  998.             if isinstance(extra_headers, DictType):
  999.                 extra_headers = extra_headers.items()
  1000.             
  1001.             for key, value in extra_headers:
  1002.                 connection.putheader(key, value)
  1003.             
  1004.         
  1005.  
  1006.     
  1007.     def send_user_agent(self, connection):
  1008.         connection.putheader('User-Agent', self.user_agent)
  1009.  
  1010.     
  1011.     def send_content(self, connection, request_body):
  1012.         connection.putheader('Content-Type', 'text/xml')
  1013.         connection.putheader('Content-Length', str(len(request_body)))
  1014.         connection.endheaders()
  1015.         if request_body:
  1016.             connection.send(request_body)
  1017.         
  1018.  
  1019.     
  1020.     def parse_response(self, file):
  1021.         return self._parse_response(file, None)
  1022.  
  1023.     
  1024.     def _parse_response(self, file, sock):
  1025.         (p, u) = self.getparser()
  1026.         while sock:
  1027.             response = sock.recv(1024)
  1028.         response = file.read(1024)
  1029.         if not response:
  1030.             break
  1031.         
  1032.         if self.verbose:
  1033.             print 'body:', repr(response)
  1034.         
  1035.         p.feed(response)
  1036.         continue
  1037.         file.close()
  1038.         p.close()
  1039.         return u.close()
  1040.  
  1041.  
  1042.  
  1043. class SafeTransport(Transport):
  1044.     
  1045.     def make_connection(self, host):
  1046.         import httplib
  1047.         (host, extra_headers, x509) = self.get_host_info(host)
  1048.         
  1049.         try:
  1050.             HTTPS = httplib.HTTPS
  1051.         except AttributeError:
  1052.             raise NotImplementedError("your version of httplib doesn't support HTTPS")
  1053.  
  1054.         if not x509:
  1055.             pass
  1056.         return HTTPS(host, None, **{ })
  1057.  
  1058.  
  1059.  
  1060. class ServerProxy:
  1061.     
  1062.     def __init__(self, uri, transport = None, encoding = None, verbose = 0, allow_none = 0, use_datetime = 0):
  1063.         import urllib
  1064.         (type, uri) = urllib.splittype(uri)
  1065.         if type not in ('http', 'https'):
  1066.             raise IOError, 'unsupported XML-RPC protocol'
  1067.         type not in ('http', 'https')
  1068.         (self._ServerProxy__host, self._ServerProxy__handler) = urllib.splithost(uri)
  1069.         if not self._ServerProxy__handler:
  1070.             self._ServerProxy__handler = '/RPC2'
  1071.         
  1072.         if transport is None:
  1073.             if type == 'https':
  1074.                 transport = SafeTransport(use_datetime = use_datetime)
  1075.             else:
  1076.                 transport = Transport(use_datetime = use_datetime)
  1077.         
  1078.         self._ServerProxy__transport = transport
  1079.         self._ServerProxy__encoding = encoding
  1080.         self._ServerProxy__verbose = verbose
  1081.         self._ServerProxy__allow_none = allow_none
  1082.  
  1083.     
  1084.     def __request(self, methodname, params):
  1085.         request = dumps(params, methodname, encoding = self._ServerProxy__encoding, allow_none = self._ServerProxy__allow_none)
  1086.         response = self._ServerProxy__transport.request(self._ServerProxy__host, self._ServerProxy__handler, request, verbose = self._ServerProxy__verbose)
  1087.         if len(response) == 1:
  1088.             response = response[0]
  1089.         
  1090.         return response
  1091.  
  1092.     
  1093.     def __repr__(self):
  1094.         return '<ServerProxy for %s%s>' % (self._ServerProxy__host, self._ServerProxy__handler)
  1095.  
  1096.     __str__ = __repr__
  1097.     
  1098.     def __getattr__(self, name):
  1099.         return _Method(self._ServerProxy__request, name)
  1100.  
  1101.  
  1102. Server = ServerProxy
  1103. if __name__ == '__main__':
  1104.     server = ServerProxy('http://time.xmlrpc.com/RPC2')
  1105.     print server
  1106.     
  1107.     try:
  1108.         print server.currentTime.getCurrentTime()
  1109.     except Error:
  1110.         v = None
  1111.         print 'ERROR', v
  1112.  
  1113.     multi = MultiCall(server)
  1114.     multi.currentTime.getCurrentTime()
  1115.     multi.currentTime.getCurrentTime()
  1116.     
  1117.     try:
  1118.         for response in multi():
  1119.             print response
  1120.     except Error:
  1121.         v = None
  1122.         print 'ERROR', v
  1123.     except:
  1124.         None<EXCEPTION MATCH>Error
  1125.     
  1126.  
  1127. None<EXCEPTION MATCH>Error
  1128.