Merge branch 'master' of https://github.com/JulianEberius/redis-py

Conflicts:
	redis/connection.py
	tests/__init__.py
	tests/server_commands.py

Author: Samuel Charron

redis/client.py

@@ -2,7 +2,16 @@
 import datetime
 import time
 import warnings
-from itertools import imap, izip, starmap
+from itertools import starmap
+from redis.compat import (
+    basestring,
+    bytes,
+    imap,
+    izip,
+    long,
+    MAJOR_VERSION,
+    unicode,
+    )
 from redis.connection import ConnectionPool, UnixDomainSocketConnection
 from redis.exceptions import (
     ConnectionError,
@@ -109,7 +118,7 @@ def zset_score_pairs(response, **options):
         return response
     score_cast_func = options.get('score_cast_func', float)
     it = iter(response)
-    return zip(it, imap(score_cast_func, it))
+    return list(zip(it, imap(score_cast_func, it)))
 
 def int_or_none(response):
     if response is None:
@@ -463,7 +472,7 @@ def mget(self, keys, *args):
     def mset(self, mapping):
         "Sets each key in the ``mapping`` dict to its corresponding value"
         items = []
-        for pair in mapping.iteritems():
+        for pair in mapping.items():
             items.extend(pair)
         return self.execute_command('MSET', *items)
 
@@ -473,7 +482,7 @@ def msetnx(self, mapping):
         none of the keys are already set
         """
         items = []
-        for pair in mapping.iteritems():
+        for pair in mapping.items():
             items.extend(pair)
         return self.execute_command('MSETNX', *items)
 
@@ -857,7 +866,7 @@ def zadd(self, name, *args, **kwargs):
                 raise RedisError("ZADD requires an equal number of "
                                  "values and scores")
             pieces.extend(args)
-        for pair in kwargs.iteritems():
+        for pair in kwargs.items():
             pieces.append(pair[1])
             pieces.append(pair[0])
         return self.execute_command('ZADD', name, *pieces)
@@ -1085,7 +1094,7 @@ def hmset(self, name, mapping):
         if not mapping:
             raise DataError("'hmset' with 'mapping' of length 0")
         items = []
-        for pair in mapping.iteritems():
+        for pair in mapping.items():
             items.extend(pair)
         return self.execute_command('HMSET', name, *items)
 
@@ -1180,7 +1189,7 @@ def zadd(self, name, *args, **kwargs):
                 raise RedisError("ZADD requires an equal number of "
                                  "values and scores")
             pieces.extend(reversed(args))
-        for pair in kwargs.iteritems():
+        for pair in kwargs.items():
             pieces.append(pair[1])
             pieces.append(pair[0])
         return self.execute_command('ZADD', name, *pieces)

redis/compat.py

@@ -0,0 +1,27 @@
+import sys
+
+__all__ = ['basestring', 'bytes', 'imap', 'izip', 'long', 'unicode', 'unichr', 'xrange']
+
+MAJOR_VERSION = sys.version_info.major
+
+if MAJOR_VERSION >= 3:
+    basestring = str
+    bytes = bytes
+    imap = map
+    izip = zip
+    long = int
+    unichr = chr
+    unicode = str
+    xrange = range
+else:
+    from itertools import imap, izip
+
+    basestring = basestring
+    try:
+        bytes = bytes
+    except NameError:
+        bytes = str
+    long = long
+    unichr = unichr
+    unicode = unicode
+    xrange = xrange

redis/connection.py

@@ -1,5 +1,14 @@
 import socket
-from itertools import chain, imap
+import sys
+from itertools import chain
+from redis.compat import (
+    bytes,
+    imap,
+    long,
+    unicode,
+    xrange,
+    MAJOR_VERSION
+    )
 from redis.exceptions import (
     RedisError,
     ConnectionError,
@@ -8,10 +17,13 @@
     AuthenticationError
 )
 
-try:
-    from cStringIO import StringIO
-except ImportError:
-    from StringIO import StringIO
+if MAJOR_VERSION >= 3:
+    from io import StringIO
+else:
+    try:
+        from cStringIO import StringIO
+    except ImportError:
+        from StringIO import StringIO
 
 try:
     import hiredis
@@ -34,7 +46,11 @@ def __del__(self):
 
     def on_connect(self, connection):
         "Called when the socket connects"
-        self._fp = connection._sock.makefile('r')
+        if MAJOR_VERSION >= 3:
+            fmode = 'rb'
+        else:
+            fmode = 'r'
+        self._fp = connection._sock.makefile(fmode)
 
     def on_disconnect(self):
         "Called when the socket disconnects"
@@ -44,7 +60,7 @@ def on_disconnect(self):
 
     def read(self, length=None):
         """
-        Read a line from the socket is no length is specified,
+        Read a line from the socket if no length is specified,
         otherwise read ``length`` bytes. Always strip away the newlines.
         """
         try:
@@ -59,17 +75,28 @@ def read(self, length=None):
                         buf = StringIO()
                         while bytes_left > 0:
                             read_len = min(bytes_left, self.MAX_READ_LENGTH)
-                            buf.write(self._fp.read(read_len))
+                            if MAJOR_VERSION >= 3:
+                                buf.write(self._fp.read(read_len).decode("utf-8"))
+                            else:
+                                buf.write(self._fp.read(read_len))
                             bytes_left -= read_len
                         buf.seek(0)
-                        return buf.read(length)
+                        result = buf.read(length)
+                        return result
                     finally:
                         buf.close()
-                return self._fp.read(bytes_left)[:-2]
+                result = self._fp.read(bytes_left)[:-2]
+                if MAJOR_VERSION >= 3:
+                    result = result.decode()
+                return result
 
             # no length, read a full line
-            return self._fp.readline()[:-2]
-        except (socket.error, socket.timeout), e:
+            result = self._fp.readline()[:-2]
+            if MAJOR_VERSION >= 3:
+                result = result.decode()
+            return result
+        except (socket.error, socket.timeout):
+            e = sys.exc_info()[1]
             raise ConnectionError("Error while reading from socket: %s" % \
                 (e.args,))
 
@@ -139,7 +166,8 @@ def read_response(self):
         while response is False:
             try:
                 buffer = self._sock.recv(4096)
-            except (socket.error, socket.timeout), e:
+            except (socket.error, socket.timeout):
+                e = sys.exc_info()[1]
                 raise ConnectionError("Error while reading from socket: %s" % \
                     (e.args,))
             if not buffer:
@@ -185,7 +213,8 @@ def connect(self):
             return
         try:
             sock = self._connect()
-        except socket.error, e:
+        except socket.error:
+            e = sys.exc_info()[1]
             raise ConnectionError(self._error_message(e))
 
         self._sock = sock
@@ -240,8 +269,11 @@ def send_packed_command(self, command):
         if not self._sock:
             self.connect()
         try:
+            if MAJOR_VERSION >= 3:
+                command = command.encode()
             self._sock.sendall(command)
-        except socket.error, e:
+        except socket.error:
+            e = sys.exc_info()[1]
             self.disconnect()
             if len(e.args) == 1:
                 _errno, errmsg = 'UNKNOWN', e.args[0]
@@ -276,9 +308,23 @@ def encode(self, value):
 
     def pack_command(self, *args):
         "Pack a series of arguments into a value Redis command"
-        command = ['$%s\r\n%s\r\n' % (len(enc_value), enc_value)
-                   for enc_value in imap(self.encode, args)]
-        return '*%s\r\n%s' % (len(command), ''.join(command))
+
+        cmds = []
+        if MAJOR_VERSION >= 3:
+            for enc_value in imap(self.encode, args):
+                if isinstance(enc_value, bytes):
+                    cmds += ['$%s\r\n%s\r\n' % (len(enc_value),
+                                                enc_value.decode())]
+                else:
+                    cmds += ['$%s\r\n%s\r\n' % (len(enc_value),
+                                                 enc_value)]
+        else:
+            for enc_value in imap(self.encode, args):
+                cmds += ['$%s\r\n%s\r\n' % (len(enc_value),
+                                             enc_value)]
+
+        return '*%s\r\n%s' % (len(cmds), ''.join(cmds))
+
 
 class UnixDomainSocketConnection(Connection):
     def __init__(self, path='', db=0, password=None,

tests/__init__.py

@@ -1,9 +1,9 @@
 import unittest
-from server_commands import ServerCommandsTestCase
-from connection_pool import ConnectionPoolTestCase
-from pipeline import PipelineTestCase
-from lock import LockTestCase
-from pubsub import PubSubTestCase, PubSubRedisDownTestCase
+from tests.server_commands import ServerCommandsTestCase
+from tests.connection_pool import ConnectionPoolTestCase
+from tests.pipeline import PipelineTestCase
+from tests.lock import LockTestCase
+from tests.pubsub import PubSubTestCase, PubSubRedisDownTestCase
 
 use_hiredis = False
 try:

tests/pubsub.py

@@ -19,7 +19,7 @@ def test_channel_subscribe(self):
             )
         self.assertEquals(self.client.publish('foo', 'hello foo'), 1)
         self.assertEquals(
-            self.pubsub.listen().next(),
+            next(self.pubsub.listen()),
             {
                 'type': 'message',
                 'pattern': None,
@@ -39,7 +39,7 @@ def test_pattern_subscribe(self):
             )
         self.assertEquals(self.client.publish('foo', 'hello foo'), 1)
         self.assertEquals(
-            self.pubsub.listen().next(),
+            next(self.pubsub.listen()),
             {
                 'type': 'pmessage',
                 'pattern': 'fo*',

tests/server_commands.py

@@ -2,9 +2,17 @@
 import unittest
 import datetime
 import time
-from string import letters
 from distutils.version import StrictVersion
 from redis.client import parse_info
+from redis.compat import (
+    unichr,
+    unicode,
+    MAJOR_VERSION
+    )
+if MAJOR_VERSION >= 3:
+    from string import ascii_letters as letters
+else:
+    from string import letters
 
 class ServerCommandsTestCase(unittest.TestCase):
 
@@ -41,15 +49,19 @@ def test_get_and_set(self):
         self.assertEquals(self.client.get('a'), None)
         byte_string = 'value'
         integer = 5
-        unicode_string = unichr(3456) + u'abcd' + unichr(3421)
+        unicode_string = unichr(3456) + unicode('abcd') + unichr(3421)
         self.assert_(self.client.set('byte_string', byte_string))
         self.assert_(self.client.set('integer', 5))
         self.assert_(self.client.set('unicode_string', unicode_string))
         self.assertEquals(self.client.get('byte_string'), byte_string)
         self.assertEquals(self.client.get('integer'), str(integer))
-        self.assertEquals(
-                self.client.get('unicode_string').decode('utf-8'),
-                unicode_string)
+        if MAJOR_VERSION >= 3:
+                self.assertEquals(self.client.get("unicode_string"),
+                        unicode_string)
+        else:
+                self.assertEquals(
+                        self.client.get('unicode_string').decode('utf-8'),
+                        unicode_string)
 
     def test_getitem_and_setitem(self):
         self.client['a'] = 'bar'
@@ -122,7 +134,7 @@ def test_append(self):
         # real logic
         self.assertEquals(self.client.append('a', 'a1'), 2)
         self.assertEquals(self.client['a'], 'a1')
-        self.assert_(self.client.append('a', 'a2'), 4)
+        self.assertEqual(self.client.append('a', 'a2'), 4)
         self.assertEquals(self.client['a'], 'a1a2')
 
     def test_decr(self):
@@ -202,15 +214,15 @@ def test_mget(self):
     def test_mset(self):
         d = {'a': '1', 'b': '2', 'c': '3'}
         self.assert_(self.client.mset(d))
-        for k, v in d.iteritems():
+        for k,v in d.items():
             self.assertEquals(self.client[k], v)
 
     def test_msetnx(self):
         d = {'a': '1', 'b': '2', 'c': '3'}
         self.assert_(self.client.msetnx(d))
         d2 = {'a': 'x', 'd': '4'}
         self.assert_(not self.client.msetnx(d2))
-        for k, v in d.iteritems():
+        for k,v in d.items():
             self.assertEquals(self.client[k], v)
         self.assertEquals(self.client.get('d'), None)
 
@@ -957,7 +969,7 @@ def test_zunionstore(self):
 
     # HASHES
     def make_hash(self, key, d):
-        for k, v in d.iteritems():
+        for k,v in d.items():
             self.client.hset(key, k, v)
 
     def test_hget_and_hset(self):
@@ -1081,7 +1093,7 @@ def test_hkeys(self):
         h = {'a1': '1', 'a2': '2', 'a3': '3'}
         self.make_hash('a', h)
         keys = h.keys()
-        keys.sort()
+        keys = sorted(keys)
         remote_keys = self.client.hkeys('a')
         remote_keys.sort()
         self.assertEquals(keys, remote_keys)
@@ -1110,7 +1122,7 @@ def test_hvals(self):
         h = {'a1': '1', 'a2': '2', 'a3': '3'}
         self.make_hash('a', h)
         vals = h.values()
-        vals.sort()
+        vals = sorted(vals)
         remote_vals = self.client.hvals('a')
         remote_vals.sort()
         self.assertEquals(vals, remote_vals)
@@ -1253,7 +1265,7 @@ def test_binary_lists(self):
                    'foo\tbar\x07': '789',
                    }
         # fill in lists
-        for key, value in mapping.iteritems():
+        for key, value in mapping.items():
             for c in value:
                 self.assertTrue(self.client.rpush(key, c))
 
@@ -1301,7 +1313,7 @@ def test_large_responses(self):
         "The PythonParser has some special cases for return values > 1MB"
         # load up 5MB of data into a key
         data = []
-        for i in range(5000000/len(letters)):
+        for i in range(5000000//len(letters)):
             data.append(letters)
         data = ''.join(data)
         self.client.set('a', data)