Drop support for EOL Python 2.6 and 3.3

.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.py

@@ -29,9 +29,9 @@
 from redis.client import PubSubWorkerThread
 
 try:
-    # Python 2.6, 2.7
+    # Python 2.7
     from Queue import Queue, Empty
-except:
+except ImportError:
     # Python 3
     from queue import Queue, Empty
 
@@ -217,7 +217,7 @@ def _decode(value):
     elif isinstance(value, bytes):
         value = value.decode(DEFAULT_ENCODING)
     elif isinstance(value, dict):
-        value = dict((_decode(k), _decode(v)) for k, v in value.items())
+        value = {_decode(k): _decode(v) for k, v in value.items()}
     elif isinstance(value, (list, set, tuple)):
         value = value.__class__(_decode(x) for x in value)
     elif isinstance(value, types.GeneratorType):
@@ -1600,7 +1600,7 @@ def sadd(self, name, *values):
         "Add ``value`` to set ``name``"
         a_set = self._setdefault_set(name)
         card = len(a_set)
-        a_set |= set(to_bytes(x) for x in values)
+        a_set |= {to_bytes(x) for x in values}
         return len(a_set) - card
 
     @_locked
@@ -1625,7 +1625,7 @@ def sdiffstore(self, dest, keys, *args):
         set named ``dest``.  Returns the number of keys in the new set.
         """
         diff = self.sdiff(keys, *args)
-        self._db[dest] = set(to_bytes(x) for x in diff)
+        self._db[dest] = {to_bytes(x) for x in diff}
         return len(diff)
 
     @_locked
@@ -1645,7 +1645,7 @@ def sinterstore(self, dest, keys, *args):
         set named ``dest``.  Returns the number of keys in the new set.
         """
         intersect = self.sinter(keys, *args)
-        self._db[dest] = set(to_bytes(x) for x in intersect)
+        self._db[dest] = {to_bytes(x) for x in intersect}
         return len(intersect)
 
     @_locked
@@ -1716,7 +1716,7 @@ def srem(self, name, *values):
         "Remove ``value`` from set ``name``"
         a_set = self._setdefault_set(name)
         card = len(a_set)
-        a_set -= set(to_bytes(x) for x in values)
+        a_set -= {to_bytes(x) for x in values}
         return card - len(a_set)
 
     @_locked
@@ -1735,7 +1735,7 @@ def sunionstore(self, dest, keys, *args):
         set named ``dest``.  Returns the number of keys in the new set.
         """
         union = self.sunion(keys, *args)
-        self._db[dest] = set(to_bytes(x) for x in union)
+        self._db[dest] = {to_bytes(x) for x in union}
         return len(union)
 
     def _get_zset(self, name):
@@ -2233,7 +2233,7 @@ def _zaggregate(self, dest, keys, aggregate, should_include):
             current_zset = self._get_anyset(key)
             if isinstance(current_zset, set):
                 # When casting set to zset redis uses a default score of 1.0
-                current_zset = dict((k, 1.0) for k in current_zset)
+                current_zset = {k: 1.0 for k in current_zset}
             for el in current_zset:
                 if not should_include(el):
                     continue
@@ -2525,7 +2525,7 @@ def execute(self, raise_on_error=True):
                     self.commands = []
                     self.watching = {}
                     raise redis.WatchError(
-                        'Watched key%s %s changed' % (
+                        'Watched key{} {} changed'.format(
                             '' if len(mismatches) == 1 else
                             's', ', '.join(k for (k, _, _) in mismatches)))
             if raise_on_error:
@@ -2588,7 +2588,7 @@ def _normalize_keys(self, data):
         based on whether responses are automatically decoded. this saves us
         from coercing the value for each message coming in.
         """
-        return dict([(self._normalize(k), v) for k, v in iteritems(data)])
+        return {self._normalize(k): v for k, v in iteritems(data)}
 
     def put(self, channel, message, message_type):
         """
@@ -2758,7 +2758,7 @@ def handle_message(self, message, ignore_subscribe_messages=False):
             try:
                 channel = message['channel']
                 del subscribed_dict[channel]
-            except:
+            except Exception:
                 pass
 
         if message_type in self.PUBLISH_MESSAGE_TYPES:

requirements.txt

@@ -1,5 +1,4 @@
-# Flake8 3.0.0 does not support Python 2.6.
-flake8<3.0.0
+flake8
 nose==1.3.4
 redis==2.10.6
 lupa==1.6

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
 
 from nose.plugins.skip import SkipTest
 from nose.plugins.attrib import attr
@@ -17,9 +18,9 @@
 from datetime import datetime, timedelta
 
 try:
-    # Python 2.6, 2.7
+    # Python 2.7
     from Queue import Queue
-except:
+except ImportError:
     # Python 3
     from queue import Queue
 
@@ -28,18 +29,13 @@
 if not PY2:
     long = int
 
-if sys.version_info[:2] == (2, 6):
-    import unittest2 as unittest
-else:
-    import unittest
-
 # Try importlib, then imp, then the old builtin `reload`
 try:
     from importlib import reload
-except:
+except ImportError:
     try:
         from imp import reload
-    except:
+    except ImportError:
         pass
 
 
@@ -70,8 +66,8 @@ def skip_test(*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):
@@ -1180,8 +1176,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.redis.zadd('foo', 1, 'bar')
@@ -1201,8 +1197,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.redis.zadd('foo', 1, 'bar')
@@ -1345,17 +1341,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.redis.zadd('foo', 1, 'member')
@@ -1370,11 +1366,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)
@@ -1434,18 +1430,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())
@@ -1492,9 +1488,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)
@@ -1503,8 +1499,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.redis.zadd('foo', 1, 'member')
@@ -1559,7 +1555,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)
@@ -1570,7 +1566,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')
 
@@ -1598,15 +1594,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)
@@ -1619,16 +1615,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):
@@ -1642,7 +1638,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.redis.zadd('foo', 1, 'member')
@@ -1659,7 +1655,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'}
@@ -4225,7 +4221,7 @@ def test_searches_for_c_stdlib_and_raises_if_missing(self):
             with self.assertRaises(ImportError):
                 reload(fakeredis)
 
-            self.assertEqual(set(['c', 'msvcrt', 'System']), searched_libraries)
+            self.assertEqual({'c', 'msvcrt', 'System'}, searched_libraries)
         finally:
             ctypes.util.find_library = old_find_library
 

tox.ini

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