Django cache backend using uwsgi caching framework

uwsgi.py

"""
uWSGI cache backend
http://projects.unbit.it/uwsgi/wiki/CachingFramework
"""
from __future__ import absolute_import
from django.core.cache.backends.base import BaseCache, InvalidCacheBackendError
from django.utils.encoding import force_str

try:
    import cPickle as pickle
except ImportError:
    import pickle

try:
    import uwsgi
except:
    raise InvalidCacheBackendError(
        "uWSGI cache backend requires you're running under it to have the 'uwsgi' module available")


class UWSGICache(BaseCache):
    def __init__(self, server, params):
        BaseCache.__init__(self, params)
        self._cache = uwsgi
        self._server = server
        options = uwsgi.opt.get('cache2')
        if not options:
            raise InvalidCacheBackendError('To use UWSGICache uwsgi must be run with the '
                                           '--cache2 option.')
        options = dict(opt.split('=') for opt in options.split(','))

        self._max_entries = int(options['items'])
        name = options['name']
        if name != server.split('@')[0]:
            raise InvalidCacheBackendError(
                'The cache name %s is not equal to cache in uwsgi, found %s', server, name)

    def make_key(self, key, version=None):
        return force_str(super(UWSGICache, self).make_key(key, version))

    def exists(self, key):
        return self._cache.cache_exists(key, self._server)

    def add(self, key, value, timeout=0, version=None):
        key = self.make_key(key, version)
        if self.exists(key):
            return False
        return self.set(key, value, timeout, self._server)

    def get(self, key, default=None, version=None):
        key = self.make_key(key, version)
        val = self._cache.cache_get(key, self._server)
        if val is None:
            return default
        return pickle.loads(val)

    def set(self, key, value, timeout=0, version=None):
        key = self.make_key(key, version)
        timeout = timeout or self.default_timeout
        value = pickle.dumps(value)
        self._cache.cache_set(key, value, timeout, self._server)

    def delete(self, key, version=None):
        key = self.make_key(key, version)
        self._cache.cache_del(key, self._server)

    def clear(self):
        self._cache.cache_clear()