Rip out Python 2.7 and 3.3 support

This is based on #210, but applied to the rewrite branch.

.travis.yml

@@ -1,8 +1,6 @@
 language: python
 python:
-  - 2.6
   - 2.7
-  - 3.3
   - 3.4
   - 3.5
   - 3.6
@@ -20,7 +18,6 @@ cache:
 services:
   - redis-server
 install:
-  - if [[ $TRAVIS_PYTHON_VERSION == '2.6' ]]; then pip install -r requirements-26.txt; fi
   - pip install -r requirements.txt
   - pip install coverage python-coveralls
 before_script:

fakeredis/server.py

@@ -448,7 +448,7 @@ def decode(cls, value):
 
     def __str__(self):
         if self.exclusive:
-            return '({0!r}'.format(self.value)
+            return '({!r}'.format(self.value)
         else:
             return repr(self.value)
 
@@ -2150,7 +2150,7 @@ def _convert_redis_result(self, lua_runtime, result):
         elif isinstance(result, redis.ResponseError):
             raise result
         else:
-            raise RuntimeError("Unexpected return type from redis: {0}".format(type(result)))
+            raise RuntimeError("Unexpected return type from redis: {}".format(type(result)))
 
     def _convert_lua_result(self, result, nested=True):
         from lupa import lua_type

requirements.txt

@@ -1,5 +1,8 @@
-# Flake8 3.0.0 does not support Python 2.6.
-flake8<3.0.0
+flake8==3.6.0
+configparser-3.5.0
+mccabe==0.6.1
+pycodestyle==2.4.0
+pyflakes==2.0.0
 attrs==18.2.0
 enum34==1.1.6; python_version<"3"
 nose==1.3.7

setup.py

@@ -20,10 +20,8 @@
         'Development Status :: 5 - Production/Stable',
         'License :: OSI Approved :: BSD License',
         'Programming Language :: Python :: 2',
-        'Programming Language :: Python :: 2.6',
         'Programming Language :: Python :: 2.7',
         'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.3',
         'Programming Language :: Python :: 3.4',
         'Programming Language :: Python :: 3.5',
         'Programming Language :: Python :: 3.6',

test_fakeredis.py

@@ -7,6 +7,7 @@
 import os
 import sys
 import threading
+import unittest
 
 import six
 from six.moves.queue import Queue
@@ -21,11 +22,6 @@
 if not six.PY2:
     long = int
 
-if sys.version_info[:2] == (2, 6):
-    import unittest2 as unittest
-else:
-    import unittest
-
 
 REDIS3 = int(redis.__version__.split('.')[0]) >= 3
 
@@ -63,8 +59,8 @@ def wrapper(*args, **kwargs):
 
 
 def key_val_dict(size=100):
-    return dict([(b'key:' + bytes([i]), b'val:' + bytes([i]))
-                 for i in range(size)])
+    return {b'key:' + bytes([i]): b'val:' + bytes([i])
+            for i in range(size)}
 
 
 class TestFakeStrictRedis(unittest.TestCase):
@@ -1195,8 +1191,8 @@ def test_hexists_wrong_type(self):
     def test_hkeys(self):
         self.redis.hset('foo', 'k1', 'v1')
         self.redis.hset('foo', 'k2', 'v2')
-        self.assertEqual(set(self.redis.hkeys('foo')), set([b'k1', b'k2']))
-        self.assertEqual(set(self.redis.hkeys('bar')), set([]))
+        self.assertEqual(set(self.redis.hkeys('foo')), {b'k1', b'k2'})
+        self.assertEqual(set(self.redis.hkeys('bar')), set())
 
     def test_hkeys_wrong_type(self):
         self.zadd('foo', {'bar': 1})
@@ -1216,8 +1212,8 @@ def test_hlen_wrong_type(self):
     def test_hvals(self):
         self.redis.hset('foo', 'k1', 'v1')
         self.redis.hset('foo', 'k2', 'v2')
-        self.assertEqual(set(self.redis.hvals('foo')), set([b'v1', b'v2']))
-        self.assertEqual(set(self.redis.hvals('bar')), set([]))
+        self.assertEqual(set(self.redis.hvals('foo')), {b'v1', b'v2'})
+        self.assertEqual(set(self.redis.hvals('bar')), set())
 
     def test_hvals_wrong_type(self):
         self.zadd('foo', {'bar': 1})
@@ -1362,17 +1358,17 @@ def test_empty_hash(self):
     def test_sadd(self):
         self.assertEqual(self.redis.sadd('foo', 'member1'), 1)
         self.assertEqual(self.redis.sadd('foo', 'member1'), 0)
-        self.assertEqual(self.redis.smembers('foo'), set([b'member1']))
+        self.assertEqual(self.redis.smembers('foo'), {b'member1'})
         self.assertEqual(self.redis.sadd('foo', 'member2', 'member3'), 2)
         self.assertEqual(self.redis.smembers('foo'),
-                         set([b'member1', b'member2', b'member3']))
+                         {b'member1', b'member2', b'member3'})
         self.assertEqual(self.redis.sadd('foo', 'member3', 'member4'), 1)
         self.assertEqual(self.redis.smembers('foo'),
-                         set([b'member1', b'member2', b'member3', b'member4']))
+                         {b'member1', b'member2', b'member3', b'member4'})
 
     def test_sadd_as_str_type(self):
         self.assertEqual(self.redis.sadd('foo', *range(3)), 3)
-        self.assertEqual(self.redis.smembers('foo'), set([b'0', b'1', b'2']))
+        self.assertEqual(self.redis.smembers('foo'), {b'0', b'1', b'2'})
 
     def test_sadd_wrong_type(self):
         self.zadd('foo', {'member': 1})
@@ -1387,11 +1383,11 @@ def test_scan_iter_single_page(self):
         self.redis.set('foo1', 'bar1')
         self.redis.set('foo2', 'bar2')
         self.assertEqual(set(self.redis.scan_iter(match="foo*")),
-                         set([b'foo1', b'foo2']))
+                         {b'foo1', b'foo2'})
         self.assertEqual(set(self.redis.scan_iter()),
-                         set([b'foo1', b'foo2']))
+                         {b'foo1', b'foo2'})
         self.assertEqual(set(self.redis.scan_iter(match="")),
-                         set([]))
+                         set())
 
     def test_scan_iter_multiple_pages(self):
         all_keys = key_val_dict(size=100)
@@ -1451,18 +1447,18 @@ def test_sdiff(self):
         self.redis.sadd('foo', 'member2')
         self.redis.sadd('bar', 'member2')
         self.redis.sadd('bar', 'member3')
-        self.assertEqual(self.redis.sdiff('foo', 'bar'), set([b'member1']))
+        self.assertEqual(self.redis.sdiff('foo', 'bar'), {b'member1'})
         # Original sets shouldn't be modified.
         self.assertEqual(self.redis.smembers('foo'),
-                         set([b'member1', b'member2']))
+                         {b'member1', b'member2'})
         self.assertEqual(self.redis.smembers('bar'),
-                         set([b'member2', b'member3']))
+                         {b'member2', b'member3'})
 
     def test_sdiff_one_key(self):
         self.redis.sadd('foo', 'member1')
         self.redis.sadd('foo', 'member2')
         self.assertEqual(self.redis.sdiff('foo'),
-                         set([b'member1', b'member2']))
+                         {b'member1', b'member2'})
 
     def test_sdiff_empty(self):
         self.assertEqual(self.redis.sdiff('foo'), set())
@@ -1509,9 +1505,9 @@ def test_sinter(self):
         self.redis.sadd('foo', 'member2')
         self.redis.sadd('bar', 'member2')
         self.redis.sadd('bar', 'member3')
-        self.assertEqual(self.redis.sinter('foo', 'bar'), set([b'member2']))
+        self.assertEqual(self.redis.sinter('foo', 'bar'), {b'member2'})
         self.assertEqual(self.redis.sinter('foo'),
-                         set([b'member1', b'member2']))
+                         {b'member1', b'member2'})
 
     def test_sinter_bytes_keys(self):
         foo = os.urandom(10)
@@ -1520,8 +1516,8 @@ def test_sinter_bytes_keys(self):
         self.redis.sadd(foo, 'member2')
         self.redis.sadd(bar, 'member2')
         self.redis.sadd(bar, 'member3')
-        self.assertEqual(self.redis.sinter(foo, bar), set([b'member2']))
-        self.assertEqual(self.redis.sinter(foo), set([b'member1', b'member2']))
+        self.assertEqual(self.redis.sinter(foo, bar), {b'member2'})
+        self.assertEqual(self.redis.sinter(foo), {b'member1', b'member2'})
 
     def test_sinter_wrong_type(self):
         self.zadd('foo', {'member': 1})
@@ -1576,7 +1572,7 @@ def test_smove(self):
         self.redis.sadd('foo', 'member1')
         self.redis.sadd('foo', 'member2')
         self.assertEqual(self.redis.smove('foo', 'bar', 'member1'), True)
-        self.assertEqual(self.redis.smembers('bar'), set([b'member1']))
+        self.assertEqual(self.redis.smembers('bar'), {b'member1'})
 
     def test_smove_non_existent_key(self):
         self.assertEqual(self.redis.smove('foo', 'bar', 'member1'), False)
@@ -1587,7 +1583,7 @@ def test_move_wrong_type(self):
         with self.assertRaises(redis.ResponseError):
             self.redis.smove('bar', 'foo', 'member')
         # Must raise the error before removing member from bar
-        self.assertEqual(self.redis.smembers('bar'), set([b'member']))
+        self.assertEqual(self.redis.smembers('bar'), {b'member'})
         with self.assertRaises(redis.ResponseError):
             self.redis.smove('foo', 'bar', 'member')
 
@@ -1615,15 +1611,15 @@ def test_srandmember_number(self):
         self.assertEqual(self.redis.srandmember('foo', 2), [b'member1'])
         self.redis.sadd('foo', b'member2')
         self.assertEqual(set(self.redis.srandmember('foo', 2)),
-                         set([b'member1', b'member2']))
+                         {b'member1', b'member2'})
         self.redis.sadd('foo', b'member3')
         res = self.redis.srandmember('foo', 2)
         self.assertEqual(len(res), 2)
 
         if self.decode_responses:
-            superset = set(['member1', 'member2', 'member3'])
+            superset = {'member1', 'member2', 'member3'}
         else:
-            superset = set([b'member1', b'member2', b'member3'])
+            superset = {b'member1', b'member2', b'member3'}
 
         for e in res:
             self.assertIn(e, superset)
@@ -1636,16 +1632,16 @@ def test_srandmember_wrong_type(self):
     def test_srem(self):
         self.redis.sadd('foo', 'member1', 'member2', 'member3', 'member4')
         self.assertEqual(self.redis.smembers('foo'),
-                         set([b'member1', b'member2', b'member3', b'member4']))
+                         {b'member1', b'member2', b'member3', b'member4'})
         self.assertEqual(self.redis.srem('foo', 'member1'), True)
         self.assertEqual(self.redis.smembers('foo'),
-                         set([b'member2', b'member3', b'member4']))
+                         {b'member2', b'member3', b'member4'})
         self.assertEqual(self.redis.srem('foo', 'member1'), False)
         # Since redis>=2.7.6 returns number of deleted items.
         self.assertEqual(self.redis.srem('foo', 'member2', 'member3'), 2)
-        self.assertEqual(self.redis.smembers('foo'), set([b'member4']))
+        self.assertEqual(self.redis.smembers('foo'), {b'member4'})
         self.assertEqual(self.redis.srem('foo', 'member3', 'member4'), True)
-        self.assertEqual(self.redis.smembers('foo'), set([]))
+        self.assertEqual(self.redis.smembers('foo'), set())
         self.assertEqual(self.redis.srem('foo', 'member3', 'member4'), False)
 
     def test_srem_wrong_type(self):
@@ -1659,7 +1655,7 @@ def test_sunion(self):
         self.redis.sadd('bar', 'member2')
         self.redis.sadd('bar', 'member3')
         self.assertEqual(self.redis.sunion('foo', 'bar'),
-                         set([b'member1', b'member2', b'member3']))
+                         {b'member1', b'member2', b'member3'})
 
     def test_sunion_wrong_type(self):
         self.zadd('foo', {'member': 1})
@@ -1676,7 +1672,7 @@ def test_sunionstore(self):
         self.redis.sadd('bar', 'member3')
         self.assertEqual(self.redis.sunionstore('baz', 'foo', 'bar'), 3)
         self.assertEqual(self.redis.smembers('baz'),
-                         set([b'member1', b'member2', b'member3']))
+                         {b'member1', b'member2', b'member3'})
 
         # Catch instances where we store bytes and strings inconsistently
         # and thus baz = {b'member1', b'member2', b'member3', 'member3'}
@@ -4113,7 +4109,7 @@ def _decode(cls, value):
         elif isinstance(value, tuple):
             return tuple([cls._decode(item) for item in value])
         elif isinstance(value, set):
-            return set(cls._decode(item) for item in value)
+            return {cls._decode(item) for item in value}
         elif isinstance(value, dict):
             return {cls._decode(k): cls._decode(v) for k, v in value.items()}
         elif isinstance(value, bytes):

tox.ini

@@ -1,5 +1,5 @@
 [tox]
-envlist = py26,py27,py33,py34,py35,py36,py3.7
+envlist = py27,py34,py35,py36,py3.7
 
 [testenv]
 usedevelop = True
@@ -8,11 +8,3 @@ extras = lua
 deps =
     nose
     hypothesis
-
-[testenv:py26]
-commands = nosetests -v {posargs}
-extras = lua
-deps =
-    nose
-    unittest2
-    hypothesis