Merge lp:~jr.allen/unifield-server/py27 into lp:unifield-server

[Jeff Allen]

=== removed file 'MANIFEST.in'
--- MANIFEST.in	2011-04-06 07:57:57 +0000
+++ MANIFEST.in	1970-01-01 00:00:00 +0000
@@ -1,20 +0,0 @@
-include rpminstall_sh.txt
-include README
-include LICENSE
-include MANIFEST.in
-include setup.nsi
-include setup.cfg
-include bin/import_xml.rng
-include bin/server.cert
-include bin/server.pkey
-include bin/gpl.txt
-include man/openerp-server.1
-include man/openerp_serverrc.5
-recursive-include pixmaps *
-recursive-include win32 *
-recursive-include doc *
-recursive-include bin *xml *xsl *sql *rml *sxw *csv *rng
-graft debian
-graft bin/addons
-graft python25-compat
-global-exclude *pyc *~

=== modified file 'bin/addons/base/publisher_warranty/publisher_warranty.py'
--- bin/addons/base/publisher_warranty/publisher_warranty.py	2011-01-19 01:38:10 +0000
+++ bin/addons/base/publisher_warranty/publisher_warranty.py	2017-05-22 10:09:36 +0000
@@ -25,7 +25,6 @@
 
 import datetime
 import logging
-import sys
 import urllib
 import urllib2
 
@@ -89,22 +88,22 @@
             email = user.email
 
             msg = {'contract_name': valid_contract.name,
-                'tb': tb,
-                'explanations': explanations,
-                'remarks': remarks,
-                'origin': origin,
-                'dbname': cr.dbname,
-                'dbuuid': dbuuid,
-                'db_create_date': db_create_date,
-                'issue_name': issue_name,
-                'email': email,
-                'user_name': user_name,
-            }
-
-
-            add_arg = {"timeout":30} if sys.version_info >= (2,6) else {}
+                   'tb': tb,
+                   'explanations': explanations,
+                   'remarks': remarks,
+                   'origin': origin,
+                   'dbname': cr.dbname,
+                   'dbuuid': dbuuid,
+                   'db_create_date': db_create_date,
+                   'issue_name': issue_name,
+                   'email': email,
+                   'user_name': user_name,
+                   }
+
+
+            add_arg = {"timeout":30}
             uo = urllib2.urlopen(config.get("publisher_warranty_url"),
-                                    urllib.urlencode({'arg0': msg, "action": "send",}),**add_arg)
+                                 urllib.urlencode({'arg0': msg, "action": "send",}),**add_arg)
             try:
                 submit_result = uo.read()
             finally:
@@ -189,19 +188,19 @@
             limit_date = (datetime.datetime.now() - _PREVIOUS_LOG_CHECK).strftime(misc.DEFAULT_SERVER_DATETIME_FORMAT)
             for message in result["messages"]:
                 ids = self.pool.get("res.log").search(cr, uid, [("res_model", "=", "publisher_warranty.contract"),
-                                                          ("create_date", ">=", limit_date),
-                                                          ("name", "=", message)])
+                                                                ("create_date", ">=", limit_date),
+                                                                ("name", "=", message)])
                 if ids:
                     continue
                 self.pool.get('res.log').create(cr, uid,
-                        {
-                            'name': message,
-                            'res_model': "publisher_warranty.contract",
-                            "read": True,
-                            "user_id": False,
-                        },
-                        context=context
-                )
+                                                {
+                                                    'name': message,
+                                                    'res_model': "publisher_warranty.contract",
+                                                    "read": True,
+                                                    "user_id": False,
+                                                },
+                                                context=context
+                                                )
         except Exception:
             if cron_mode:
                 return False # we don't want to see any stack trace in cron
@@ -216,7 +215,7 @@
         @rtype: list of tuples(int,string)
         """
         ids = self.pool.get('res.log').search(cr, uid, [("res_model", "=", "publisher_warranty.contract")]
-                                        , order="create_date desc", limit=limit)
+                                              , order="create_date desc", limit=limit)
         if not ids:
             return []
         messages = [(x.id, x.name) for x in self.pool.get('res.log').browse(cr, uid, ids)]
@@ -236,7 +235,7 @@
         'date_start' : fields.date('Starting Date', readonly=True),
         'date_stop' : fields.date('Ending Date', readonly=True),
         'state' : fields.selection([('unvalidated', 'Unvalidated'), ('valid', 'Valid')
-                            , ('terminated', 'Terminated'), ('canceled', 'Canceled')], string="State", readonly=True),
+                                    , ('terminated', 'Terminated'), ('canceled', 'Canceled')], string="State", readonly=True),
         'kind' : fields.char('Kind', size=64, readonly=True),
         "check_support": fields.boolean("Support Level 1", readonly=True),
         "check_opw": fields.boolean("OPW", readonly=True, help="Checked if this is an OpenERP Publisher's Warranty contract (versus older contract types"),
@@ -262,7 +261,7 @@
 
     def send(self, cr, uid, tb, explanations, remarks=None, issue_name=None):
         return self.pool.get("publisher_warranty.contract").send(cr, uid, tb,
-                        explanations, remarks, issue_name)
+                                                                 explanations, remarks, issue_name)
 
 maintenance_contract()
 
@@ -331,7 +330,7 @@
         "language": user.context_lang,
     }
 
-    add_arg = {"timeout":30} if sys.version_info >= (2,6) else {}
+    add_arg = {"timeout":30}
     arguments = {'arg0': msg, "action": "update",}
     arguments_raw = urllib.urlencode(arguments)
     url = config.get("publisher_warranty_url")

=== removed directory 'bin/addons/patches'
=== removed file 'bin/addons/patches/README'
--- bin/addons/patches/README	2012-05-02 14:50:59 +0000
+++ bin/addons/patches/README	1970-01-01 00:00:00 +0000
@@ -1,27 +0,0 @@
-Mandatory Patch
-
-=== export_many2many.diff
-Patch to apply on the server.
-This patch allow the synchro module to export many2many properly
-
-=== server_patch_export_boolean.diff
-Change the original way in the server to export boolean False value to print a string containing "False" instead
-bzr merge lp:openobject-server/6.0-msf-patch-export-boolean
-
-
-Needed to enable compressed communication
-
-=== server_patch_gzip_xmlrpc.diff
-Add a new protocol of communication with the server: gzipxmlrpc. It's all based on XML-RPC protocol but transfer its data compressed in gzip instead
-bzr merge lp:openobject-server/6.0-msf-patch-gzip-xmlrpc
-
-=== server_patch_netrpc_gzip.diff
-Add a new protocol of communication with the server: netrpc_gzip. It's all based on netrpc protocol but transfer its data compressed in gzip instead
-bzr branch lp:openobject-server/6.0-msf-patch-netrpc-gzip
-
-
-Needed when testing and running Openerp netrpc on a different port
-
-=== web_patch_choose_server_port.diff
-Enable OpenERP Web Client to use a different OpenERP Server host, port and protocol.
-bzr branch lp:openobject-client-web/6.0-msf-patch-choose-server-port

=== removed file 'bin/addons/patches/export_many2many.diff'
--- bin/addons/patches/export_many2many.diff	2012-04-07 17:42:54 +0000
+++ bin/addons/patches/export_many2many.diff	1970-01-01 00:00:00 +0000
@@ -1,57 +0,0 @@
-=== modified file 'bin/osv/orm.py'
---- bin/osv/orm.py	2011-12-11 11:55:32 +0000
-+++ bin/osv/orm.py	2012-04-06 09:26:29 +0000
-@@ -551,6 +551,8 @@
-     def __export_row(self, cr, uid, row, fields, context=None):
-         if context is None:
-             context = {}
-+            
-+        sync_context = context.get('sync_context')
- 
-         def check_type(field_type):
-             if field_type == 'float':
-@@ -569,6 +571,31 @@
-                 selection_field(col_obj._inherits)
-             else:
-                 return False
-+            
-+        def _get_xml_id(self, cr, uid, r):
-+            model_data = self.pool.get('ir.model.data')
-+            data_ids = model_data.search(cr, uid, [('model', '=', r._table_name), ('res_id', '=', r['id'])])
-+            if len(data_ids):
-+                d = model_data.read(cr, uid, data_ids, ['name', 'module'])[0]
-+                if d['module']:
-+                    r = '%s.%s' % (d['module'], d['name'])
-+                else:
-+                    r = d['name']
-+            else:
-+                postfix = 0
-+                while True:
-+                    n = self._table+'_'+str(r['id']) + (postfix and ('_'+str(postfix)) or '' )
-+                    if not model_data.search(cr, uid, [('name', '=', n)]):
-+                        break
-+                    postfix += 1
-+                model_data.create(cr, uid, {
-+                    'name': n,
-+                    'model': self._name,
-+                    'res_id': r['id'],
-+                    'module': '__export__',
-+                })
-+                r = '__export__.'+n
-+            return r
- 
-         lines = []
-         data = map(lambda x: '', range(len(fields)))
-@@ -620,6 +647,11 @@
-                             if [x for x in fields2 if x]:
-                                 break
-                         done.append(fields2)
-+                        
-+                        if sync_context and cols and cols._type=='many2many' and len(fields[fpos])>(i+1) and (fields[fpos][i+1]=='id'):
-+                            data[fpos] = ','.join([_get_xml_id(self, cr, uid, x) for x in r])
-+                            break
-+                        
-                         for row2 in r:
-                             lines2 = self.__export_row(cr, uid, row2, fields2,
-                                     context)
-

=== removed file 'bin/addons/patches/generate_server_ssl_key_cert.sh'
--- bin/addons/patches/generate_server_ssl_key_cert.sh	2011-09-09 13:20:20 +0000
+++ bin/addons/patches/generate_server_ssl_key_cert.sh	1970-01-01 00:00:00 +0000
@@ -1,21 +0,0 @@
-#!/bin/sh
-
-echo "generating SSL keys"
-
-openssl genrsa -des3 -out server.pkey 2048
-
-openssl req -new -key server.pkey -out server.csr
-
-openssl genrsa -des3 -out ca.pkey 2048
-
-openssl req -new -x509 -days 365 -key ca.pkey -out ca.crt
-
-openssl x509 -req -in server.csr -out server.crt -CA ca.crt -CAkey ca.pkey -CAcreateserial -CAserial ca.srl
-
-# decrypt private key to avoid typing passphrase at each client connection
-openssl rsa -in server.pkey -out server.pkey
-
-#start openerp server with --cert-file=YOUR .crt FILE PATH --pkey-file=YOUR pkey FILE PATH
-
-#./openerp-server --addons-path=../openobject-addons/ --cert-file=bin/ssl/server.crt --pkey-file=bin/ssl/server.pkey
-

=== removed file 'bin/addons/patches/server_patch_export_boolean.diff'
--- bin/addons/patches/server_patch_export_boolean.diff	2011-09-09 13:20:20 +0000
+++ bin/addons/patches/server_patch_export_boolean.diff	1970-01-01 00:00:00 +0000
@@ -1,13 +0,0 @@
-=== modified file 'bin/osv/orm.py'
---- bin/osv/orm.py	2011-06-20 11:12:35 +0000
-+++ bin/osv/orm.py	2011-08-22 11:19:48 +0000
-@@ -557,7 +557,7 @@
-             elif field_type == 'integer':
-                 return 0
-             elif field_type == 'boolean':
--                return False
-+                return 'False'
-             return ''
- 
-         def selection_field(in_field):
-

=== removed file 'bin/addons/patches/server_patch_gzip_xmlrpc.diff'
--- bin/addons/patches/server_patch_gzip_xmlrpc.diff	2011-09-09 13:20:20 +0000
+++ bin/addons/patches/server_patch_gzip_xmlrpc.diff	1970-01-01 00:00:00 +0000
@@ -1,223 +0,0 @@
-=== added file 'bin/service/gzip_xmlrpclib.py'
---- bin/service/gzip_xmlrpclib.py	1970-01-01 00:00:00 +0000
-+++ bin/service/gzip_xmlrpclib.py	2011-09-08 13:10:09 +0000
-@@ -0,0 +1,109 @@
-+import zlib
-+import xmlrpclib
-+from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler
-+import logging
-+
-+from timeout_transport import TimeoutTransport
-+
-+# xmlrpc server side
-+
-+class GzipXMLRPCRequestHandler(SimpleXMLRPCRequestHandler):
-+
-+    def do_POST(self):
-+        if not(self.headers.has_key('accept-encoding') and self.headers['accept-encoding'] == 'gzip'):
-+            return SimpleXMLRPCRequestHandler.do_POST(self)
-+        else:
-+            if not self.is_rpc_path_valid():
-+                self.report_404()
-+                return
-+            try:
-+                max_chunk_size = 10*1024*1024
-+                size_remaining = int(self.headers["content-length"])
-+                L = []
-+                while size_remaining:
-+                    chunk_size = min(size_remaining, max_chunk_size)
-+                    L.append(self.rfile.read(chunk_size))
-+                    size_remaining -= len(L[-1])
-+                data = ''.join(L)
-+                data = zlib.decompress(data) # is_gzip
-+                response = self.server._marshaled_dispatch(
-+                        data, getattr(self, '_dispatch', None)
-+                    )
-+            except Exception, e:
-+                self.send_response(500)
-+                self.end_headers()
-+            else:
-+                response = zlib.compress(response, zlib.Z_BEST_COMPRESSION) # is_gzip
-+                self.send_response(200)
-+                self.send_header("Content-type", "text/xml")
-+                self.send_header("Content-length", str(len(response)))
-+                self.send_header("Accept-Encoding", "gzip") # is_gzip
-+                self.end_headers()
-+                self.wfile.write(response)
-+                self.wfile.flush()
-+                self.connection.shutdown(1)
-+
-+# xmlrpc client side
-+
-+class GzipTransport(TimeoutTransport):
-+
-+    def __init__(self, timeout=None, *args, **kwargs):
-+        TimeoutTransport.__init__(self, timeout=timeout, *args, **kwargs)
-+        self.__logger = logging.getLogger('xmlrpc.transport')
-+
-+    def request(self, host, handler, request_body, verbose=0):
-+        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)
-+
-+        # is_gzip
-+        h.putheader('Accept-Encoding', 'gzip')
-+        raw_size = len(request_body)
-+        request_body = zlib.compress(request_body, zlib.Z_BEST_COMPRESSION)
-+        gzipped_size = len(request_body)
-+        saving = 100*(float(raw_size-gzipped_size))/gzipped_size if gzipped_size else 0
-+        self.__logger.debug('payload size: raw %s, gzipped %s, saving %.2f%%',
-+                raw_size, gzipped_size, saving)
-+
-+        self.send_content(h, request_body)
-+        errcode, errmsg, headers = h.getreply()
-+        if errcode != 200:
-+            raise xmlrpclib.ProtocolError(
-+                    host + handler,
-+                    errcode, errmsg,
-+                    headers
-+                    )
-+        self.verbose = verbose
-+        try:
-+            sock = h._conn.sock
-+        except AttributeError:
-+            sock = None
-+
-+        # is_gzip
-+        if headers.has_key('accept-encoding') and headers['accept-encoding'] == 'gzip':
-+            return self._parse_gzipped_response(h.getfile(), sock)
-+
-+        return self._parse_response(h.getfile(), sock)
-+
-+    def _parse_gzipped_response(self, file, sock):
-+        p, u = self.getparser()
-+        response_chunks = []
-+        while 1:
-+            if sock:
-+                chunk = sock.recv(1024)
-+            else:
-+                chunk = file.read(1024)
-+            if not chunk:
-+                break
-+            response_chunks.append(chunk)
-+        response = zlib.decompress("".join(response_chunks))
-+        if self.verbose:
-+            print "body:", repr(response)
-+        p.feed(response)
-+        file.close()
-+        p.close()
-+        return u.close()
-+
-
-=== modified file 'bin/service/http_server.py'
---- bin/service/http_server.py	2011-01-18 23:50:33 +0000
-+++ bin/service/http_server.py	2011-09-08 15:43:15 +0000
-@@ -43,7 +43,9 @@
- import xmlrpclib
- import logging
- 
-+import SimpleXMLRPCServer
- from SimpleXMLRPCServer import SimpleXMLRPCDispatcher
-+import gzip_xmlrpclib
- 
- try:
-     import fcntl
-@@ -227,7 +229,7 @@
- 
- def init_servers():
-     global httpd, httpsd
--    if tools.config.get('xmlrpc'):
-+    if tools.config.get('xmlrpc') or tools.config.get('gzipxmlrpc'):
-         httpd = HttpDaemon(tools.config.get('xmlrpc_interface', ''),
-                            int(tools.config.get('xmlrpc_port', 8069)))
- 
-@@ -260,7 +262,6 @@
-     else:
-         raise Exception("Incorrect protocol or no http services")
- 
--import SimpleXMLRPCServer
- class XMLRPCRequestHandler(netsvc.OpenERPDispatcher,FixSendError,HttpLogHandler,SimpleXMLRPCServer.SimpleXMLRPCRequestHandler):
-     rpc_paths = []
-     protocol_version = 'HTTP/1.1'
-@@ -283,6 +284,27 @@
-         self.connection = dummyconn()
-         self.rpc_paths = map(lambda s: '/%s' % s, netsvc.ExportService._services.keys())
- 
-+class GzipXMLRPCRequestHandler(netsvc.OpenERPDispatcher,FixSendError,HttpLogHandler, gzip_xmlrpclib.GzipXMLRPCRequestHandler):
-+    rpc_paths = []
-+    protocol_version = 'HTTP/1.1'
-+    _logger = logging.getLogger('xmlrpc')
-+
-+    def _dispatch(self, method, params):
-+        try:
-+            service_name = self.path.split("/")[-1]
-+            return self.dispatch(service_name, method, params)
-+        except netsvc.OpenERPDispatcherException, e:
-+            raise xmlrpclib.Fault(tools.exception_to_unicode(e.exception), e.traceback)
-+
-+    def handle(self):
-+        pass
-+
-+    def finish(self):
-+        pass
-+
-+    def setup(self):
-+        self.connection = dummyconn()
-+        self.rpc_paths = map(lambda s: '/%s' % s, netsvc.ExportService._services.keys())
- 
- def init_xmlrpc():
-     if tools.config.get('xmlrpc', False):
-@@ -291,6 +313,12 @@
-         reg_http_service(HTTPDir('/xmlrpc/', XMLRPCRequestHandler))
-         logging.getLogger("web-services").info("Registered XML-RPC over HTTP")
- 
-+    if tools.config.get('gzipxmlrpc', False):
-+        # Example of http file serving:
-+        # reg_http_service(HTTPDir('/test/',HTTPHandler))
-+        reg_http_service(HTTPDir('/xmlrpc/', GzipXMLRPCRequestHandler))
-+        logging.getLogger("web-services").info("Registered gzipped XML-RPC over HTTP")
-+
-     if tools.config.get('xmlrpcs', False) \
-             and not tools.config.get('xmlrpc', False):
-         # only register at the secure server
-
-=== modified file 'bin/tools/config.py'
---- bin/tools/config.py	2011-05-17 05:54:43 +0000
-+++ bin/tools/config.py	2011-09-08 15:36:04 +0000
-@@ -55,6 +55,7 @@
-             'reportgz': False,
-             'netrpc': True,
-             'xmlrpc': True,
-+            'gzipxmlrpc': False,
-             'xmlrpcs': True,
-             'translate_in': None,
-             'translate_out': None,
-@@ -119,6 +120,7 @@
-         group.add_option("--xmlrpc-interface", dest="xmlrpc_interface", help="specify the TCP IP address for the XML-RPC protocol")
-         group.add_option("--xmlrpc-port", dest="xmlrpc_port", help="specify the TCP port for the XML-RPC protocol", type="int")
-         group.add_option("--no-xmlrpc", dest="xmlrpc", action="store_false", help="disable the XML-RPC protocol")
-+        group.add_option("--gzipxmlrpc", dest="gzipxmlrpc", action="store_true", help="enable gzipping XML-RPC protocol (disable standard XMLRPC)")
-         parser.add_option_group(group)
- 
-         title = "XML-RPC Secure Configuration"
-@@ -290,11 +292,15 @@
-         if self.options['pidfile'] in ('None', 'False'):
-             self.options['pidfile'] = False
- 
-+        if opt.gzipxmlrpc:
-+            # gzip prevails over standard
-+            opt.xmlrpc = False
-+
-         keys = ['xmlrpc_interface', 'xmlrpc_port', 'db_name', 'db_user', 'db_password', 'db_host',
-                 'db_port', 'logfile', 'pidfile', 'smtp_port', 'cache_timeout',
-                 'email_from', 'smtp_server', 'smtp_user', 'smtp_password',
-                 'netrpc_interface', 'netrpc_port', 'db_maxconn', 'import_partial', 'addons_path',
--                'netrpc', 'xmlrpc', 'syslog', 'without_demo', 'timezone',
-+                'netrpc', 'xmlrpc', 'gzipxmlrpc', 'syslog', 'without_demo', 'timezone',
-                 'xmlrpcs_interface', 'xmlrpcs_port', 'xmlrpcs',
-                 'secure_cert_file', 'secure_pkey_file',
-                 'static_http_enable', 'static_http_document_root', 'static_http_url_prefix'
-

=== removed file 'bin/addons/patches/server_patch_netrpc_gzip.diff'
--- bin/addons/patches/server_patch_netrpc_gzip.diff	2012-04-04 10:18:51 +0000
+++ bin/addons/patches/server_patch_netrpc_gzip.diff	1970-01-01 00:00:00 +0000
@@ -1,156 +0,0 @@
-=== modified file 'bin/service/netrpc_server.py'
---- bin/service/netrpc_server.py	2011-01-18 23:50:33 +0000
-+++ bin/service/netrpc_server.py	2011-09-08 22:58:33 +0000
-@@ -35,7 +35,7 @@
- import tools
- 
- class TinySocketClientThread(threading.Thread, netsvc.OpenERPDispatcher):
--    def __init__(self, sock, threads):
-+    def __init__(self, sock, threads, is_gzip):
-         spn = sock and sock.getpeername()
-         spn = 'netrpc-client-%s:%s' % spn[0:2]
-         threading.Thread.__init__(self, name=spn)
-@@ -44,6 +44,7 @@
-         # clients connection when they're idle for 20min.
-         self.sock.settimeout(1200)
-         self.threads = threads
-+        self.is_gzip = is_gzip
- 
-     def __del__(self):
-         if self.sock:
-@@ -58,7 +59,7 @@
-     def run(self):
-         self.running = True
-         try:
--            ts = tiny_socket.mysocket(self.sock)
-+            ts = tiny_socket.mysocket(self.sock, self.is_gzip)
-         except Exception:
-             self.threads.remove(self)
-             self.running = False
-@@ -101,7 +102,7 @@
- 
- 
- class TinySocketServerThread(threading.Thread,netsvc.Server):
--    def __init__(self, interface, port, secure=False):
-+    def __init__(self, interface, port, secure=False, is_gzip=False):
-         threading.Thread.__init__(self, name="NetRPCDaemon-%d"%port)
-         netsvc.Server.__init__(self)
-         self.__port = port
-@@ -113,6 +114,7 @@
-         self.threads = []
-         netsvc.Logger().notifyChannel("web-services", netsvc.LOG_INFO, 
-                          "starting NET-RPC service at %s port %d" % (interface or '0.0.0.0', port,))
-+        self.is_gzip = is_gzip
- 
-     def run(self):
-         try:
-@@ -122,7 +124,7 @@
-                 if not fd_sets[0]:
-                     continue
-                 (clientsocket, address) = self.socket.accept()
--                ct = TinySocketClientThread(clientsocket, self.threads)
-+                ct = TinySocketClientThread(clientsocket, self.threads, self.is_gzip)
-                 clientsocket = None
-                 self.threads.append(ct)
-                 ct.start()
-@@ -162,7 +164,9 @@
- 
- def init_servers():
-     global netrpcd
--    if tools.config.get('netrpc', False):
-+    if tools.config.get('netrpc', False) or tools.config.get('netrpc_gzip', False):
-         netrpcd = TinySocketServerThread(
-             tools.config.get('netrpc_interface', ''), 
--            int(tools.config.get('netrpc_port', 8070)))
-+            int(tools.config.get('netrpc_port', 8070)),
-+            is_gzip=tools.config.get('netrpc_gzip'),
-+        )
-
-=== modified file 'bin/tiny_socket.py'
---- bin/tiny_socket.py	2011-01-18 23:52:38 +0000
-+++ bin/tiny_socket.py	2011-09-08 23:10:19 +0000
-@@ -22,7 +22,9 @@
- import socket
- import cPickle
- import cStringIO
--import marshal
-+
-+import zlib
-+GZIP_MAGIC = '\x78\xda' # magic when max compression used
- 
- class Myexception(Exception):
-     """
-@@ -39,7 +41,7 @@
- 
- class mysocket:
- 
--    def __init__(self, sock=None):
-+    def __init__(self, sock=None, is_gzip=False):
-         if sock is None:
-             self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-         else:
-@@ -48,6 +50,7 @@
-         # prepare this socket for long operations: it may block for infinite
-         # time, but should exit as soon as the net is down
-         self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
-+        self.is_gzip = is_gzip
-         
-     def connect(self, host, port=False):
-         if not port:
-@@ -61,6 +64,8 @@
-         
-     def mysend(self, msg, exception=False, traceback=None):
-         msg = cPickle.dumps([msg,traceback])
-+        if self.is_gzip:
-+            msg = zlib.compress(msg, zlib.Z_BEST_COMPRESSION)
-         self.sock.sendall('%8d%s%s' % (len(msg), exception and "1" or "0", msg))
-             
-     def myreceive(self):
-@@ -82,6 +87,8 @@
-             if not chunk:
-                 raise socket.timeout
-             msg = msg + chunk
-+        if msg.startswith(GZIP_MAGIC):
-+            msg = zlib.decompress(msg)
-         msgio = cStringIO.StringIO(msg)
-         unpickler = cPickle.Unpickler(msgio)
-         unpickler.find_global = None
-
-=== modified file 'bin/tools/config.py'
---- bin/tools/config.py	2011-05-17 05:54:43 +0000
-+++ bin/tools/config.py	2011-09-08 22:17:09 +0000
-@@ -54,7 +54,8 @@
-             'db_maxconn': 64,
-             'reportgz': False,
-             'netrpc': True,
-+            'netrpc_gzip': False,
-             'xmlrpc': True,
-             'xmlrpcs': True,
-             'translate_in': None,
-             'translate_out': None,
-@@ -138,6 +141,7 @@
-         group.add_option("--netrpc-interface", dest="netrpc_interface", help="specify the TCP IP address for the NETRPC protocol")
-         group.add_option("--netrpc-port", dest="netrpc_port", help="specify the TCP port for the NETRPC protocol", type="int")
-         group.add_option("--no-netrpc", dest="netrpc", action="store_false", help="disable the NETRPC protocol")
-+        group.add_option("--netrpc-gzip", dest="netrpc_gzip", action="store_true", help="enable gzipping the NETRPC protocol")
-         parser.add_option_group(group)
- 
-         # Static HTTP
-@@ -290,11 +294,15 @@
-         if self.options['pidfile'] in ('None', 'False'):
-             self.options['pidfile'] = False
- 
-+        if opt.netrpc_gzip:
-+            # gzip prevails over standard
-+            opt.netrpc = False
-+
-         keys = ['xmlrpc_interface', 'xmlrpc_port', 'db_name', 'db_user', 'db_password', 'db_host',
-                 'db_port', 'logfile', 'pidfile', 'smtp_port', 'cache_timeout',
-                 'email_from', 'smtp_server', 'smtp_user', 'smtp_password',
-                 'netrpc_interface', 'netrpc_port', 'db_maxconn', 'import_partial', 'addons_path',
--                'netrpc', 'xmlrpc', 'syslog', 'without_demo', 'timezone',
-+                'netrpc', 'netrpc_gzip', 'xmlrpc', 'syslog', 'without_demo', 'timezone',
-                 'xmlrpcs_interface', 'xmlrpcs_port', 'xmlrpcs',
-                 'secure_cert_file', 'secure_pkey_file',
-                 'static_http_enable', 'static_http_document_root', 'static_http_url_prefix'
-

=== removed file 'bin/addons/patches/web_patch_choose_server_port.diff'
--- bin/addons/patches/web_patch_choose_server_port.diff	2011-09-09 13:20:20 +0000
+++ bin/addons/patches/web_patch_choose_server_port.diff	1970-01-01 00:00:00 +0000
@@ -1,30 +0,0 @@
-=== modified file 'openobject/commands.py'
---- openobject/commands.py	2011-03-03 16:36:17 +0000
-+++ openobject/commands.py	2011-08-22 15:00:29 +0000
-@@ -50,6 +50,9 @@
-                       help="configuration file", default=get_config_file())
-     parser.add_option("-a", "--address", help="host address, overrides server.socket_host")
-     parser.add_option("-p", "--port", help="port number, overrides server.socket_port")
-+    parser.add_option("--openerp-host", dest="openerp_host", help="overrides openerp.server.host")
-+    parser.add_option("--openerp-port", dest="openerp_port", help="overrides openerp.server.port")
-+    parser.add_option("--openerp-protocol", dest="openerp_protocol", help="overrides openerp.server.protocol")
-     parser.add_option("--no-static", dest="static",
-                       action="store_false", default=True,
-                       help="Disables serving static files through CherryPy")
-@@ -72,6 +75,15 @@
-             cherrypy.config['server.socket_port'] = int(options.port)
-         except:
-             pass
-+    if options.openerp_host:
-+        cherrypy.config['openerp.server.host'] = options.openerp_host
-+    if options.openerp_port:
-+        try:
-+            cherrypy.config['openerp.server.port'] = int(options.openerp_port)
-+        except:
-+            pass
-+    if options.openerp_protocol in ['http', 'https', 'socket']:
-+        cherrypy.config['openerp.server.protocol'] = options.openerp_protocol
- 
-     configure_babel()
- 
-

=== removed file 'bin/addons/sync_client/gzip_xmlrpclib.py'
--- bin/addons/sync_client/gzip_xmlrpclib.py	2014-09-04 13:12:41 +0000
+++ bin/addons/sync_client/gzip_xmlrpclib.py	1970-01-01 00:00:00 +0000
@@ -1,114 +0,0 @@
-import zlib
-import xmlrpclib
-from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler
-import logging
-
-from timeout_transport import TimeoutTransport, TimeoutSafeTransport
-
-# xmlrpc server side
-
-class GzipXMLRPCRequestHandler(SimpleXMLRPCRequestHandler):
-
-    def do_POST(self):
-        if not(self.headers.has_key('accept-encoding') and self.headers['accept-encoding'] == 'gzip'):
-            return SimpleXMLRPCRequestHandler.do_POST(self)
-        else:
-            if not self.is_rpc_path_valid():
-                self.report_404()
-                return
-            try:
-                max_chunk_size = 10*1024*1024
-                size_remaining = int(self.headers["content-length"])
-                L = []
-                while size_remaining:
-                    chunk_size = min(size_remaining, max_chunk_size)
-                    L.append(self.rfile.read(chunk_size))
-                    size_remaining -= len(L[-1])
-                data = ''.join(L)
-                data = zlib.decompress(data) # is_gzip
-                response = self.server._marshaled_dispatch(
-                        data, getattr(self, '_dispatch', None)
-                    )
-            except Exception, e:
-                self.send_response(500)
-                self.end_headers()
-            else:
-                response = zlib.compress(response, zlib.Z_BEST_COMPRESSION) # is_gzip
-                self.send_response(200)
-                self.send_header("Content-type", "text/xml")
-                self.send_header("Content-length", str(len(response)))
-                self.send_header("Accept-Encoding", "gzip") # is_gzip
-                self.end_headers()
-                self.wfile.write(response)
-                self.wfile.flush()
-                self.connection.shutdown(1)
-
-# xmlrpc client side
-class GzipTransport(TimeoutTransport):
-
-    def __init__(self, timeout=None, *args, **kwargs):
-        TimeoutTransport.__init__(self, timeout=timeout, *args, **kwargs)
-        self._logger = logging.getLogger('xmlrpc.transport')
-
-    def request(self, host, handler, request_body, verbose=0):
-        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)
-
-        # is_gzip
-        h.putheader('Accept-Encoding', 'gzip')
-        raw_size = len(request_body)
-        request_body = zlib.compress(request_body, zlib.Z_BEST_COMPRESSION)
-        gzipped_size = len(request_body)
-        saving = 100*(float(raw_size-gzipped_size))/gzipped_size if gzipped_size else 0
-        self._logger.debug('payload size: raw %s, gzipped %s, saving %.2f%%',
-                raw_size, gzipped_size, saving)
-
-        self.send_content(h, request_body)
-        errcode, errmsg, headers = h.getreply()
-        if errcode != 200:
-            raise xmlrpclib.ProtocolError(
-                    host + handler,
-                    errcode, errmsg,
-                    headers
-                    )
-        self.verbose = verbose
-        try:
-            sock = h._conn.sock
-        except AttributeError:
-            sock = None
-
-        # is_gzip
-        if headers.has_key('accept-encoding') and headers['accept-encoding'] == 'gzip':
-            return self._parse_gzipped_response(h.getfile(), sock)
-        return self._parse_response(h.getfile(), sock)
-
-    def _parse_gzipped_response(self, file, sock):
-        p, u = self.getparser()
-        response_chunks = []
-        while 1:
-            if sock:
-                chunk = sock.recv(1024)
-            else:
-                chunk = file.read(1024)
-            if not chunk:
-                break
-            response_chunks.append(chunk)
-        response = zlib.decompress("".join(response_chunks))
-        if self.verbose:
-            print "body:", repr(response)
-        p.feed(response)
-        file.close()
-        p.close()
-        return u.close()
-
-class GzipSafeTransport(TimeoutSafeTransport, GzipTransport):
-    def __init__(self, timeout=None, *args, **kwargs):
-        TimeoutSafeTransport.__init__(self, timeout=timeout, *args, **kwargs)
-        self._logger = logging.getLogger('xmlrpc.transport')
-
-    def request(self, host, handler, request_body, verbose=0):
-        return GzipTransport.request(self, host, handler, request_body, verbose)

=== modified file 'bin/addons/sync_client/rpc.py'
--- bin/addons/sync_client/rpc.py	2016-11-15 15:32:01 +0000
+++ bin/addons/sync_client/rpc.py	2017-05-22 10:09:36 +0000
@@ -10,10 +10,10 @@
 import zlib
 import xmlrpclib
 from timeout_transport import TimeoutTransport
-from gzip_xmlrpclib import GzipTransport, GzipSafeTransport
 from osv import osv
 from tools.translate import _
 import tools
+import ssl
 
 try:
     import cPickle as pickle
@@ -26,9 +26,6 @@
     import StringIO
 
 import logging
-#import logging.config
-
-#logging.config.fileConfig('logging.cfg')
 
 GZIP_MAGIC = '\x78\xda' # magic when max compression used
 NB_RETRY = 10
@@ -93,6 +90,8 @@
     def send(self, service_name, method, *args):
         url = '%s/%s' % (self.url, service_name)
         transport = TimeoutTransport(timeout=self.timeout)
+        # Enable gzip on all payloads
+        transport.encode_threshold = 0
         service = xmlrpclib.ServerProxy(url, allow_none=1, transport=transport)
         return self._send(service, method, *args)
 
@@ -113,36 +112,6 @@
             raise osv.except_osv(_('Error!'), "Unable to proceed for the following reason:\n%s" % (e.faultCode if hasattr(e, 'faultCode') else tools.ustr(e)))
 
 
-"""Modified version of xmlrcpclib.Transport.request (same in Python 2.4, 2.5, 2.6)
-   to workaround Python bug http://bugs.python.org/issue1223
-   for Python versions before 2.6
-   This patch is inspired by http://www.cherrypy.org/ticket/743.
-   See LP bug https://bugs.launchpad.net/openobject-client/+bug/673775
-"""
-def fixed_request(self, host, handler, request_body, verbose=0):
-    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 xmlrpclib.ProtocolError(host + handler, errcode, errmsg,
-                                      headers)
-    self.verbose = verbose
-    # below we make sure to call parse_response() and
-    # not _parse_response(), and don't pass the socket,
-    # so it will have to use the file instead, and avoid
-    # the problem of the original code.
-    return self.parse_response(h.getfile())
-
-# Rude monkey-patch to fix the SSL connection error in Python 2.5-,
-# as last resort solution to fix it all at once.
-if sys.version_info < (2,6):
-    xmlrpclib.SafeTransport.request = fixed_request
-
 class SecuredXmlRPCConnector(XmlRPCConnector):
     """
     This class supports the XmlRPC protocol over HTTPS
@@ -155,33 +124,13 @@
 
     def send(self, service_name, method, *args):
         url = '%s/%s' % (self.url, service_name)
-        service = xmlrpclib.ServerProxy(url, allow_none=1)
-        return self._send(service, method, *args)
-
-class GzipXmlRPCConnector(XmlRPCConnector):
-    """
-    This class supports the XmlRPC protocol with gzipped payload
-    """
-    PROTOCOL = 'gzipxmlrpc'
-
-    def send(self, service_name, method, *args):
-        url = '%s/%s' % (self.url, service_name)
-        gzip_transport = GzipTransport(timeout=self.timeout)
-        service = xmlrpclib.ServerProxy(url, allow_none=1, transport=gzip_transport)
-        return self._send(service, method, *args)
-
-class GzipXmlRPCSConnector(GzipXmlRPCConnector):
-    PROTOCOL = 'gzipxmlrpcs'
-
-    def __init__(self, hostname, port=8069, *args, **kwargs):
-        GzipXmlRPCConnector.__init__(self, hostname, port, *args, **kwargs)
-        self.url = 'https://%s:%s/xmlrpc' % (self.hostname, self.port)
-
-    def send(self, service_name, method, *args):
-        url = '%s/%s' % (self.url, service_name)
-        gzip_safe_transport = GzipSafeTransport(timeout=self.timeout)
-        service = xmlrpclib.ServerProxy(url, allow_none=1, transport=gzip_safe_transport)
-        return getattr(service, method)(*args)
+        # Decide whether to accept self-signed certificates
+        ctx = ssl.create_default_context()
+        if not tools.config.get('secure_verify', True):
+            ctx.check_hostname = False
+            ctx.verify_mode = ssl.CERT_NONE
+        service = xmlrpclib.ServerProxy(url, allow_none=1, context=ctx)
+        return self._send(service, method, *args)
 
 class NetRPC_Exception(Exception):
     def __init__(self, faultCode, faultString):
@@ -217,11 +166,7 @@
         #self._logger.debug("rpc message : %s", msg)
         msg = pickle.dumps([msg,traceback])
         if self.is_gzip:
-            #raw_size = len(msg)
             msg = zlib.compress(msg, zlib.Z_BEST_COMPRESSION)
-            #gzipped_size = len(msg)
-            #saving = 100*(float(raw_size-gzipped_size))/gzipped_size if gzipped_size else 0
-            #self._logger.debug('payload size: raw %s, gzipped %s, saving %.2f%%', raw_size, gzipped_size, saving)
         size = len(msg)
         self.sock.send('%8d' % size)
         self.sock.send(exception and "1" or "0")
@@ -252,11 +197,7 @@
                 raise RuntimeError, "socket connection broken"
             msg = msg + chunk
         if msg.startswith(GZIP_MAGIC):
-            #gzipped_size = len(msg)
             msg = zlib.decompress(msg)
-            #raw_size = len(msg)
-            #saving = 100*(float(raw_size-gzipped_size))/gzipped_size if gzipped_size else 0
-            #self._logger.debug('payload size: raw %s, gzipped %s, saving %.2f%%', raw_size, gzipped_size, saving)
         res = SafeUnpickler.loads(msg)
 
         if isinstance(res[0],Exception):

=== modified file 'bin/addons/sync_client/sync_client.py'
--- bin/addons/sync_client/sync_client.py	2017-04-28 07:21:12 +0000
+++ bin/addons/sync_client/sync_client.py	2017-05-22 10:09:36 +0000
@@ -557,7 +557,7 @@
             if obj[model_field_name] not in model_field_dict:
                 model_field_dict[obj[model_field_name]] = set()
             model_field_dict[obj[model_field_name]].update(eval(obj['arguments']))
-       
+
         model_set = set(model_field_dict.keys())
 
         def get_field_obj(model, field_name):
@@ -1354,13 +1354,10 @@
         return self.browse(cr, uid, ids, context=context)[0]
 
     def connector_factory(self, con):
-        if con.protocol == 'xmlrpc':
+        # xmlrpc now does gzip by default
+        if con.protocol == 'xmlrpc' or con.protocol == 'gzipxmlrpc':
             connector = rpc.XmlRPCConnector(con.host, con.port, timeout=con.timeout, retry=con.xmlrpc_retry)
-        elif con.protocol == 'gzipxmlrpc':
-            connector = rpc.GzipXmlRPCConnector(con.host, con.port, timeout=con.timeout, retry=con.xmlrpc_retry)
-        elif con.protocol == 'gzipxmlrpcs':
-            connector = rpc.GzipXmlRPCSConnector(con.host, con.port, timeout=con.timeout, retry=con.xmlrpc_retry)
-        elif con.protocol == 'xmlrpcs':
+        elif con.protocol == 'xmlrpcs' or con.protocol == 'gzipxmlrpcs':
             connector = rpc.SecuredXmlRPCConnector(con.host, con.port, timeout=con.timeout, retry=con.xmlrpc_retry)
         elif con.protocol == 'netrpc':
             connector = rpc.NetRPCConnector(con.host, con.port, timeout=con.timeout, retry=con.netrpc_retry)

=== modified file 'bin/addons/sync_client/timeout_transport.py'
--- bin/addons/sync_client/timeout_transport.py	2014-10-29 11:09:22 +0000
+++ bin/addons/sync_client/timeout_transport.py	2017-05-22 10:09:36 +0000
@@ -1,6 +1,5 @@
 import httplib
 import xmlrpclib
-import sys
 
 class TimeoutHTTPConnection(httplib.HTTPConnection):
 
@@ -12,13 +11,6 @@
     def set_timeout(self, timeout):
         self.timeout = timeout
 
-class TimeoutHTTP(httplib.HTTP):
-
-    _connection_class = TimeoutHTTPConnection
-
-    def set_timeout(self, timeout):
-        self._conn.timeout = timeout
-
 class TimeoutTransport(xmlrpclib.Transport):
 
     def __init__(self, timeout=None, *args, **kwargs):
@@ -27,10 +19,7 @@
 
     def make_connection(self, host):
         chost, self._extra_headers, _ = self.get_host_info(host)
-        if sys.version_info < (2,7):
-            self._connection = host, TimeoutHTTP(host)
-        else:
-            self._connection = host, TimeoutHTTPConnection(chost)
+        self._connection = host, TimeoutHTTPConnection(chost)
         self._connection[1].set_timeout(self.timeout)
         return self._connection[1]
 
@@ -41,13 +30,6 @@
         if self.timeout is not None:
             self.sock.settimeout(self.timeout)
 
-class TimeoutHTTPS(httplib.HTTPS):
-
-    _connection_class = TimeoutHTTPSConnection
-
-    def set_timeout(self, timeout):
-        self._conn.timeout = timeout
-
 class TimeoutSafeTransport(xmlrpclib.SafeTransport):
 
     def __init__(self, timeout=None, *args, **kwargs):
@@ -55,8 +37,7 @@
         self.timeout = timeout
 
     def make_connection(self, host):
-        # TODO: check make_connection for python > 2.6
-        conn = TimeoutHTTPS(host)
-        conn.set_timeout(self.timeout)
-        return conn
+        self._connection = host, TimeoutHTTPSConnection(host)
+        self._connection[1].set_timeout(self.timeout)
+        return self._connection[1]
 

=== modified file 'bin/addons/update_client/wizard.py'
--- bin/addons/update_client/wizard.py	2016-06-06 12:37:19 +0000
+++ bin/addons/update_client/wizard.py	2017-05-22 10:09:36 +0000
@@ -1,26 +1,20 @@
 from __future__ import with_statement
-import sys
 import os
 import logging
 import urllib2
 import threading
 from base64 import b64decode
-import hashlib
 from StringIO import StringIO
 import tarfile
 
 from osv import osv, fields
 from tools.translate import _
-import tools
 import base64
 from tools import config
-from updater import *
+import updater
 
 from version import IMPORT_PATCH_SUCCESS, IMPORT_PATCH_INVALID, IMPORT_PATCH_UNKNOWN, IMPORT_PATCH_IGNORED
 
-assert sys.version_info >= (2, 6), \
-    "timeout argument of urllib2.urlopen() needs Python >= 2.6"
-
 th_local = threading.local()
 
 def is_online():
@@ -46,7 +40,7 @@
 
     def restart(self, cr, uid, ids, context=None):
         os.chdir( config['root_path'] )
-        restart_server()
+        updater.restart_server()
         return {'type': 'ir.actions.act_window_close'}
 
     def _get_error(self, cr, uid, context=None):
@@ -87,7 +81,7 @@
         """Actualy, prepare the upgrade to be done at server restart"""
         # backup before patching
         self.pool.get('backup.config').exp_dump_for_state(cr, uid,
-                'beforepatching', context=context, force=True)
+                                                          'beforepatching', context=context, force=True)
 
         connection_module = self.pool.get("sync.client.sync_server_connection")
         proxy = connection_module.get_connection(cr, uid, "sync.server.sync_manager")
@@ -95,7 +89,7 @@
         # SYNC_SERVER connection credentials to be able to automatically
         # reconnect to the SYNC_SERVER after an upgrade
         automatic_patching = sync_type=='automatic' and\
-                connection_module.is_automatic_patching_allowed(cr, uid)
+            connection_module.is_automatic_patching_allowed(cr, uid)
         if automatic_patching:
             password = connection_module._get_password(cr, uid, [proxy], None, None, None).values()[0]
             password = base64.encodestring(password)
@@ -118,7 +112,7 @@
                 }, context=context)
         next_revisions = self.pool.get('sync_client.version')._get_next_revisions(cr, uid, context=context)
         ## Prepare
-        (status, message, values) = do_prepare(cr, next_revisions)
+        (status, message, values) = updater.do_prepare(cr, next_revisions)
         wiz_value = {'message':_(message)}
         if status in ('corrupt','missing'):
             wiz_value['state'] = 'need-download'
@@ -150,7 +144,7 @@
                     tar = tarfile.open(fileobj=StringIO(b64decode(wiz.patch)))
                     for content in (fh.read() for fh in (tar.extractfile(name) for name in tar.getnames()) if fh):
                         status = revisions.import_patch(cr, uid,
-                            decoded=content, context=context)
+                                                        decoded=content, context=context)
                         cr.commit()
                         if status == IMPORT_PATCH_SUCCESS: count += 1
                         elif status == IMPORT_PATCH_INVALID: pass
@@ -179,10 +173,10 @@
             self.write(cr, uid, ids, {'message':text}, context=context)
         else:
             self.write(cr, uid, ids, {
-                    'message' : _("%d revision(s) has been imported.") % count + \
-                                "\n\n" + self._generate(cr, uid, context=context),
-                    'state' : self._get_state(cr, uid, context=context),
-                }, context=context)
+                'message' : _("%d revision(s) has been imported.") % count + \
+                "\n\n" + self._generate(cr, uid, context=context),
+                'state' : self._get_state(cr, uid, context=context),
+            }, context=context)
 
         return {}
 
@@ -204,8 +198,8 @@
             text += _("No revision has been applied yet.")
         text += "\n"
         next_revisions = revisions.browse(cr, uid,
-            revisions._get_next_revisions(cr, uid, context=context),
-            context=context)
+                                          revisions._get_next_revisions(cr, uid, context=context),
+                                          context=context)
         if next_revisions:
             text += "\n"
             if len(next_revisions) == 1:
@@ -246,20 +240,20 @@
             entity = self.pool.get('sync.client.entity').get_entity(cr, uid)
             if entity.usb_instance_type == 'remote_warehouse':
                 return True
-        except Exception, e:
+        except Exception:
             pass
         return False
 
     _columns = {
         'message' : fields.text("Caption", readonly=True),
         'state' : fields.selection([
-                ('need-provide-manually','Need To Provide Manually The Files'),
-                ('need-download','Need Download'),
-                ('up-to-date','Up-To-Date'),
-                ('need-install','Need Install'),
-                ('need-restart','Need Restart'),
-                ('blocked','Blocked')
-            ], string="Status"),
+            ('need-provide-manually','Need To Provide Manually The Files'),
+            ('need-download','Need Download'),
+            ('up-to-date','Up-To-Date'),
+            ('need-install','Need Install'),
+            ('need-restart','Need Restart'),
+            ('blocked','Blocked')
+        ], string="Status"),
         'patch' : fields.binary("Patch"),
         'error': fields.text('Error', readonly="1"),
     }

=== removed file 'bin/service/gzip_xmlrpclib.py'
--- bin/service/gzip_xmlrpclib.py	2014-09-04 13:14:34 +0000
+++ bin/service/gzip_xmlrpclib.py	1970-01-01 00:00:00 +0000
@@ -1,45 +0,0 @@
-import zlib
-import xmlrpclib
-from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler
-import logging
-
-# xmlrpc server side
-
-class GzipXMLRPCRequestHandler(SimpleXMLRPCRequestHandler):
-
-    def do_POST(self):
-        if not(self.headers.has_key('accept-encoding') and self.headers['accept-encoding'] == 'gzip'):
-            return SimpleXMLRPCRequestHandler.do_POST(self)
-        else:
-            if not self.is_rpc_path_valid():
-                self.report_404()
-                return
-            try:
-                max_chunk_size = 10*1024*1024
-                size_remaining = int(self.headers["content-length"])
-                L = []
-                while size_remaining:
-                    chunk_size = min(size_remaining, max_chunk_size)
-                    L.append(self.rfile.read(chunk_size))
-                    size_remaining -= len(L[-1])
-                data = ''.join(L)
-                data = zlib.decompress(data) # is_gzip
-                response = self.server._marshaled_dispatch(
-                        data, getattr(self, '_dispatch', None)
-                    )
-            except Exception, e:
-                self.send_response(500)
-                self.end_headers()
-            else:
-                response = zlib.compress(response, zlib.Z_BEST_COMPRESSION) # is_gzip
-                self.send_response(200)
-                self.send_header("Content-type", "text/xml")
-                self.send_header("Content-length", str(len(response)))
-                self.send_header("Accept-Encoding", "gzip") # is_gzip
-                self.end_headers()
-                self.wfile.write(response)
-                self.wfile.flush()
-                self.connection.shutdown(1)
-
-# xmlrpc client side
-

=== modified file 'bin/service/http_server.py'
--- bin/service/http_server.py	2017-03-17 13:33:26 +0000
+++ bin/service/http_server.py	2017-05-22 10:09:36 +0000
@@ -46,8 +46,8 @@
 import pooler
 
 import SimpleXMLRPCServer
+import BaseHTTPServer
 from SimpleXMLRPCServer import SimpleXMLRPCDispatcher
-import gzip_xmlrpclib
 
 try:
     import fcntl
@@ -59,7 +59,7 @@
 except ImportError:
     class SSLError(Exception): pass
 
-class ThreadedHTTPServer(websrv_lib.ConnThreadingMixIn, SimpleXMLRPCDispatcher, websrv_lib.HTTPServer):
+class ThreadedHTTPServer(websrv_lib.ConnThreadingMixIn, SimpleXMLRPCDispatcher, BaseHTTPServer.HTTPServer):
     """ A threaded httpd server, with all the necessary functionality for us.
 
         It also inherits the xml-rpc dispatcher, so that some xml-rpc functions
@@ -76,7 +76,7 @@
         self.logRequests = logRequests
 
         SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
-        websrv_lib.HTTPServer.__init__(self, addr, requestHandler)
+        BaseHTTPServer.HTTPServer.__init__(self, addr, requestHandler)
 
         self.numThreads = 0
         self.proto = proto
@@ -231,11 +231,11 @@
 
 def init_servers():
     global httpd, httpsd
-    if tools.config.get('xmlrpc') or tools.config.get('gzipxmlrpc'):
+    if tools.config.get('xmlrpc'):
         httpd = HttpDaemon(tools.config.get('xmlrpc_interface', ''),
                            int(tools.config.get('xmlrpc_port', 8069)))
 
-    if tools.config.get('xmlrpcs') or tools.config.get('gzipxmlrpcs'):
+    if tools.config.get('xmlrpcs'):
         httpsd = HttpSDaemon(tools.config.get('xmlrpcs_interface', ''),
                              int(tools.config.get('xmlrpcs_port', 8071)))
 
@@ -272,6 +272,11 @@
 
     xmlrpc_uid_cache = {}
 
+    def __init__(self, conn, addr, svr):
+        SimpleXMLRPCServer.SimpleXMLRPCRequestHandler.__init__(self, conn, addr, svr)
+        # Always use gzip.
+        self.encode_threshold = 0
+
     def get_uid_list2log(self, db_name):
         '''
         return a list of user id for which the xmlrpc requests should be logged
@@ -319,29 +324,6 @@
         self.connection = websrv_lib.dummyconn()
         self.rpc_paths = map(lambda s: '/%s' % s, netsvc.ExportService._services.keys())
 
-
-class GzipXMLRPCRequestHandler(netsvc.OpenERPDispatcher,websrv_lib.FixSendError,HttpLogHandler, gzip_xmlrpclib.GzipXMLRPCRequestHandler):
-    rpc_paths = []
-    protocol_version = 'HTTP/1.1'
-    _logger = logging.getLogger('xmlrpc')
-
-    def _dispatch(self, method, params):
-        try:
-            service_name = self.path.split("/")[-1]
-            return self.dispatch(service_name, method, params)
-        except netsvc.OpenERPDispatcherException, e:
-            raise xmlrpclib.Fault(tools.exception_to_unicode(e.exception), e.traceback)
-
-    def handle(self):
-        pass
-
-    def finish(self):
-        pass
-
-    def setup(self):
-        self.connection = websrv_lib.dummyconn()
-        self.rpc_paths = map(lambda s: '/%s' % s, netsvc.ExportService._services.keys())
-
 def init_xmlrpc():
     if tools.config.get('xmlrpc', False):
         # Example of http file serving:
@@ -349,16 +331,9 @@
         reg_http_service(websrv_lib.HTTPDir('/xmlrpc/', XMLRPCRequestHandler))
         logging.getLogger("web-services").info("Registered XML-RPC over HTTP")
 
-    if tools.config.get('gzipxmlrpc', False):
-        # Example of http file serving:
-        # reg_http_service(HTTPDir('/test/',HTTPHandler))
-        reg_http_service(websrv_lib.HTTPDir('/xmlrpc/', GzipXMLRPCRequestHandler))
-        logging.getLogger("web-services").info("Registered gzipped XML-RPC over HTTP")
-
-    if (tools.config.get('xmlrpcs', False) or tools.config.get('gzipxmlrpcs', False) ) \
-            and not tools.config.get('xmlrpc', False):
+    if (tools.config.get('xmlrpcs', False), False) and not tools.config.get('xmlrpc', False):
         # only register at the secure server
-        reg_http_service(websrv_lib.HTTPDir('/xmlrpc/', GzipXMLRPCRequestHandler), True)
+        reg_http_service(websrv_lib.HTTPDir('/xmlrpc/', XMLRPCRequestHandler), True)
         logging.getLogger("web-services").info("Registered XML-RPC over HTTPS only")
 
 class StaticHTTPHandler(HttpLogHandler, websrv_lib.FixSendError, websrv_lib.HttpOptions, websrv_lib.HTTPHandler):

=== modified file 'bin/service/websrv_lib.py'
--- bin/service/websrv_lib.py	2011-01-18 23:50:33 +0000
+++ bin/service/websrv_lib.py	2017-05-22 10:09:36 +0000
@@ -32,7 +32,7 @@
 import base64
 import errno
 import SocketServer
-from BaseHTTPServer import *
+import BaseHTTPServer
 from SimpleHTTPServer import SimpleHTTPRequestHandler
 
 class AuthRequiredExc(Exception):
@@ -184,7 +184,7 @@
         self.end_headers()
         if hasattr(self, '_flush'):
             self._flush()
-        
+
         if self.command != 'HEAD' and code >= 200 and code not in (204, 304):
             self.wfile.write(content)
 
@@ -217,16 +217,16 @@
 
     def _prep_OPTIONS(self, opts):
         """Prepare the OPTIONS response, if needed
-        
+
         Sometimes, like in special DAV folders, the OPTIONS may contain
         extra keywords, perhaps also dependant on the request url. 
         @param the options already. MUST be copied before being altered
         @return the updated options.
-        
+
         """
         return opts
 
-class MultiHTTPHandler(FixSendError, HttpOptions, BaseHTTPRequestHandler):
+class MultiHTTPHandler(FixSendError, HttpOptions, BaseHTTPServer.BaseHTTPRequestHandler):
     """ this is a multiple handler, that will dispatch each request
         to a nested handler, iff it matches
 
@@ -311,7 +311,7 @@
             if hasattr(fore, '_flush'):
                 fore._flush()
             return
-        
+
         if fore.close_connection:
             # print "Closing connection because of handler"
             self.close_connection = fore.close_connection
@@ -364,7 +364,7 @@
                 self.close_connection = 0
             if version_number >= (2, 0):
                 self.send_error(505,
-                          "Invalid HTTP Version (%s)" % base_version_number)
+                                "Invalid HTTP Version (%s)" % base_version_number)
                 return False
         elif len(words) == 2:
             [command, path] = words
@@ -397,14 +397,14 @@
             self.log_message("Could not parse rawline.")
             return
         # self.parse_request(): # Do NOT parse here. the first line should be the only
-        
+
         if self.path == '*' and self.command == 'OPTIONS':
             # special handling of path='*', must not use any vdir at all.
             if not self.parse_request():
                 return
             self.do_OPTIONS()
             return
-            
+
         for vdir in self.server.vdirs:
             p = vdir.matches(self.path)
             if p == False:
@@ -426,7 +426,7 @@
             except IOError, e:
                 if e.errno == errno.EPIPE:
                     self.log_message("Could not complete request %s," \
-                            "client closed connection", self.rlpath.rstrip())
+                                     "client closed connection", self.rlpath.rstrip())
                 else:
                     raise
             return
@@ -459,10 +459,10 @@
         certfile, keyfile = self.getcert_fnames()
         try:
             self.connection = ssl.wrap_socket(self.request,
-                                server_side=True,
-                                certfile=certfile,
-                                keyfile=keyfile,
-                                ssl_version=ssl.PROTOCOL_SSLv23)
+                                              server_side=True,
+                                              certfile=certfile,
+                                              keyfile=keyfile,
+                                              ssl_version=ssl.PROTOCOL_TLSv1_2)
             self.rfile = self.connection.makefile('rb', self.rbufsize)
             self.wfile = self.connection.makefile('wb', self.wbufsize)
             self.log_message("Secure %s connection from %s",self.connection.cipher(),self.client_address)

=== modified file 'bin/tools/misc.py'
--- bin/tools/misc.py	2017-02-21 13:51:44 +0000
+++ bin/tools/misc.py	2017-05-22 10:09:36 +0000
@@ -46,10 +46,7 @@
 from itertools import islice, izip
 from lxml import etree
 from which import which
-if sys.version_info[:2] < (2, 4):
-    from threadinglocal import local
-else:
-    from threading import local
+from threading import local
 try:
     from html2text import html2text
 except ImportError:
@@ -1151,8 +1148,6 @@
 
 
 def exception_to_unicode(e):
-    if (sys.version_info[:2] < (2,6)) and hasattr(e, 'message'):
-        return ustr(e.message)
     if hasattr(e, 'args'):
         return "\n".join((ustr(a) for a in e.args))
     try:

=== modified file 'bin/updater.py'
--- bin/updater.py	2017-04-12 13:47:39 +0000
+++ bin/updater.py	2017-05-22 10:09:36 +0000
@@ -12,11 +12,7 @@
 from base64 import b64decode
 from StringIO import StringIO
 import logging
-
-if sys.version_info >= (2, 6, 6):
-    from zipfile import ZipFile
-else:
-    from zipfile266 import ZipFile
+from zipfile import ZipFile
 
 __all__ = ('isset_lock', 'server_version', 'base_version', 'do_prepare', 'base_module_upgrade', 'restart_server')
 

=== removed file 'bin/zipfile266.py'
--- bin/zipfile266.py	2012-11-22 13:34:36 +0000
+++ bin/zipfile266.py	1970-01-01 00:00:00 +0000
@@ -1,1409 +0,0 @@
-"""
-Read and write ZIP files.
-"""
-import struct, os, time, sys, shutil
-import binascii, cStringIO, stat
-
-try:
-    import zlib # We may need its compression method
-    crc32 = zlib.crc32
-except ImportError:
-    zlib = None
-    crc32 = binascii.crc32
-
-__all__ = ["BadZipfile", "error", "ZIP_STORED", "ZIP_DEFLATED", "is_zipfile",
-           "ZipInfo", "ZipFile", "PyZipFile", "LargeZipFile" ]
-
-class BadZipfile(Exception):
-    pass
-
-
-class LargeZipFile(Exception):
-    """
-    Raised when writing a zipfile, the zipfile requires ZIP64 extensions
-    and those extensions are disabled.
-    """
-
-error = BadZipfile      # The exception raised by this module
-
-ZIP64_LIMIT = (1 << 31) - 1
-ZIP_FILECOUNT_LIMIT = 1 << 16
-ZIP_MAX_COMMENT = (1 << 16) - 1
-
-# constants for Zip file compression methods
-ZIP_STORED = 0
-ZIP_DEFLATED = 8
-# Other ZIP compression methods not supported
-
-# Below are some formats and associated data for reading/writing headers using
-# the struct module.  The names and structures of headers/records are those used
-# in the PKWARE description of the ZIP file format:
-#     http://www.pkware.com/documents/casestudies/APPNOTE.TXT
-# (URL valid as of January 2008)
-
-# The "end of central directory" structure, magic number, size, and indices
-# (section V.I in the format document)
-structEndArchive = "<4s4H2LH"
-stringEndArchive = "PK\005\006"
-sizeEndCentDir = struct.calcsize(structEndArchive)
-
-_ECD_SIGNATURE = 0
-_ECD_DISK_NUMBER = 1
-_ECD_DISK_START = 2
-_ECD_ENTRIES_THIS_DISK = 3
-_ECD_ENTRIES_TOTAL = 4
-_ECD_SIZE = 5
-_ECD_OFFSET = 6
-_ECD_COMMENT_SIZE = 7
-# These last two indices are not part of the structure as defined in the
-# spec, but they are used internally by this module as a convenience
-_ECD_COMMENT = 8
-_ECD_LOCATION = 9
-
-# The "central directory" structure, magic number, size, and indices
-# of entries in the structure (section V.F in the format document)
-structCentralDir = "<4s4B4HL2L5H2L"
-stringCentralDir = "PK\001\002"
-sizeCentralDir = struct.calcsize(structCentralDir)
-
-# indexes of entries in the central directory structure
-_CD_SIGNATURE = 0
-_CD_CREATE_VERSION = 1
-_CD_CREATE_SYSTEM = 2
-_CD_EXTRACT_VERSION = 3
-_CD_EXTRACT_SYSTEM = 4
-_CD_FLAG_BITS = 5
-_CD_COMPRESS_TYPE = 6
-_CD_TIME = 7
-_CD_DATE = 8
-_CD_CRC = 9
-_CD_COMPRESSED_SIZE = 10
-_CD_UNCOMPRESSED_SIZE = 11
-_CD_FILENAME_LENGTH = 12
-_CD_EXTRA_FIELD_LENGTH = 13
-_CD_COMMENT_LENGTH = 14
-_CD_DISK_NUMBER_START = 15
-_CD_INTERNAL_FILE_ATTRIBUTES = 16
-_CD_EXTERNAL_FILE_ATTRIBUTES = 17
-_CD_LOCAL_HEADER_OFFSET = 18
-
-# The "local file header" structure, magic number, size, and indices
-# (section V.A in the format document)
-structFileHeader = "<4s2B4HL2L2H"
-stringFileHeader = "PK\003\004"
-sizeFileHeader = struct.calcsize(structFileHeader)
-
-_FH_SIGNATURE = 0
-_FH_EXTRACT_VERSION = 1
-_FH_EXTRACT_SYSTEM = 2
-_FH_GENERAL_PURPOSE_FLAG_BITS = 3
-_FH_COMPRESSION_METHOD = 4
-_FH_LAST_MOD_TIME = 5
-_FH_LAST_MOD_DATE = 6
-_FH_CRC = 7
-_FH_COMPRESSED_SIZE = 8
-_FH_UNCOMPRESSED_SIZE = 9
-_FH_FILENAME_LENGTH = 10
-_FH_EXTRA_FIELD_LENGTH = 11
-
-# The "Zip64 end of central directory locator" structure, magic number, and size
-structEndArchive64Locator = "<4sLQL"
-stringEndArchive64Locator = "PK\x06\x07"
-sizeEndCentDir64Locator = struct.calcsize(structEndArchive64Locator)
-
-# The "Zip64 end of central directory" record, magic number, size, and indices
-# (section V.G in the format document)
-structEndArchive64 = "<4sQ2H2L4Q"
-stringEndArchive64 = "PK\x06\x06"
-sizeEndCentDir64 = struct.calcsize(structEndArchive64)
-
-_CD64_SIGNATURE = 0
-_CD64_DIRECTORY_RECSIZE = 1
-_CD64_CREATE_VERSION = 2
-_CD64_EXTRACT_VERSION = 3
-_CD64_DISK_NUMBER = 4
-_CD64_DISK_NUMBER_START = 5
-_CD64_NUMBER_ENTRIES_THIS_DISK = 6
-_CD64_NUMBER_ENTRIES_TOTAL = 7
-_CD64_DIRECTORY_SIZE = 8
-_CD64_OFFSET_START_CENTDIR = 9
-
-def is_zipfile(filename):
-    """Quickly see if file is a ZIP file by checking the magic number."""
-    try:
-        fpin = open(filename, "rb")
-        endrec = _EndRecData(fpin)
-        fpin.close()
-        if endrec:
-            return True                 # file has correct magic number
-    except IOError:
-        pass
-    return False
-
-def _EndRecData64(fpin, offset, endrec):
-    """
-    Read the ZIP64 end-of-archive records and use that to update endrec
-    """
-    fpin.seek(offset - sizeEndCentDir64Locator, 2)
-    data = fpin.read(sizeEndCentDir64Locator)
-    sig, diskno, reloff, disks = struct.unpack(structEndArchive64Locator, data)
-    if sig != stringEndArchive64Locator:
-        return endrec
-
-    if diskno != 0 or disks != 1:
-        raise BadZipfile("zipfiles that span multiple disks are not supported")
-
-    # Assume no 'zip64 extensible data'
-    fpin.seek(offset - sizeEndCentDir64Locator - sizeEndCentDir64, 2)
-    data = fpin.read(sizeEndCentDir64)
-    sig, sz, create_version, read_version, disk_num, disk_dir, \
-            dircount, dircount2, dirsize, diroffset = \
-            struct.unpack(structEndArchive64, data)
-    if sig != stringEndArchive64:
-        return endrec
-
-    # Update the original endrec using data from the ZIP64 record
-    endrec[_ECD_SIGNATURE] = sig
-    endrec[_ECD_DISK_NUMBER] = disk_num
-    endrec[_ECD_DISK_START] = disk_dir
-    endrec[_ECD_ENTRIES_THIS_DISK] = dircount
-    endrec[_ECD_ENTRIES_TOTAL] = dircount2
-    endrec[_ECD_SIZE] = dirsize
-    endrec[_ECD_OFFSET] = diroffset
-    return endrec
-
-
-def _EndRecData(fpin):
-    """Return data from the "End of Central Directory" record, or None.
-
-    The data is a list of the nine items in the ZIP "End of central dir"
-    record followed by a tenth item, the file seek offset of this record."""
-
-    # Determine file size
-    fpin.seek(0, 2)
-    filesize = fpin.tell()
-
-    # Check to see if this is ZIP file with no archive comment (the
-    # "end of central directory" structure should be the last item in the
-    # file if this is the case).
-    try:
-        fpin.seek(-sizeEndCentDir, 2)
-    except IOError:
-        return None
-    data = fpin.read()
-    if data[0:4] == stringEndArchive and data[-2:] == "\000\000":
-        # the signature is correct and there's no comment, unpack structure
-        endrec = struct.unpack(structEndArchive, data)
-        endrec=list(endrec)
-
-        # Append a blank comment and record start offset
-        endrec.append("")
-        endrec.append(filesize - sizeEndCentDir)
-
-        # Try to read the "Zip64 end of central directory" structure
-        return _EndRecData64(fpin, -sizeEndCentDir, endrec)
-
-    # Either this is not a ZIP file, or it is a ZIP file with an archive
-    # comment.  Search the end of the file for the "end of central directory"
-    # record signature. The comment is the last item in the ZIP file and may be
-    # up to 64K long.  It is assumed that the "end of central directory" magic
-    # number does not appear in the comment.
-    maxCommentStart = max(filesize - (1 << 16) - sizeEndCentDir, 0)
-    fpin.seek(maxCommentStart, 0)
-    data = fpin.read()
-    start = data.rfind(stringEndArchive)
-    if start >= 0:
-        # found the magic number; attempt to unpack and interpret
-        recData = data[start:start+sizeEndCentDir]
-        endrec = list(struct.unpack(structEndArchive, recData))
-        comment = data[start+sizeEndCentDir:]
-        # check that comment length is correct
-        if endrec[_ECD_COMMENT_SIZE] == len(comment):
-            # Append the archive comment and start offset
-            endrec.append(comment)
-            endrec.append(maxCommentStart + start)
-
-            # Try to read the "Zip64 end of central directory" structure
-            return _EndRecData64(fpin, maxCommentStart + start - filesize,
-                                 endrec)
-
-    # Unable to find a valid end of central directory structure
-    return
-
-
-class ZipInfo (object):
-    """Class with attributes describing each file in the ZIP archive."""
-
-    __slots__ = (
-            'orig_filename',
-            'filename',
-            'date_time',
-            'compress_type',
-            'comment',
-            'extra',
-            'create_system',
-            'create_version',
-            'extract_version',
-            'reserved',
-            'flag_bits',
-            'volume',
-            'internal_attr',
-            'external_attr',
-            'header_offset',
-            'CRC',
-            'compress_size',
-            'file_size',
-            '_raw_time',
-        )
-
-    def __init__(self, filename="NoName", date_time=(1980,1,1,0,0,0)):
-        self.orig_filename = filename   # Original file name in archive
-
-        # Terminate the file name at the first null byte.  Null bytes in file
-        # names are used as tricks by viruses in archives.
-        null_byte = filename.find(chr(0))
-        if null_byte >= 0:
-            filename = filename[0:null_byte]
-        # This is used to ensure paths in generated ZIP files always use
-        # forward slashes as the directory separator, as required by the
-        # ZIP format specification.
-        if os.sep != "/" and os.sep in filename:
-            filename = filename.replace(os.sep, "/")
-
-        self.filename = filename        # Normalized file name
-        self.date_time = date_time      # year, month, day, hour, min, sec
-        # Standard values:
-        self.compress_type = ZIP_STORED # Type of compression for the file
-        self.comment = ""               # Comment for each file
-        self.extra = ""                 # ZIP extra data
-        if sys.platform == 'win32':
-            self.create_system = 0          # System which created ZIP archive
-        else:
-            # Assume everything else is unix-y
-            self.create_system = 3          # System which created ZIP archive
-        self.create_version = 20        # Version which created ZIP archive
-        self.extract_version = 20       # Version needed to extract archive
-        self.reserved = 0               # Must be zero
-        self.flag_bits = 0              # ZIP flag bits
-        self.volume = 0                 # Volume number of file header
-        self.internal_attr = 0          # Internal attributes
-        self.external_attr = 0          # External file attributes
-        # Other attributes are set by class ZipFile:
-        # header_offset         Byte offset to the file header
-        # CRC                   CRC-32 of the uncompressed file
-        # compress_size         Size of the compressed file
-        # file_size             Size of the uncompressed file
-
-    def FileHeader(self):
-        """Return the per-file header as a string."""
-        dt = self.date_time
-        dosdate = (dt[0] - 1980) << 9 | dt[1] << 5 | dt[2]
-        dostime = dt[3] << 11 | dt[4] << 5 | (dt[5] // 2)
-        if self.flag_bits & 0x08:
-            # Set these to zero because we write them after the file data
-            CRC = compress_size = file_size = 0
-        else:
-            CRC = self.CRC
-            compress_size = self.compress_size
-            file_size = self.file_size
-
-        extra = self.extra
-
-        if file_size > ZIP64_LIMIT or compress_size > ZIP64_LIMIT:
-            # File is larger than what fits into a 4 byte integer,
-            # fall back to the ZIP64 extension
-            fmt = '<HHQQ'
-            extra = extra + struct.pack(fmt,
-                    1, struct.calcsize(fmt)-4, file_size, compress_size)
-            file_size = 0xffffffff
-            compress_size = 0xffffffff
-            self.extract_version = max(45, self.extract_version)
-            self.create_version = max(45, self.extract_version)
-
-        filename, flag_bits = self._encodeFilenameFlags()
-        header = struct.pack(structFileHeader, stringFileHeader,
-                 self.extract_version, self.reserved, flag_bits,
-                 self.compress_type, dostime, dosdate, CRC,
-                 compress_size, file_size,
-                 len(filename), len(extra))
-        return header + filename + extra
-
-    def _encodeFilenameFlags(self):
-        if isinstance(self.filename, unicode):
-            try:
-                return self.filename.encode('ascii'), self.flag_bits
-            except UnicodeEncodeError:
-                return self.filename.encode('utf-8'), self.flag_bits | 0x800
-        else:
-            return self.filename, self.flag_bits
-
-    def _decodeFilename(self):
-        if self.flag_bits & 0x800:
-            return self.filename.decode('utf-8')
-        else:
-            return self.filename
-
-    def _decodeExtra(self):
-        # Try to decode the extra field.
-        extra = self.extra
-        unpack = struct.unpack
-        while extra:
-            tp, ln = unpack('<HH', extra[:4])
-            if tp == 1:
-                if ln >= 24:
-                    counts = unpack('<QQQ', extra[4:28])
-                elif ln == 16:
-                    counts = unpack('<QQ', extra[4:20])
-                elif ln == 8:
-                    counts = unpack('<Q', extra[4:12])
-                elif ln == 0:
-                    counts = ()
-                else:
-                    raise RuntimeError, "Corrupt extra field %s"%(ln,)
-
-                idx = 0
-
-                # ZIP64 extension (large files and/or large archives)
-                if self.file_size in (0xffffffffffffffffL, 0xffffffffL):
-                    self.file_size = counts[idx]
-                    idx += 1
-
-                if self.compress_size == 0xFFFFFFFFL:
-                    self.compress_size = counts[idx]
-                    idx += 1
-
-                if self.header_offset == 0xffffffffL:
-                    old = self.header_offset
-                    self.header_offset = counts[idx]
-                    idx+=1
-
-            extra = extra[ln+4:]
-
-
-class _ZipDecrypter:
-    """Class to handle decryption of files stored within a ZIP archive.
-
-    ZIP supports a password-based form of encryption. Even though known
-    plaintext attacks have been found against it, it is still useful
-    to be able to get data out of such a file.
-
-    Usage:
-        zd = _ZipDecrypter(mypwd)
-        plain_char = zd(cypher_char)
-        plain_text = map(zd, cypher_text)
-    """
-
-    def _GenerateCRCTable():
-        """Generate a CRC-32 table.
-
-        ZIP encryption uses the CRC32 one-byte primitive for scrambling some
-        internal keys. We noticed that a direct implementation is faster than
-        relying on binascii.crc32().
-        """
-        poly = 0xedb88320
-        table = [0] * 256
-        for i in range(256):
-            crc = i
-            for j in range(8):
-                if crc & 1:
-                    crc = ((crc >> 1) & 0x7FFFFFFF) ^ poly
-                else:
-                    crc = ((crc >> 1) & 0x7FFFFFFF)
-            table[i] = crc
-        return table
-    crctable = _GenerateCRCTable()
-
-    def _crc32(self, ch, crc):
-        """Compute the CRC32 primitive on one byte."""
-        return ((crc >> 8) & 0xffffff) ^ self.crctable[(crc ^ ord(ch)) & 0xff]
-
-    def __init__(self, pwd):
-        self.key0 = 305419896
-        self.key1 = 591751049
-        self.key2 = 878082192
-        for p in pwd:
-            self._UpdateKeys(p)
-
-    def _UpdateKeys(self, c):
-        self.key0 = self._crc32(c, self.key0)
-        self.key1 = (self.key1 + (self.key0 & 255)) & 4294967295
-        self.key1 = (self.key1 * 134775813 + 1) & 4294967295
-        self.key2 = self._crc32(chr((self.key1 >> 24) & 255), self.key2)
-
-    def __call__(self, c):
-        """Decrypt a single character."""
-        c = ord(c)
-        k = self.key2 | 2
-        c = c ^ (((k * (k^1)) >> 8) & 255)
-        c = chr(c)
-        self._UpdateKeys(c)
-        return c
-
-class ZipExtFile:
-    """File-like object for reading an archive member.
-       Is returned by ZipFile.open().
-    """
-
-    def __init__(self, fileobj, zipinfo, decrypt=None):
-        self.fileobj = fileobj
-        self.decrypter = decrypt
-        self.bytes_read = 0L
-        self.rawbuffer = ''
-        self.readbuffer = ''
-        self.linebuffer = ''
-        self.eof = False
-        self.univ_newlines = False
-        self.nlSeps = ("\n", )
-        self.lastdiscard = ''
-
-        self.compress_type = zipinfo.compress_type
-        self.compress_size = zipinfo.compress_size
-
-        self.closed  = False
-        self.mode    = "r"
-        self.name = zipinfo.filename
-
-        # read from compressed files in 64k blocks
-        self.compreadsize = 64*1024
-        if self.compress_type == ZIP_DEFLATED:
-            self.dc = zlib.decompressobj(-15)
-
-    def set_univ_newlines(self, univ_newlines):
-        self.univ_newlines = univ_newlines
-
-        # pick line separator char(s) based on universal newlines flag
-        self.nlSeps = ("\n", )
-        if self.univ_newlines:
-            self.nlSeps = ("\r\n", "\r", "\n")
-
-    def __iter__(self):
-        return self
-
-    def next(self):
-        nextline = self.readline()
-        if not nextline:
-            raise StopIteration()
-
-        return nextline
-
-    def close(self):
-        self.closed = True
-
-    def _checkfornewline(self):
-        nl, nllen = -1, -1
-        if self.linebuffer:
-            # ugly check for cases where half of an \r\n pair was
-            # read on the last pass, and the \r was discarded.  In this
-            # case we just throw away the \n at the start of the buffer.
-            if (self.lastdiscard, self.linebuffer[0]) == ('\r','\n'):
-                self.linebuffer = self.linebuffer[1:]
-
-            for sep in self.nlSeps:
-                nl = self.linebuffer.find(sep)
-                if nl >= 0:
-                    nllen = len(sep)
-                    return nl, nllen
-
-        return nl, nllen
-
-    def readline(self, size = -1):
-        """Read a line with approx. size. If size is negative,
-           read a whole line.
-        """
-        if size < 0:
-            size = sys.maxint
-        elif size == 0:
-            return ''
-
-        # check for a newline already in buffer
-        nl, nllen = self._checkfornewline()
-
-        if nl >= 0:
-            # the next line was already in the buffer
-            nl = min(nl, size)
-        else:
-            # no line break in buffer - try to read more
-            size -= len(self.linebuffer)
-            while nl < 0 and size > 0:
-                buf = self.read(min(size, 100))
-                if not buf:
-                    break
-                self.linebuffer += buf
-                size -= len(buf)
-
-                # check for a newline in buffer
-                nl, nllen = self._checkfornewline()
-
-            # we either ran out of bytes in the file, or
-            # met the specified size limit without finding a newline,
-            # so return current buffer
-            if nl < 0:
-                s = self.linebuffer
-                self.linebuffer = ''
-                return s
-
-        buf = self.linebuffer[:nl]
-        self.lastdiscard = self.linebuffer[nl:nl + nllen]
-        self.linebuffer = self.linebuffer[nl + nllen:]
-
-        # line is always returned with \n as newline char (except possibly
-        # for a final incomplete line in the file, which is handled above).
-        return buf + "\n"
-
-    def readlines(self, sizehint = -1):
-        """Return a list with all (following) lines. The sizehint parameter
-        is ignored in this implementation.
-        """
-        result = []
-        while True:
-            line = self.readline()
-            if not line: break
-            result.append(line)
-        return result
-
-    def read(self, size = None):
-        # act like file() obj and return empty string if size is 0
-        if size == 0:
-            return ''
-
-        # determine read size
-        bytesToRead = self.compress_size - self.bytes_read
-
-        # adjust read size for encrypted files since the first 12 bytes
-        # are for the encryption/password information
-        if self.decrypter is not None:
-            bytesToRead -= 12
-
-        if size is not None and size >= 0:
-            if self.compress_type == ZIP_STORED:
-                lr = len(self.readbuffer)
-                bytesToRead = min(bytesToRead, size - lr)
-            elif self.compress_type == ZIP_DEFLATED:
-                if len(self.readbuffer) > size:
-                    # the user has requested fewer bytes than we've already
-                    # pulled through the decompressor; don't read any more
-                    bytesToRead = 0
-                else:
-                    # user will use up the buffer, so read some more
-                    lr = len(self.rawbuffer)
-                    bytesToRead = min(bytesToRead, self.compreadsize - lr)
-
-        # avoid reading past end of file contents
-        if bytesToRead + self.bytes_read > self.compress_size:
-            bytesToRead = self.compress_size - self.bytes_read
-
-        # try to read from file (if necessary)
-        if bytesToRead > 0:
-            bytes = self.fileobj.read(bytesToRead)
-            self.bytes_read += len(bytes)
-            self.rawbuffer += bytes
-
-            # handle contents of raw buffer
-            if self.rawbuffer:
-                newdata = self.rawbuffer
-                self.rawbuffer = ''
-
-                # decrypt new data if we were given an object to handle that
-                if newdata and self.decrypter is not None:
-                    newdata = ''.join(map(self.decrypter, newdata))
-
-                # decompress newly read data if necessary
-                if newdata and self.compress_type == ZIP_DEFLATED:
-                    newdata = self.dc.decompress(newdata)
-                    self.rawbuffer = self.dc.unconsumed_tail
-                    if self.eof and len(self.rawbuffer) == 0:
-                        # we're out of raw bytes (both from the file and
-                        # the local buffer); flush just to make sure the
-                        # decompressor is done
-                        newdata += self.dc.flush()
-                        # prevent decompressor from being used again
-                        self.dc = None
-
-                self.readbuffer += newdata
-
-
-        # return what the user asked for
-        if size is None or len(self.readbuffer) <= size:
-            bytes = self.readbuffer
-            self.readbuffer = ''
-        else:
-            bytes = self.readbuffer[:size]
-            self.readbuffer = self.readbuffer[size:]
-
-        return bytes
-
-
-class ZipFile:
-    """ Class with methods to open, read, write, close, list zip files.
-
-    z = ZipFile(file, mode="r", compression=ZIP_STORED, allowZip64=False)
-
-    file: Either the path to the file, or a file-like object.
-          If it is a path, the file will be opened and closed by ZipFile.
-    mode: The mode can be either read "r", write "w" or append "a".
-    compression: ZIP_STORED (no compression) or ZIP_DEFLATED (requires zlib).
-    allowZip64: if True ZipFile will create files with ZIP64 extensions when
-                needed, otherwise it will raise an exception when this would
-                be necessary.
-
-    """
-
-    fp = None                   # Set here since __del__ checks it
-
-    def __init__(self, file, mode="r", compression=ZIP_STORED, allowZip64=False):
-        """Open the ZIP file with mode read "r", write "w" or append "a"."""
-        if mode not in ("r", "w", "a"):
-            raise RuntimeError('ZipFile() requires mode "r", "w", or "a"')
-
-        if compression == ZIP_STORED:
-            pass
-        elif compression == ZIP_DEFLATED:
-            if not zlib:
-                raise RuntimeError,\
-                      "Compression requires the (missing) zlib module"
-        else:
-            raise RuntimeError, "That compression method is not supported"
-
-        self._allowZip64 = allowZip64
-        self._didModify = False
-        self.debug = 0  # Level of printing: 0 through 3
-        self.NameToInfo = {}    # Find file info given name
-        self.filelist = []      # List of ZipInfo instances for archive
-        self.compression = compression  # Method of compression
-        self.mode = key = mode.replace('b', '')[0]
-        self.pwd = None
-        self.comment = ''
-
-        # Check if we were passed a file-like object
-        if isinstance(file, basestring):
-            self._filePassed = 0
-            self.filename = file
-            modeDict = {'r' : 'rb', 'w': 'wb', 'a' : 'r+b'}
-            try:
-                self.fp = open(file, modeDict[mode])
-            except IOError:
-                if mode == 'a':
-                    mode = key = 'w'
-                    self.fp = open(file, modeDict[mode])
-                else:
-                    raise
-        else:
-            self._filePassed = 1
-            self.fp = file
-            self.filename = getattr(file, 'name', None)
-
-        if key == 'r':
-            self._GetContents()
-        elif key == 'w':
-            pass
-        elif key == 'a':
-            try:                        # See if file is a zip file
-                self._RealGetContents()
-                # seek to start of directory and overwrite
-                self.fp.seek(self.start_dir, 0)
-            except BadZipfile:          # file is not a zip file, just append
-                self.fp.seek(0, 2)
-        else:
-            if not self._filePassed:
-                self.fp.close()
-                self.fp = None
-            raise RuntimeError, 'Mode must be "r", "w" or "a"'
-
-    def _GetContents(self):
-        """Read the directory, making sure we close the file if the format
-        is bad."""
-        try:
-            self._RealGetContents()
-        except BadZipfile:
-            if not self._filePassed:
-                self.fp.close()
-                self.fp = None
-            raise
-
-    def _RealGetContents(self):
-        """Read in the table of contents for the ZIP file."""
-        fp = self.fp
-        endrec = _EndRecData(fp)
-        if not endrec:
-            raise BadZipfile, "File is not a zip file"
-        if self.debug > 1:
-            print endrec
-        size_cd = endrec[_ECD_SIZE]             # bytes in central directory
-        offset_cd = endrec[_ECD_OFFSET]         # offset of central directory
-        self.comment = endrec[_ECD_COMMENT]     # archive comment
-
-        # "concat" is zero, unless zip was concatenated to another file
-        concat = endrec[_ECD_LOCATION] - size_cd - offset_cd
-        if endrec[_ECD_SIGNATURE] == stringEndArchive64:
-            # If Zip64 extension structures are present, account for them
-            concat -= (sizeEndCentDir64 + sizeEndCentDir64Locator)
-
-        if self.debug > 2:
-            inferred = concat + offset_cd
-            print "given, inferred, offset", offset_cd, inferred, concat
-        # self.start_dir:  Position of start of central directory
-        self.start_dir = offset_cd + concat
-        fp.seek(self.start_dir, 0)
-        data = fp.read(size_cd)
-        fp = cStringIO.StringIO(data)
-        total = 0
-        while total < size_cd:
-            centdir = fp.read(sizeCentralDir)
-            if centdir[0:4] != stringCentralDir:
-                raise BadZipfile, "Bad magic number for central directory"
-            centdir = struct.unpack(structCentralDir, centdir)
-            if self.debug > 2:
-                print centdir
-            filename = fp.read(centdir[_CD_FILENAME_LENGTH])
-            # Create ZipInfo instance to store file information
-            x = ZipInfo(filename)
-            x.extra = fp.read(centdir[_CD_EXTRA_FIELD_LENGTH])
-            x.comment = fp.read(centdir[_CD_COMMENT_LENGTH])
-            x.header_offset = centdir[_CD_LOCAL_HEADER_OFFSET]
-            (x.create_version, x.create_system, x.extract_version, x.reserved,
-                x.flag_bits, x.compress_type, t, d,
-                x.CRC, x.compress_size, x.file_size) = centdir[1:12]
-            x.volume, x.internal_attr, x.external_attr = centdir[15:18]
-            # Convert date/time code to (year, month, day, hour, min, sec)
-            x._raw_time = t
-            x.date_time = ( (d>>9)+1980, (d>>5)&0xF, d&0x1F,
-                                     t>>11, (t>>5)&0x3F, (t&0x1F) * 2 )
-
-            x._decodeExtra()
-            x.header_offset = x.header_offset + concat
-            x.filename = x._decodeFilename()
-            self.filelist.append(x)
-            self.NameToInfo[x.filename] = x
-
-            # update total bytes read from central directory
-            total = (total + sizeCentralDir + centdir[_CD_FILENAME_LENGTH]
-                     + centdir[_CD_EXTRA_FIELD_LENGTH]
-                     + centdir[_CD_COMMENT_LENGTH])
-
-            if self.debug > 2:
-                print "total", total
-
-
-    def namelist(self):
-        """Return a list of file names in the archive."""
-        l = []
-        for data in self.filelist:
-            l.append(data.filename)
-        return l
-
-    def infolist(self):
-        """Return a list of class ZipInfo instances for files in the
-        archive."""
-        return self.filelist
-
-    def printdir(self):
-        """Print a table of contents for the zip file."""
-        print "%-46s %19s %12s" % ("File Name", "Modified    ", "Size")
-        for zinfo in self.filelist:
-            date = "%d-%02d-%02d %02d:%02d:%02d" % zinfo.date_time[:6]
-            print "%-46s %s %12d" % (zinfo.filename, date, zinfo.file_size)
-
-    def testzip(self):
-        """Read all the files and check the CRC."""
-        chunk_size = 2 ** 20
-        for zinfo in self.filelist:
-            try:
-                # Read by chunks, to avoid an OverflowError or a
-                # MemoryError with very large embedded files.
-                f = self.open(zinfo.filename, "r")
-                while f.read(chunk_size):     # Check CRC-32
-                    pass
-            except BadZipfile:
-                return zinfo.filename
-
-    def getinfo(self, name):
-        """Return the instance of ZipInfo given 'name'."""
-        info = self.NameToInfo.get(name)
-        if info is None:
-            raise KeyError(
-                'There is no item named %r in the archive' % name)
-
-        return info
-
-    def setpassword(self, pwd):
-        """Set default password for encrypted files."""
-        self.pwd = pwd
-
-    def read(self, name, pwd=None):
-        """Return file bytes (as a string) for name."""
-        return self.open(name, "r", pwd).read()
-
-    def open(self, name, mode="r", pwd=None):
-        """Return file-like object for 'name'."""
-        if mode not in ("r", "U", "rU"):
-            raise RuntimeError, 'open() requires mode "r", "U", or "rU"'
-        if not self.fp:
-            raise RuntimeError, \
-                  "Attempt to read ZIP archive that was already closed"
-
-        # Only open a new file for instances where we were not
-        # given a file object in the constructor
-        if self._filePassed:
-            zef_file = self.fp
-        else:
-            zef_file = open(self.filename, 'rb')
-
-        # Make sure we have an info object
-        if isinstance(name, ZipInfo):
-            # 'name' is already an info object
-            zinfo = name
-        else:
-            # Get info object for name
-            zinfo = self.getinfo(name)
-
-        zef_file.seek(zinfo.header_offset, 0)
-
-        # Skip the file header:
-        fheader = zef_file.read(sizeFileHeader)
-        if fheader[0:4] != stringFileHeader:
-            raise BadZipfile, "Bad magic number for file header"
-
-        fheader = struct.unpack(structFileHeader, fheader)
-        fname = zef_file.read(fheader[_FH_FILENAME_LENGTH])
-        if fheader[_FH_EXTRA_FIELD_LENGTH]:
-            zef_file.read(fheader[_FH_EXTRA_FIELD_LENGTH])
-
-        if fname != zinfo.orig_filename:
-            raise BadZipfile, \
-                      'File name in directory "%s" and header "%s" differ.' % (
-                          zinfo.orig_filename, fname)
-
-        # check for encrypted flag & handle password
-        is_encrypted = zinfo.flag_bits & 0x1
-        zd = None
-        if is_encrypted:
-            if not pwd:
-                pwd = self.pwd
-            if not pwd:
-                raise RuntimeError, "File %s is encrypted, " \
-                      "password required for extraction" % name
-
-            zd = _ZipDecrypter(pwd)
-            # The first 12 bytes in the cypher stream is an encryption header
-            #  used to strengthen the algorithm. The first 11 bytes are
-            #  completely random, while the 12th contains the MSB of the CRC,
-            #  or the MSB of the file time depending on the header type
-            #  and is used to check the correctness of the password.
-            bytes = zef_file.read(12)
-            h = map(zd, bytes[0:12])
-            if zinfo.flag_bits & 0x8:
-                # compare against the file type from extended local headers
-                check_byte = (zinfo._raw_time >> 8) & 0xff
-            else:
-                # compare against the CRC otherwise
-                check_byte = (zinfo.CRC >> 24) & 0xff
-            if ord(h[11]) != check_byte:
-                raise RuntimeError("Bad password for file", name)
-
-        # build and return a ZipExtFile
-        if zd is None:
-            zef = ZipExtFile(zef_file, zinfo)
-        else:
-            zef = ZipExtFile(zef_file, zinfo, zd)
-
-        # set universal newlines on ZipExtFile if necessary
-        if "U" in mode:
-            zef.set_univ_newlines(True)
-        return zef
-
-    def extract(self, member, path=None, pwd=None):
-        """Extract a member from the archive to the current working directory,
-           using its full name. Its file information is extracted as accurately
-           as possible. `member' may be a filename or a ZipInfo object. You can
-           specify a different directory using `path'.
-        """
-        if not isinstance(member, ZipInfo):
-            member = self.getinfo(member)
-
-        if path is None:
-            path = os.getcwd()
-
-        return self._extract_member(member, path, pwd)
-
-    def extractall(self, path=None, members=None, pwd=None):
-        """Extract all members from the archive to the current working
-           directory. `path' specifies a different directory to extract to.
-           `members' is optional and must be a subset of the list returned
-           by namelist().
-        """
-        if members is None:
-            members = self.namelist()
-
-        for zipinfo in members:
-            self.extract(zipinfo, path, pwd)
-
-    def _extract_member(self, member, targetpath, pwd):
-        """Extract the ZipInfo object 'member' to a physical
-           file on the path targetpath.
-        """
-        # build the destination pathname, replacing
-        # forward slashes to platform specific separators.
-        # Strip trailing path separator, unless it represents the root.
-        if (targetpath[-1:] in (os.path.sep, os.path.altsep)
-            and len(os.path.splitdrive(targetpath)[1]) > 1):
-            targetpath = targetpath[:-1]
-
-        # don't include leading "/" from file name if present
-        if member.filename[0] == '/':
-            targetpath = os.path.join(targetpath, member.filename[1:])
-        else:
-            targetpath = os.path.join(targetpath, member.filename)
-
-        targetpath = os.path.normpath(targetpath)
-
-        # Create all upper directories if necessary.
-        upperdirs = os.path.dirname(targetpath)
-        if upperdirs and not os.path.exists(upperdirs):
-            os.makedirs(upperdirs)
-
-        if member.filename[-1] == '/':
-            if not os.path.isdir(targetpath):
-                os.mkdir(targetpath)
-            return targetpath
-
-        source = self.open(member, pwd=pwd)
-        target = file(targetpath, "wb")
-        shutil.copyfileobj(source, target)
-        source.close()
-        target.close()
-
-        return targetpath
-
-    def _writecheck(self, zinfo):
-        """Check for errors before writing a file to the archive."""
-        if zinfo.filename in self.NameToInfo:
-            if self.debug:      # Warning for duplicate names
-                print "Duplicate name:", zinfo.filename
-        if self.mode not in ("w", "a"):
-            raise RuntimeError, 'write() requires mode "w" or "a"'
-        if not self.fp:
-            raise RuntimeError, \
-                  "Attempt to write ZIP archive that was already closed"
-        if zinfo.compress_type == ZIP_DEFLATED and not zlib:
-            raise RuntimeError, \
-                  "Compression requires the (missing) zlib module"
-        if zinfo.compress_type not in (ZIP_STORED, ZIP_DEFLATED):
-            raise RuntimeError, \
-                  "That compression method is not supported"
-        if zinfo.file_size > ZIP64_LIMIT:
-            if not self._allowZip64:
-                raise LargeZipFile("Filesize would require ZIP64 extensions")
-        if zinfo.header_offset > ZIP64_LIMIT:
-            if not self._allowZip64:
-                raise LargeZipFile("Zipfile size would require ZIP64 extensions")
-
-    def write(self, filename, arcname=None, compress_type=None):
-        """Put the bytes from filename into the archive under the name
-        arcname."""
-        if not self.fp:
-            raise RuntimeError(
-                  "Attempt to write to ZIP archive that was already closed")
-
-        st = os.stat(filename)
-        isdir = stat.S_ISDIR(st.st_mode)
-        mtime = time.localtime(st.st_mtime)
-        date_time = mtime[0:6]
-        # Create ZipInfo instance to store file information
-        if arcname is None:
-            arcname = filename
-        arcname = os.path.normpath(os.path.splitdrive(arcname)[1])
-        while arcname[0] in (os.sep, os.altsep):
-            arcname = arcname[1:]
-        if isdir:
-            arcname += '/'
-        zinfo = ZipInfo(arcname, date_time)
-        zinfo.external_attr = (st[0] & 0xFFFF) << 16L      # Unix attributes
-        if compress_type is None:
-            zinfo.compress_type = self.compression
-        else:
-            zinfo.compress_type = compress_type
-
-        zinfo.file_size = st.st_size
-        zinfo.flag_bits = 0x00
-        zinfo.header_offset = self.fp.tell()    # Start of header bytes
-
-        self._writecheck(zinfo)
-        self._didModify = True
-
-        if isdir:
-            zinfo.file_size = 0
-            zinfo.compress_size = 0
-            zinfo.CRC = 0
-            self.filelist.append(zinfo)
-            self.NameToInfo[zinfo.filename] = zinfo
-            self.fp.write(zinfo.FileHeader())
-            return
-
-        fp = open(filename, "rb")
-        # Must overwrite CRC and sizes with correct data later
-        zinfo.CRC = CRC = 0
-        zinfo.compress_size = compress_size = 0
-        zinfo.file_size = file_size = 0
-        self.fp.write(zinfo.FileHeader())
-        if zinfo.compress_type == ZIP_DEFLATED:
-            cmpr = zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION,
-                 zlib.DEFLATED, -15)
-        else:
-            cmpr = None
-        while 1:
-            buf = fp.read(1024 * 8)
-            if not buf:
-                break
-            file_size = file_size + len(buf)
-            CRC = crc32(buf, CRC) & 0xffffffff
-            if cmpr:
-                buf = cmpr.compress(buf)
-                compress_size = compress_size + len(buf)
-            self.fp.write(buf)
-        fp.close()
-        if cmpr:
-            buf = cmpr.flush()
-            compress_size = compress_size + len(buf)
-            self.fp.write(buf)
-            zinfo.compress_size = compress_size
-        else:
-            zinfo.compress_size = file_size
-        zinfo.CRC = CRC
-        zinfo.file_size = file_size
-        # Seek backwards and write CRC and file sizes
-        position = self.fp.tell()       # Preserve current position in file
-        self.fp.seek(zinfo.header_offset + 14, 0)
-        self.fp.write(struct.pack("<LLL", zinfo.CRC, zinfo.compress_size,
-              zinfo.file_size))
-        self.fp.seek(position, 0)
-        self.filelist.append(zinfo)
-        self.NameToInfo[zinfo.filename] = zinfo
-
-    def writestr(self, zinfo_or_arcname, bytes):
-        """Write a file into the archive.  The contents is the string
-        'bytes'.  'zinfo_or_arcname' is either a ZipInfo instance or
-        the name of the file in the archive."""
-        if not isinstance(zinfo_or_arcname, ZipInfo):
-            zinfo = ZipInfo(filename=zinfo_or_arcname,
-                            date_time=time.localtime(time.time())[:6])
-            zinfo.compress_type = self.compression
-            zinfo.external_attr = 0600 << 16
-        else:
-            zinfo = zinfo_or_arcname
-
-        if not self.fp:
-            raise RuntimeError(
-                  "Attempt to write to ZIP archive that was already closed")
-
-        zinfo.file_size = len(bytes)            # Uncompressed size
-        zinfo.header_offset = self.fp.tell()    # Start of header bytes
-        self._writecheck(zinfo)
-        self._didModify = True
-        zinfo.CRC = crc32(bytes) & 0xffffffff       # CRC-32 checksum
-        if zinfo.compress_type == ZIP_DEFLATED:
-            co = zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION,
-                 zlib.DEFLATED, -15)
-            bytes = co.compress(bytes) + co.flush()
-            zinfo.compress_size = len(bytes)    # Compressed size
-        else:
-            zinfo.compress_size = zinfo.file_size
-        zinfo.header_offset = self.fp.tell()    # Start of header bytes
-        self.fp.write(zinfo.FileHeader())
-        self.fp.write(bytes)
-        self.fp.flush()
-        if zinfo.flag_bits & 0x08:
-            # Write CRC and file sizes after the file data
-            self.fp.write(struct.pack("<LLL", zinfo.CRC, zinfo.compress_size,
-                  zinfo.file_size))
-        self.filelist.append(zinfo)
-        self.NameToInfo[zinfo.filename] = zinfo
-
-    def __del__(self):
-        """Call the "close()" method in case the user forgot."""
-        self.close()
-
-    def close(self):
-        """Close the file, and for mode "w" and "a" write the ending
-        records."""
-        if self.fp is None:
-            return
-
-        if self.mode in ("w", "a") and self._didModify: # write ending records
-            count = 0
-            pos1 = self.fp.tell()
-            for zinfo in self.filelist:         # write central directory
-                count = count + 1
-                dt = zinfo.date_time
-                dosdate = (dt[0] - 1980) << 9 | dt[1] << 5 | dt[2]
-                dostime = dt[3] << 11 | dt[4] << 5 | (dt[5] // 2)
-                extra = []
-                if zinfo.file_size > ZIP64_LIMIT \
-                        or zinfo.compress_size > ZIP64_LIMIT:
-                    extra.append(zinfo.file_size)
-                    extra.append(zinfo.compress_size)
-                    file_size = 0xffffffff
-                    compress_size = 0xffffffff
-                else:
-                    file_size = zinfo.file_size
-                    compress_size = zinfo.compress_size
-
-                if zinfo.header_offset > ZIP64_LIMIT:
-                    extra.append(zinfo.header_offset)
-                    header_offset = 0xffffffffL
-                else:
-                    header_offset = zinfo.header_offset
-
-                extra_data = zinfo.extra
-                if extra:
-                    # Append a ZIP64 field to the extra's
-                    extra_data = struct.pack(
-                            '<HH' + 'Q'*len(extra),
-                            1, 8*len(extra), *extra) + extra_data
-
-                    extract_version = max(45, zinfo.extract_version)
-                    create_version = max(45, zinfo.create_version)
-                else:
-                    extract_version = zinfo.extract_version
-                    create_version = zinfo.create_version
-
-                try:
-                    filename, flag_bits = zinfo._encodeFilenameFlags()
-                    centdir = struct.pack(structCentralDir,
-                     stringCentralDir, create_version,
-                     zinfo.create_system, extract_version, zinfo.reserved,
-                     flag_bits, zinfo.compress_type, dostime, dosdate,
-                     zinfo.CRC, compress_size, file_size,
-                     len(filename), len(extra_data), len(zinfo.comment),
-                     0, zinfo.internal_attr, zinfo.external_attr,
-                     header_offset)
-                except DeprecationWarning:
-                    print >>sys.stderr, (structCentralDir,
-                     stringCentralDir, create_version,
-                     zinfo.create_system, extract_version, zinfo.reserved,
-                     zinfo.flag_bits, zinfo.compress_type, dostime, dosdate,
-                     zinfo.CRC, compress_size, file_size,
-                     len(zinfo.filename), len(extra_data), len(zinfo.comment),
-                     0, zinfo.internal_attr, zinfo.external_attr,
-                     header_offset)
-                    raise
-                self.fp.write(centdir)
-                self.fp.write(filename)
-                self.fp.write(extra_data)
-                self.fp.write(zinfo.comment)
-
-            pos2 = self.fp.tell()
-            # Write end-of-zip-archive record
-            centDirCount = count
-            centDirSize = pos2 - pos1
-            centDirOffset = pos1
-            if (centDirCount >= ZIP_FILECOUNT_LIMIT or
-                centDirOffset > ZIP64_LIMIT or
-                centDirSize > ZIP64_LIMIT):
-                # Need to write the ZIP64 end-of-archive records
-                zip64endrec = struct.pack(
-                        structEndArchive64, stringEndArchive64,
-                        44, 45, 45, 0, 0, centDirCount, centDirCount,
-                        centDirSize, centDirOffset)
-                self.fp.write(zip64endrec)
-
-                zip64locrec = struct.pack(
-                        structEndArchive64Locator,
-                        stringEndArchive64Locator, 0, pos2, 1)
-                self.fp.write(zip64locrec)
-                centDirCount = min(centDirCount, 0xFFFF)
-                centDirSize = min(centDirSize, 0xFFFFFFFF)
-                centDirOffset = min(centDirOffset, 0xFFFFFFFF)
-
-            # check for valid comment length
-            if len(self.comment) >= ZIP_MAX_COMMENT:
-                if self.debug > 0:
-                    msg = 'Archive comment is too long; truncating to %d bytes' \
-                          % ZIP_MAX_COMMENT
-                self.comment = self.comment[:ZIP_MAX_COMMENT]
-
-            endrec = struct.pack(structEndArchive, stringEndArchive,
-                                 0, 0, centDirCount, centDirCount,
-                                 centDirSize, centDirOffset, len(self.comment))
-            self.fp.write(endrec)
-            self.fp.write(self.comment)
-            self.fp.flush()
-
-        if not self._filePassed:
-            self.fp.close()
-        self.fp = None
-
-
-class PyZipFile(ZipFile):
-    """Class to create ZIP archives with Python library files and packages."""
-
-    def writepy(self, pathname, basename = ""):
-        """Add all files from "pathname" to the ZIP archive.
-
-        If pathname is a package directory, search the directory and
-        all package subdirectories recursively for all *.py and enter
-        the modules into the archive.  If pathname is a plain
-        directory, listdir *.py and enter all modules.  Else, pathname
-        must be a Python *.py file and the module will be put into the
-        archive.  Added modules are always module.pyo or module.pyc.
-        This method will compile the module.py into module.pyc if
-        necessary.
-        """
-        dir, name = os.path.split(pathname)
-        if os.path.isdir(pathname):
-            initname = os.path.join(pathname, "__init__.py")
-            if os.path.isfile(initname):
-                # This is a package directory, add it
-                if basename:
-                    basename = "%s/%s" % (basename, name)
-                else:
-                    basename = name
-                if self.debug:
-                    print "Adding package in", pathname, "as", basename
-                fname, arcname = self._get_codename(initname[0:-3], basename)
-                if self.debug:
-                    print "Adding", arcname
-                self.write(fname, arcname)
-                dirlist = os.listdir(pathname)
-                dirlist.remove("__init__.py")
-                # Add all *.py files and package subdirectories
-                for filename in dirlist:
-                    path = os.path.join(pathname, filename)
-                    root, ext = os.path.splitext(filename)
-                    if os.path.isdir(path):
-                        if os.path.isfile(os.path.join(path, "__init__.py")):
-                            # This is a package directory, add it
-                            self.writepy(path, basename)  # Recursive call
-                    elif ext == ".py":
-                        fname, arcname = self._get_codename(path[0:-3],
-                                         basename)
-                        if self.debug:
-                            print "Adding", arcname
-                        self.write(fname, arcname)
-            else:
-                # This is NOT a package directory, add its files at top level
-                if self.debug:
-                    print "Adding files from directory", pathname
-                for filename in os.listdir(pathname):
-                    path = os.path.join(pathname, filename)
-                    root, ext = os.path.splitext(filename)
-                    if ext == ".py":
-                        fname, arcname = self._get_codename(path[0:-3],
-                                         basename)
-                        if self.debug:
-                            print "Adding", arcname
-                        self.write(fname, arcname)
-        else:
-            if pathname[-3:] != ".py":
-                raise RuntimeError, \
-                      'Files added with writepy() must end with ".py"'
-            fname, arcname = self._get_codename(pathname[0:-3], basename)
-            if self.debug:
-                print "Adding file", arcname
-            self.write(fname, arcname)
-
-    def _get_codename(self, pathname, basename):
-        """Return (filename, archivename) for the path.
-
-        Given a module name path, return the correct file path and
-        archive name, compiling if necessary.  For example, given
-        /python/lib/string, return (/python/lib/string.pyc, string).
-        """
-        file_py  = pathname + ".py"
-        file_pyc = pathname + ".pyc"
-        file_pyo = pathname + ".pyo"
-        if os.path.isfile(file_pyo) and \
-                            os.stat(file_pyo).st_mtime >= os.stat(file_py).st_mtime:
-            fname = file_pyo    # Use .pyo file
-        elif not os.path.isfile(file_pyc) or \
-             os.stat(file_pyc).st_mtime < os.stat(file_py).st_mtime:
-            import py_compile
-            if self.debug:
-                print "Compiling", file_py
-            try:
-                py_compile.compile(file_py, file_pyc, None, True)
-            except py_compile.PyCompileError,err:
-                print err.msg
-            fname = file_pyc
-        else:
-            fname = file_pyc
-        archivename = os.path.split(fname)[1]
-        if basename:
-            archivename = "%s/%s" % (basename, archivename)
-        return (fname, archivename)
-
-
-def main(args = None):
-    import textwrap
-    USAGE=textwrap.dedent("""\
-        Usage:
-            zipfile.py -l zipfile.zip        # Show listing of a zipfile
-            zipfile.py -t zipfile.zip        # Test if a zipfile is valid
-            zipfile.py -e zipfile.zip target # Extract zipfile into target dir
-            zipfile.py -c zipfile.zip src ... # Create zipfile from sources
-        """)
-    if args is None:
-        args = sys.argv[1:]
-
-    if not args or args[0] not in ('-l', '-c', '-e', '-t'):
-        print USAGE
-        sys.exit(1)
-
-    if args[0] == '-l':
-        if len(args) != 2:
-            print USAGE
-            sys.exit(1)
-        zf = ZipFile(args[1], 'r')
-        zf.printdir()
-        zf.close()
-
-    elif args[0] == '-t':
-        if len(args) != 2:
-            print USAGE
-            sys.exit(1)
-        zf = ZipFile(args[1], 'r')
-        zf.testzip()
-        print "Done testing"
-
-    elif args[0] == '-e':
-        if len(args) != 3:
-            print USAGE
-            sys.exit(1)
-
-        zf = ZipFile(args[1], 'r')
-        out = args[2]
-        for path in zf.namelist():
-            if path.startswith('./'):
-                tgt = os.path.join(out, path[2:])
-            else:
-                tgt = os.path.join(out, path)
-
-            tgtdir = os.path.dirname(tgt)
-            if not os.path.exists(tgtdir):
-                os.makedirs(tgtdir)
-            fp = open(tgt, 'wb')
-            fp.write(zf.read(path))
-            fp.close()
-        zf.close()
-
-    elif args[0] == '-c':
-        if len(args) < 3:
-            print USAGE
-            sys.exit(1)
-
-        def addToZip(zf, path, zippath):
-            if os.path.isfile(path):
-                zf.write(path, zippath, ZIP_DEFLATED)
-            elif os.path.isdir(path):
-                for nm in os.listdir(path):
-                    addToZip(zf,
-                            os.path.join(path, nm), os.path.join(zippath, nm))
-            # else: ignore
-
-        zf = ZipFile(args[1], 'w', allowZip64=True)
-        for src in args[2:]:
-            addToZip(zf, src, os.path.basename(src))
-
-        zf.close()
-
-if __name__ == "__main__":
-    main()

=== removed directory 'python25-compat'
=== removed file 'python25-compat/BaseHTTPServer.py'
--- python25-compat/BaseHTTPServer.py	2009-09-10 00:02:41 +0000
+++ python25-compat/BaseHTTPServer.py	1970-01-01 00:00:00 +0000
@@ -1,587 +0,0 @@
-"""HTTP server base class.
-
-Note: the class in this module doesn't implement any HTTP request; see
-SimpleHTTPServer for simple implementations of GET, HEAD and POST
-(including CGI scripts).  It does, however, optionally implement HTTP/1.1
-persistent connections, as of version 0.3.
-
-Contents:
-
-- BaseHTTPRequestHandler: HTTP request handler base class
-- test: test function
-
-XXX To do:
-
-- log requests even later (to capture byte count)
-- log user-agent header and other interesting goodies
-- send error log to separate file
-"""
-
-
-# See also:
-#
-# HTTP Working Group                                        T. Berners-Lee
-# INTERNET-DRAFT                                            R. T. Fielding
-# <draft-ietf-http-v10-spec-00.txt>                     H. Frystyk Nielsen
-# Expires September 8, 1995                                  March 8, 1995
-#
-# URL: http://www.ics.uci.edu/pub/ietf/http/draft-ietf-http-v10-spec-00.txt
-#
-# and
-#
-# Network Working Group                                      R. Fielding
-# Request for Comments: 2616                                       et al
-# Obsoletes: 2068                                              June 1999
-# Category: Standards Track
-#
-# URL: http://www.faqs.org/rfcs/rfc2616.html
-
-# Log files
-# ---------
-#
-# Here's a quote from the NCSA httpd docs about log file format.
-#
-# | The logfile format is as follows. Each line consists of:
-# |
-# | host rfc931 authuser [DD/Mon/YYYY:hh:mm:ss] "request" ddd bbbb
-# |
-# |        host: Either the DNS name or the IP number of the remote client
-# |        rfc931: Any information returned by identd for this person,
-# |                - otherwise.
-# |        authuser: If user sent a userid for authentication, the user name,
-# |                  - otherwise.
-# |        DD: Day
-# |        Mon: Month (calendar name)
-# |        YYYY: Year
-# |        hh: hour (24-hour format, the machine's timezone)
-# |        mm: minutes
-# |        ss: seconds
-# |        request: The first line of the HTTP request as sent by the client.
-# |        ddd: the status code returned by the server, - if not available.
-# |        bbbb: the total number of bytes sent,
-# |              *not including the HTTP/1.0 header*, - if not available
-# |
-# | You can determine the name of the file accessed through request.
-#
-# (Actually, the latter is only true if you know the server configuration
-# at the time the request was made!)
-
-__version__ = "0.3"
-
-__all__ = ["HTTPServer", "BaseHTTPRequestHandler"]
-
-import sys
-import time
-import socket # For gethostbyaddr()
-import mimetools
-import SocketServer
-
-# Default error message template
-DEFAULT_ERROR_MESSAGE = """\
-<head>
-<title>Error response</title>
-</head>
-<body>
-<h1>Error response</h1>
-<p>Error code %(code)d.
-<p>Message: %(message)s.
-<p>Error code explanation: %(code)s = %(explain)s.
-</body>
-"""
-
-DEFAULT_ERROR_CONTENT_TYPE = "text/html"
-
-def _quote_html(html):
-    return html.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
-
-class HTTPServer(SocketServer.TCPServer):
-
-    allow_reuse_address = 1    # Seems to make sense in testing environment
-
-    def server_bind(self):
-        """Override server_bind to store the server name."""
-        SocketServer.TCPServer.server_bind(self)
-        host, port = self.socket.getsockname()[:2]
-        self.server_name = socket.getfqdn(host)
-        self.server_port = port
-
-
-class BaseHTTPRequestHandler(SocketServer.StreamRequestHandler):
-
-    """HTTP request handler base class.
-
-    The following explanation of HTTP serves to guide you through the
-    code as well as to expose any misunderstandings I may have about
-    HTTP (so you don't need to read the code to figure out I'm wrong
-    :-).
-
-    HTTP (HyperText Transfer Protocol) is an extensible protocol on
-    top of a reliable stream transport (e.g. TCP/IP).  The protocol
-    recognizes three parts to a request:
-
-    1. One line identifying the request type and path
-    2. An optional set of RFC-822-style headers
-    3. An optional data part
-
-    The headers and data are separated by a blank line.
-
-    The first line of the request has the form
-
-    <command> <path> <version>
-
-    where <command> is a (case-sensitive) keyword such as GET or POST,
-    <path> is a string containing path information for the request,
-    and <version> should be the string "HTTP/1.0" or "HTTP/1.1".
-    <path> is encoded using the URL encoding scheme (using %xx to signify
-    the ASCII character with hex code xx).
-
-    The specification specifies that lines are separated by CRLF but
-    for compatibility with the widest range of clients recommends
-    servers also handle LF.  Similarly, whitespace in the request line
-    is treated sensibly (allowing multiple spaces between components
-    and allowing trailing whitespace).
-
-    Similarly, for output, lines ought to be separated by CRLF pairs
-    but most clients grok LF characters just fine.
-
-    If the first line of the request has the form
-
-    <command> <path>
-
-    (i.e. <version> is left out) then this is assumed to be an HTTP
-    0.9 request; this form has no optional headers and data part and
-    the reply consists of just the data.
-
-    The reply form of the HTTP 1.x protocol again has three parts:
-
-    1. One line giving the response code
-    2. An optional set of RFC-822-style headers
-    3. The data
-
-    Again, the headers and data are separated by a blank line.
-
-    The response code line has the form
-
-    <version> <responsecode> <responsestring>
-
-    where <version> is the protocol version ("HTTP/1.0" or "HTTP/1.1"),
-    <responsecode> is a 3-digit response code indicating success or
-    failure of the request, and <responsestring> is an optional
-    human-readable string explaining what the response code means.
-
-    This server parses the request and the headers, and then calls a
-    function specific to the request type (<command>).  Specifically,
-    a request SPAM will be handled by a method do_SPAM().  If no
-    such method exists the server sends an error response to the
-    client.  If it exists, it is called with no arguments:
-
-    do_SPAM()
-
-    Note that the request name is case sensitive (i.e. SPAM and spam
-    are different requests).
-
-    The various request details are stored in instance variables:
-
-    - client_address is the client IP address in the form (host,
-    port);
-
-    - command, path and version are the broken-down request line;
-
-    - headers is an instance of mimetools.Message (or a derived
-    class) containing the header information;
-
-    - rfile is a file object open for reading positioned at the
-    start of the optional input data part;
-
-    - wfile is a file object open for writing.
-
-    IT IS IMPORTANT TO ADHERE TO THE PROTOCOL FOR WRITING!
-
-    The first thing to be written must be the response line.  Then
-    follow 0 or more header lines, then a blank line, and then the
-    actual data (if any).  The meaning of the header lines depends on
-    the command executed by the server; in most cases, when data is
-    returned, there should be at least one header line of the form
-
-    Content-type: <type>/<subtype>
-
-    where <type> and <subtype> should be registered MIME types,
-    e.g. "text/html" or "text/plain".
-
-    """
-
-    # The Python system version, truncated to its first component.
-    sys_version = "Python/" + sys.version.split()[0]
-
-    # The server software version.  You may want to override this.
-    # The format is multiple whitespace-separated strings,
-    # where each string is of the form name[/version].
-    server_version = "BaseHTTP/" + __version__
-
-    # The default request version.  This only affects responses up until
-    # the point where the request line is parsed, so it mainly decides what
-    # the client gets back when sending a malformed request line.
-    # Most web servers default to HTTP 0.9, i.e. don't send a status line.
-    default_request_version = "HTTP/0.9"
-
-    def parse_request(self):
-        """Parse a request (internal).
-
-        The request should be stored in self.raw_requestline; the results
-        are in self.command, self.path, self.request_version and
-        self.headers.
-
-        Return True for success, False for failure; on failure, an
-        error is sent back.
-
-        """
-        self.command = None  # set in case of error on the first line
-        self.request_version = version = self.default_request_version
-        self.close_connection = 1
-        requestline = self.raw_requestline
-        if requestline[-2:] == '\r\n':
-            requestline = requestline[:-2]
-        elif requestline[-1:] == '\n':
-            requestline = requestline[:-1]
-        self.requestline = requestline
-        words = requestline.split()
-        if len(words) == 3:
-            [command, path, version] = words
-            if version[:5] != 'HTTP/':
-                self.send_error(400, "Bad request version (%r)" % version)
-                return False
-            try:
-                base_version_number = version.split('/', 1)[1]
-                version_number = base_version_number.split(".")
-                # RFC 2145 section 3.1 says there can be only one "." and
-                #   - major and minor numbers MUST be treated as
-                #      separate integers;
-                #   - HTTP/2.4 is a lower version than HTTP/2.13, which in
-                #      turn is lower than HTTP/12.3;
-                #   - Leading zeros MUST be ignored by recipients.
-                if len(version_number) != 2:
-                    raise ValueError
-                version_number = int(version_number[0]), int(version_number[1])
-            except (ValueError, IndexError):
-                self.send_error(400, "Bad request version (%r)" % version)
-                return False
-            if version_number >= (1, 1) and self.protocol_version >= "HTTP/1.1":
-                self.close_connection = 0
-            if version_number >= (2, 0):
-                self.send_error(505,
-                          "Invalid HTTP Version (%s)" % base_version_number)
-                return False
-        elif len(words) == 2:
-            [command, path] = words
-            self.close_connection = 1
-            if command != 'GET':
-                self.send_error(400,
-                                "Bad HTTP/0.9 request type (%r)" % command)
-                return False
-        elif not words:
-            return False
-        else:
-            self.send_error(400, "Bad request syntax (%r)" % requestline)
-            return False
-        self.command, self.path, self.request_version = command, path, version
-
-        # Examine the headers and look for a Connection directive
-        self.headers = self.MessageClass(self.rfile, 0)
-
-        conntype = self.headers.get('Connection', "")
-        if conntype.lower() == 'close':
-            self.close_connection = 1
-        elif (conntype.lower() == 'keep-alive' and
-              self.protocol_version >= "HTTP/1.1"):
-            self.close_connection = 0
-        return True
-
-    def handle_one_request(self):
-        """Handle a single HTTP request.
-
-        You normally don't need to override this method; see the class
-        __doc__ string for information on how to handle specific HTTP
-        commands such as GET and POST.
-
-        """
-        self.raw_requestline = self.rfile.readline()
-        if not self.raw_requestline:
-            self.close_connection = 1
-            return
-        if not self.parse_request(): # An error code has been sent, just exit
-            return
-        mname = 'do_' + self.command
-        if not hasattr(self, mname):
-            self.send_error(501, "Unsupported method (%r)" % self.command)
-            return
-        method = getattr(self, mname)
-        method()
-
-    def handle(self):
-        """Handle multiple requests if necessary."""
-        self.close_connection = 1
-
-        self.handle_one_request()
-        while not self.close_connection:
-            self.handle_one_request()
-
-    def send_error(self, code, message=None):
-        """Send and log an error reply.
-
-        Arguments are the error code, and a detailed message.
-        The detailed message defaults to the short entry matching the
-        response code.
-
-        This sends an error response (so it must be called before any
-        output has been generated), logs the error, and finally sends
-        a piece of HTML explaining the error to the user.
-
-        """
-
-        try:
-            short, long = self.responses[code]
-        except KeyError:
-            short, long = '???', '???'
-        if message is None:
-            message = short
-        explain = long
-        self.log_error("code %d, message %s", code, message)
-        # using _quote_html to prevent Cross Site Scripting attacks (see bug #1100201)
-        content = (self.error_message_format %
-                   {'code': code, 'message': _quote_html(message), 'explain': explain})
-        self.send_response(code, message)
-        self.send_header("Content-Type", self.error_content_type)
-        self.send_header('Connection', 'close')
-        self.end_headers()
-        if self.command != 'HEAD' and code >= 200 and code not in (204, 304):
-            self.wfile.write(content)
-
-    error_message_format = DEFAULT_ERROR_MESSAGE
-    error_content_type = DEFAULT_ERROR_CONTENT_TYPE
-
-    def send_response(self, code, message=None):
-        """Send the response header and log the response code.
-
-        Also send two standard headers with the server software
-        version and the current date.
-
-        """
-        self.log_request(code)
-        if message is None:
-            if code in self.responses:
-                message = self.responses[code][0]
-            else:
-                message = ''
-        if self.request_version != 'HTTP/0.9':
-            self.wfile.write("%s %d %s\r\n" %
-                             (self.protocol_version, code, message))
-            # print (self.protocol_version, code, message)
-        self.send_header('Server', self.version_string())
-        self.send_header('Date', self.date_time_string())
-
-    def send_header(self, keyword, value):
-        """Send a MIME header."""
-        if self.request_version != 'HTTP/0.9':
-            self.wfile.write("%s: %s\r\n" % (keyword, value))
-
-        if keyword.lower() == 'connection':
-            if value.lower() == 'close':
-                self.close_connection = 1
-            elif value.lower() == 'keep-alive':
-                self.close_connection = 0
-
-    def end_headers(self):
-        """Send the blank line ending the MIME headers."""
-        if self.request_version != 'HTTP/0.9':
-            self.wfile.write("\r\n")
-
-    def log_request(self, code='-', size='-'):
-        """Log an accepted request.
-
-        This is called by send_response().
-
-        """
-
-        self.log_message('"%s" %s %s',
-                         self.requestline, str(code), str(size))
-
-    def log_error(self, format, *args):
-        """Log an error.
-
-        This is called when a request cannot be fulfilled.  By
-        default it passes the message on to log_message().
-
-        Arguments are the same as for log_message().
-
-        XXX This should go to the separate error log.
-
-        """
-
-        self.log_message(format, *args)
-
-    def log_message(self, format, *args):
-        """Log an arbitrary message.
-
-        This is used by all other logging functions.  Override
-        it if you have specific logging wishes.
-
-        The first argument, FORMAT, is a format string for the
-        message to be logged.  If the format string contains
-        any % escapes requiring parameters, they should be
-        specified as subsequent arguments (it's just like
-        printf!).
-
-        The client host and current date/time are prefixed to
-        every message.
-
-        """
-
-        sys.stderr.write("%s - - [%s] %s\n" %
-                         (self.address_string(),
-                          self.log_date_time_string(),
-                          format%args))
-
-    def version_string(self):
-        """Return the server software version string."""
-        return self.server_version + ' ' + self.sys_version
-
-    def date_time_string(self, timestamp=None):
-        """Return the current date and time formatted for a message header."""
-        if timestamp is None:
-            timestamp = time.time()
-        year, month, day, hh, mm, ss, wd, y, z = time.gmtime(timestamp)
-        s = "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (
-                self.weekdayname[wd],
-                day, self.monthname[month], year,
-                hh, mm, ss)
-        return s
-
-    def log_date_time_string(self):
-        """Return the current time formatted for logging."""
-        now = time.time()
-        year, month, day, hh, mm, ss, x, y, z = time.localtime(now)
-        s = "%02d/%3s/%04d %02d:%02d:%02d" % (
-                day, self.monthname[month], year, hh, mm, ss)
-        return s
-
-    weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
-
-    monthname = [None,
-                 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
-                 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
-
-    def address_string(self):
-        """Return the client address formatted for logging.
-
-        This version looks up the full hostname using gethostbyaddr(),
-        and tries to find a name that contains at least one dot.
-
-        """
-
-        host, port = self.client_address[:2]
-        return socket.getfqdn(host)
-
-    # Essentially static class variables
-
-    # The version of the HTTP protocol we support.
-    # Set this to HTTP/1.1 to enable automatic keepalive
-    protocol_version = "HTTP/1.0"
-
-    # The Message-like class used to parse headers
-    MessageClass = mimetools.Message
-
-    # Table mapping response codes to messages; entries have the
-    # form {code: (shortmessage, longmessage)}.
-    # See RFC 2616.
-    responses = {
-        100: ('Continue', 'Request received, please continue'),
-        101: ('Switching Protocols',
-              'Switching to new protocol; obey Upgrade header'),
-
-        200: ('OK', 'Request fulfilled, document follows'),
-        201: ('Created', 'Document created, URL follows'),
-        202: ('Accepted',
-              'Request accepted, processing continues off-line'),
-        203: ('Non-Authoritative Information', 'Request fulfilled from cache'),
-        204: ('No Content', 'Request fulfilled, nothing follows'),
-        205: ('Reset Content', 'Clear input form for further input.'),
-        206: ('Partial Content', 'Partial content follows.'),
-
-        300: ('Multiple Choices',
-              'Object has several resources -- see URI list'),
-        301: ('Moved Permanently', 'Object moved permanently -- see URI list'),
-        302: ('Found', 'Object moved temporarily -- see URI list'),
-        303: ('See Other', 'Object moved -- see Method and URL list'),
-        304: ('Not Modified',
-              'Document has not changed since given time'),
-        305: ('Use Proxy',
-              'You must use proxy specified in Location to access this '
-              'resource.'),
-        307: ('Temporary Redirect',
-              'Object moved temporarily -- see URI list'),
-
-        400: ('Bad Request',
-              'Bad request syntax or unsupported method'),
-        401: ('Unauthorized',
-              'No permission -- see authorization schemes'),
-        402: ('Payment Required',
-              'No payment -- see charging schemes'),
-        403: ('Forbidden',
-              'Request forbidden -- authorization will not help'),
-        404: ('Not Found', 'Nothing matches the given URI'),
-        405: ('Method Not Allowed',
-              'Specified method is invalid for this server.'),
-        406: ('Not Acceptable', 'URI not available in preferred format.'),
-        407: ('Proxy Authentication Required', 'You must authenticate with '
-              'this proxy before proceeding.'),
-        408: ('Request Timeout', 'Request timed out; try again later.'),
-        409: ('Conflict', 'Request conflict.'),
-        410: ('Gone',
-              'URI no longer exists and has been permanently removed.'),
-        411: ('Length Required', 'Client must specify Content-Length.'),
-        412: ('Precondition Failed', 'Precondition in headers is false.'),
-        413: ('Request Entity Too Large', 'Entity is too large.'),
-        414: ('Request-URI Too Long', 'URI is too long.'),
-        415: ('Unsupported Media Type', 'Entity body in unsupported format.'),
-        416: ('Requested Range Not Satisfiable',
-              'Cannot satisfy request range.'),
-        417: ('Expectation Failed',
-              'Expect condition could not be satisfied.'),
-
-        500: ('Internal Server Error', 'Server got itself in trouble'),
-        501: ('Not Implemented',
-              'Server does not support this operation'),
-        502: ('Bad Gateway', 'Invalid responses from another server/proxy.'),
-        503: ('Service Unavailable',
-              'The server cannot process the request due to a high load'),
-        504: ('Gateway Timeout',
-              'The gateway server did not receive a timely response'),
-        505: ('HTTP Version Not Supported', 'Cannot fulfill request.'),
-        }
-
-
-def test(HandlerClass = BaseHTTPRequestHandler,
-         ServerClass = HTTPServer, protocol="HTTP/1.0"):
-    """Test the HTTP request handler class.
-
-    This runs an HTTP server on port 8000 (or the first command line
-    argument).
-
-    """
-
-    if sys.argv[1:]:
-        port = int(sys.argv[1])
-    else:
-        port = 8000
-    server_address = ('', port)
-
-    HandlerClass.protocol_version = protocol
-    httpd = ServerClass(server_address, HandlerClass)
-
-    sa = httpd.socket.getsockname()
-    print "Serving HTTP on", sa[0], "port", sa[1], "..."
-    httpd.serve_forever()
-
-
-if __name__ == '__main__':
-    test()

=== removed file 'python25-compat/SimpleXMLRPCServer.py'
--- python25-compat/SimpleXMLRPCServer.py	2009-09-10 00:02:41 +0000
+++ python25-compat/SimpleXMLRPCServer.py	1970-01-01 00:00:00 +0000
@@ -1,611 +0,0 @@
-"""Simple XML-RPC Server.
-
-This module can be used to create simple XML-RPC servers
-by creating a server and either installing functions, a
-class instance, or by extending the SimpleXMLRPCServer
-class.
-
-It can also be used to handle XML-RPC requests in a CGI
-environment using CGIXMLRPCRequestHandler.
-
-A list of possible usage patterns follows:
-
-1. Install functions:
-
-server = SimpleXMLRPCServer(("localhost", 8000))
-server.register_function(pow)
-server.register_function(lambda x,y: x+y, 'add')
-server.serve_forever()
-
-2. Install an instance:
-
-class MyFuncs:
-    def __init__(self):
-        # make all of the string functions available through
-        # string.func_name
-        import string
-        self.string = string
-    def _listMethods(self):
-        # implement this method so that system.listMethods
-        # knows to advertise the strings methods
-        return list_public_methods(self) + \
-                ['string.' + method for method in list_public_methods(self.string)]
-    def pow(self, x, y): return pow(x, y)
-    def add(self, x, y) : return x + y
-
-server = SimpleXMLRPCServer(("localhost", 8000))
-server.register_introspection_functions()
-server.register_instance(MyFuncs())
-server.serve_forever()
-
-3. Install an instance with custom dispatch method:
-
-class Math:
-    def _listMethods(self):
-        # this method must be present for system.listMethods
-        # to work
-        return ['add', 'pow']
-    def _methodHelp(self, method):
-        # this method must be present for system.methodHelp
-        # to work
-        if method == 'add':
-            return "add(2,3) => 5"
-        elif method == 'pow':
-            return "pow(x, y[, z]) => number"
-        else:
-            # By convention, return empty
-            # string if no help is available
-            return ""
-    def _dispatch(self, method, params):
-        if method == 'pow':
-            return pow(*params)
-        elif method == 'add':
-            return params[0] + params[1]
-        else:
-            raise 'bad method'
-
-server = SimpleXMLRPCServer(("localhost", 8000))
-server.register_introspection_functions()
-server.register_instance(Math())
-server.serve_forever()
-
-4. Subclass SimpleXMLRPCServer:
-
-class MathServer(SimpleXMLRPCServer):
-    def _dispatch(self, method, params):
-        try:
-            # We are forcing the 'export_' prefix on methods that are
-            # callable through XML-RPC to prevent potential security
-            # problems
-            func = getattr(self, 'export_' + method)
-        except AttributeError:
-            raise Exception('method "%s" is not supported' % method)
-        else:
-            return func(*params)
-
-    def export_add(self, x, y):
-        return x + y
-
-server = MathServer(("localhost", 8000))
-server.serve_forever()
-
-5. CGI script:
-
-server = CGIXMLRPCRequestHandler()
-server.register_function(pow)
-server.handle_request()
-"""
-
-# Written by Brian Quinlan ([e-mail]).
-# Based on code written by Fredrik Lundh.
-
-import xmlrpclib
-from xmlrpclib import Fault
-import SocketServer
-import BaseHTTPServer
-import sys
-import os
-import traceback
-try:
-    import fcntl
-except ImportError:
-    fcntl = None
-
-def resolve_dotted_attribute(obj, attr, allow_dotted_names=True):
-    """resolve_dotted_attribute(a, 'b.c.d') => a.b.c.d
-
-    Resolves a dotted attribute name to an object.  Raises
-    an AttributeError if any attribute in the chain starts with a '_'.
-
-    If the optional allow_dotted_names argument is false, dots are not
-    supported and this function operates similar to getattr(obj, attr).
-    """
-
-    if allow_dotted_names:
-        attrs = attr.split('.')
-    else:
-        attrs = [attr]
-
-    for i in attrs:
-        if i.startswith('_'):
-            raise AttributeError(
-                'attempt to access private attribute "%s"' % i
-                )
-        else:
-            obj = getattr(obj,i)
-    return obj
-
-def list_public_methods(obj):
-    """Returns a list of attribute strings, found in the specified
-    object, which represent callable attributes"""
-
-    return [member for member in dir(obj)
-                if not member.startswith('_') and
-                    hasattr(getattr(obj, member), '__call__')]
-
-def remove_duplicates(lst):
-    """remove_duplicates([2,2,2,1,3,3]) => [3,1,2]
-
-    Returns a copy of a list without duplicates. Every list
-    item must be hashable and the order of the items in the
-    resulting list is not defined.
-    """
-    u = {}
-    for x in lst:
-        u[x] = 1
-
-    return u.keys()
-
-class SimpleXMLRPCDispatcher:
-    """Mix-in class that dispatches XML-RPC requests.
-
-    This class is used to register XML-RPC method handlers
-    and then to dispatch them. There should never be any
-    reason to instantiate this class directly.
-    """
-
-    def __init__(self, allow_none, encoding):
-        self.funcs = {}
-        self.instance = None
-        self.allow_none = allow_none
-        self.encoding = encoding
-
-    def register_instance(self, instance, allow_dotted_names=False):
-        """Registers an instance to respond to XML-RPC requests.
-
-        Only one instance can be installed at a time.
-
-        If the registered instance has a _dispatch method then that
-        method will be called with the name of the XML-RPC method and
-        its parameters as a tuple
-        e.g. instance._dispatch('add',(2,3))
-
-        If the registered instance does not have a _dispatch method
-        then the instance will be searched to find a matching method
-        and, if found, will be called. Methods beginning with an '_'
-        are considered private and will not be called by
-        SimpleXMLRPCServer.
-
-        If a registered function matches a XML-RPC request, then it
-        will be called instead of the registered instance.
-
-        If the optional allow_dotted_names argument is true and the
-        instance does not have a _dispatch method, method names
-        containing dots are supported and resolved, as long as none of
-        the name segments start with an '_'.
-
-            *** SECURITY WARNING: ***
-
-            Enabling the allow_dotted_names options allows intruders
-            to access your module's global variables and may allow
-            intruders to execute arbitrary code on your machine.  Only
-            use this option on a secure, closed network.
-
-        """
-
-        self.instance = instance
-        self.allow_dotted_names = allow_dotted_names
-
-    def register_function(self, function, name = None):
-        """Registers a function to respond to XML-RPC requests.
-
-        The optional name argument can be used to set a Unicode name
-        for the function.
-        """
-
-        if name is None:
-            name = function.__name__
-        self.funcs[name] = function
-
-    def register_introspection_functions(self):
-        """Registers the XML-RPC introspection methods in the system
-        namespace.
-
-        see http://xmlrpc.usefulinc.com/doc/reserved.html
-        """
-
-        self.funcs.update({'system.listMethods' : self.system_listMethods,
-                      'system.methodSignature' : self.system_methodSignature,
-                      'system.methodHelp' : self.system_methodHelp})
-
-    def register_multicall_functions(self):
-        """Registers the XML-RPC multicall method in the system
-        namespace.
-
-        see http://www.xmlrpc.com/discuss/msgReader$1208"""
-
-        self.funcs.update({'system.multicall' : self.system_multicall})
-
-    def _marshaled_dispatch(self, data, dispatch_method = None):
-        """Dispatches an XML-RPC method from marshalled (XML) data.
-
-        XML-RPC methods are dispatched from the marshalled (XML) data
-        using the _dispatch method and the result is returned as
-        marshalled data. For backwards compatibility, a dispatch
-        function can be provided as an argument (see comment in
-        SimpleXMLRPCRequestHandler.do_POST) but overriding the
-        existing method through subclassing is the prefered means
-        of changing method dispatch behavior.
-        """
-
-        try:
-            params, method = xmlrpclib.loads(data)
-
-            # generate response
-            if dispatch_method is not None:
-                response = dispatch_method(method, params)
-            else:
-                response = self._dispatch(method, params)
-            # wrap response in a singleton tuple
-            response = (response,)
-            response = xmlrpclib.dumps(response, methodresponse=1,
-                                       allow_none=self.allow_none, encoding=self.encoding)
-        except Fault, fault:
-            response = xmlrpclib.dumps(fault, allow_none=self.allow_none,
-                                       encoding=self.encoding)
-        except:
-            # report exception back to server
-            exc_type, exc_value, exc_tb = sys.exc_info()
-            response = xmlrpclib.dumps(
-                xmlrpclib.Fault(1, "%s:%s" % (exc_type, exc_value)),
-                encoding=self.encoding, allow_none=self.allow_none,
-                )
-
-        return response
-
-    def system_listMethods(self):
-        """system.listMethods() => ['add', 'subtract', 'multiple']
-
-        Returns a list of the methods supported by the server."""
-
-        methods = self.funcs.keys()
-        if self.instance is not None:
-            # Instance can implement _listMethod to return a list of
-            # methods
-            if hasattr(self.instance, '_listMethods'):
-                methods = remove_duplicates(
-                        methods + self.instance._listMethods()
-                    )
-            # if the instance has a _dispatch method then we
-            # don't have enough information to provide a list
-            # of methods
-            elif not hasattr(self.instance, '_dispatch'):
-                methods = remove_duplicates(
-                        methods + list_public_methods(self.instance)
-                    )
-        methods.sort()
-        return methods
-
-    def system_methodSignature(self, method_name):
-        """system.methodSignature('add') => [double, int, int]
-
-        Returns a list describing the signature of the method. In the
-        above example, the add method takes two integers as arguments
-        and returns a double result.
-
-        This server does NOT support system.methodSignature."""
-
-        # See http://xmlrpc.usefulinc.com/doc/sysmethodsig.html
-
-        return 'signatures not supported'
-
-    def system_methodHelp(self, method_name):
-        """system.methodHelp('add') => "Adds two integers together"
-
-        Returns a string containing documentation for the specified method."""
-
-        method = None
-        if method_name in self.funcs:
-            method = self.funcs[method_name]
-        elif self.instance is not None:
-            # Instance can implement _methodHelp to return help for a method
-            if hasattr(self.instance, '_methodHelp'):
-                return self.instance._methodHelp(method_name)
-            # if the instance has a _dispatch method then we
-            # don't have enough information to provide help
-            elif not hasattr(self.instance, '_dispatch'):
-                try:
-                    method = resolve_dotted_attribute(
-                                self.instance,
-                                method_name,
-                                self.allow_dotted_names
-                                )
-                except AttributeError:
-                    pass
-
-        # Note that we aren't checking that the method actually
-        # be a callable object of some kind
-        if method is None:
-            return ""
-        else:
-            import pydoc
-            return pydoc.getdoc(method)
-
-    def system_multicall(self, call_list):
-        """system.multicall([{'methodName': 'add', 'params': [2, 2]}, ...]) => \
-[[4], ...]
-
-        Allows the caller to package multiple XML-RPC calls into a single
-        request.
-
-        See http://www.xmlrpc.com/discuss/msgReader$1208
-        """
-
-        results = []
-        for call in call_list:
-            method_name = call['methodName']
-            params = call['params']
-
-            try:
-                # XXX A marshalling error in any response will fail the entire
-                # multicall. If someone cares they should fix this.
-                results.append([self._dispatch(method_name, params)])
-            except Fault, fault:
-                results.append(
-                    {'faultCode' : fault.faultCode,
-                     'faultString' : fault.faultString}
-                    )
-            except:
-                exc_type, exc_value, exc_tb = sys.exc_info()
-                results.append(
-                    {'faultCode' : 1,
-                     'faultString' : "%s:%s" % (exc_type, exc_value)}
-                    )
-        return results
-
-    def _dispatch(self, method, params):
-        """Dispatches the XML-RPC method.
-
-        XML-RPC calls are forwarded to a registered function that
-        matches the called XML-RPC method name. If no such function
-        exists then the call is forwarded to the registered instance,
-        if available.
-
-        If the registered instance has a _dispatch method then that
-        method will be called with the name of the XML-RPC method and
-        its parameters as a tuple
-        e.g. instance._dispatch('add',(2,3))
-
-        If the registered instance does not have a _dispatch method
-        then the instance will be searched to find a matching method
-        and, if found, will be called.
-
-        Methods beginning with an '_' are considered private and will
-        not be called.
-        """
-
-        func = None
-        try:
-            # check to see if a matching function has been registered
-            func = self.funcs[method]
-        except KeyError:
-            if self.instance is not None:
-                # check for a _dispatch method
-                if hasattr(self.instance, '_dispatch'):
-                    return self.instance._dispatch(method, params)
-                else:
-                    # call instance method directly
-                    try:
-                        func = resolve_dotted_attribute(
-                            self.instance,
-                            method,
-                            self.allow_dotted_names
-                            )
-                    except AttributeError:
-                        pass
-
-        if func is not None:
-            return func(*params)
-        else:
-            raise Exception('method "%s" is not supported' % method)
-
-class SimpleXMLRPCRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
-    """Simple XML-RPC request handler class.
-
-    Handles all HTTP POST requests and attempts to decode them as
-    XML-RPC requests.
-    """
-
-    # Class attribute listing the accessible path components;
-    # paths not on this list will result in a 404 error.
-    rpc_paths = ('/', '/RPC2')
-
-    def is_rpc_path_valid(self):
-        if self.rpc_paths:
-            return self.path in self.rpc_paths
-        else:
-            # If .rpc_paths is empty, just assume all paths are legal
-            return True
-
-    def do_POST(self):
-        """Handles the HTTP POST request.
-
-        Attempts to interpret all HTTP POST requests as XML-RPC calls,
-        which are forwarded to the server's _dispatch method for handling.
-        """
-
-        # Check that the path is legal
-        if not self.is_rpc_path_valid():
-            self.report_404()
-            return
-
-        try:
-            # Get arguments by reading body of request.
-            # We read this in chunks to avoid straining
-            # socket.read(); around the 10 or 15Mb mark, some platforms
-            # begin to have problems (bug #792570).
-            max_chunk_size = 10*1024*1024
-            size_remaining = int(self.headers["content-length"])
-            L = []
-            while size_remaining:
-                chunk_size = min(size_remaining, max_chunk_size)
-                L.append(self.rfile.read(chunk_size))
-                size_remaining -= len(L[-1])
-            data = ''.join(L)
-
-            # In previous versions of SimpleXMLRPCServer, _dispatch
-            # could be overridden in this class, instead of in
-            # SimpleXMLRPCDispatcher. To maintain backwards compatibility,
-            # check to see if a subclass implements _dispatch and dispatch
-            # using that method if present.
-            response = self.server._marshaled_dispatch(
-                    data, getattr(self, '_dispatch', None)
-                )
-        except Exception, e: # This should only happen if the module is buggy
-            # internal error, report as HTTP server error
-            self.send_response(500)
-
-            # Send information about the exception if requested
-            if hasattr(self.server, '_send_traceback_header') and \
-                    self.server._send_traceback_header:
-                self.send_header("X-exception", str(e))
-                self.send_header("X-traceback", traceback.format_exc())
-
-            self.end_headers()
-        else:
-            # got a valid XML RPC response
-            self.send_response(200)
-            self.send_header("Content-type", "text/xml")
-            self.send_header("Content-length", str(len(response)))
-            self.end_headers()
-            self.wfile.write(response)
-
-            # shut down the connection
-            self.wfile.flush()
-            self.connection.shutdown(1)
-
-    def report_404 (self):
-            # Report a 404 error
-        self.send_response(404)
-        response = 'No such page'
-        self.send_header("Content-type", "text/plain")
-        self.send_header("Content-length", str(len(response)))
-        self.end_headers()
-        self.wfile.write(response)
-        # shut down the connection
-        self.wfile.flush()
-        self.connection.shutdown(1)
-
-    def log_request(self, code='-', size='-'):
-        """Selectively log an accepted request."""
-
-        if self.server.logRequests:
-            BaseHTTPServer.BaseHTTPRequestHandler.log_request(self, code, size)
-
-class SimpleXMLRPCServer(SocketServer.TCPServer,
-                         SimpleXMLRPCDispatcher):
-    """Simple XML-RPC server.
-
-    Simple XML-RPC server that allows functions and a single instance
-    to be installed to handle requests. The default implementation
-    attempts to dispatch XML-RPC calls to the functions or instance
-    installed in the server. Override the _dispatch method inhereted
-    from SimpleXMLRPCDispatcher to change this behavior.
-    """
-
-    allow_reuse_address = True
-
-    # Warning: this is for debugging purposes only! Never set this to True in
-    # production code, as will be sending out sensitive information (exception
-    # and stack trace details) when exceptions are raised inside
-    # SimpleXMLRPCRequestHandler.do_POST
-    _send_traceback_header = False
-
-    def __init__(self, addr, requestHandler=SimpleXMLRPCRequestHandler,
-                 logRequests=True, allow_none=False, encoding=None, bind_and_activate=True):
-        self.logRequests = logRequests
-
-        SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
-        SocketServer.TCPServer.__init__(self, addr, requestHandler, bind_and_activate)
-
-        # [Bug #1222790] If possible, set close-on-exec flag; if a
-        # method spawns a subprocess, the subprocess shouldn't have
-        # the listening socket open.
-        if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
-            flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
-            flags |= fcntl.FD_CLOEXEC
-            fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
-
-class CGIXMLRPCRequestHandler(SimpleXMLRPCDispatcher):
-    """Simple handler for XML-RPC data passed through CGI."""
-
-    def __init__(self, allow_none=False, encoding=None):
-        SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
-
-    def handle_xmlrpc(self, request_text):
-        """Handle a single XML-RPC request"""
-
-        response = self._marshaled_dispatch(request_text)
-
-        print 'Content-Type: text/xml'
-        print 'Content-Length: %d' % len(response)
-        print
-        sys.stdout.write(response)
-
-    def handle_get(self):
-        """Handle a single HTTP GET request.
-
-        Default implementation indicates an error because
-        XML-RPC uses the POST method.
-        """
-
-        code = 400
-        message, explain = \
-                 BaseHTTPServer.BaseHTTPRequestHandler.responses[code]
-
-        response = BaseHTTPServer.DEFAULT_ERROR_MESSAGE % \
-            {
-             'code' : code,
-             'message' : message,
-             'explain' : explain
-            }
-        print 'Status: %d %s' % (code, message)
-        print 'Content-Type: text/html'
-        print 'Content-Length: %d' % len(response)
-        print
-        sys.stdout.write(response)
-
-    def handle_request(self, request_text = None):
-        """Handle a single XML-RPC request passed through a CGI post method.
-
-        If no XML data is given then it is read from stdin. The resulting
-        XML-RPC response is printed to stdout along with the correct HTTP
-        headers.
-        """
-
-        if request_text is None and \
-            os.environ.get('REQUEST_METHOD', None) == 'GET':
-            self.handle_get()
-        else:
-            # POST data is normally available through stdin
-            if request_text is None:
-                request_text = sys.stdin.read()
-
-            self.handle_xmlrpc(request_text)
-
-if __name__ == '__main__':
-    print 'Running XML-RPC server on port 8000'
-    server = SimpleXMLRPCServer(("localhost", 8000))
-    server.register_function(pow)
-    server.register_function(lambda x,y: x+y, 'add')
-    server.serve_forever()

=== removed file 'python25-compat/SocketServer.py'
--- python25-compat/SocketServer.py	2009-09-10 00:02:41 +0000
+++ python25-compat/SocketServer.py	1970-01-01 00:00:00 +0000
@@ -1,681 +0,0 @@
-"""Generic socket server classes.
-
-This module tries to capture the various aspects of defining a server:
-
-For socket-based servers:
-
-- address family:
-        - AF_INET{,6}: IP (Internet Protocol) sockets (default)
-        - AF_UNIX: Unix domain sockets
-        - others, e.g. AF_DECNET are conceivable (see <socket.h>
-- socket type:
-        - SOCK_STREAM (reliable stream, e.g. TCP)
-        - SOCK_DGRAM (datagrams, e.g. UDP)
-
-For request-based servers (including socket-based):
-
-- client address verification before further looking at the request
-        (This is actually a hook for any processing that needs to look
-         at the request before anything else, e.g. logging)
-- how to handle multiple requests:
-        - synchronous (one request is handled at a time)
-        - forking (each request is handled by a new process)
-        - threading (each request is handled by a new thread)
-
-The classes in this module favor the server type that is simplest to
-write: a synchronous TCP/IP server.  This is bad class design, but
-save some typing.  (There's also the issue that a deep class hierarchy
-slows down method lookups.)
-
-There are five classes in an inheritance diagram, four of which represent
-synchronous servers of four types:
-
-        +------------+
-        | BaseServer |
-        +------------+
-              |
-              v
-        +-----------+        +------------------+
-        | TCPServer |------->| UnixStreamServer |
-        +-----------+        +------------------+
-              |
-              v
-        +-----------+        +--------------------+
-        | UDPServer |------->| UnixDatagramServer |
-        +-----------+        +--------------------+
-
-Note that UnixDatagramServer derives from UDPServer, not from
-UnixStreamServer -- the only difference between an IP and a Unix
-stream server is the address family, which is simply repeated in both
-unix server classes.
-
-Forking and threading versions of each type of server can be created
-using the ForkingMixIn and ThreadingMixIn mix-in classes.  For
-instance, a threading UDP server class is created as follows:
-
-        class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass
-
-The Mix-in class must come first, since it overrides a method defined
-in UDPServer! Setting the various member variables also changes
-the behavior of the underlying server mechanism.
-
-To implement a service, you must derive a class from
-BaseRequestHandler and redefine its handle() method.  You can then run
-various versions of the service by combining one of the server classes
-with your request handler class.
-
-The request handler class must be different for datagram or stream
-services.  This can be hidden by using the request handler
-subclasses StreamRequestHandler or DatagramRequestHandler.
-
-Of course, you still have to use your head!
-
-For instance, it makes no sense to use a forking server if the service
-contains state in memory that can be modified by requests (since the
-modifications in the child process would never reach the initial state
-kept in the parent process and passed to each child).  In this case,
-you can use a threading server, but you will probably have to use
-locks to avoid two requests that come in nearly simultaneous to apply
-conflicting changes to the server state.
-
-On the other hand, if you are building e.g. an HTTP server, where all
-data is stored externally (e.g. in the file system), a synchronous
-class will essentially render the service "deaf" while one request is
-being handled -- which may be for a very long time if a client is slow
-to reqd all the data it has requested.  Here a threading or forking
-server is appropriate.
-
-In some cases, it may be appropriate to process part of a request
-synchronously, but to finish processing in a forked child depending on
-the request data.  This can be implemented by using a synchronous
-server and doing an explicit fork in the request handler class
-handle() method.
-
-Another approach to handling multiple simultaneous requests in an
-environment that supports neither threads nor fork (or where these are
-too expensive or inappropriate for the service) is to maintain an
-explicit table of partially finished requests and to use select() to
-decide which request to work on next (or whether to handle a new
-incoming request).  This is particularly important for stream services
-where each client can potentially be connected for a long time (if
-threads or subprocesses cannot be used).
-
-Future work:
-- Standard classes for Sun RPC (which uses either UDP or TCP)
-- Standard mix-in classes to implement various authentication
-  and encryption schemes
-- Standard framework for select-based multiplexing
-
-XXX Open problems:
-- What to do with out-of-band data?
-
-BaseServer:
-- split generic "request" functionality out into BaseServer class.
-  Copyright (C) 2000  Luke Kenneth Casson Leighton <[e-mail]>
-
-  example: read entries from a SQL database (requires overriding
-  get_request() to return a table entry from the database).
-  entry is processed by a RequestHandlerClass.
-
-"""
-
-# Author of the BaseServer patch: Luke Kenneth Casson Leighton
-
-# XXX Warning!
-# There is a test suite for this module, but it cannot be run by the
-# standard regression test.
-# To run it manually, run Lib/test/test_socketserver.py.
-
-__version__ = "0.4"
-
-
-import socket
-import select
-import sys
-import os
-try:
-    import threading
-except ImportError:
-    import dummy_threading as threading
-
-__all__ = ["TCPServer","UDPServer","ForkingUDPServer","ForkingTCPServer",
-           "ThreadingUDPServer","ThreadingTCPServer","BaseRequestHandler",
-           "StreamRequestHandler","DatagramRequestHandler",
-           "ThreadingMixIn", "ForkingMixIn"]
-if hasattr(socket, "AF_UNIX"):
-    __all__.extend(["UnixStreamServer","UnixDatagramServer",
-                    "ThreadingUnixStreamServer",
-                    "ThreadingUnixDatagramServer"])
-
-class BaseServer:
-
-    """Base class for server classes.
-
-    Methods for the caller:
-
-    - __init__(server_address, RequestHandlerClass)
-    - serve_forever(poll_interval=0.5)
-    - shutdown()
-    - handle_request()  # if you do not use serve_forever()
-    - fileno() -> int   # for select()
-
-    Methods that may be overridden:
-
-    - server_bind()
-    - server_activate()
-    - get_request() -> request, client_address
-    - handle_timeout()
-    - verify_request(request, client_address)
-    - server_close()
-    - process_request(request, client_address)
-    - close_request(request)
-    - handle_error()
-
-    Methods for derived classes:
-
-    - finish_request(request, client_address)
-
-    Class variables that may be overridden by derived classes or
-    instances:
-
-    - timeout
-    - address_family
-    - socket_type
-    - allow_reuse_address
-
-    Instance variables:
-
-    - RequestHandlerClass
-    - socket
-
-    """
-
-    timeout = None
-
-    def __init__(self, server_address, RequestHandlerClass):
-        """Constructor.  May be extended, do not override."""
-        self.server_address = server_address
-        self.RequestHandlerClass = RequestHandlerClass
-        self.__is_shut_down = threading.Event()
-        self.__serving = False
-
-    def server_activate(self):
-        """Called by constructor to activate the server.
-
-        May be overridden.
-
-        """
-        pass
-
-    def serve_forever(self, poll_interval=0.5):
-        """Handle one request at a time until shutdown.
-
-        Polls for shutdown every poll_interval seconds. Ignores
-        self.timeout. If you need to do periodic tasks, do them in
-        another thread.
-        """
-        self.__serving = True
-        self.__is_shut_down.clear()
-        while self.__serving:
-            # XXX: Consider using another file descriptor or
-            # connecting to the socket to wake this up instead of
-            # polling. Polling reduces our responsiveness to a
-            # shutdown request and wastes cpu at all other times.
-            r, w, e = select.select([self], [], [], poll_interval)
-            if r:
-                self._handle_request_noblock()
-        self.__is_shut_down.set()
-
-    def shutdown(self):
-        """Stops the serve_forever loop.
-
-        Blocks until the loop has finished. This must be called while
-        serve_forever() is running in another thread, or it will
-        deadlock.
-        """
-        self.__serving = False
-        self.__is_shut_down.wait()
-
-    # The distinction between handling, getting, processing and
-    # finishing a request is fairly arbitrary.  Remember:
-    #
-    # - handle_request() is the top-level call.  It calls
-    #   select, get_request(), verify_request() and process_request()
-    # - get_request() is different for stream or datagram sockets
-    # - process_request() is the place that may fork a new process
-    #   or create a new thread to finish the request
-    # - finish_request() instantiates the request handler class;
-    #   this constructor will handle the request all by itself
-
-    def handle_request(self):
-        """Handle one request, possibly blocking.
-
-        Respects self.timeout.
-        """
-        # Support people who used socket.settimeout() to escape
-        # handle_request before self.timeout was available.
-        timeout = self.socket.gettimeout()
-        if timeout is None:
-            timeout = self.timeout
-        elif self.timeout is not None:
-            timeout = min(timeout, self.timeout)
-        fd_sets = select.select([self], [], [], timeout)
-        if not fd_sets[0]:
-            self.handle_timeout()
-            return
-        self._handle_request_noblock()
-
-    def _handle_request_noblock(self):
-        """Handle one request, without blocking.
-
-        I assume that select.select has returned that the socket is
-        readable before this function was called, so there should be
-        no risk of blocking in get_request().
-        """
-        try:
-            request, client_address = self.get_request()
-        except socket.error:
-            return
-        if self.verify_request(request, client_address):
-            try:
-                self.process_request(request, client_address)
-            except:
-                self.handle_error(request, client_address)
-                self.close_request(request)
-
-    def handle_timeout(self):
-        """Called if no new request arrives within self.timeout.
-
-        Overridden by ForkingMixIn.
-        """
-        pass
-
-    def verify_request(self, request, client_address):
-        """Verify the request.  May be overridden.
-
-        Return True if we should proceed with this request.
-
-        """
-        return True
-
-    def process_request(self, request, client_address):
-        """Call finish_request.
-
-        Overridden by ForkingMixIn and ThreadingMixIn.
-
-        """
-        self.finish_request(request, client_address)
-        self.close_request(request)
-
-    def server_close(self):
-        """Called to clean-up the server.
-
-        May be overridden.
-
-        """
-        pass
-
-    def finish_request(self, request, client_address):
-        """Finish one request by instantiating RequestHandlerClass."""
-        self.RequestHandlerClass(request, client_address, self)
-
-    def close_request(self, request):
-        """Called to clean up an individual request."""
-        pass
-
-    def handle_error(self, request, client_address):
-        """Handle an error gracefully.  May be overridden.
-
-        The default is to print a traceback and continue.
-
-        """
-        print '-'*40
-        print 'Exception happened during processing of request from',
-        print client_address
-        import traceback
-        traceback.print_exc() # XXX But this goes to stderr!
-        print '-'*40
-
-
-class TCPServer(BaseServer):
-
-    """Base class for various socket-based server classes.
-
-    Defaults to synchronous IP stream (i.e., TCP).
-
-    Methods for the caller:
-
-    - __init__(server_address, RequestHandlerClass, bind_and_activate=True)
-    - serve_forever(poll_interval=0.5)
-    - shutdown()
-    - handle_request()  # if you don't use serve_forever()
-    - fileno() -> int   # for select()
-
-    Methods that may be overridden:
-
-    - server_bind()
-    - server_activate()
-    - get_request() -> request, client_address
-    - handle_timeout()
-    - verify_request(request, client_address)
-    - process_request(request, client_address)
-    - close_request(request)
-    - handle_error()
-
-    Methods for derived classes:
-
-    - finish_request(request, client_address)
-
-    Class variables that may be overridden by derived classes or
-    instances:
-
-    - timeout
-    - address_family
-    - socket_type
-    - request_queue_size (only for stream sockets)
-    - allow_reuse_address
-
-    Instance variables:
-
-    - server_address
-    - RequestHandlerClass
-    - socket
-
-    """
-
-    address_family = socket.AF_INET
-
-    socket_type = socket.SOCK_STREAM
-
-    request_queue_size = 5
-
-    allow_reuse_address = False
-
-    def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True):
-        """Constructor.  May be extended, do not override."""
-        BaseServer.__init__(self, server_address, RequestHandlerClass)
-        self.socket = socket.socket(self.address_family,
-                                    self.socket_type)
-        if bind_and_activate:
-            self.server_bind()
-            self.server_activate()
-
-    def server_bind(self):
-        """Called by constructor to bind the socket.
-
-        May be overridden.
-
-        """
-        if self.allow_reuse_address:
-            self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-        self.socket.bind(self.server_address)
-        self.server_address = self.socket.getsockname()
-
-    def server_activate(self):
-        """Called by constructor to activate the server.
-
-        May be overridden.
-
-        """
-        self.socket.listen(self.request_queue_size)
-
-    def server_close(self):
-        """Called to clean-up the server.
-
-        May be overridden.
-
-        """
-        self.socket.close()
-
-    def fileno(self):
-        """Return socket file number.
-
-        Interface required by select().
-
-        """
-        return self.socket.fileno()
-
-    def get_request(self):
-        """Get the request and client address from the socket.
-
-        May be overridden.
-
-        """
-        return self.socket.accept()
-
-    def close_request(self, request):
-        """Called to clean up an individual request."""
-        request.close()
-
-
-class UDPServer(TCPServer):
-
-    """UDP server class."""
-
-    allow_reuse_address = False
-
-    socket_type = socket.SOCK_DGRAM
-
-    max_packet_size = 8192
-
-    def get_request(self):
-        data, client_addr = self.socket.recvfrom(self.max_packet_size)
-        return (data, self.socket), client_addr
-
-    def server_activate(self):
-        # No need to call listen() for UDP.
-        pass
-
-    def close_request(self, request):
-        # No need to close anything.
-        pass
-
-class ForkingMixIn:
-
-    """Mix-in class to handle each request in a new process."""
-
-    timeout = 300
-    active_children = None
-    max_children = 40
-
-    def collect_children(self):
-        """Internal routine to wait for children that have exited."""
-        if self.active_children is None: return
-        while len(self.active_children) >= self.max_children:
-            # XXX: This will wait for any child process, not just ones
-            # spawned by this library. This could confuse other
-            # libraries that expect to be able to wait for their own
-            # children.
-            try:
-                pid, status = os.waitpid(0, options=0)
-            except os.error:
-                pid = None
-            if pid not in self.active_children: continue
-            self.active_children.remove(pid)
-
-        # XXX: This loop runs more system calls than it ought
-        # to. There should be a way to put the active_children into a
-        # process group and then use os.waitpid(-pgid) to wait for any
-        # of that set, but I couldn't find a way to allocate pgids
-        # that couldn't collide.
-        for child in self.active_children:
-            try:
-                pid, status = os.waitpid(child, os.WNOHANG)
-            except os.error:
-                pid = None
-            if not pid: continue
-            try:
-                self.active_children.remove(pid)
-            except ValueError, e:
-                raise ValueError('%s. x=%d and list=%r' % (e.message, pid,
-                                                           self.active_children))
-
-    def handle_timeout(self):
-        """Wait for zombies after self.timeout seconds of inactivity.
-
-        May be extended, do not override.
-        """
-        self.collect_children()
-
-    def process_request(self, request, client_address):
-        """Fork a new subprocess to process the request."""
-        self.collect_children()
-        pid = os.fork()
-        if pid:
-            # Parent process
-            if self.active_children is None:
-                self.active_children = []
-            self.active_children.append(pid)
-            self.close_request(request)
-            return
-        else:
-            # Child process.
-            # This must never return, hence os._exit()!
-            try:
-                self.finish_request(request, client_address)
-                os._exit(0)
-            except:
-                try:
-                    self.handle_error(request, client_address)
-                finally:
-                    os._exit(1)
-
-
-class ThreadingMixIn:
-    """Mix-in class to handle each request in a new thread."""
-
-    # Decides how threads will act upon termination of the
-    # main process
-    daemon_threads = False
-
-    def process_request_thread(self, request, client_address):
-        """Same as in BaseServer but as a thread.
-
-        In addition, exception handling is done here.
-
-        """
-        try:
-            self.finish_request(request, client_address)
-            self.close_request(request)
-        except:
-            self.handle_error(request, client_address)
-            self.close_request(request)
-
-    def process_request(self, request, client_address):
-        """Start a new thread to process the request."""
-        t = threading.Thread(target = self.process_request_thread,
-                             args = (request, client_address))
-        if self.daemon_threads:
-            t.setDaemon (1)
-        t.start()
-
-
-class ForkingUDPServer(ForkingMixIn, UDPServer): pass
-class ForkingTCPServer(ForkingMixIn, TCPServer): pass
-
-class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass
-class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass
-
-if hasattr(socket, 'AF_UNIX'):
-
-    class UnixStreamServer(TCPServer):
-        address_family = socket.AF_UNIX
-
-    class UnixDatagramServer(UDPServer):
-        address_family = socket.AF_UNIX
-
-    class ThreadingUnixStreamServer(ThreadingMixIn, UnixStreamServer): pass
-
-    class ThreadingUnixDatagramServer(ThreadingMixIn, UnixDatagramServer): pass
-
-class BaseRequestHandler:
-
-    """Base class for request handler classes.
-
-    This class is instantiated for each request to be handled.  The
-    constructor sets the instance variables request, client_address
-    and server, and then calls the handle() method.  To implement a
-    specific service, all you need to do is to derive a class which
-    defines a handle() method.
-
-    The handle() method can find the request as self.request, the
-    client address as self.client_address, and the server (in case it
-    needs access to per-server information) as self.server.  Since a
-    separate instance is created for each request, the handle() method
-    can define arbitrary other instance variariables.
-
-    """
-
-    def __init__(self, request, client_address, server):
-        self.request = request
-        self.client_address = client_address
-        self.server = server
-        try:
-            self.setup()
-            self.handle()
-            self.finish()
-        finally:
-            sys.exc_traceback = None    # Help garbage collection
-
-    def setup(self):
-        pass
-
-    def handle(self):
-        pass
-
-    def finish(self):
-        pass
-
-
-# The following two classes make it possible to use the same service
-# class for stream or datagram servers.
-# Each class sets up these instance variables:
-# - rfile: a file object from which receives the request is read
-# - wfile: a file object to which the reply is written
-# When the handle() method returns, wfile is flushed properly
-
-
-class StreamRequestHandler(BaseRequestHandler):
-
-    """Define self.rfile and self.wfile for stream sockets."""
-
-    # Default buffer sizes for rfile, wfile.
-    # We default rfile to buffered because otherwise it could be
-    # really slow for large data (a getc() call per byte); we make
-    # wfile unbuffered because (a) often after a write() we want to
-    # read and we need to flush the line; (b) big writes to unbuffered
-    # files are typically optimized by stdio even when big reads
-    # aren't.
-    rbufsize = -1
-    wbufsize = 0
-
-    def setup(self):
-        self.connection = self.request
-        self.rfile = self.connection.makefile('rb', self.rbufsize)
-        self.wfile = self.connection.makefile('wb', self.wbufsize)
-
-    def finish(self):
-        if not self.wfile.closed:
-            self.wfile.flush()
-        self.wfile.close()
-        self.rfile.close()
-
-
-class DatagramRequestHandler(BaseRequestHandler):
-
-    # XXX Regrettably, I cannot get this working on Linux;
-    # s.recvfrom() doesn't return a meaningful client address.
-
-    """Define self.rfile and self.wfile for datagram sockets."""
-
-    def setup(self):
-        try:
-            from cStringIO import StringIO
-        except ImportError:
-            from StringIO import StringIO
-        self.packet, self.socket = self.request
-        self.rfile = StringIO(self.packet)
-        self.wfile = StringIO()
-
-    def finish(self):
-        self.socket.sendto(self.wfile.getvalue(), self.client_address)

=== modified file 'setup.py'
--- setup.py	2017-02-21 15:53:48 +0000
+++ setup.py	2017-05-22 10:09:36 +0000
@@ -36,11 +36,8 @@
 from distutils.sysconfig import get_python_lib
 from setup_py2exe_custom import custom_py2exe, fixup_data_pytz_zoneinfo
 
-has_py2exe = False
 py2exe_keywords = {}
 if os.name == 'nt':
-    import py2exe
-    has_py2exe = True
     py2exe_keywords['console'] = [
         { "script": join("bin", "openerp-server.py"),
           "icon_resources": [(1, join("pixmaps","openerp-icon.ico"))]
@@ -54,31 +51,48 @@
             "collected_libs_dir": "libs",
             "collected_libs_data_relocate": "pytz",
             "package_build_extra_dirs": join(os.path.abspath(os.path.dirname(__file__)), "bin"),
-            "dist_dir": 'dist',
             "packages": [
                 "lxml", "lxml.builder", "lxml._elementpath", "lxml.etree",
                 "lxml.objectify", "decimal", "xml", "xml", "xml.dom",
                 "encodings", "dateutil", "wizard", "pychart", "PIL", "pyparsing",
-                "pydot", "asyncore","asynchat", "reportlab", "vobject",
+                "pydot", "asyncore","asynchat", "reportlab",
                 "HTMLParser", "select", "mako", "poplib",
-                "imaplib", "smtplib", "email", "yaml", "DAV",
+                "imaplib", "smtplib", "email", "yaml",
                 "uuid", "commands", "mx.DateTime", "json",
                 "pylzma", "xlwt", "passlib", "bcrypt", "six", "cffi",
             ],
-            "excludes" : ["Tkconstants","Tkinter","tcl"],
+            'dist_dir': 'dist',
+            'excludes' : ["Tkconstants","Tkinter","tcl"],
+            'dll_excludes': [
+                'w9xpopen.exe', 'PSAPI.dll', 'CRYPT32.dll', 'MPR.dll',
+                'Secur32.dll', 'SHFOLDER.dll',
+                'api-ms-win-core-delayload-l1-1-1.dll',
+                'api-ms-win-core-errorhandling-l1-1-1.dll',
+                'api-ms-win-core-heap-obsolete-l1-1-0.dll',
+                'api-ms-win-core-libraryloader-l1-2-0.dll',
+                'api-ms-win-core-processthreads-l1-1-2.dll',
+                'api-ms-win-core-profile-l1-1-0.dll',
+                'api-ms-win-core-string-obsolete-l1-1-0.dll',
+                'api-ms-win-core-sysinfo-l1-2-1.dll',
+                'api-ms-win-security-activedirectoryclient-l1-1-0.dll',
+            ],
         }
     }
 
 sys.path.append(join(os.path.abspath(os.path.dirname(__file__)), "bin"))
 
+# The following are all overridden in release.py
+name = None
+description = None
+long_desc = None
+url = None
+author = None
+author_email = None
+classifiers = None
+version = None
+
 execfile(join('bin', 'release.py'))
 
-if 'bdist_rpm' in sys.argv:
-    version = version.split('-')[0]
-
-# get python short version
-py_short_version = '%s.%s' % sys.version_info[:2]
-
 # backports os.walk with followlinks from python 2.6
 def walk_followlinks(top, topdown=True, onerror=None, followlinks=False):
     from os.path import join, isdir, islink
@@ -108,9 +122,6 @@
     if not topdown:
         yield top, dirs, nondirs
 
-if sys.version_info < (2, 6):
-    os.walk = walk_followlinks
-
 def find_addons():
     for root, _, names in os.walk(join('bin', 'addons'), followlinks=True):
         if '__openerp__.py' in names or '__terp__.py' in names:
@@ -152,8 +163,6 @@
         #for root, _, names in os.walk('pixmaps'):
         #    files.append((root, [join(root, name) for name in names]))
         files.append(('.', [join('bin', 'import_xml.rng'),]))
-        files.append(("Microsoft.VC90.CRT", glob.glob('C:\Microsoft.VC90.CRT\*.*')))
-        files.append((join('service','Microsoft.VC90.CRT'), glob.glob('C:\Microsoft.VC90.CRT\*.*')))
         files.extend(fixup_data_pytz_zoneinfo())
     else:
         man_directory = join('share', 'man')
@@ -171,11 +180,6 @@
 
         files.append((openerp_site_packages, [join('bin', 'import_xml.rng'),]))
 
-        if sys.version_info[0:2] == (2,5):
-            files.append((openerp_site_packages, [ join('python25-compat','BaseHTTPServer.py'),
-                                                   join('python25-compat','SimpleXMLRPCServer.py'),
-                                                   join('python25-compat','SocketServer.py')]))
-
         for addonname, add_path in find_addons():
             addon_path = join(get_python_lib(prefix=''), 'openerp-server','addons', addonname)
             for root, dirs, innerfiles in os.walk(add_path):
@@ -213,8 +217,6 @@
         install.run(self)
 
 
-
-
 setup(name             = name,
       version          = version,
       description      = description,
@@ -239,23 +241,22 @@
           '': ['*.yml', '*.xml', '*.po', '*.pot', '*.csv'],
       },
       package_dir      = find_package_dirs(),
+      python_requires = ">=2.7.13",
       install_requires = [
           'lxml==3.7.3',
-          'mako==0.2.5',
-          'python-dateutil==2.5.3',
-          'psycopg2==2.0.13',
-          'pydot==1.0.2',
-          'pytz==2010b0',
-          'reportlab==2.4',
+          'mako==1.0.6',
+          'python-dateutil==2.6.0',
+          'psycopg2==2.7.1',
+          'pydot==1.2.3',
+          'pytz==2017.2',
+          'pylzma==0.4.8',
+          'reportlab==3.4.0',
           'pyyaml==3.12',
           'egenix-mx-base==3.2.9',
-          'passlib==1.6.5',
-          'bcrypt==3.1.1',
-          'xlwt==1.1.2',
+          'passlib==1.7.1',
+          'bcrypt==3.1.3',
+          'xlwt==1.2.0',
       ],
-      extras_require={
-          'SSL' : ['pyopenssl'],
-      },
       **py2exe_keywords
       )
 

=== removed file 'ssl-cert.cfg'
--- ssl-cert.cfg	2010-11-23 13:58:44 +0000
+++ ssl-cert.cfg	1970-01-01 00:00:00 +0000
@@ -1,89 +0,0 @@
-# X.509 Certificate options
-#
-# DN options
-
-# The organization of the subject.
-organization = "Some organization."
-
-# The organizational unit of the subject.
-unit = "ERP dept."
-
-# The locality of the subject.
-# locality =
-
-# The state of the certificate owner.
-state = "State"
-
-# The country of the subject. Two letter code.
-country = BE
-
-# The common name of the certificate owner.
-cn = "Some company"
-
-# A user id of the certificate owner.
-#uid = "clauper"
-
-# If the supported DN OIDs are not adequate you can set
-# any OID here.
-# For example set the X.520 Title and the X.520 Pseudonym
-# by using OID and string pairs.
-#dn_oid = "2.5.4.12" "Dr." "2.5.4.65" "jackal"
-
-# This is deprecated and should not be used in new
-# certificates.
-# pkcs9_email = "[e-mail]"
-
-# The serial number of the certificate
-serial = 001
-
-# In how many days, counting from today, this certificate will expire.
-expiration_days = 700
-
-# X.509 v3 extensions
-
-# A dnsname in case of a WWW server.
-#dns_name = "www.none.org"
-#dns_name = "www.morethanone.org"
-
-# An IP address in case of a server.
-#ip_address = "192.168.1.1"
-
-# An email in case of a person
-email = "[e-mail]"