xmlrpclib (version 1.0.1)
index
/usr/local/lib/python2.5/xmlrpclib.py
Module Docs

An XML-RPC client interface for Python.
 
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).

 
Modules
       
cStringIO
base64
datetime
xml.parsers.expat
operator
re
string
time

 
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 0x8125440>
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 0x8125440>
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 0xb716d684>)
dump_struct(self, value, write, escape=<function escape at 0xb716d684>)
dump_time(self, value, write)
dump_unicode(self, value, write, escape=<function escape at 0xb716d684>)
dumps(self, values)

Data and other attributes defined here:
dispatch = {<type 'datetime.date'>: <function dump_date at 0xb7179b1c>, <type 'datetime.time'>: <function dump_time at 0xb7179b54>, <type 'datetime.datetime'>: <function dump_datetime at 0xb7179ae4>, <type 'bool'>: <function dump_bool at 0xb717995c>, <type 'instance'>: <function dump_instance at 0xb7179b8c>, <type 'float'>: <function dump_double at 0xb71799cc>, <type 'int'>: <function dump_int at 0xb7179924>, <type 'list'>: <function dump_array at 0xb7179a74>, <type 'long'>: <function dump_long at 0xb7179994>, <type 'dict'>: <function dump_struct at 0xb7179aac>, ...}

 
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 0x8125440>
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 0x8125440>
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 0xb721ee9c>)
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 0xb7179e9c>, 'base64': <function end_base64 at 0xb7179f0c>, 'boolean': <function end_boolean at 0xb7179dbc>, 'dateTime.iso8601': <function end_dateTime at 0xb7179f44>, 'double': <function end_double at 0xb7179e2c>, 'fault': <function end_fault at 0xb717a02c>, 'i4': <function end_int at 0xb7179df4>, 'int': <function end_int at 0xb7179df4>, 'methodName': <function end_methodName at 0xb717a064>, 'name': <function end_string at 0xb7179e64>, ...}

 
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 0xb722b25c>)
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 0xb71760bc>, <class xmlrpclib.Binary at 0xb717647c>)
__version__ = '1.0.1'