A few cleanups to capture the minimum amount of code in try/except blocks.

from django.core.cache.backends.base import BaseCache, DEFAULT_TIMEOUT

from django.utils.synch import RWLock

# Global in-memory store of cache data. Keyed by name, to provide

# multiple named local memory caches.

_caches = {}

_expire_info = {}

_locks = {}

class LocMemCache(BaseCache):

    def __init__(self, name, params):

        BaseCache.__init__(self, params)

        global _caches, _expire_info, _locks

        self._cache = _caches.setdefault(name, {})

        self._expire_info = _expire_info.setdefault(name, {})

        self._lock = _locks.setdefault(name, RWLock())

            exp = self._expire_info.get(key, 0)

            if exp is None or exp > time.time():

                pickled = self._cache[key]

        try:

        if pickled is not None:

            try:

                return pickle.loads(pickled)

            except pickle.PickleError:

                return default

        self.validate_key(key)

        try:

            pickled = pickle.dumps(value, pickle.HIGHEST_PROTOCOL)

            with self._lock.writer():

                self._set(key, pickled, timeout)

        except pickle.PickleError:

            pass

        else:

            with self._lock.writer():

                self._set(key, pickled, timeout)

    def incr(self, key, delta=1, version=None):

        value = self.get(key, version=version)

        key = self.make_key(key, version=version)

        try:

            pickled = pickle.dumps(new_value, pickle.HIGHEST_PROTOCOL)

            with self._lock.writer():

                self._cache[key] = pickled

        except pickle.PickleError:

            pass

        else:

            with self._lock.writer():

                self._cache[key] = pickled

        return new_value

    def has_key(self, key, version=None):

        self._cache.clear()

        self._expire_info.clear()

# For backwards compatibility

class CacheClass(LocMemCache):

    pass