--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/web/lib/django/core/cache/backends/base.py	Wed Jun 02 18:57:35 2010 +0200
@@ -0,0 +1,118 @@
+"Base Cache class."
+
+from django.core.exceptions import ImproperlyConfigured
+
+class InvalidCacheBackendError(ImproperlyConfigured):
+    pass
+
+class BaseCache(object):
+    def __init__(self, params):
+        timeout = params.get('timeout', 300)
+        try:
+            timeout = int(timeout)
+        except (ValueError, TypeError):
+            timeout = 300
+        self.default_timeout = timeout
+
+    def add(self, key, value, timeout=None):
+        """
+        Set a value in the cache if the key does not already exist. If
+        timeout is given, that timeout will be used for the key; otherwise
+        the default cache timeout will be used.
+
+        Returns True if the value was stored, False otherwise.
+        """
+        raise NotImplementedError
+
+    def get(self, key, default=None):
+        """
+        Fetch a given key from the cache. If the key does not exist, return
+        default, which itself defaults to None.
+        """
+        raise NotImplementedError
+
+    def set(self, key, value, timeout=None):
+        """
+        Set a value in the cache. If timeout is given, that timeout will be
+        used for the key; otherwise the default cache timeout will be used.
+        """
+        raise NotImplementedError
+
+    def delete(self, key):
+        """
+        Delete a key from the cache, failing silently.
+        """
+        raise NotImplementedError
+
+    def get_many(self, keys):
+        """
+        Fetch a bunch of keys from the cache. For certain backends (memcached,
+        pgsql) this can be *much* faster when fetching multiple values.
+
+        Returns a dict mapping each key in keys to its value. If the given
+        key is missing, it will be missing from the response dict.
+        """
+        d = {}
+        for k in keys:
+            val = self.get(k)
+            if val is not None:
+                d[k] = val
+        return d
+
+    def has_key(self, key):
+        """
+        Returns True if the key is in the cache and has not expired.
+        """
+        return self.get(key) is not None
+
+    def incr(self, key, delta=1):
+        """
+        Add delta to value in the cache. If the key does not exist, raise a
+        ValueError exception.
+        """
+        if key not in self:
+            raise ValueError("Key '%s' not found" % key)
+        new_value = self.get(key) + delta
+        self.set(key, new_value)
+        return new_value
+
+    def decr(self, key, delta=1):
+        """
+        Subtract delta from value in the cache. If the key does not exist, raise
+        a ValueError exception.
+        """
+        return self.incr(key, -delta)
+
+    def __contains__(self, key):
+        """
+        Returns True if the key is in the cache and has not expired.
+        """
+        # This is a separate method, rather than just a copy of has_key(),
+        # so that it always has the same functionality as has_key(), even
+        # if a subclass overrides it.
+        return self.has_key(key)
+
+    def set_many(self, data, timeout=None):
+        """
+        Set a bunch of values in the cache at once from a dict of key/value
+        pairs.  For certain backends (memcached), this is much more efficient
+        than calling set() multiple times.
+
+        If timeout is given, that timeout will be used for the key; otherwise
+        the default cache timeout will be used.
+        """
+        for key, value in data.items():
+            self.set(key, value, timeout)
+
+    def delete_many(self, keys):
+        """
+        Set a bunch of values in the cache at once.  For certain backends
+        (memcached), this is much more efficient than calling delete() multiple
+        times.
+        """
+        for key in keys:
+            self.delete(key)
+
+    def clear(self):
+        """Remove *all* values from the cache at once."""
+        raise NotImplementedError