text: 
  """
    Copyright 2011 Jeff Garzik
  
    AuthServiceProxy has the following improvements over python-jsonrpc's
    ServiceProxy class:
  
    - HTTP connections persist for the life of the AuthServiceProxy object
      (if server supports HTTP/1.1)
    - sends protocol 'version', per JSON-RPC 1.1
    - sends proper, incrementing 'id'
    - sends Basic HTTP authentication headers
    - parses all JSON numbers that look like floats as Decimal
    - uses standard Python json lib
  
    Previous copyright, from python-jsonrpc/jsonrpc/proxy.py:
  
    Copyright (c) 2007 Jan-Klaas Kollhof
  
    This file is part of jsonrpc.
  
    jsonrpc is free software; you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation; either version 2.1 of the License, or
    (at your option) any later version.
  
    This software is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.
  
    You should have received a copy of the GNU Lesser General Public License
    along with this software; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  """
  
  try:
      import http.client as httplib
  except ImportError:
      import httplib
  import base64
  import json
  import decimal
  try:
      import urllib.parse as urlparse
  except ImportError:
      import urlparse
  
  USER_AGENT = "AuthServiceProxy/0.1"
  
  HTTP_TIMEOUT = 30
  
  
  class JSONRPCException(Exception):
      def __init__(self, rpc_error):
          Exception.__init__(self)
          self.error = rpc_error
  
  
  def EncodeDecimal(o):
      if isinstance(o, decimal.Decimal):
          return round(o, 8)
      raise TypeError(repr(o) + " is not JSON serializable")
  
  class AuthServiceProxy(object):
      __id_count = 0
  
      def __init__(self, service_url, service_name=None, timeout=HTTP_TIMEOUT, connection=None):
          self.__service_url = service_url
          self.__service_name = service_name
          self.__url = urlparse.urlparse(service_url)
          if self.__url.port is None:
              port = 80
          else:
              port = self.__url.port
          (user, passwd) = (self.__url.username, self.__url.password)
          try:
              user = user.encode('utf8')
          except AttributeError:
              pass
          try:
              passwd = passwd.encode('utf8')
          except AttributeError:
              pass
          authpair = user + b':' + passwd
          self.__auth_header = b'Basic ' + base64.b64encode(authpair)
          
          if connection: 
              # Callables re-use the connection of the original proxy 
              self.__conn = connection
          elif self.__url.scheme == 'https':
              self.__conn = httplib.HTTPSConnection(self.__url.hostname, port,
                                                    None, None, False,
                                                    timeout)
          else:
              self.__conn = httplib.HTTPConnection(self.__url.hostname, port,
                                                   False, timeout)
  
      def __getattr__(self, name):
          if name.startswith('__') and name.endswith('__'):
              # Python internal stuff
              raise AttributeError
          if self.__service_name is not None:
              name = "%s.%s" % (self.__service_name, name)
          return AuthServiceProxy(self.__service_url, name, connection=self.__conn)
  
      def __call__(self, *args):
          AuthServiceProxy.__id_count += 1
  
          postdata = json.dumps({'version': '1.1',
                                 'method': self.__service_name,
                                 'params': args,
                                 'id': AuthServiceProxy.__id_count}, default=EncodeDecimal)
          self.__conn.request('POST', self.__url.path, postdata,
                              {'Host': self.__url.hostname,
                               'User-Agent': USER_AGENT,
                               'Authorization': self.__auth_header,
                               'Content-type': 'application/json'})
  
          response = self._get_response()
          if response['error'] is not None:
              raise JSONRPCException(response['error'])
          elif 'result' not in response:
              raise JSONRPCException({
                  'code': -343, 'message': 'missing JSON-RPC result'})
          else:
              return response['result']
  
      def _batch(self, rpc_call_list):
          postdata = json.dumps(list(rpc_call_list), default=EncodeDecimal)
          self.__conn.request('POST', self.__url.path, postdata,
                              {'Host': self.__url.hostname,
                               'User-Agent': USER_AGENT,
                               'Authorization': self.__auth_header,
                               'Content-type': 'application/json'})
  
          return self._get_response()
  
      def _get_response(self):
          http_response = self.__conn.getresponse()
          if http_response is None:
              raise JSONRPCException({
                  'code': -342, 'message': 'missing HTTP response from server'})
  
          return json.loads(http_response.read().decode('utf8'),
                            parse_float=decimal.Decimal)
  