add compatibility with django 1.6

newcache.py

@@ -1,11 +1,14 @@
 "Modified memcached cache backend"
 
 import time
+import os
+import hashlib
 
 from threading import local
 
 from django.core.cache.backends.base import BaseCache, InvalidCacheBackendError
-from django.utils.hashcompat import sha_constructor
+from django.utils import six
+
 from django.utils.encoding import smart_str
 from django.conf import settings
 
@@ -24,7 +27,7 @@
         import memcache
         NotFoundError = ValueError
     except ImportError:
-        raise InvalidCacheBackendError('Memcached cache backend requires ' + 
+        raise InvalidCacheBackendError('Memcached cache backend requires ' +
             'either the "pylibmc" or "memcache" library')
 
 # Flavor is used amongst multiple apps to differentiate the "flavor" of the
@@ -36,28 +39,38 @@
 CACHE_KEY_MODULE = getattr(settings, 'CACHE_KEY_MODULE', 'newcache')
 CACHE_HERD_TIMEOUT = getattr(settings, 'CACHE_HERD_TIMEOUT', 60)
 
+CACHE_MIN_COMPRESS = getattr(settings, 'PYLIBMC_MIN_COMPRESS_LEN', 0)  # Disabled
+if CACHE_MIN_COMPRESS > 0 and not memcache.support_compression:
+    CACHE_MIN_COMPRESS = 0
+
 class Marker(object):
     pass
 
 MARKER = Marker()
 
-def get_key(key):
+def get_key(key, version=None):
     """
     Returns a hashed, versioned, flavored version of the string that was input.
     """
-    hashed = sha_constructor(smart_str(key)).hexdigest()
-    return ''.join((FLAVOR, '-', CACHE_VERSION, '-', hashed))
+    hashed = hashlib.sha1(smart_str(key)).hexdigest()
+    return ''.join((FLAVOR, '-', CACHE_VERSION, '-', hashed, version if version is not None else ''))
 
 key_func = importlib.import_module(CACHE_KEY_MODULE).get_key
 
 class CacheClass(BaseCache):
 
-    def __init__(self, server, params):
+    def __init__(self, server, params, username=None, password=None):
         super(CacheClass, self).__init__(params)
-        self._servers = server.split(';')
+        if isinstance(server, six.string_types):
+            self._servers = server.split(';')
+        else:
+            self._servers = server
         self._use_binary = bool(params.get('binary'))
+        self._use_binary = bool(params.get('BINARY'))
+        self._username = os.environ.get('MEMCACHE_USERNAME', username)
+        self._password = os.environ.get('MEMCACHE_PASSWORD', password)
         self._local = local()
-    
+
     @property
     def _cache(self):
         """
@@ -66,17 +79,19 @@ def _cache(self):
         client = getattr(self._local, 'client', None)
         if client:
             return client
-        
+
         # Use binary mode if it's both supported and requested
         if using_pylibmc and self._use_binary:
-            client = memcache.Client(self._servers, binary=True)
+            client = memcache.Client(self._servers, binary=True,
+                username=self._username, password=self._password)
         else:
-            client = memcache.Client(self._servers)
+            client = memcache.Client(self._servers,
+                username=self._username, password=self._password)
 
         # If we're using pylibmc, set the behaviors according to settings
         if using_pylibmc:
             client.behaviors = CACHE_BEHAVIORS
-        
+
         self._local.client = client
         return client
 
@@ -87,7 +102,7 @@ def _pack_value(self, value, timeout):
         """
         herd_timeout = (timeout or self.default_timeout) + int(time.time())
         return (MARKER, value, herd_timeout)
-    
+
     def _unpack_value(self, value, default=None):
         """
         Unpacks a value and returns a tuple whose first element is the value,
@@ -120,92 +135,102 @@ def _get_memcache_timeout(self, timeout):
             timeout += int(time.time())
         return timeout
 
-    def add(self, key, value, timeout=None, herd=True):
+    def add(self, key, value, timeout=None, herd=True, version=None, **kwargs):
         # If the user chooses to use the herd mechanism, then encode some
         # timestamp information into the object to be persisted into memcached
         if herd and timeout != 0:
+            if timeout is None:
+                timeout = self.default_timeout
             packed = self._pack_value(value, timeout)
-            real_timeout = (self._get_memcache_timeout(timeout) +
+            real_timeout = self._get_memcache_timeout(timeout +
                 CACHE_HERD_TIMEOUT)
         else:
             packed = value
             real_timeout = self._get_memcache_timeout(timeout)
-        return self._cache.add(key_func(key), packed, real_timeout)
+        args = [key_func(key, version), packed, real_timeout]
+        if using_pylibmc is True:
+            args.append(CACHE_MIN_COMPRESS)
+        return self._cache.add(*args)
 
-    def get(self, key, default=None):
-        encoded_key = key_func(key)
+    def get(self, key, default=None, version=None, **kwargs):
+        encoded_key = key_func(key, version)
         packed = self._cache.get(encoded_key)
         if packed is None:
             return default
-        
+
         val, refresh = self._unpack_value(packed)
-        
+
         # If the cache has expired according to the embedded timeout, then
         # shove it back into the cache for a while, but act as if it was a
         # cache miss.
         if refresh:
             self._cache.set(encoded_key, val,
                 self._get_memcache_timeout(CACHE_HERD_TIMEOUT))
             return default
-        
+
         return val
 
-    def set(self, key, value, timeout=None, herd=True):
+    def set(self, key, value, timeout=None, herd=True, version=None, **kwargs):
         # If the user chooses to use the herd mechanism, then encode some
         # timestamp information into the object to be persisted into memcached
         if herd and timeout != 0:
+            if timeout is None:
+                timeout = self.default_timeout
             packed = self._pack_value(value, timeout)
-            real_timeout = (self._get_memcache_timeout(timeout) +
+            real_timeout = self._get_memcache_timeout(timeout +
                 CACHE_HERD_TIMEOUT)
         else:
             packed = value
             real_timeout = self._get_memcache_timeout(timeout)
-        return self._cache.set(key_func(key), packed, real_timeout)
+        args = [key_func(key, version), packed, real_timeout]
+        if using_pylibmc is True:
+            args.append(CACHE_MIN_COMPRESS)
+        return self._cache.set(*args)
 
-    def delete(self, key):
-        self._cache.delete(key_func(key))
+    def delete(self, key, version=None, **kwargs):
+        self._cache.delete(key_func(key, version))
 
-    def get_many(self, keys):
+    def get_many(self, keys, version=None, **kwargs):
         # First, map all of the keys through our key function
-        rvals = map(key_func, keys)
+        rvals = [key_func(k, version) for k in keys]
 
         packed_resp = self._cache.get_multi(rvals)
-        
+
         resp = {}
         reinsert = {}
-                
+
         for key, packed in packed_resp.iteritems():
             # If it was a miss, treat it as a miss to our response & continue
             if packed is None:
                 resp[key] = packed
                 continue
-            
+
             val, refresh = self._unpack_value(packed)
             if refresh:
                 reinsert[key] = val
                 resp[key] = None
             else:
                 resp[key] = val
-        
+
         # If there are values to re-insert for a short period of time, then do
         # so now.
         if reinsert:
             self._cache.set_multi(reinsert,
                 self._get_memcache_timeout(CACHE_HERD_TIMEOUT))
-        
+
         # Build a reverse map of encoded keys to the original keys, so that
         # the returned dict's keys are what users expect (in that they match
         # what the user originally entered)
         reverse = dict(zip(rvals, keys))
-        
+
         return dict(((reverse[k], v) for k, v in resp.iteritems()))
 
     def close(self, **kwargs):
         self._cache.disconnect_all()
 
-    def incr(self, key, delta=1):
+    def incr(self, key, delta=1, version=None):
         try:
-            return self._cache.incr(key_func(key), delta)
+            return self._cache.incr(key_func(key, version), delta)
         except NotFoundError:
             raise ValueError("Key '%s' not found" % (key,))
 
@@ -215,17 +240,17 @@ def decr(self, key, delta=1):
         except NotFoundError:
             raise ValueError("Key '%s' not found" % (key,))
 
-    def set_many(self, data, timeout=None, herd=True):
+    def set_many(self, data, timeout=None, herd=True, version=None, **kwargs):
         if herd and timeout != 0:
-            safe_data = dict(((key_func(k), self._pack_value(v, timeout))
+            safe_data = dict(((key_func(k, version), self._pack_value(v, timeout))
                 for k, v in data.iteritems()))
         else:
             safe_data = dict((
-                (key_func(k), v) for k, v in data.iteritems()))
+                (key_func(k, version), v) for k, v in data.iteritems()))
         self._cache.set_multi(safe_data, self._get_memcache_timeout(timeout))
 
-    def delete_many(self, keys):
-        self._cache.delete_multi(map(key_func, keys))
+    def delete_many(self, keys, version=None, **kwargs):
+        self._cache.delete_multi([key_func(k, version) for k in keys])
 
-    def clear(self):
-        self._cache.flush_all()
+    def clear(self, **kwargs):
+        self._cache.flush_all()

setup.py

@@ -2,7 +2,7 @@
 
 from setuptools import setup
 
-VERSION = '0.2.4'
+VERSION = '0.2.6-1'
 
 setup(
     name='django-newcache',
@@ -25,4 +25,4 @@
     ],
     zip_safe=False,
     py_modules=['newcache'],
-)
+)