xmlrpclib (version 1.0.0)
index
/usr/lib/python2.2/xmlrpclib.py

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
 
  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
            
xml.parsers.expat
operator
re
string
time
 
Classes
            
Binary
Boolean
DateTime
exceptions.Exception
Error
Fault
ProtocolError
ResponseError
ExpatParser
Marshaller
ServerProxy
SlowParser
Transport
SafeTransport
Unmarshaller
_Method
 
class Binary
      Wrapper for binary data.
 
   Methods defined here:
__cmp__(self, other)
__init__(self, data=None)
decode(self, data)
encode(self, out)

Data and non-method functions defined here:
__doc__ = 'Wrapper for binary data.'
__module__ = 'xmlrpclib'
 
class Boolean
      Boolean-value wrapper.
 
Use True or False to generate a "boolean" XML-RPC value.
 
   Methods defined here:
__cmp__(self, other)
__init__(self, value=0)
__int__(self)
__nonzero__(self)
__repr__(self)
encode(self, out)

Data and non-method functions defined here:
__doc__ = 'Boolean-value wrapper.\n\n Use True or False to generate a "boolean" XML-RPC value.\n '
__module__ = 'xmlrpclib'
 
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)
decode(self, data)
encode(self, out)

Data and non-method functions defined here:
__doc__ = "DateTime wrapper for an ISO 8601 string or time...ate 'dateTime.iso8601' XML-RPC\n value.\n "
__module__ = 'xmlrpclib'
 
class Error(exceptions.Exception)
      Base class for client errors.
 
   Methods defined here:
__str__(self)

Data and non-method functions defined here:
__doc__ = 'Base class for client errors.'
__module__ = 'xmlrpclib'

Methods inherited from exceptions.Exception:
__getitem__(...)
__init__(...)
 
class ExpatParser
       
   Methods defined here:
__init__(self, target)
# fast expat parser for Python 2.0.  this is about 50%
# slower than sgmlop, on roundtrip testing
close(self)
feed(self, data)

Data and non-method functions defined here:
__doc__ = None
__module__ = 'xmlrpclib'
 
class Fault(Error)
      Indicates an XML-RPC fault package.
 
  
Method resolution order:
Fault
Error
exceptions.Exception

Methods defined here:
__init__(self, faultCode, faultString, **extra)
__repr__(self)

Data and non-method functions defined here:
__doc__ = 'Indicates an XML-RPC fault package.'
__module__ = 'xmlrpclib'

Methods inherited from Error:
__str__(self)

Methods inherited from exceptions.Exception:
__getitem__(...)
 
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:
_Marshaller__dump = __dump(self, value)
__init__(self, encoding=None)
closecontainer(self, value)
dump_array(self, value)
dump_double(self, value)
dump_instance(self, value)
dump_int(self, value)
dump_long(self, value)
dump_string(self, value, escape=<function escape>)
dump_struct(self, value, escape=<function escape>)
dump_unicode(self, value, escape=<function escape>)
dumps(self, values)
opencontainer(self, value)

Data and non-method functions defined here:
__doc__ = 'Generate an XML-RPC params chunk from a Python ...ps" module\n function for this purpose.\n '
__module__ = 'xmlrpclib'
dispatch = {<type 'str'>: <function dump_string>, <type 'tuple'>: <function dump_array>, <type 'unicode'>: <function dump_unicode>, <type 'instance'>: <function dump_instance>, <type 'float'>: <function dump_double>, <type 'int'>: <function dump_int>, <type 'list'>: <function dump_array>, <type 'long'>: <function dump_long>, <type 'dict'>: <function dump_struct>}
 
class ProtocolError(Error)
      Indicates an HTTP protocol error.
 
  
Method resolution order:
ProtocolError
Error
exceptions.Exception

Methods defined here:
__init__(self, url, errcode, errmsg, headers)
__repr__(self)

Data and non-method functions defined here:
__doc__ = 'Indicates an HTTP protocol error.'
__module__ = 'xmlrpclib'

Methods inherited from Error:
__str__(self)

Methods inherited from exceptions.Exception:
__getitem__(...)
 
class ResponseError(Error)
      Indicates a broken response package.
 
  
Method resolution order:
ResponseError
Error
exceptions.Exception

Data and non-method functions defined here:
__doc__ = 'Indicates a broken response package.'
__module__ = 'xmlrpclib'

Methods inherited from Error:
__str__(self)

Methods inherited from exceptions.Exception:
__getitem__(...)
__init__(...)
 
class SafeTransport(Transport)
      Handles an HTTPS transaction to an XML-RPC server.
 
   Methods defined here:
make_connection(self, host)
send_host(self, connection, host)

Data and non-method functions defined here:
__doc__ = 'Handles an HTTPS transaction to an XML-RPC server.'
__module__ = 'xmlrpclib'

Methods inherited from Transport:
getparser(self)
parse_response(self, f)
request(self, host, handler, request_body, verbose=0)
send_content(self, connection, request_body)
send_request(self, connection, handler, request_body)
send_user_agent(self, connection)

Data and non-method functions inherited from Transport:
user_agent = 'xmlrpclib.py/1.0.0 (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:
_ServerProxy__request = __request(self, methodname, params)
__getattr__(self, name)
__init__(self, uri, transport=None, encoding=None, verbose=0)
__repr__(self)
__str__ = __repr__(self)

Data and non-method functions defined here:
__doc__ = 'uri [,options] -> a logical connection to an XM...re assumed to use\n the given encoding.\n '
__module__ = 'xmlrpclib'
 
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:
_ServerProxy__request = __request(self, methodname, params)
__getattr__(self, name)
__init__(self, uri, transport=None, encoding=None, verbose=0)
__repr__(self)
__str__ = __repr__(self)

Data and non-method functions defined here:
__doc__ = 'uri [,options] -> a logical connection to an XM...re assumed to use\n the given encoding.\n '
__module__ = 'xmlrpclib'
 
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.

Data and non-method functions defined here:
__doc__ = 'Default XML parser (based on xmllib.XMLParser).'
__module__ = 'xmlrpclib'
 
class Transport
      Handles an HTTP transaction to an XML-RPC server.
 
   Methods defined here:
getparser(self)
make_connection(self, host)
parse_response(self, f)
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 non-method functions defined here:
__doc__ = 'Handles an HTTP transaction to an XML-RPC server.'
__module__ = 'xmlrpclib'
user_agent = 'xmlrpclib.py/1.0.0 (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)
close(self)
data(self, text)
end(self, tag, join=<function join>)
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_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 non-method functions defined here:
__doc__ = 'Unmarshal an XML-RPC response, based on incomin...a without complaining (but not bogus XML).\n '
__module__ = 'xmlrpclib'
dispatch = {'array': <function end_array>, 'base64': <function end_base64>, 'boolean': <function end_boolean>, 'dateTime.iso8601': <function end_dateTime>, 'double': <function end_double>, 'fault': <function end_fault>, 'i4': <function end_int>, 'int': <function end_int>, 'methodName': <function end_methodName>, 'name': <function end_string>, ...}
 
class _Method
       
   Methods defined here:
__call__(self, *args)
__getattr__(self, name)
__init__(self, send, name)
# some magic to bind an XML-RPC method to an RPC server.
# supports "nested" methods (e.g. examples.getStateName)

Data and non-method functions defined here:
__doc__ = None
__module__ = 'xmlrpclib'
 
Functions
            
_decode(data, encoding, is8bit=<built-in method search of _sre.SRE_Pattern object>)
_stringify(string)
binary(data)
boolean(value, truefalse=(<Boolean False at 8746cd4>, <Boolean True at 8746bfc>))
Convert any Python value to XML-RPC 'boolean'.
datetime(data)
dumps(params, methodname=None, methodresponse=None, encoding=None)
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>)
getparser()
getparser() -> parser, unmarshaller
 
Create an instance of the fastest available parser, and attach it
to an unmarshalling object.  Return both objects.
loads(data)
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
             False = <Boolean False at 8746cd4>
FastParser = None
FastUnmarshaller = None
MAXINT = 2147483647L
MININT = -2147483648L
SgmlopParser = None
StringTypes = (<type 'str'>, <type 'unicode'>)
True = <Boolean True at 8746bfc>
WRAPPERS = (<class xmlrpclib.DateTime>, <class xmlrpclib.Binary>, <class xmlrpclib.Boolean>)
__file__ = '/usr/lib/python2.2/xmlrpclib.pyc'
__name__ = 'xmlrpclib'
__version__ = '1.0.0'