RubyGems - utopia-wiki - Versions diffs - 0.2.0 - Mend

utopia-wiki 0.2.0

Files changed (415) hide show

data/lib/components/jquery-syntax/examples/ex.ooc.html ADDED

@@ -0,0 +1,119 @@
+<!DOCTYPE html>
+<html>
+	<head>
+		<link rel="stylesheet" href="index.css" type="text/css" media="screen" />
+		<script src="jquery-1.6.min.js" type="text/javascript"></script>
+		<script src="../dist/jquery.syntax.js" type="text/javascript"></script>
+		<script src="../dist/jquery.syntax.cache.js" type="text/javascript"></script>
+		<script type="text/javascript">
+			$(function() {
+				jQuery.syntax();
+			});
+		</script>
+	</head>
+	<body>
+		<h1>Syntax: OOC</h1>
+		<pre><code class="syntax brush-ooc">
+include stdint, stdlib, memory, ./myheader // C includes, &quot;./&quot; means relative
+use gtk, yajit // .use files define include paths, libraries, sourcepath extensions
+import rock/middle/[FunctionCall, VariableAccess, Expression], gtk/Button // import other ooc files
+Representable: interface {
+    toString: func -&gt; String
+}
+String: cover from Char* implements Representable {
+    length: extern(strlen) func -&gt; Int
+    toString: func -&gt; String { this } // implicit return
+}
+/**
+ * Dereference is actually a node used in rock (ooc compiler in ooc)
+ * You generate html docs with rock+sonofaj+sphinx, see http://docs.ooc-lang.org
+ * @author nddrylliog
+ */
+Dereference: class extends Expression implements Representable {
+    expr: Expression
+    count := 0
+    /* ~ is a suffix, =expr is an Assign-arg, .token is a Member-arg */
+    init: func ~addressOf (=expr, .token) {
+        super(token)
+    }
+    accept: func (visitor: Visitor) {
+        visitor visitDereference(this)
+    }
+    getType: func -&gt; Type { expr getType() ? expr getType() dereference() : null }
+    toString: func -&gt; String {
+        return expr toString() + &quot;@&quot;
+    }
+    /**
+     * @return Responses OK if the node is resolved now, Responses LOOP otherwise
+     */
+    resolve: func (trail: Trail, res: Resolver) -&gt; Response {
+        trail push(this)
+        {
+            response := expr resolve(trail, res)
+            if(!response ok()) {
+                trail pop(this)
+                return response
+            }
+        }
+        trail pop(this)
+        return Responses OK
+    }
+    replace: func (oldie, kiddo: Node) -&gt; Bool {
+        // here the match is used implicitly for the returne xception
+        match oldie {
+            case expr =&gt; expr = kiddo; true
+            case      =&gt; false
+        }
+    }
+}
+pointerFiddling: func (p: Int*) -&gt; Float* {
+    printf(&quot;%d, %d, %d\n&quot;, p@, (p+1)@, (p+2)@)
+    // qualifiers are okay in decl-assigns, casting is done with &#x27;as&#x27;
+    i := static const 42 as Float
+    return i&amp;
+}
+reference: func (i: Int@) {
+    i = 4
+}
+main: func {
+    Dereference new(expr, token)
+    a := 3
+    reference(a&amp;)
+    &quot;a = %d&quot; format(a) println()
+}
+List: class &lt;T&gt; extends Enumerable&lt;T&gt; {
+    data: T*
+    get: func (i: Int) -&gt; T {
+        data[i]
+    }
+}
+&quot;Bye world!&quot; println()
+		</code></pre>
+	</body>
+</html>

data/lib/components/jquery-syntax/examples/ex.php.html ADDED

@@ -0,0 +1,54 @@
+<!DOCTYPE html>
+<html>
+	<head>
+		<link rel="stylesheet" href="index.css" type="text/css" media="screen" />
+		<script src="jquery-1.6.min.js" type="text/javascript"></script>
+		<script src="../dist/jquery.syntax.js" type="text/javascript"></script>
+		<script src="../dist/jquery.syntax.cache.js" type="text/javascript"></script>
+		<script type="text/javascript">
+			$(function() {
+				jQuery.syntax();
+			});
+		</script>
+	</head>
+	<body>
+		<h1>Syntax: PHP</h1>
+    <pre><code class="syntax php">&lt;?php
+    $curl = curl_init();
+    $options = array(CURLOPT_URL =&gt; 'http://api.twitter.com/1/statuses/public_timeline.json', CURLOPT_RETURNTRANSFER =&gt; true);
+    curl_setopt_array($curl, $options);
+    $json = curl_exec($curl);
+    $obj = json_decode($json);
+    $val5 = trim($_GET['val5']);
+    $val10 = trim($_GET['val10']);
+    $val20 = trim($_GET['val20']);
+    $count = -1;
+    if($val5){$count = 4;}
+    if($val10){$count = 9;}
+    if($val20){$count = 19;}
+    if($val1){$count = -1;}
+    if($count&lt;0){
+    	echo &quot;&lt;img class='twitter-bird' src='twitter-bird.png' width='490px' height='315px' /&gt;&quot;;
+    } else {
+    	if($obj){
+    		foreach($obj as $var =&gt; $value)
+    		{
+    			if($var&lt;=$count){
+    					echo &quot;&lt;div id='user-tweets-container'&gt;&quot;;
+    					echo &quot;&lt;a class='a-img' href='http://www.twitter.com/&quot; . $obj[$var]-&gt;user-&gt;screen_name . &quot;' target='_blank'&gt;&lt;img src='&quot; . $obj[$var]-&gt;user-&gt;profile_image_url . &quot;' width='48px' height='48px'/&gt;&lt;/a&gt;&quot;;
+    					echo &quot;&lt;p class='text'&gt;&lt;a class='screen_name' href='http://www.twitter.com/&quot; . $obj[$var]-&gt;user-&gt;screen_name . &quot;' target='_blank'&gt;&quot; . $obj[$var]-&gt;user-&gt;screen_name . &quot;&lt;/a&gt;&amp;nbsp;&quot;;
+    					echo $obj[$var]-&gt;text . &quot;&lt;/p&gt;&lt;br/&gt;&quot;;
+    					echo &quot;&lt;/div&gt;&quot;;
+    			}
+    		}
+    	}else{
+    		echo &quot;&lt;p class='text'&gt;&lt;br&gt;Not able to retrieve Tweets... Please try again later...&lt;/p&gt;&lt;br/&gt;&quot;;
+    	}
+    }
+    ?&gt;</code></pre>
+	</body>
+</html>

data/lib/components/jquery-syntax/examples/ex.python.html ADDED

@@ -0,0 +1,1510 @@
+<!DOCTYPE html>
+<html>
+	<head>
+		<link rel="stylesheet" href="index.css" type="text/css" media="screen" />
+		<script src="jquery-1.6.min.js" type="text/javascript"></script>
+		<script src="../dist/jquery.syntax.js" type="text/javascript"></script>
+		<script src="../dist/jquery.syntax.cache.js" type="text/javascript"></script>
+		<script type="text/javascript">
+			$(function() {
+				jQuery.syntax();
+			});
+		</script>
+	</head>
+	<body>
+		<h1>Syntax: Python</h1>
+	<pre><code class="syntax brush-python">#
+# XML-RPC CLIENT LIBRARY
+# $Id: xmlrpclib.py 41594 2005-12-04 19:11:17Z andrew.kuchling $
+#
+# an XML-RPC client interface for Python.
+#
+# the marshalling and response parser code can also be used to
+# implement XML-RPC servers.
+#
+# Notes:
+# this version is designed to work with Python 2.1 or newer.
+#
+# History:
+# 1999-01-14 fl  Created
+# 1999-01-15 fl  Changed dateTime to use localtime
+# 1999-01-16 fl  Added Binary/base64 element, default to RPC2 service
+# 1999-01-19 fl  Fixed array data element (from Skip Montanaro)
+# 1999-01-21 fl  Fixed dateTime constructor, etc.
+# 1999-02-02 fl  Added fault handling, handle empty sequences, etc.
+# 1999-02-10 fl  Fixed problem with empty responses (from Skip Montanaro)
+# 1999-06-20 fl  Speed improvements, pluggable parsers/transports (0.9.8)
+# 2000-11-28 fl  Changed boolean to check the truth value of its argument
+# 2001-02-24 fl  Added encoding/Unicode/SafeTransport patches
+# 2001-02-26 fl  Added compare support to wrappers (0.9.9/1.0b1)
+# 2001-03-28 fl  Make sure response tuple is a singleton
+# 2001-03-29 fl  Don&#x27;t require empty params element (from Nicholas Riley)
+# 2001-06-10 fl  Folded in _xmlrpclib accelerator support (1.0b2)
+# 2001-08-20 fl  Base xmlrpclib.Error on built-in Exception (from Paul Prescod)
+# 2001-09-03 fl  Allow Transport subclass to override getparser
+# 2001-09-10 fl  Lazy import of urllib, cgi, xmllib (20x import speedup)
+# 2001-10-01 fl  Remove containers from memo cache when done with them
+# 2001-10-01 fl  Use faster escape method (80% dumps speedup)
+# 2001-10-02 fl  More dumps microtuning
+# 2001-10-04 fl  Make sure import expat gets a parser (from Guido van Rossum)
+# 2001-10-10 sm  Allow long ints to be passed as ints if they don&#x27;t overflow
+# 2001-10-17 sm  Test for int and long overflow (allows use on 64-bit systems)
+# 2001-11-12 fl  Use repr() to marshal doubles (from Paul Felix)
+# 2002-03-17 fl  Avoid buffered read when possible (from James Rucker)
+# 2002-04-07 fl  Added pythondoc comments
+# 2002-04-16 fl  Added __str__ methods to datetime/binary wrappers
+# 2002-05-15 fl  Added error constants (from Andrew Kuchling)
+# 2002-06-27 fl  Merged with Python CVS version
+# 2002-10-22 fl  Added basic authentication (based on code from Phillip Eby)
+# 2003-01-22 sm  Add support for the bool type
+# 2003-02-27 gvr Remove apply calls
+# 2003-04-24 sm  Use cStringIO if available
+# 2003-04-25 ak  Add support for nil
+# 2003-06-15 gn  Add support for time.struct_time
+# 2003-07-12 gp  Correct marshalling of Faults
+# 2003-10-31 mvl Add multicall support
+# 2004-08-20 mvl Bump minimum supported Python version to 2.1
+#
+# Copyright (c) 1999-2002 by Secret Labs AB.
+# Copyright (c) 1999-2002 by Fredrik Lundh.
+#
+# info@pythonware.com
+# http://www.pythonware.com
+#
+# --------------------------------------------------------------------
+# The XML-RPC client interface is
+#
+# Copyright (c) 1999-2002 by Secret Labs AB
+# Copyright (c) 1999-2002 by Fredrik Lundh
+#
+# By obtaining, using, and/or copying this software and/or its
+# associated documentation, you agree that you have read, understood,
+# and will comply with the following terms and conditions:
+#
+# Permission to use, copy, modify, and distribute this software and
+# its associated documentation for any purpose and without fee is
+# hereby granted, provided that the above copyright notice appears in
+# all copies, and that both that copyright notice and this permission
+# notice appear in supporting documentation, and that the name of
+# Secret Labs AB or the author not be used in advertising or publicity
+# pertaining to distribution of the software without specific, written
+# prior permission.
+#
+# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
+# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
+# ABILITY AND FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
+# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
+# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+# OF THIS SOFTWARE.
+# --------------------------------------------------------------------
+#
+# things to look into some day:
+# TODO: sort out True/False/boolean issues for Python 2.3
+&quot;&quot;&quot;
+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 &quot;boolean&quot; XML-RPC value
+  DateTime       dateTime wrapper for an ISO 8601 string or time tuple or
+                 localtime integer value to generate a &quot;dateTime.iso8601&quot;
+                 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 &amp; 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).
+&quot;&quot;&quot;
+import re, string, time, operator
+from types import *
+# --------------------------------------------------------------------
+# Internal stuff
+try:
+    unicode
+except NameError:
+    unicode = None # unicode support not available
+try:
+    import datetime
+except ImportError:
+    datetime = None
+try:
+    _bool_is_builtin = False.__class__.__name__ == &quot;bool&quot;
+except NameError:
+    _bool_is_builtin = 0
+def _decode(data, encoding, is8bit=re.compile(&quot;[\x80-\xff]&quot;).search):
+    # decode non-ascii string (if possible)
+    if unicode and encoding and is8bit(data):
+        data = unicode(data, encoding)
+    return data
+def escape(s, replace=string.replace):
+    s = replace(s, &quot;&amp;&quot;, &quot;&amp;amp;&quot;)
+    s = replace(s, &quot;&lt;&quot;, &quot;&amp;lt;&quot;)
+    return replace(s, &quot;&gt;&quot;, &quot;&amp;gt;&quot;,)
+if unicode:
+    def _stringify(string):
+        # convert to 7-bit ascii if possible
+        try:
+            return string.encode(&quot;ascii&quot;)
+        except UnicodeError:
+            return string
+else:
+    def _stringify(string):
+        return string
+__version__ = &quot;1.0.1&quot;
+# xmlrpc integer limits
+MAXINT =  2L**31-1
+MININT = -2L**31
+# --------------------------------------------------------------------
+# Error constants (from Dan Libby&#x27;s specification at
+# http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php)
+# Ranges of errors
+PARSE_ERROR       = -32700
+SERVER_ERROR      = -32600
+APPLICATION_ERROR = -32500
+SYSTEM_ERROR      = -32400
+TRANSPORT_ERROR   = -32300
+# Specific errors
+NOT_WELLFORMED_ERROR  = -32700
+UNSUPPORTED_ENCODING  = -32701
+INVALID_ENCODING_CHAR = -32702
+INVALID_XMLRPC        = -32600
+METHOD_NOT_FOUND      = -32601
+INVALID_METHOD_PARAMS = -32602
+INTERNAL_ERROR        = -32603
+# --------------------------------------------------------------------
+# Exceptions
+##
+# Base class for all kinds of client-side errors.
+class Error(Exception):
+    &quot;&quot;&quot;Base class for client errors.&quot;&quot;&quot;
+    def __str__(self):
+        return repr(self)
+##
+# Indicates an HTTP-level protocol error.  This is raised by the HTTP
+# transport layer, if the server returns an error code other than 200
+# (OK).
+#
+# @param url The target URL.
+# @param errcode The HTTP error code.
+# @param errmsg The HTTP error message.
+# @param headers The HTTP header dictionary.
+class ProtocolError(Error):
+    &quot;&quot;&quot;Indicates an HTTP protocol error.&quot;&quot;&quot;
+    def __init__(self, url, errcode, errmsg, headers):
+        Error.__init__(self)
+        self.url = url
+        self.errcode = errcode
+        self.errmsg = errmsg
+        self.headers = headers
+    def __repr__(self):
+        return (
+            &quot;&lt;ProtocolError for %s: %s %s&gt;&quot; %
+            (self.url, self.errcode, self.errmsg)
+            )
+##
+# Indicates a broken XML-RPC response package.  This exception is
+# raised by the unmarshalling layer, if the XML-RPC response is
+# malformed.
+class ResponseError(Error):
+    &quot;&quot;&quot;Indicates a broken response package.&quot;&quot;&quot;
+    pass
+##
+# Indicates an XML-RPC fault response package.  This exception is
+# raised by the unmarshalling layer, if the XML-RPC response contains
+# a fault string.  This exception can also used as a class, to
+# generate a fault XML-RPC message.
+#
+# @param faultCode The XML-RPC fault code.
+# @param faultString The XML-RPC fault string.
+class Fault(Error):
+    &quot;&quot;&quot;Indicates an XML-RPC fault package.&quot;&quot;&quot;
+    def __init__(self, faultCode, faultString, **extra):
+        Error.__init__(self)
+        self.faultCode = faultCode
+        self.faultString = faultString
+    def __repr__(self):
+        return (
+            &quot;&lt;Fault %s: %s&gt;&quot; %
+            (self.faultCode, repr(self.faultString))
+            )
+# --------------------------------------------------------------------
+# Special values
+##
+# Wrapper for XML-RPC boolean values.  Use the xmlrpclib.True and
+# xmlrpclib.False constants, or the xmlrpclib.boolean() function, to
+# generate boolean XML-RPC values.
+#
+# @param value A boolean value.  Any true value is interpreted as True,
+#              all other values are interpreted as False.
+if _bool_is_builtin:
+    boolean = Boolean = bool
+    # to avoid breaking code which references xmlrpclib.{True,False}
+    True, False = True, False
+else:
+    class Boolean:
+        &quot;&quot;&quot;Boolean-value wrapper.
+        Use True or False to generate a &quot;boolean&quot; XML-RPC value.
+        &quot;&quot;&quot;
+        def __init__(self, value = 0):
+            self.value = operator.truth(value)
+        def encode(self, out):
+            out.write(&quot;&lt;value&gt;&lt;boolean&gt;%d&lt;/boolean&gt;&lt;/value&gt;\n&quot; % self.value)
+        def __cmp__(self, other):
+            if isinstance(other, Boolean):
+                other = other.value
+            return cmp(self.value, other)
+        def __repr__(self):
+            if self.value:
+                return &quot;&lt;Boolean True at %x&gt;&quot; % id(self)
+            else:
+                return &quot;&lt;Boolean False at %x&gt;&quot; % id(self)
+        def __int__(self):
+            return self.value
+		@bob # dole
+        def __nonzero__(self):
+            return self.value
+    True, False = Boolean(1), Boolean(0)
+    ##
+    # Map true or false value to XML-RPC boolean values.
+    #
+    # @def boolean(value)
+    # @param value A boolean value.  Any true value is mapped to True,
+    #              all other values are mapped to False.
+    # @return xmlrpclib.True or xmlrpclib.False.
+    # @see Boolean
+    # @see True
+    # @see False
+    def boolean(value, _truefalse=(False, True)):
+        &quot;&quot;&quot;Convert any Python value to XML-RPC &#x27;boolean&#x27;.&quot;&quot;&quot;
+        return _truefalse[operator.truth(value)]
+##
+# Wrapper for XML-RPC DateTime values.  This converts a time value to
+# the format used by XML-RPC.
+# &lt;p&gt;
+# The value can be given as a string in the format
+# &quot;yyyymmddThh:mm:ss&quot;, as a 9-item time tuple (as returned by
+# time.localtime()), or an integer value (as returned by time.time()).
+# The wrapper uses time.localtime() to convert an integer to a time
+# tuple.
+#
+# @param value The time, given as an ISO 8601 string, a time
+#              tuple, or a integer time value.
+class DateTime:
+    &quot;&quot;&quot;DateTime wrapper for an ISO 8601 string or time tuple or
+    localtime integer value to generate &#x27;dateTime.iso8601&#x27; XML-RPC
+    value.
+    &quot;&quot;&quot;
+    def __init__(self, value=0):
+        if not isinstance(value, StringType):
+            if datetime and isinstance(value, datetime.datetime):
+                self.value = value.strftime(&quot;%Y%m%dT%H:%M:%S&quot;)
+                return
+            if datetime and isinstance(value, datetime.date):
+                self.value = value.strftime(&quot;%Y%m%dT%H:%M:%S&quot;)
+                return
+            if datetime and isinstance(value, datetime.time):
+                today = datetime.datetime.now().strftime(&quot;%Y%m%d&quot;)
+                self.value = value.strftime(today+&quot;T%H:%M:%S&quot;)
+                return
+            if not isinstance(value, (TupleType, time.struct_time)):
+                if value == 0:
+                    value = time.time()
+                value = time.localtime(value)
+            value = time.strftime(&quot;%Y%m%dT%H:%M:%S&quot;, value)
+        self.value = value
+    def __cmp__(self, other):
+        if isinstance(other, DateTime):
+            other = other.value
+        return cmp(self.value, other)
+    ##
+    # Get date/time value.
+    #
+    # @return Date/time value, as an ISO 8601 string.
+    def __str__(self):
+        return self.value
+    def __repr__(self):
+        return &quot;&lt;DateTime %s at %x&gt;&quot; % (repr(self.value), id(self))
+    def decode(self, data):
+        data = str(data)
+        self.value = string.strip(data)
+    def encode(self, out):
+        out.write(&quot;&lt;value&gt;&lt;dateTime.iso8601&gt;&quot;)
+        out.write(self.value)
+        out.write(&quot;&lt;/dateTime.iso8601&gt;&lt;/value&gt;\n&quot;)
+def _datetime(data):
+    # decode xml element contents into a DateTime structure.
+    value = DateTime()
+    value.decode(data)
+    return value
+def _datetime_type(data):
+    t = time.strptime(data, &quot;%Y%m%dT%H:%M:%S&quot;)
+    return datetime.datetime(*tuple(t)[:6])
+##
+# Wrapper for binary data.  This can be used to transport any kind
+# of binary data over XML-RPC, using BASE64 encoding.
+#
+# @param data An 8-bit string containing arbitrary data.
+import base64
+try:
+    import cStringIO as StringIO
+except ImportError:
+    import StringIO
+class Binary:
+    &quot;&quot;&quot;Wrapper for binary data.&quot;&quot;&quot;
+    def __init__(self, data=None):
+        self.data = data
+    ##
+    # Get buffer contents.
+    #
+    # @return Buffer contents, as an 8-bit string.
+    def __str__(self):
+        return self.data or &quot;&quot;
+    def __cmp__(self, other):
+        if isinstance(other, Binary):
+            other = other.data
+        return cmp(self.data, other)
+    def decode(self, data):
+        self.data = base64.decodestring(data)
+    def encode(self, out):
+        out.write(&quot;&lt;value&gt;&lt;base64&gt;\n&quot;)
+        base64.encode(StringIO.StringIO(self.data), out)
+        out.write(&quot;&lt;/base64&gt;&lt;/value&gt;\n&quot;)
+def _binary(data):
+    # decode xml element contents into a Binary structure
+    value = Binary()
+    value.decode(data)
+    return value
+WRAPPERS = (DateTime, Binary)
+if not _bool_is_builtin:
+    WRAPPERS = WRAPPERS + (Boolean,)
+# --------------------------------------------------------------------
+# XML parsers
+try:
+    # optional xmlrpclib accelerator
+    import _xmlrpclib
+    FastParser = _xmlrpclib.Parser
+    FastUnmarshaller = _xmlrpclib.Unmarshaller
+except (AttributeError, ImportError):
+    FastParser = FastUnmarshaller = None
+try:
+    import _xmlrpclib
+    FastMarshaller = _xmlrpclib.Marshaller
+except (AttributeError, ImportError):
+    FastMarshaller = None
+#
+# the SGMLOP parser is about 15x faster than Python&#x27;s builtin
+# XML parser.  SGMLOP sources can be downloaded from:
+#
+#     http://www.pythonware.com/products/xml/sgmlop.htm
+#
+try:
+    import sgmlop
+    if not hasattr(sgmlop, &quot;XMLParser&quot;):
+        raise ImportError
+except ImportError:
+    SgmlopParser = None # sgmlop accelerator not available
+else:
+    class SgmlopParser:
+        def __init__(self, target):
+            # setup callbacks
+            self.finish_starttag = target.start
+            self.finish_endtag = target.end
+            self.handle_data = target.data
+            self.handle_xml = target.xml
+            # activate parser
+            self.parser = sgmlop.XMLParser()
+            self.parser.register(self)
+            self.feed = self.parser.feed
+            self.entity = {
+                &quot;amp&quot;: &quot;&amp;&quot;, &quot;gt&quot;: &quot;&gt;&quot;, &quot;lt&quot;: &quot;&lt;&quot;,
+                &quot;apos&quot;: &quot;&#x27;&quot;, &quot;quot&quot;: &#x27;&quot;&#x27;
+                }
+        def close(self):
+            try:
+                self.parser.close()
+            finally:
+                self.parser = self.feed = None # nuke circular reference
+        def handle_proc(self, tag, attr):
+            m = re.search(&quot;encoding\s*=\s*[&#x27;\&quot;]([^\&quot;&#x27;]+)[\&quot;&#x27;]&quot;, attr)
+            if m:
+                self.handle_xml(m.group(1), 1)
+        def handle_entityref(self, entity):
+            # &lt;string&gt; entity
+            try:
+                self.handle_data(self.entity[entity])
+            except KeyError:
+                self.handle_data(&quot;&amp;%s;&quot; % entity)
+try:
+    from xml.parsers import expat
+    if not hasattr(expat, &quot;ParserCreate&quot;):
+        raise ImportError
+except ImportError:
+    ExpatParser = None # expat not available
+else:
+    class ExpatParser:
+        # fast expat parser for Python 2.0 and later.  this is about
+        # 50% slower than sgmlop, on roundtrip testing
+        def __init__(self, target):
+            self._parser = parser = expat.ParserCreate(None, None)
+            self._target = target
+            parser.StartElementHandler = target.start
+            parser.EndElementHandler = target.end
+            parser.CharacterDataHandler = target.data
+            encoding = None
+            if not parser.returns_unicode:
+                encoding = &quot;utf-8&quot;
+            target.xml(encoding, None)
+        def feed(self, data):
+            self._parser.Parse(data, 0)
+        def close(self):
+            self._parser.Parse(&quot;&quot;, 1) # end of data
+            del self._target, self._parser # get rid of circular references
+class SlowParser:
+    &quot;&quot;&quot;Default XML parser (based on xmllib.XMLParser).&quot;&quot;&quot;
+    # this is about 10 times slower than sgmlop, on roundtrip
+    # testing.
+    def __init__(self, target):
+        import xmllib # lazy subclassing (!)
+        if xmllib.XMLParser not in SlowParser.__bases__:
+            SlowParser.__bases__ = (xmllib.XMLParser,)
+        self.handle_xml = target.xml
+        self.unknown_starttag = target.start
+        self.handle_data = target.data
+        self.handle_cdata = target.data
+        self.unknown_endtag = target.end
+        try:
+            xmllib.XMLParser.__init__(self, accept_utf8=1)
+        except TypeError:
+            xmllib.XMLParser.__init__(self) # pre-2.0
+# --------------------------------------------------------------------
+# XML-RPC marshalling and unmarshalling code
+##
+# XML-RPC marshaller.
+#
+# @param encoding Default encoding for 8-bit strings.  The default
+#     value is None (interpreted as UTF-8).
+# @see dumps
+class Marshaller:
+    &quot;&quot;&quot;Generate an XML-RPC params chunk from a Python data structure.
+    Create a Marshaller instance for each set of parameters, and use
+    the &quot;dumps&quot; 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 &quot;dumps&quot; module
+    function for this purpose.
+    &quot;&quot;&quot;
+    # by the way, if you don&#x27;t understand what&#x27;s going on in here,
+    # that&#x27;s perfectly ok.
+    def __init__(self, encoding=None, allow_none=0):
+        self.memo = {}
+        self.data = None
+        self.encoding = encoding
+        self.allow_none = allow_none
+    dispatch = {}
+    def dumps(self, values):
+        out = []
+        write = out.append
+        dump = self.__dump
+        if isinstance(values, Fault):
+            # fault instance
+            write(&quot;&lt;fault&gt;\n&quot;)
+            dump({&#x27;faultCode&#x27;: values.faultCode,
+                  &#x27;faultString&#x27;: values.faultString},
+                 write)
+            write(&quot;&lt;/fault&gt;\n&quot;)
+        else:
+            # parameter block
+            # FIXME: the xml-rpc specification allows us to leave out
+            # the entire &lt;params&gt; block if there are no parameters.
+            # however, changing this may break older code (including
+            # old versions of xmlrpclib.py), so this is better left as
+            # is for now.  See @XMLRPC3 for more information. /F
+            write(&quot;&lt;params&gt;\n&quot;)
+            for v in values:
+                write(&quot;&lt;param&gt;\n&quot;)
+                dump(v, write)
+                write(&quot;&lt;/param&gt;\n&quot;)
+            write(&quot;&lt;/params&gt;\n&quot;)
+        result = string.join(out, &quot;&quot;)
+        return result
+    def __dump(self, value, write):
+        try:
+            f = self.dispatch[type(value)]
+        except KeyError:
+            raise TypeError, &quot;cannot marshal %s objects&quot; % type(value)
+        else:
+            f(self, value, write)
+    def dump_nil (self, value, write):
+        if not self.allow_none:
+            raise TypeError, &quot;cannot marshal None unless allow_none is enabled&quot;
+        write(&quot;&lt;value&gt;&lt;nil/&gt;&lt;/value&gt;&quot;)
+    dispatch[NoneType] = dump_nil
+    def dump_int(self, value, write):
+        # in case ints are &gt; 32 bits
+        if value &gt; MAXINT or value &lt; MININT:
+            raise OverflowError, &quot;int exceeds XML-RPC limits&quot;
+        write(&quot;&lt;value&gt;&lt;int&gt;&quot;)
+        write(str(value))
+        write(&quot;&lt;/int&gt;&lt;/value&gt;\n&quot;)
+    dispatch[IntType] = dump_int
+    if _bool_is_builtin:
+        def dump_bool(self, value, write):
+            write(&quot;&lt;value&gt;&lt;boolean&gt;&quot;)
+            write(value and &quot;1&quot; or &quot;0&quot;)
+            write(&quot;&lt;/boolean&gt;&lt;/value&gt;\n&quot;)
+        dispatch[bool] = dump_bool
+    def dump_long(self, value, write):
+        if value &gt; MAXINT or value &lt; MININT:
+            raise OverflowError, &quot;long int exceeds XML-RPC limits&quot;
+        write(&quot;&lt;value&gt;&lt;int&gt;&quot;)
+        write(str(int(value)))
+        write(&quot;&lt;/int&gt;&lt;/value&gt;\n&quot;)
+    dispatch[LongType] = dump_long
+    def dump_double(self, value, write):
+        write(&quot;&lt;value&gt;&lt;double&gt;&quot;)
+        write(repr(value))
+        write(&quot;&lt;/double&gt;&lt;/value&gt;\n&quot;)
+    dispatch[FloatType] = dump_double
+    def dump_string(self, value, write, escape=escape):
+        write(&quot;&lt;value&gt;&lt;string&gt;&quot;)
+        write(escape(value))
+        write(&quot;&lt;/string&gt;&lt;/value&gt;\n&quot;)
+    dispatch[StringType] = dump_string
+    if unicode:
+        def dump_unicode(self, value, write, escape=escape):
+            value = value.encode(self.encoding)
+            write(&quot;&lt;value&gt;&lt;string&gt;&quot;)
+            write(escape(value))
+            write(&quot;&lt;/string&gt;&lt;/value&gt;\n&quot;)
+        dispatch[UnicodeType] = dump_unicode
+    def dump_array(self, value, write):
+        i = id(value)
+        if self.memo.has_key(i):
+            raise TypeError, &quot;cannot marshal recursive sequences&quot;
+        self.memo[i] = None
+        dump = self.__dump
+        write(&quot;&lt;value&gt;&lt;array&gt;&lt;data&gt;\n&quot;)
+        for v in value:
+            dump(v, write)
+        write(&quot;&lt;/data&gt;&lt;/array&gt;&lt;/value&gt;\n&quot;)
+        del self.memo[i]
+    dispatch[TupleType] = dump_array
+    dispatch[ListType] = dump_array
+    def dump_struct(self, value, write, escape=escape):
+        i = id(value)
+        if self.memo.has_key(i):
+            raise TypeError, &quot;cannot marshal recursive dictionaries&quot;
+        self.memo[i] = None
+        dump = self.__dump
+        write(&quot;&lt;value&gt;&lt;struct&gt;\n&quot;)
+        for k, v in value.items():
+            write(&quot;&lt;member&gt;\n&quot;)
+            if type(k) is not StringType:
+                if unicode and type(k) is UnicodeType:
+                    k = k.encode(self.encoding)
+                else:
+                    raise TypeError, &quot;dictionary key must be string&quot;
+            write(&quot;&lt;name&gt;%s&lt;/name&gt;\n&quot; % escape(k))
+            dump(v, write)
+            write(&quot;&lt;/member&gt;\n&quot;)
+        write(&quot;&lt;/struct&gt;&lt;/value&gt;\n&quot;)
+        del self.memo[i]
+    dispatch[DictType] = dump_struct
+    if datetime:
+        def dump_datetime(self, value, write):
+            write(&quot;&lt;value&gt;&lt;dateTime.iso8601&gt;&quot;)
+            write(value.strftime(&quot;%Y%m%dT%H:%M:%S&quot;))
+            write(&quot;&lt;/dateTime.iso8601&gt;&lt;/value&gt;\n&quot;)
+        dispatch[datetime.datetime] = dump_datetime
+        def dump_date(self, value, write):
+            write(&quot;&lt;value&gt;&lt;dateTime.iso8601&gt;&quot;)
+            write(value.strftime(&quot;%Y%m%dT00:00:00&quot;))
+            write(&quot;&lt;/dateTime.iso8601&gt;&lt;/value&gt;\n&quot;)
+        dispatch[datetime.date] = dump_date
+        def dump_time(self, value, write):
+            write(&quot;&lt;value&gt;&lt;dateTime.iso8601&gt;&quot;)
+            write(datetime.datetime.now().date().strftime(&quot;%Y%m%dT&quot;))
+            write(value.strftime(&quot;%H:%M:%S&quot;))
+            write(&quot;&lt;/dateTime.iso8601&gt;&lt;/value&gt;\n&quot;)
+        dispatch[datetime.time] = dump_time
+    def dump_instance(self, value, write):
+        # check for special wrappers
+        if value.__class__ in WRAPPERS:
+            self.write = write
+            value.encode(self)
+            del self.write
+        else:
+            # store instance attributes as a struct (really?)
+            self.dump_struct(value.__dict__, write)
+    dispatch[InstanceType] = dump_instance
+##
+# XML-RPC unmarshaller.
+#
+# @see loads
+class Unmarshaller:
+    &quot;&quot;&quot;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).
+    &quot;&quot;&quot;
+    # and again, if you don&#x27;t understand what&#x27;s going on in here,
+    # that&#x27;s perfectly ok.
+    def __init__(self, use_datetime=0):
+        self._type = None
+        self._stack = []
+        self._marks = []
+        self._data = []
+        self._methodname = None
+        self._encoding = &quot;utf-8&quot;
+        self.append = self._stack.append
+        self._use_datetime = use_datetime
+        if use_datetime and not datetime:
+            raise ValueError, &quot;the datetime module is not available&quot;
+    def close(self):
+        # return response tuple and target method
+        if self._type is None or self._marks:
+            raise ResponseError()
+        if self._type == &quot;fault&quot;:
+            raise Fault(**self._stack[0])
+        return tuple(self._stack)
+    def getmethodname(self):
+        return self._methodname
+    #
+    # event handlers
+    def xml(self, encoding, standalone):
+        self._encoding = encoding
+        # FIXME: assert standalone == 1 ???
+    def start(self, tag, attrs):
+        # prepare to handle this element
+        if tag == &quot;array&quot; or tag == &quot;struct&quot;:
+            self._marks.append(len(self._stack))
+        self._data = []
+        self._value = (tag == &quot;value&quot;)
+    def data(self, text):
+        self._data.append(text)
+    def end(self, tag, join=string.join):
+        # call the appropriate end tag handler
+        try:
+            f = self.dispatch[tag]
+        except KeyError:
+            pass # unknown tag ?
+        else:
+            return f(self, join(self._data, &quot;&quot;))
+    #
+    # accelerator support
+    def end_dispatch(self, tag, data):
+        # dispatch data
+        try:
+            f = self.dispatch[tag]
+        except KeyError:
+            pass # unknown tag ?
+        else:
+            return f(self, data)
+    #
+    # element decoders
+    dispatch = {}
+    def end_nil (self, data):
+        self.append(None)
+        self._value = 0
+    dispatch[&quot;nil&quot;] = end_nil
+    def end_boolean(self, data):
+        if data == &quot;0&quot;:
+            self.append(False)
+        elif data == &quot;1&quot;:
+            self.append(True)
+        else:
+            raise TypeError, &quot;bad boolean value&quot;
+        self._value = 0
+    dispatch[&quot;boolean&quot;] = end_boolean
+    def end_int(self, data):
+        self.append(int(data))
+        self._value = 0
+    dispatch[&quot;i4&quot;] = end_int
+    dispatch[&quot;int&quot;] = end_int
+    def end_double(self, data):
+        self.append(float(data))
+        self._value = 0
+    dispatch[&quot;double&quot;] = end_double
+    def end_string(self, data):
+        if self._encoding:
+            data = _decode(data, self._encoding)
+        self.append(_stringify(data))
+        self._value = 0
+    dispatch[&quot;string&quot;] = end_string
+    dispatch[&quot;name&quot;] = end_string # struct keys are always strings
+    def end_array(self, data):
+        mark = self._marks.pop()
+        # map arrays to Python lists
+        self._stack[mark:] = [self._stack[mark:]]
+        self._value = 0
+    dispatch[&quot;array&quot;] = end_array
+    def end_struct(self, data):
+        mark = self._marks.pop()
+        # map structs to Python dictionaries
+        dict = {}
+        items = self._stack[mark:]
+        for i in range(0, len(items), 2):
+            dict[_stringify(items[i])] = items[i+1]
+        self._stack[mark:] = [dict]
+        self._value = 0
+    dispatch[&quot;struct&quot;] = end_struct
+    def end_base64(self, data):
+        value = Binary()
+        value.decode(data)
+        self.append(value)
+        self._value = 0
+    dispatch[&quot;base64&quot;] = end_base64
+    def end_dateTime(self, data):
+        value = DateTime()
+        value.decode(data)
+        if self._use_datetime:
+            value = _datetime_type(data)
+        self.append(value)
+    dispatch[&quot;dateTime.iso8601&quot;] = end_dateTime
+    def end_value(self, data):
+        # if we stumble upon a value element with no internal
+        # elements, treat it as a string element
+        if self._value:
+            self.end_string(data)
+    dispatch[&quot;value&quot;] = end_value
+    def end_params(self, data):
+        self._type = &quot;params&quot;
+    dispatch[&quot;params&quot;] = end_params
+    def end_fault(self, data):
+        self._type = &quot;fault&quot;
+    dispatch[&quot;fault&quot;] = end_fault
+    def end_methodName(self, data):
+        if self._encoding:
+            data = _decode(data, self._encoding)
+        self._methodname = data
+        self._type = &quot;methodName&quot; # no params
+    dispatch[&quot;methodName&quot;] = end_methodName
+## Multicall support
+#
+class _MultiCallMethod:
+    # some lesser magic to store calls made to a MultiCall object
+    # for batch execution
+    def __init__(self, call_list, name):
+        self.__call_list = call_list
+        self.__name = name
+    def __getattr__(self, name):
+        return _MultiCallMethod(self.__call_list, &quot;%s.%s&quot; % (self.__name, name))
+    def __call__(self, *args):
+        self.__call_list.append((self.__name, args))
+class MultiCallIterator:
+    &quot;&quot;&quot;Iterates over the results of a multicall. Exceptions are
+    thrown in response to xmlrpc faults.&quot;&quot;&quot;
+    def __init__(self, results):
+        self.results = results
+    def __getitem__(self, i):
+        item = self.results[i]
+        if type(item) == type({}):
+            raise Fault(item[&#x27;faultCode&#x27;], item[&#x27;faultString&#x27;])
+        elif type(item) == type([]):
+            return item[0]
+        else:
+            raise ValueError,\
+                  &quot;unexpected type in multicall result&quot;
+class MultiCall:
+    &quot;&quot;&quot;server -&gt; 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(&quot;Guido&quot;)
+    To execute the multicall, call the MultiCall object e.g.:
+    add_result, address = multicall()
+    &quot;&quot;&quot;
+    def __init__(self, server):
+        self.__server = server
+        self.__call_list = []
+    def __repr__(self):
+        return &quot;&lt;MultiCall at %x&gt;&quot; % id(self)
+    __str__ = __repr__
+    def __getattr__(self, name):
+        return _MultiCallMethod(self.__call_list, name)
+    def __call__(self):
+        marshalled_list = []
+        for name, args in self.__call_list:
+            marshalled_list.append({&#x27;methodName&#x27; : name, &#x27;params&#x27; : args})
+        return MultiCallIterator(self.__server.system.multicall(marshalled_list))
+# --------------------------------------------------------------------
+# convenience functions
+##
+# Create a parser object, and connect it to an unmarshalling instance.
+# This function picks the fastest available XML parser.
+#
+# return A (parser, unmarshaller) tuple.
+def getparser(use_datetime=0):
+    &quot;&quot;&quot;getparser() -&gt; parser, unmarshaller
+    Create an instance of the fastest available parser, and attach it
+    to an unmarshalling object.  Return both objects.
+    &quot;&quot;&quot;
+    if use_datetime and not datetime:
+        raise ValueError, &quot;the datetime module is not available&quot;
+    if FastParser and FastUnmarshaller:
+        if use_datetime:
+            mkdatetime = _datetime_type
+        else:
+            mkdatetime = _datetime
+        target = FastUnmarshaller(True, False, _binary, mkdatetime, Fault)
+        parser = FastParser(target)
+    else:
+        target = Unmarshaller(use_datetime=use_datetime)
+        if FastParser:
+            parser = FastParser(target)
+        elif SgmlopParser:
+            parser = SgmlopParser(target)
+        elif ExpatParser:
+            parser = ExpatParser(target)
+        else:
+            parser = SlowParser(target)
+    return parser, target
+##
+# Convert a Python tuple or a Fault instance to an XML-RPC packet.
+#
+# @def dumps(params, **options)
+# @param params A tuple or Fault instance.
+# @keyparam methodname If given, create a methodCall request for
+#     this method name.
+# @keyparam methodresponse If given, create a methodResponse packet.
+#     If used with a tuple, the tuple must be a singleton (that is,
+#     it must contain exactly one element).
+# @keyparam encoding The packet encoding.
+# @return A string containing marshalled data.
+def dumps(params, methodname=None, methodresponse=None, encoding=None,
+          allow_none=0):
+    &quot;&quot;&quot;data [,options] -&gt; 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.
+    &quot;&quot;&quot;
+    assert isinstance(params, TupleType) or isinstance(params, Fault),\
+           &quot;argument must be tuple or Fault instance&quot;
+    if isinstance(params, Fault):
+        methodresponse = 1
+    elif methodresponse and isinstance(params, TupleType):
+        assert len(params) == 1, &quot;response tuple must be a singleton&quot;
+    if not encoding:
+        encoding = &quot;utf-8&quot;
+    if FastMarshaller:
+        m = FastMarshaller(encoding)
+    else:
+        m = Marshaller(encoding, allow_none)
+    data = m.dumps(params)
+    if encoding != &quot;utf-8&quot;:
+        xmlheader = &quot;&lt;?xml version=&#x27;1.0&#x27; encoding=&#x27;%s&#x27;?&gt;\n&quot; % str(encoding)
+    else:
+        xmlheader = &quot;&lt;?xml version=&#x27;1.0&#x27;?&gt;\n&quot; # utf-8 is default
+    # standard XML-RPC wrappings
+    if methodname:
+        # a method call
+        if not isinstance(methodname, StringType):
+            methodname = methodname.encode(encoding)
+        data = (
+            xmlheader,
+            &quot;&lt;methodCall&gt;\n&quot;
+            &quot;&lt;methodName&gt;&quot;, methodname, &quot;&lt;/methodName&gt;\n&quot;,
+            data,
+            &quot;&lt;/methodCall&gt;\n&quot;
+            )
+    elif methodresponse:
+        # a method response, or a fault structure
+        data = (
+            xmlheader,
+            &quot;&lt;methodResponse&gt;\n&quot;,
+            data,
+            &quot;&lt;/methodResponse&gt;\n&quot;
+            )
+    else:
+        return data # return as is
+    return string.join(data, &quot;&quot;)
+##
+# Convert an XML-RPC packet to a Python object.  If the XML-RPC packet
+# represents a fault condition, this function raises a Fault exception.
+#
+# @param data An XML-RPC packet, given as an 8-bit string.
+# @return A tuple containing the unpacked data, and the method name
+#     (None if not present).
+# @see Fault
+def loads(data, use_datetime=0):
+    &quot;&quot;&quot;data -&gt; 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.
+    &quot;&quot;&quot;
+    p, u = getparser(use_datetime=use_datetime)
+    p.feed(data)
+    p.close()
+    return u.close(), u.getmethodname()
+# --------------------------------------------------------------------
+# request dispatcher
+class _Method:
+    # some magic to bind an XML-RPC method to an RPC server.
+    # supports &quot;nested&quot; methods (e.g. examples.getStateName)
+    def __init__(self, send, name):
+        self.__send = send
+        self.__name = name
+    def __getattr__(self, name):
+        return _Method(self.__send, &quot;%s.%s&quot; % (self.__name, name))
+    def __call__(self, *args):
+        return self.__send(self.__name, args)
+##
+# Standard transport class for XML-RPC over HTTP.
+# &lt;p&gt;
+# You can create custom transports by subclassing this method, and
+# overriding selected methods.
+class Transport:
+    &quot;&quot;&quot;Handles an HTTP transaction to an XML-RPC server.&quot;&quot;&quot;
+    # client identifier (may be overridden)
+    user_agent = &quot;xmlrpclib.py/%s (by www.pythonware.com)&quot; % __version__
+    def __init__(self, use_datetime=0):
+        self._use_datetime = use_datetime
+    ##
+    # Send a complete request, and parse the response.
+    #
+    # @param host Target host.
+    # @param handler Target PRC handler.
+    # @param request_body XML-RPC request body.
+    # @param verbose Debugging flag.
+    # @return Parsed response.
+    def request(self, host, handler, request_body, verbose=0):
+        # issue XML-RPC request
+        h = self.make_connection(host)
+        if verbose:
+            h.set_debuglevel(1)
+        self.send_request(h, handler, request_body)
+        self.send_host(h, host)
+        self.send_user_agent(h)
+        self.send_content(h, request_body)
+        errcode, errmsg, headers = h.getreply()
+        if errcode != 200:
+            raise ProtocolError(
+                host + handler,
+                errcode, errmsg,
+                headers
+                )
+        self.verbose = verbose
+        try:
+            sock = h._conn.sock
+        except AttributeError:
+            sock = None
+        return self._parse_response(h.getfile(), sock)
+    ##
+    # Create parser.
+    #
+    # @return A 2-tuple containing a parser and a unmarshaller.
+    def getparser(self):
+        # get parser and unmarshaller
+        return getparser(use_datetime=self._use_datetime)
+    ##
+    # Get authorization info from host parameter
+    # Host may be a string, or a (host, x509-dict) tuple; if a string,
+    # it is checked for a &quot;user:pw@host&quot; format, and a &quot;Basic
+    # Authentication&quot; header is added if appropriate.
+    #
+    # @param host Host descriptor (URL or (URL, x509 info) tuple).
+    # @return A 3-tuple containing (actual host, extra headers,
+    #     x509 info).  The header and x509 fields may be None.
+    def get_host_info(self, host):
+        x509 = {}
+        if isinstance(host, TupleType):
+            host, x509 = host
+        import urllib
+        auth, host = urllib.splituser(host)
+        if auth:
+            import base64
+            auth = base64.encodestring(urllib.unquote(auth))
+            auth = string.join(string.split(auth), &quot;&quot;) # get rid of whitespace
+            extra_headers = [
+                (&quot;Authorization&quot;, &quot;Basic &quot; + auth)
+                ]
+        else:
+            extra_headers = None
+        return host, extra_headers, x509
+    ##
+    # Connect to server.
+    #
+    # @param host Target host.
+    # @return A connection handle.
+    def make_connection(self, host):
+        # create a HTTP connection object from a host descriptor
+        import httplib
+        host, extra_headers, x509 = self.get_host_info(host)
+        return httplib.HTTP(host)
+    ##
+    # Send request header.
+    #
+    # @param connection Connection handle.
+    # @param handler Target RPC handler.
+    # @param request_body XML-RPC body.
+    def send_request(self, connection, handler, request_body):
+        connection.putrequest(&quot;POST&quot;, handler)
+    ##
+    # Send host name.
+    #
+    # @param connection Connection handle.
+    # @param host Host name.
+    def send_host(self, connection, host):
+        host, extra_headers, x509 = self.get_host_info(host)
+        connection.putheader(&quot;Host&quot;, host)
+        if extra_headers:
+            if isinstance(extra_headers, DictType):
+                extra_headers = extra_headers.items()
+            for key, value in extra_headers:
+                connection.putheader(key, value)
+    ##
+    # Send user-agent identifier.
+    #
+    # @param connection Connection handle.
+    def send_user_agent(self, connection):
+        connection.putheader(&quot;User-Agent&quot;, self.user_agent)
+    ##
+    # Send request body.
+    #
+    # @param connection Connection handle.
+    # @param request_body XML-RPC request body.
+    def send_content(self, connection, request_body):
+        connection.putheader(&quot;Content-Type&quot;, &quot;text/xml&quot;)
+        connection.putheader(&quot;Content-Length&quot;, str(len(request_body)))
+        connection.endheaders()
+        if request_body:
+            connection.send(request_body)
+    ##
+    # Parse response.
+    #
+    # @param file Stream.
+    # @return Response tuple and target method.
+    def parse_response(self, file):
+        # compatibility interface
+        return self._parse_response(file, None)
+    ##
+    # Parse response (alternate interface).  This is similar to the
+    # parse_response method, but also provides direct access to the
+    # underlying socket object (where available).
+    #
+    # @param file Stream.
+    # @param sock Socket handle (or None, if the socket object
+    #    could not be accessed).
+    # @return Response tuple and target method.
+    def _parse_response(self, file, sock):
+        # read response from input file/socket, and parse it
+        p, u = self.getparser()
+        while 1:
+            if sock:
+                response = sock.recv(1024)
+            else:
+                response = file.read(1024)
+            if not response:
+                break
+            if self.verbose:
+                print &quot;body:&quot;, repr(response)
+            p.feed(response)
+        file.close()
+        p.close()
+        return u.close()
+##
+# Standard transport class for XML-RPC over HTTPS.
+class SafeTransport(Transport):
+    &quot;&quot;&quot;Handles an HTTPS transaction to an XML-RPC server.&quot;&quot;&quot;
+    # FIXME: mostly untested
+    def make_connection(self, host):
+        # create a HTTPS connection object from a host descriptor
+        # host may be a string, or a (host, x509-dict) tuple
+        import httplib
+        host, extra_headers, x509 = self.get_host_info(host)
+        try:
+            HTTPS = httplib.HTTPS
+        except AttributeError:
+            raise NotImplementedError(
+                &quot;your version of httplib doesn&#x27;t support HTTPS&quot;
+                )
+        else:
+            return HTTPS(host, None, **(x509 or {}))
+##
+# Standard server proxy.  This class establishes a virtual connection
+# to an XML-RPC server.
+# &lt;p&gt;
+# This class is available as ServerProxy and Server.  New code should
+# use ServerProxy, to avoid confusion.
+#
+# @def ServerProxy(uri, **options)
+# @param uri The connection point on the server.
+# @keyparam transport A transport factory, compatible with the
+#    standard transport class.
+# @keyparam encoding The default encoding used for 8-bit strings
+#    (default is UTF-8).
+# @keyparam verbose Use a true value to enable debugging output.
+#    (printed to standard output).
+# @see Transport
+class ServerProxy:
+    &quot;&quot;&quot;uri [,options] -&gt; 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 &quot;http&quot; scheme.  If
+    SSL socket support is available (Python 2.0), it also supports
+    &quot;https&quot;.
+    If the target part and the slash preceding it are both omitted,
+    &quot;/RPC2&quot; 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.
+    &quot;&quot;&quot;
+    def __init__(self, uri, transport=None, encoding=None, verbose=0,
+                 allow_none=0, use_datetime=0):
+        # establish a &quot;logical&quot; server connection
+        # get the url
+        import urllib
+        type, uri = urllib.splittype(uri)
+        if type not in (&quot;http&quot;, &quot;https&quot;):
+            raise IOError, &quot;unsupported XML-RPC protocol&quot;
+        self.__host, self.__handler = urllib.splithost(uri)
+        if not self.__handler:
+            self.__handler = &quot;/RPC2&quot;
+        if transport is None:
+            if type == &quot;https&quot;:
+                transport = SafeTransport(use_datetime=use_datetime)
+            else:
+                transport = Transport(use_datetime=use_datetime)
+        self.__transport = transport
+        self.__encoding = encoding
+        self.__verbose = verbose
+        self.__allow_none = allow_none
+    def __request(self, methodname, params):
+        # call a method on the remote server
+        request = dumps(params, methodname, encoding=self.__encoding,
+                        allow_none=self.__allow_none)
+        response = self.__transport.request(
+            self.__host,
+            self.__handler,
+            request,
+            verbose=self.__verbose
+            )
+        if len(response) == 1:
+            response = response[0]
+        return response
+    def __repr__(self):
+        return (
+            &quot;&lt;ServerProxy for %s%s&gt;&quot; %
+            (self.__host, self.__handler)
+            )
+    __str__ = __repr__
+    def __getattr__(self, name):
+        # magic method dispatcher
+        return _Method(self.__request, name)
+    # note: to call a remote object with an non-standard name, use
+    # result getattr(server, &quot;strange-python-name&quot;)(args)
+# compatibility
+Server = ServerProxy
+# --------------------------------------------------------------------
+# test code
+if __name__ == &quot;__main__&quot;:
+    # simple test program (from the XML-RPC specification)
+    # server = ServerProxy(&quot;http://localhost:8000&quot;) # local server
+    server = ServerProxy(&quot;http://time.xmlrpc.com/RPC2&quot;)
+    print server
+    try:
+        print server.currentTime.getCurrentTime()
+    except Error, v:
+        print &quot;ERROR&quot;, v
+    multi = MultiCall(server)
+    multi.currentTime.getCurrentTime()
+    multi.currentTime.getCurrentTime()
+    try:
+        for response in multi():
+            print response
+    except Error, v:
+        print &quot;ERROR&quot;, v
+	</code></pre>
+	</body>
+</html>