path: root/xmlrpc.txt

Help on module xmlrpclib:

NAME
    xmlrpclib - An XML-RPC client interface for Python.

FILE
    /usr/lib/python2.5/xmlrpclib.py

MODULE DOCS
    http://www.python.org/doc/current/lib/module-xmlrpclib.html

DESCRIPTION
    The marshalling and response parser code can also be used to
    implement XML-RPC servers.
    
    Exported exceptions:
    
      Error          Base class for client errors
      ProtocolError  Indicates an HTTP protocol error
      ResponseError  Indicates a broken response package
      Fault          Indicates an XML-RPC fault package
    
    Exported classes:
    
      ServerProxy    Represents a logical connection to an XML-RPC server
    
      MultiCall      Executor of boxcared xmlrpc requests
      Boolean        boolean wrapper to generate a "boolean" XML-RPC value
      DateTime       dateTime wrapper for an ISO 8601 string or time tuple or
                     localtime integer value to generate a "dateTime.iso8601"
                     XML-RPC value
      Binary         binary data wrapper
    
      SlowParser     Slow but safe standard parser (based on xmllib)
      Marshaller     Generate an XML-RPC params chunk from a Python data structure
      Unmarshaller   Unmarshal an XML-RPC response from incoming XML event message
      Transport      Handles an HTTP transaction to an XML-RPC server
      SafeTransport  Handles an HTTPS transaction to an XML-RPC server
    
    Exported constants:
    
      True
      False
    
    Exported functions:
    
      boolean        Convert any Python value to an XML-RPC boolean
      getparser      Create instance of the fastest available parser & attach
                     to an unmarshalling object
      dumps          Convert an argument tuple or a Fault instance to an XML-RPC
                     request (or response, if the methodresponse option is used).
      loads          Convert an XML-RPC packet to unmarshalled data plus a method
                     name (None if not present).

CLASSES
    exceptions.Exception(exceptions.BaseException)
        Error
            Fault
            ProtocolError
            ResponseError
    Binary
    DateTime
    ExpatParser
    Marshaller
    MultiCall
    MultiCallIterator
    ServerProxy
    SlowParser
    Transport
        SafeTransport
    Unmarshaller
    
    class Binary
     |  Wrapper for binary data.
     |  
     |  Methods defined here:
     |  
     |  __cmp__(self, other)
     |  
     |  __init__(self, data=None)
     |  
     |  __str__(self)
     |  
     |  decode(self, data)
     |  
     |  encode(self, out)
    
    class DateTime
     |  DateTime wrapper for an ISO 8601 string or time tuple or
     |  localtime integer value to generate 'dateTime.iso8601' XML-RPC
     |  value.
     |  
     |  Methods defined here:
     |  
     |  __cmp__(self, other)
     |  
     |  __init__(self, value=0)
     |  
     |  __repr__(self)
     |  
     |  __str__(self)
     |  
     |  decode(self, data)
     |  
     |  encode(self, out)
    
    class Error(exceptions.Exception)
     |  Base class for client errors.
     |  
     |  Method resolution order:
     |      Error
     |      exceptions.Exception
     |      exceptions.BaseException
     |      __builtin__.object
     |  
     |  Methods defined here:
     |  
     |  __str__(self)
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from exceptions.Exception:
     |  
     |  __init__(...)
     |      x.__init__(...) initializes x; see x.__class__.__doc__ for signature
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from exceptions.Exception:
     |  
     |  __new__ = <built-in method __new__ of type object at 0x6eb8560>
     |      T.__new__(S, ...) -> a new object with type S, a subtype of T
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from exceptions.BaseException:
     |  
     |  __delattr__(...)
     |      x.__delattr__('name') <==> del x.name
     |  
     |  __getattribute__(...)
     |      x.__getattribute__('name') <==> x.name
     |  
     |  __getitem__(...)
     |      x.__getitem__(y) <==> x[y]
     |  
     |  __getslice__(...)
     |      x.__getslice__(i, j) <==> x[i:j]
     |      
     |      Use of negative indices is not supported.
     |  
     |  __reduce__(...)
     |  
     |  __repr__(...)
     |      x.__repr__() <==> repr(x)
     |  
     |  __setattr__(...)
     |      x.__setattr__('name', value) <==> x.name = value
     |  
     |  __setstate__(...)
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from exceptions.BaseException:
     |  
     |  __dict__
     |  
     |  args
     |  
     |  message
     |      exception message
    
    class ExpatParser
     |  Methods defined here:
     |  
     |  __init__(self, target)
     |      # fast expat parser for Python 2.0 and later.  this is about
     |      # 50% slower than sgmlop, on roundtrip testing
     |  
     |  close(self)
     |  
     |  feed(self, data)
    
    class Fault(Error)
     |  Indicates an XML-RPC fault package.
     |  
     |  Method resolution order:
     |      Fault
     |      Error
     |      exceptions.Exception
     |      exceptions.BaseException
     |      __builtin__.object
     |  
     |  Methods defined here:
     |  
     |  __init__(self, faultCode, faultString, **extra)
     |  
     |  __repr__(self)
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from Error:
     |  
     |  __str__(self)
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Error:
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from exceptions.Exception:
     |  
     |  __new__ = <built-in method __new__ of type object at 0x6eb8560>
     |      T.__new__(S, ...) -> a new object with type S, a subtype of T
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from exceptions.BaseException:
     |  
     |  __delattr__(...)
     |      x.__delattr__('name') <==> del x.name
     |  
     |  __getattribute__(...)
     |      x.__getattribute__('name') <==> x.name
     |  
     |  __getitem__(...)
     |      x.__getitem__(y) <==> x[y]
     |  
     |  __getslice__(...)
     |      x.__getslice__(i, j) <==> x[i:j]
     |      
     |      Use of negative indices is not supported.
     |  
     |  __reduce__(...)
     |  
     |  __setattr__(...)
     |      x.__setattr__('name', value) <==> x.name = value
     |  
     |  __setstate__(...)
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from exceptions.BaseException:
     |  
     |  __dict__
     |  
     |  args
     |  
     |  message
     |      exception message
    
    class Marshaller
     |  Generate an XML-RPC params chunk from a Python data structure.
     |  
     |  Create a Marshaller instance for each set of parameters, and use
     |  the "dumps" method to convert your data (represented as a tuple)
     |  to an XML-RPC params chunk.  To write a fault response, pass a
     |  Fault instance instead.  You may prefer to use the "dumps" module
     |  function for this purpose.
     |  
     |  Methods defined here:
     |  
     |  __init__(self, encoding=None, allow_none=0)
     |  
     |  dump_array(self, value, write)
     |  
     |  dump_bool(self, value, write)
     |  
     |  dump_date(self, value, write)
     |  
     |  dump_datetime(self, value, write)
     |  
     |  dump_double(self, value, write)
     |  
     |  dump_instance(self, value, write)
     |  
     |  dump_int(self, value, write)
     |  
     |  dump_long(self, value, write)
     |  
     |  dump_nil(self, value, write)
     |  
     |  dump_string(self, value, write, escape=<function escape at 0xb7de0304>)
     |  
     |  dump_struct(self, value, write, escape=<function escape at 0xb7de0304>)
     |  
     |  dump_time(self, value, write)
     |  
     |  dump_unicode(self, value, write, escape=<function escape at 0xb7de0304>)
     |  
     |  dumps(self, values)
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  dispatch = {<type 'datetime.date'>: <function dump_date at 0xb7d68d4c>...
    
    class MultiCall
     |  server -> a object used to boxcar method calls
     |  
     |  server should be a ServerProxy object.
     |  
     |  Methods can be added to the MultiCall using normal
     |  method call syntax e.g.:
     |  
     |  multicall = MultiCall(server_proxy)
     |  multicall.add(2,3)
     |  multicall.get_address("Guido")
     |  
     |  To execute the multicall, call the MultiCall object e.g.:
     |  
     |  add_result, address = multicall()
     |  
     |  Methods defined here:
     |  
     |  __call__(self)
     |  
     |  __getattr__(self, name)
     |  
     |  __init__(self, server)
     |  
     |  __repr__(self)
     |  
     |  __str__ = __repr__(self)
    
    class MultiCallIterator
     |  Iterates over the results of a multicall. Exceptions are
     |  thrown in response to xmlrpc faults.
     |  
     |  Methods defined here:
     |  
     |  __getitem__(self, i)
     |  
     |  __init__(self, results)
    
    class ProtocolError(Error)
     |  Indicates an HTTP protocol error.
     |  
     |  Method resolution order:
     |      ProtocolError
     |      Error
     |      exceptions.Exception
     |      exceptions.BaseException
     |      __builtin__.object
     |  
     |  Methods defined here:
     |  
     |  __init__(self, url, errcode, errmsg, headers)
     |  
     |  __repr__(self)
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from Error:
     |  
     |  __str__(self)
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Error:
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from exceptions.Exception:
     |  
     |  __new__ = <built-in method __new__ of type object at 0x6eb8560>
     |      T.__new__(S, ...) -> a new object with type S, a subtype of T
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from exceptions.BaseException:
     |  
     |  __delattr__(...)
     |      x.__delattr__('name') <==> del x.name
     |  
     |  __getattribute__(...)
     |      x.__getattribute__('name') <==> x.name
     |  
     |  __getitem__(...)
     |      x.__getitem__(y) <==> x[y]
     |  
     |  __getslice__(...)
     |      x.__getslice__(i, j) <==> x[i:j]
     |      
     |      Use of negative indices is not supported.
     |  
     |  __reduce__(...)
     |  
     |  __setattr__(...)
     |      x.__setattr__('name', value) <==> x.name = value
     |  
     |  __setstate__(...)
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from exceptions.BaseException:
     |  
     |  __dict__
     |  
     |  args
     |  
     |  message
     |      exception message
    
    class ResponseError(Error)
     |  Indicates a broken response package.
     |  
     |  Method resolution order:
     |      ResponseError
     |      Error
     |      exceptions.Exception
     |      exceptions.BaseException
     |      __builtin__.object
     |  
     |  Methods inherited from Error:
     |  
     |  __str__(self)
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Error:
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from exceptions.Exception:
     |  
     |  __init__(...)
     |      x.__init__(...) initializes x; see x.__class__.__doc__ for signature
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from exceptions.Exception:
     |  
     |  __new__ = <built-in method __new__ of type object at 0x6eb8560>
     |      T.__new__(S, ...) -> a new object with type S, a subtype of T
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from exceptions.BaseException:
     |  
     |  __delattr__(...)
     |      x.__delattr__('name') <==> del x.name
     |  
     |  __getattribute__(...)
     |      x.__getattribute__('name') <==> x.name
     |  
     |  __getitem__(...)
     |      x.__getitem__(y) <==> x[y]
     |  
     |  __getslice__(...)
     |      x.__getslice__(i, j) <==> x[i:j]
     |      
     |      Use of negative indices is not supported.
     |  
     |  __reduce__(...)
     |  
     |  __repr__(...)
     |      x.__repr__() <==> repr(x)
     |  
     |  __setattr__(...)
     |      x.__setattr__('name', value) <==> x.name = value
     |  
     |  __setstate__(...)
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from exceptions.BaseException:
     |  
     |  __dict__
     |  
     |  args
     |  
     |  message
     |      exception message
    
    class SafeTransport(Transport)
     |  Handles an HTTPS transaction to an XML-RPC server.
     |  
     |  Methods defined here:
     |  
     |  make_connection(self, host)
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from Transport:
     |  
     |  __init__(self, use_datetime=0)
     |  
     |  get_host_info(self, host)
     |  
     |  getparser(self)
     |  
     |  parse_response(self, file)
     |  
     |  request(self, host, handler, request_body, verbose=0)
     |  
     |  send_content(self, connection, request_body)
     |  
     |  send_host(self, connection, host)
     |  
     |  send_request(self, connection, handler, request_body)
     |  
     |  send_user_agent(self, connection)
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from Transport:
     |  
     |  user_agent = 'xmlrpclib.py/1.0.1 (by www.pythonware.com)'
    
    Server = class ServerProxy
     |  uri [,options] -> a logical connection to an XML-RPC server
     |  
     |  uri is the connection point on the server, given as
     |  scheme://host/target.
     |  
     |  The standard implementation always supports the "http" scheme.  If
     |  SSL socket support is available (Python 2.0), it also supports
     |  "https".
     |  
     |  If the target part and the slash preceding it are both omitted,
     |  "/RPC2" is assumed.
     |  
     |  The following options can be given as keyword arguments:
     |  
     |      transport: a transport factory
     |      encoding: the request encoding (default is UTF-8)
     |  
     |  All 8-bit strings passed to the server proxy are assumed to use
     |  the given encoding.
     |  
     |  Methods defined here:
     |  
     |  __getattr__(self, name)
     |  
     |  __init__(self, uri, transport=None, encoding=None, verbose=0, allow_none=0, use_datetime=0)
     |  
     |  __repr__(self)
     |  
     |  __str__ = __repr__(self)
    
    class ServerProxy
     |  uri [,options] -> a logical connection to an XML-RPC server
     |  
     |  uri is the connection point on the server, given as
     |  scheme://host/target.
     |  
     |  The standard implementation always supports the "http" scheme.  If
     |  SSL socket support is available (Python 2.0), it also supports
     |  "https".
     |  
     |  If the target part and the slash preceding it are both omitted,
     |  "/RPC2" is assumed.
     |  
     |  The following options can be given as keyword arguments:
     |  
     |      transport: a transport factory
     |      encoding: the request encoding (default is UTF-8)
     |  
     |  All 8-bit strings passed to the server proxy are assumed to use
     |  the given encoding.
     |  
     |  Methods defined here:
     |  
     |  __getattr__(self, name)
     |  
     |  __init__(self, uri, transport=None, encoding=None, verbose=0, allow_none=0, use_datetime=0)
     |  
     |  __repr__(self)
     |  
     |  __str__ = __repr__(self)
    
    class SlowParser
     |  Default XML parser (based on xmllib.XMLParser).
     |  
     |  Methods defined here:
     |  
     |  __init__(self, target)
     |      # this is about 10 times slower than sgmlop, on roundtrip
     |      # testing.
    
    class Transport
     |  Handles an HTTP transaction to an XML-RPC server.
     |  
     |  Methods defined here:
     |  
     |  __init__(self, use_datetime=0)
     |  
     |  get_host_info(self, host)
     |  
     |  getparser(self)
     |  
     |  make_connection(self, host)
     |  
     |  parse_response(self, file)
     |  
     |  request(self, host, handler, request_body, verbose=0)
     |  
     |  send_content(self, connection, request_body)
     |  
     |  send_host(self, connection, host)
     |  
     |  send_request(self, connection, handler, request_body)
     |  
     |  send_user_agent(self, connection)
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  user_agent = 'xmlrpclib.py/1.0.1 (by www.pythonware.com)'
    
    class Unmarshaller
     |  Unmarshal an XML-RPC response, based on incoming XML event
     |  messages (start, data, end).  Call close() to get the resulting
     |  data structure.
     |  
     |  Note that this reader is fairly tolerant, and gladly accepts bogus
     |  XML-RPC data without complaining (but not bogus XML).
     |  
     |  Methods defined here:
     |  
     |  __init__(self, use_datetime=0)
     |  
     |  close(self)
     |  
     |  data(self, text)
     |  
     |  end(self, tag, join=<function join at 0xb7db6294>)
     |  
     |  end_array(self, data)
     |  
     |  end_base64(self, data)
     |  
     |  end_boolean(self, data)
     |  
     |  end_dateTime(self, data)
     |  
     |  end_dispatch(self, tag, data)
     |  
     |  end_double(self, data)
     |  
     |  end_fault(self, data)
     |  
     |  end_int(self, data)
     |  
     |  end_methodName(self, data)
     |  
     |  end_nil(self, data)
     |  
     |  end_params(self, data)
     |  
     |  end_string(self, data)
     |  
     |  end_struct(self, data)
     |  
     |  end_value(self, data)
     |  
     |  getmethodname(self)
     |  
     |  start(self, tag, attrs)
     |  
     |  xml(self, encoding, standalone)
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  dispatch = {'array': <function end_array at 0xb7d6a10c>, 'base64': <fu...

FUNCTIONS
    dumps(params, methodname=None, methodresponse=None, encoding=None, allow_none=0)
        data [,options] -> marshalled data
        
        Convert an argument tuple or a Fault instance to an XML-RPC
        request (or response, if the methodresponse option is used).
        
        In addition to the data object, the following options can be given
        as keyword arguments:
        
            methodname: the method name for a methodCall packet
        
            methodresponse: true to create a methodResponse packet.
            If this option is used with a tuple, the tuple must be
            a singleton (i.e. it can contain only one element).
        
            encoding: the packet encoding (default is UTF-8)
        
        All 8-bit strings in the data structure are assumed to use the
        packet encoding.  Unicode strings are automatically converted,
        where necessary.
    
    escape(s, replace=<function replace at 0xb7db6614>)
    
    getparser(use_datetime=0)
        getparser() -> parser, unmarshaller
        
        Create an instance of the fastest available parser, and attach it
        to an unmarshalling object.  Return both objects.
    
    loads(data, use_datetime=0)
        data -> unmarshalled data, method name
        
        Convert an XML-RPC packet to unmarshalled data plus a method
        name (None if not present).
        
        If the XML-RPC packet represents a fault condition, this function
        raises a Fault exception.

DATA
    APPLICATION_ERROR = -32500
    False = False
    FastMarshaller = None
    FastParser = None
    FastUnmarshaller = None
    INTERNAL_ERROR = -32603
    INVALID_ENCODING_CHAR = -32702
    INVALID_METHOD_PARAMS = -32602
    INVALID_XMLRPC = -32600
    MAXINT = 2147483647L
    METHOD_NOT_FOUND = -32601
    MININT = -2147483648L
    NOT_WELLFORMED_ERROR = -32700
    PARSE_ERROR = -32700
    SERVER_ERROR = -32600
    SYSTEM_ERROR = -32400
    SgmlopParser = None
    StringTypes = (<type 'str'>, <type 'unicode'>)
    TRANSPORT_ERROR = -32300
    True = True
    UNSUPPORTED_ENCODING = -32701
    WRAPPERS = (<class xmlrpclib.DateTime at 0xb7ddaadc>, <class xmlrpclib...
    __version__ = '1.0.1'

VERSION
    1.0.1