Merge 9bed4e8 into 754c25d

rediscluster/client.py

@@ -34,7 +34,7 @@
 from redis import StrictRedis
 from redis.client import list_or_args, parse_info
 from redis.connection import Token
-from redis._compat import iteritems, basestring, b, izip, nativestr, long
+from redis._compat import iteritems, basestring, izip, nativestr, long
 from redis.exceptions import RedisError, ResponseError, TimeoutError, DataError, ConnectionError, BusyLoadingError
 
 
@@ -886,13 +886,13 @@ def sort(self, name, start=None, num=None, by=None, get=None, desc=False, alpha=
            (start is not None and num is None):
             raise RedisError("RedisError: ``start`` and ``num`` must both be specified")
         try:
-            data_type = b(self.type(name))
+            data_type = self.type(name)
 
-            if data_type == b("none"):
+            if data_type == b"none":
                 return []
-            elif data_type == b("set"):
+            elif data_type == b"set":
                 data = list(self.smembers(name))[:]
-            elif data_type == b("list"):
+            elif data_type == b"list":
                 data = self.lrange(name, 0, -1)
             else:
                 raise RedisClusterException("Unable to sort data type : {0}".format(data_type))
@@ -913,10 +913,10 @@ def sort(self, name, start=None, num=None, by=None, get=None, desc=False, alpha=
                 data = self._retrive_data_from_sort(data, get)
 
             if store is not None:
-                if data_type == b("set"):
+                if data_type == b"set":
                     self.delete(store)
                     self.rpush(store, *data)
-                elif data_type == b("list"):
+                elif data_type == b"list":
                     self.delete(store)
                     self.rpush(store, *data)
                 else:
@@ -969,7 +969,7 @@ def _get_single_item(self, k, g):
             single_item = k
         else:
             single_item = None
-        return b(single_item)
+        return single_item
 
     def _strtod_key_func(self, arg):
         """

rediscluster/nodemanager.py

@@ -9,7 +9,7 @@
 
 # 3rd party imports
 from redis import StrictRedis
-from redis._compat import b, unicode, bytes, long, basestring
+from redis.connection import Encoder
 from redis import ConnectionError, TimeoutError, ResponseError
 
 
@@ -37,34 +37,22 @@ def __init__(self, startup_nodes=None, reinitialize_steps=None, skip_full_covera
         self.reinitialize_steps = reinitialize_steps or 25
         self._skip_full_coverage_check = skip_full_coverage_check
         self.nodemanager_follow_cluster = nodemanager_follow_cluster
+        self.encoder = Encoder(
+            connection_kwargs.get('encoding', 'utf-8'),
+            connection_kwargs.get('encoding_errors', 'strict'),
+            connection_kwargs.get('decode_responses', False)
+        )
 
         if not self.startup_nodes:
             raise RedisClusterException("No startup nodes provided")
 
-    def encode(self, value):
-        """
-        Return a bytestring representation of the value.
-        This method is copied from Redis' connection.py:Connection.encode
-        """
-        if isinstance(value, bytes):
-            return value
-        elif isinstance(value, (int, long)):
-            value = b(str(value))
-        elif isinstance(value, float):
-            value = b(repr(value))
-        elif not isinstance(value, basestring):
-            value = unicode(value)
-        if isinstance(value, unicode):
-            # The encoding should be configurable as in connection.py:Connection.encode
-            value = value.encode('utf-8')
-        return value
-
     def keyslot(self, key):
         """
         Calculate keyslot for a given key.
         Tuned for compatibility with python 2.7.x
         """
-        k = self.encode(key)
+
+        k = self.encoder.encode(key)
 
         start = k.find(b"{")
 

tests/test_cluster_obj.py

@@ -16,7 +16,7 @@
 
 # 3rd party imports
 from mock import patch, Mock, MagicMock
-from redis._compat import b, unicode
+from redis._compat import unicode
 from redis import StrictRedis
 import pytest
 
@@ -392,7 +392,7 @@ def assert_moved_redirection_on_slave(sr, connection_pool_cls, cluster_obj):
         master_value = {'host': '127.0.0.1', 'name': '127.0.0.1:7000', 'port': 7000, 'server_type': 'master'}
         with patch.object(ClusterConnectionPool, 'get_master_node_by_slot') as return_master_mock:
             return_master_mock.return_value = master_value
-            assert cluster_obj.get('foo16706') == b('foo')
+            assert cluster_obj.get('foo16706') == b'foo'
             assert return_master_mock.call_count == 1
 
 
@@ -444,11 +444,11 @@ def test_access_correct_slave_with_readonly_mode_client(sr):
                 'get_master_node_by_slot',
                 return_value=master_value) as return_master_mock:
             readonly_client = StrictRedisCluster(host="127.0.0.1", port=7000, readonly_mode=True)
-            assert b('foo') == readonly_client.get('foo16706')
+            assert b'foo' == readonly_client.get('foo16706')
             assert return_master_mock.call_count == 0
 
             readonly_client = StrictRedisCluster.from_url(url="redis://127.0.0.1:7000/0", readonly_mode=True)
-            assert b('foo') == readonly_client.get('foo16706')
+            assert b'foo' == readonly_client.get('foo16706')
             assert return_master_mock.call_count == 0