Merge pull request #119 from timgraham/trove

Drop support for Django < 1.8 and related cleanups

.travis.yml

 language: python
 python:
   - "2.7"
-  - "3.2"
   - "3.3"
   - "3.4"
+  - "3.5"
 env:
-  - DJANGO_VERSION=1.5
-  - DJANGO_VERSION=1.6
-  - DJANGO_VERSION=1.7
   - DJANGO_VERSION=1.8
 # command to run tests
 install: ./install_redis.sh

README.rst

@@ -21,6 +21,11 @@ Docs can be found at http://django-redis-cache.readthedocs.org/en/latest/.
 Changelog
 =========
 
+1.7.0
+-----
+
+* Drops support for Django < 1.8 and Python 3.2.
+
 1.5.0
 -----
 

redis_cache/backends/base.py

-from django.core.cache.backends.base import BaseCache, InvalidCacheBackendError
+from django.core.cache.backends.base import (
+    BaseCache, DEFAULT_TIMEOUT, InvalidCacheBackendError,
+)
 from django.core.exceptions import ImproperlyConfigured
 
 try:
@@ -10,7 +12,6 @@ except ImportError:
 
 from redis.connection import DefaultParser
 
-from redis_cache.compat import DEFAULT_TIMEOUT
 from redis_cache.connection import pool
 from redis_cache.utils import (
     CacheKey, get_servers, parse_connection_kwargs, import_class

redis_cache/backends/multiple.py

 from collections import defaultdict
 
+from django.core.cache.backends.base import DEFAULT_TIMEOUT
+
 from redis_cache.backends.base import BaseRedisCache
-from redis_cache.compat import DEFAULT_TIMEOUT
 from redis_cache.sharder import HashRing
 
 

redis_cache/backends/single.py

-from redis_cache.compat import DEFAULT_TIMEOUT
-
 try:
     import cPickle as pickle
 except ImportError:
     import pickle
 import random
 
+from django.core.cache.backends.base import DEFAULT_TIMEOUT
+
 from redis_cache.backends.base import BaseRedisCache
 
 

redis_cache/compat.py

-import sys
-import django
-
-
-PY3 = (sys.version_info >= (3,))
-
-try:
-    # Django 1.5+
-    from django.utils.encoding import smart_text, smart_bytes
-except ImportError:
-    # older Django, thus definitely Python 2
-    from django.utils.encoding import smart_unicode, smart_str
-    smart_text = smart_unicode
-    smart_bytes = smart_str
-
-if PY3:
-    bytes_type = bytes
-    from urllib.parse import parse_qs, urlparse
-else:
-    bytes_type = str
-    from urlparse import parse_qs, urlparse
-
-
-if django.VERSION[:2] >= (1, 6):
-    from django.core.cache.backends.base import DEFAULT_TIMEOUT as DJANGO_DEFAULT_TIMEOUT
-    DEFAULT_TIMEOUT = DJANGO_DEFAULT_TIMEOUT
-else:
-    DEFAULT_TIMEOUT = None
-
-
-def python_2_unicode_compatible(klass):
-    """
-    A decorator that defines __unicode__ and __str__ methods under Python 2.
-    Under Python 3 it does nothing.
-
-    To support Python 2 and 3 with a single code base, define a __str__ method
-    returning text and apply this decorator to the class.
-
-    Backported from Django 1.5+.
-    """
-    if not PY3:
-        klass.__unicode__ = klass.__str__
-        klass.__str__ = lambda self: self.__unicode__().encode('utf-8')
-    return klass

redis_cache/serializers.py

@@ -15,7 +15,7 @@ try:
 except ImportError:
     pass
 
-from redis_cache.compat import smart_bytes, smart_text
+from django.utils.encoding import force_bytes, force_text
 
 
 class BaseSerializer(object):
@@ -39,7 +39,7 @@ class PickleSerializer(object):
         return pickle.dumps(value, self.pickle_version)
 
     def deserialize(self, value):
-        return pickle.loads(smart_bytes(value))
+        return pickle.loads(force_bytes(value))
 
 
 class JSONSerializer(BaseSerializer):
@@ -48,10 +48,10 @@ class JSONSerializer(BaseSerializer):
         super(JSONSerializer, self).__init__(**kwargs)
 
     def serialize(self, value):
-        return smart_bytes(json.dumps(value))
+        return force_bytes(json.dumps(value))
 
     def deserialize(self, value):
-        return json.loads(smart_text(value))
+        return json.loads(force_text(value))
 
 
 class MSGPackSerializer(BaseSerializer):

redis_cache/sharder.py

 from bisect import insort, bisect
 import hashlib
-from redis_cache.compat import smart_text
+from django.utils.encoding import force_text
 
 
 DIGITS = 8
@@ -17,8 +17,8 @@ class Node(object):
         self._node = node
         self._i = i
         key = "{0}:{1}".format(
-            smart_text(i),
-            smart_text(self._node),
+            force_text(i),
+            force_text(self._node),
         )
         self._position = get_slot(key)
 
@@ -52,5 +52,5 @@ class HashRing(object):
                 del self._nodes[n - i - 1]
 
     def get_node(self, key):
-        i = bisect(self._nodes, get_slot(smart_text(key))) - 1
+        i = bisect(self._nodes, get_slot(force_text(key))) - 1
         return self._nodes[i]._node

redis_cache/utils.py

+import importlib
 import warnings
 
 from django.core.exceptions import ImproperlyConfigured
-from redis.connection import SSLConnection
-
-from redis_cache.compat import (
-    smart_text, python_2_unicode_compatible, parse_qs, urlparse
-)
+from django.utils import six
+from django.utils.encoding import force_text, python_2_unicode_compatible
+from django.utils.six.moves.urllib.parse import parse_qs, urlparse
 
-try:
-    import importlib
-except ImportError:
-    from django.utils import importlib
-
-try:
-    basestring
-except NameError:
-    basestring = str
+from redis.connection import SSLConnection
 
 
 @python_2_unicode_compatible
@@ -30,20 +21,20 @@ class CacheKey(object):
     def __eq__(self, other):
         return self._versioned_key == other
 
-    def __unicode__(self):
-        return smart_text(self._versioned_key)
+    def __str__(self):
+        return force_text(self._versioned_key)
 
     def __hash__(self):
         return hash(self._versioned_key)
 
-    __repr__ = __str__ = __unicode__
+    __repr__ = __str__
 
 
 def get_servers(location):
     """Returns a list of servers given the server argument passed in from
     Django.
     """
-    if isinstance(location, basestring):
+    if isinstance(location, six.string_types):
         servers = location.split(',')
     elif hasattr(location, '__iter__'):
         servers = location

requirements-dev.txt

 hiredis==0.2.0
 django-nose==1.4
 nose==1.3.6
-unittest2==1.0.1
 msgpack-python==0.4.6
 pyyaml==3.11

setup.py

@@ -11,15 +11,15 @@ setup(
     install_requires=['redis>=2.10.3'],
     classifiers=[
         "Programming Language :: Python",
-        "Programming Language :: Python :: 2.6",
         "Programming Language :: Python :: 2.7",
-        "Programming Language :: Python :: 3.2",
         "Programming Language :: Python :: 3.3",
         "Programming Language :: Python :: 3.4",
+        "Programming Language :: Python :: 3.5",
         "Operating System :: OS Independent",
         "Topic :: Software Development :: Libraries",
         "Topic :: Utilities",
         "Environment :: Web Environment",
         "Framework :: Django",
+        "Framework :: Django :: 1.8",
     ],
 )

tests/testapp/tests/base_tests.py

@@ -4,14 +4,8 @@ from __future__ import unicode_literals
 from hashlib import sha1
 import os
 import subprocess
-import sys
 import time
 
-if sys.version_info < (2, 7):
-    import unittest2 as unittest
-else:
-    import unittest
-
 
 try:
     import cPickle as pickle
@@ -20,17 +14,13 @@ except ImportError:
 
 from django.core.cache import get_cache
 from django.core.exceptions import ImproperlyConfigured
-from django.test import TestCase
-try:
-    from django.test import override_settings
-except ImportError:
-    from django.test.utils import override_settings
+from django.test import TestCase, override_settings
+from django.utils.encoding import force_bytes
 
 import redis
 
 from tests.testapp.models import Poll, expensive_calculation
 from redis_cache.cache import RedisCache, pool
-from redis_cache.compat import DEFAULT_TIMEOUT, smart_bytes
 from redis_cache.utils import get_servers, parse_connection_kwargs
 
 
@@ -299,7 +289,6 @@ class BaseRedisTestCase(SetupMixin):
         self.assertEqual(self.cache.get("expire2"), "newvalue")
         self.assertEqual("expire3" in self.cache, False)
 
-    @unittest.skipIf(DEFAULT_TIMEOUT is None, "Version of django doesn't support indefinite timeouts.")
     def test_set_expiration_timeout_None(self):
         key, value = 'key', 'value'
         self.cache.set(key, value, timeout=None)
@@ -479,7 +468,7 @@ class BaseRedisTestCase(SetupMixin):
     def test_reinsert_keys(self):
         self.cache._pickle_version = 0
         for i in range(2000):
-            s = sha1(smart_bytes(i)).hexdigest()
+            s = sha1(force_bytes(i)).hexdigest()
             self.cache.set(s, self.cache)
         self.cache._pickle_version = -1
         self.cache.reinsert_keys()
@@ -563,7 +552,6 @@ class BaseRedisTestCase(SetupMixin):
         ttl = self.cache.ttl('a')
         self.assertAlmostEqual(ttl, 10)
 
-    @unittest.skipIf(DEFAULT_TIMEOUT is None, "Version of django doesn't support indefinite timeouts.")
     def test_ttl_no_expiry(self):
         self.cache.set('a', 'a', timeout=None)
         ttl = self.cache.ttl('a')

tests/testapp/tests/compressor_tests.py

 # -*- coding: utf-8 -*-
-try:
-    from django.test import override_settings
-except ImportError:
-    from django.test.utils import override_settings
-from django.test import TestCase
-
+from django.test import TestCase, override_settings
 
 from tests.testapp.tests.base_tests import BaseRedisTestCase
 

tests/testapp/tests/master_slave_tests.py

 import time
 
-from django.test import TestCase
-try:
-    from django.test import override_settings
-except ImportError:
-    from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 
 from redis_cache.connection import pool
 

tests/testapp/tests/serializers_tests.py

 # -*- coding: utf-8 -*-
 from __future__ import unicode_literals
 
-from django.test import TestCase
-try:
-    from django.test import override_settings
-except ImportError:
-    from django.test.utils import override_settings
+from django.test import TestCase, override_settings
 
 from tests.testapp.tests.base_tests import SetupMixin
 
@@ -171,4 +167,3 @@ class MSGPackSerializerTestCase(BaseSerializerTestCase):
 class YAMLSerializerTestCase(BaseSerializerTestCase):
     converts_tuple_to_list = False
     serializes_objects = True
-

tests/testapp/tests/socket_tests.py

@@ -3,11 +3,7 @@ from collections import Counter
 from tests.testapp.tests.base_tests import BaseRedisTestCase
 from tests.testapp.tests.multi_server_tests import MultiServerTests
 
-try:
-    from django.test import override_settings
-except ImportError:
-    from django.test.utils import override_settings
-from django.test import TestCase
+from django.test import TestCase, override_settings
 
 
 LOCATION = "unix://:yadayada@/tmp/redis0.sock?db=15"

tests/testapp/tests/socket_timeout_tests.py

 # -*- coding: utf-8 -*-
-try:
-    from django.test import override_settings
-except ImportError:
-    from django.test.utils import override_settings
-from django.test import TestCase
+from django.test import TestCase, override_settings
 
 from redis.exceptions import ConnectionError
 from tests.testapp.tests.base_tests import SetupMixin

tests/testapp/tests/tcp_tests.py

 # -*- coding: utf-8 -*-
 from tests.testapp.tests.base_tests import BaseRedisTestCase
 from tests.testapp.tests.multi_server_tests import MultiServerTests
-try:
-    from django.test import override_settings
-except ImportError:
-    from django.test.utils import override_settings
-from django.test import TestCase
+from django.test import TestCase, override_settings
 
 from redis_cache.cache import ImproperlyConfigured
 from redis.connection import UnixDomainSocketConnection