Updates for Python 3.x compatibility

* Use `future` aliases for renamed packages
* Use `dict.items()` instead of `dict.iteritems()`
* Compare parsed URL in tests due to changed dict ordering
* Use `unicode_literals` from `__future__`

Author: robgolding

swiftype/swiftype.py

@@ -1,12 +1,21 @@
+from __future__ import unicode_literals
+
+from future.standard_library import install_aliases
+install_aliases()
+
 import anyjson
-import httplib
-import urllib
-import urlparse
 import base64
 import time
 import hashlib
+from urllib.parse import urlparse, urlunparse, urlencode
+
+try:
+    # VCRpy only works when `httplib` is imported directly on Python 2.x
+    import httplib
+except ImportError:
+    import http.client as httplib
 
-from version import VERSION
+from .version import VERSION
 
 USER_AGENT = 'Swiftype-Python/' + VERSION
 DEFAULT_API_HOST = 'api.swiftype.com'
@@ -80,41 +89,41 @@ def destroy_documents(self, engine_id, document_type_id, document_ids=[]):
 
   def search(self, engine_id, query, options={}):
     query_string = {'q': query}
-    full_query = dict(query_string.items() + options.items())
+    full_query = dict(list(query_string.items()) + list(options.items()))
     return self.conn._get(self.__search_path(engine_id), data=full_query)
 
   def search_document_type(self, engine_id, document_type_id, query, options={}):
     query_string = {'q': query}
-    full_query = dict(query_string.items() + options.items())
+    full_query = dict(list(query_string.items()) + list(options.items()))
     return self.conn._get(self.__document_type_search_path(engine_id, document_type_id), data=full_query)
 
   def suggest(self, engine_id, query, options={}):
     query_string = {'q': query}
-    full_query = dict(query_string.items() + options.items())
+    full_query = dict(list(query_string.items()) + list(options.items()))
     return self.conn._get(self.__suggest_path(engine_id), data=full_query)
 
   def suggest_document_type(self, engine_id, document_type_id, query, options={}):
     query_string = {'q': query}
-    full_query = dict(query_string.items() + options.items())
+    full_query = dict(list(query_string.items()) + list(options.items()))
     return self.conn._get(self.__document_type_suggest_path(engine_id, document_type_id), data=full_query)
 
   def analytics_searches(self, engine_id, start_date=None, end_date=None):
-    params = dict((k,v) for k,v in {'start_date': start_date, 'end_date': end_date}.iteritems() if v is not None)
+    params = dict((k,v) for k,v in {'start_date': start_date, 'end_date': end_date}.items() if v is not None)
     return self.conn._get(self.__analytics_path(engine_id) + '/searches', params)
 
   def analytics_autoselects(self, engine_id, start_date=None, end_date=None):
-    params = dict((k,v) for k,v in {'start_date': start_date, 'end_date': end_date}.iteritems() if v is not None)
+    params = dict((k,v) for k,v in {'start_date': start_date, 'end_date': end_date}.items() if v is not None)
     return self.conn._get(self.__analytics_path(engine_id) + '/autoselects', params)
 
   def analytics_top_queries(self, engine_id, page=None, per_page=None):
     return self.conn._get(self.__analytics_path(engine_id) + '/top_queries', self.__pagination_params(page, per_page))
 
   def analytics_top_queries_in_range(self, engine_id, start_date=None, end_date=None):
-    params = dict((k,v) for k,v in {'start_date': start_date, 'end_date': end_date}.iteritems() if v is not None)
+    params = dict((k,v) for k,v in {'start_date': start_date, 'end_date': end_date}.items() if v is not None)
     return self.conn._get(self.__analytics_path(engine_id) + '/top_queries_in_range', params)
 
   def analytics_top_no_result_queries(self, engine_id, start_date=None, end_date=None):
-    params = dict((k,v) for k,v in {'start_date': start_date, 'end_date': end_date}.iteritems() if v is not None)
+    params = dict((k,v) for k,v in {'start_date': start_date, 'end_date': end_date}.items() if v is not None)
     return self.conn._get(self.__analytics_path(engine_id) + '/top_no_result_queries_in_range', params)
 
   def domains(self, engine_id):
@@ -137,7 +146,7 @@ def crawl_url(self, engine_id, domain_id, url):
 
   def users(self, page=None, per_page=None):
     params = {'client_id': self.client_id, 'client_secret': self.client_secret}
-    return self.conn._get(self.__users_path(), dict(params.items() + self.__pagination_params(page, per_page).items()))
+    return self.conn._get(self.__users_path(), dict(list(params.items()) + list(self.__pagination_params(page, per_page).items())))
 
   def user(self, user_id):
     params = {'client_id': self.client_id, 'client_secret': self.client_secret}
@@ -150,10 +159,12 @@ def create_user(self):
   def sso_url(self, user_id):
     timestamp = self._get_timestamp()
     params = {'user_id': user_id, 'client_id': self.client_id, 'timestamp': timestamp, 'token': self._sso_token(user_id, timestamp)}
-    return urlparse.urlunparse(('https', 'swiftype.com', '/sso', '', urllib.urlencode(params), ''))
+    return urlunparse(('https', 'swiftype.com', '/sso', '', urlencode(params), ''))
 
   def _sso_token(self, user_id, timestamp):
-    return hashlib.sha1('%s:%s:%s' % (user_id, self.client_secret, timestamp)).hexdigest()
+    return hashlib.sha1((
+        '%s:%s:%s' % (user_id, self.client_secret, timestamp)
+    ).encode('utf-8')).hexdigest()
 
   def _get_timestamp(self):
     return int(time.time())
@@ -175,7 +186,7 @@ def __users_path(self): return 'users'
   def __user_path(self, user_id): return 'users/%s' % (user_id)
 
   def __pagination_params(self, page, per_page):
-    return dict((k,v) for k,v in {'page': page, 'per_page': per_page}.iteritems() if v is not None)
+    return dict((k,v) for k,v in {'page': page, 'per_page': per_page}.items() if v is not None)
 
 class HttpException(Exception):
     def __init__(self, status, msg):
@@ -224,7 +235,7 @@ def _request(self, method, path, params={}, data={}):
       raise Unauthorized('Authorization required.')
 
     full_path = self.__base_path + path + '.json'
-    query = urllib.urlencode(params, True)
+    query = urlencode(params, True)
     if query:
       full_path += '?' + query
 
@@ -235,11 +246,11 @@ def _request(self, method, path, params={}, data={}):
 
     response = connection.getresponse()
     response.body = response.read()
-    if (response.status / 100 == 2):
+    if (response.status // 100 == 2):
         if response.body:
             try:
-                response.body = anyjson.deserialize(response.body)
-            except ValueError, e:
+                response.body = anyjson.deserialize(response.body.decode('utf-8'))
+            except ValueError as e:
                 raise InvalidResponseFromServer('The JSON response could not be parsed: %s.\n%s' % (e, response.body))
             ret = {'status': response.status, 'body':response.body }
         else:

tests/test_swiftype.py

@@ -2,6 +2,7 @@
 import os
 import time
 import unittest2 as unittest
+from urllib.parse import urlparse, parse_qs
 import vcr
 from mock import Mock
 
@@ -269,14 +270,14 @@ def __is_expected_search_result(self, request, document_type_count, args=[]):
     def __is_expected_result(self, request, status_code, expected_values, *args):
         response = request(*args)
         self.assertEqual(response['status'], status_code)
-        for k,v in expected_values.iteritems():
+        for k,v in expected_values.items():
             self.assertEqual(response['body'][k], v)
 
     def __is_expected_collection(self, request, status_code, collection_length, expected_values, *args):
         response = request(*args)
         self.assertEqual(response['status'], status_code)
         self.assertEqual(len(response['body']), collection_length)
-        for k,v in expected_values.iteritems():
+        for k,v in expected_values.items():
             self.assertEqual(len([item for item in response['body'] if item[k] == v]), 1)
 
     def __time_name(self):
@@ -331,7 +332,15 @@ def test_sso_url(self):
         self.client._get_timestamp = Mock(return_value=1379382520)
         user_id = '5064a7de2ed960e715000276'
         url = self.client.sso_url(user_id)
-        self.assertEqual(url, 'https://swiftype.com/sso?timestamp=1379382520&token=81033d182ad51f231cc9cda9fb24f2298a411437&user_id=5064a7de2ed960e715000276&client_id=3e4fd842fc99aecb4dc50e5b88a186c1e206ddd516cdd336da3622c4afd7e2e9')
+        self.assertEqual(
+            parse_qs(urlparse(url).query),
+            {
+                'user_id': ['5064a7de2ed960e715000276'],
+                'client_id': ['3e4fd842fc99aecb4dc50e5b88a186c1e206ddd516cdd336da3622c4afd7e2e9'],
+                'token': ['81033d182ad51f231cc9cda9fb24f2298a411437'],
+                'timestamp': ['1379382520'],
+            },
+        )
 
 class TestPlatformResources(unittest.TestCase):