from django.core.cache import cache

def cached(cache_key):
    """Cache decorator
    """
    def doCache(func):
        def _get_cached(*args, **kwargs):
            result = cache.get(cache_key)
            if result is None:
                result = func(*args, **kwargs)
                cache.set(cache_key, result)

            return result
        return _get_cached
    return doCache

def delete_cached(cache_key):
    """Delete cache decorator
    """
    def doDeleteCache(func):
        def _delete_cached(*args, **kwargs):
            result = func(*args, **kwargs)
            cache.delete(cache_key)
            return result
        return _delete_cached
    return doDeleteCache

from google.appengine.ext import db
class Tag(db.Model):
    """The snippet tags
    """
    name = db.StringProperty()
    description = db.TextProperty()
    entrycount = db.IntegerProperty(default=0)
    
    @staticmethod
    @cached('tags')
    def getall():
        return [tag for tag in Tag.all()]

    @delete_cached('tags')
    def save(self):
        """Will save the current tag and invalidate the cache automatically"""
        self.put()
  
    @delete_cached('tags')
    def remove(self):
        self.delete()

from django.core.cache.backends.base import BaseCache
from google.appengine.api.memcache import Client

class CacheClass(Client, BaseCache):
    def __init__(self, default_timeout=300):
        Client.__init__(self)
        BaseCache.__init__(self, {'timeout': default_timeout})

    def get(self, key, default=None):
        val = super(CacheClass, self).get(key)
        if val is None:
            return default
        return val

    def get_many(self, keys, key_prefix=''):
        return self.get_multi(keys, key_prefix)

    def set(self, key, value, timeout=0):
        return super(CacheClass, self).set(key, value,
            timeout or self.default_timeout)
            
    def delete(self, key):
        return super(CacheClass, self).delete(key)

    def set_many(self, mapping, timeout=0, key_prefix=''):
        return self.set_multi(mapping, timeout, key_prefix)

    def delete_many(self, keys, seconds=0, key_prefix=''):
        return self.delete_multi(keys, seconds, key_prefix)

from cache_backend import CacheClass
from django.core import cache
from google.appengine.api import memcache
cache.cache = CacheClass()
memcache.setup_client(cache.cache)