"""

 Random Django snippets I like to keep for quick reference

 """

 def cache_key_for_function(func, args=None, kwargs=None):

     """Calculate a cache key for a function

     Prefix keys with the module and function name

     Use sha1 of repr() of args and kwargs as the final piece of the

     cache key. This limits the maximum length (so we don't go over

     memcached's limit, which I don't remember offhand) and swallows

     control characters.

     This relies on accurate reprs - if the repr of the arguments are

     the same, the hash will be the same, and the cached value will be

     returned.

     """

     from hashlib import sha1

     if args is None:

         args = ()

     if kwargs is None:

         kwargs = {}

     cache_key = "%s.%s(%s)" % (

         func.__module__, func.__name__,

         sha1(repr(args)+repr(kwargs)).hexdigest())

     return cache_key

 def cache_key_for_method(obj, method, args=None, kwargs=None):

     "Like cache_key_for_function, but for methods"

     from hashlib import sha1

     cache_key = "%s.%s.%s(%s)" % (

         obj.__class__.__module__,

         obj.__class__.__name__,

         method.__name__,

         sha1(repr(args)+repr(kwargs)).hexdigest())

     return cache_key

 def dictproperty(method):

     """Turn dictionary or attribute access into a function call"""

     class _Object(object):

         def __init__(self, obj):

             self.obj = obj

         def __getattr__(self, attr):

             return method(self.obj, attr)

         __getitem__ = __getattr__

     _Object.__name__ = method.__name__

     return property(_Object)

 def decorators(*decos):

     """Some people say I need to handle my decorator problem.

     They are wrong.

     The evaulation is such that the things on the left are on the

     "outside" of the decorator chain. EG::

         @foo

         @bar

     Could also be::

         @decorators(foo, bar)

     Which itself is, of course, a shortcut for::

         foo(bar(function))

     """

     def _decorator(func):

         # The reversed is needed - step through it, it'll make sense.

         for deco in reversed(list(decos)):

             func = deco(func)

         return func

     return _decorator

 def cached_function(func):

     """A caching decorator for functions"""

     from functools import wraps

     from django.core.cache import cache

     @wraps(func)

     def _closure(*args, **kwargs):

         cache_key = cache_key_for_function(

             func, args, kwargs)

         val = cache.get(cache_key)

         if val is None:

             val = func(*args, **kwargs)

             cache.set(cache_key, val)

         return val

     return _closure

 def cached_method(method):

     """A caching decorator for methods"""

     from functools import wraps

     from django.core.cache import cache

     @wraps(method)

     def _closure(self, *args, **kwargs):

         cache_key = cache_key_for_method(

             self, method, (self,)+args, kwargs)

         val = cache.get(cache_key)

         if val is None:

             val = method(self, *args, **kwargs)

             cache.set(cache_key, val)

         return val

     return _closure

 cached_property = decorators(property, cached_method)

 def use_template(template_name, request_context=True):

     """A view decorator that wraps render_to_response and uses RequestContext by default"""

     from functools import wraps

     from django.template import RequestContext

     from django.shortcuts import render_to_response

     def _decorator(func):

         @wraps(func)

         def _closure(request, *args, **kwargs):

             # Use a different variable to avoid 'referenced before

             # assignment'. 'template' is the kwarg used by

             # direct_to_template; copy its interface for consistency.

             actual_template = kwargs.pop("template", template_name)

             actual_rc = kwargs.pop("request_context", request_context)

             val = func(request, *args, **kwargs)

             if isinstance(val, dict) and template_name is not None:

                 if actual_rc:

                     context = RequestContext(request)

                     return render_to_response(actual_template, val,

                                               context_instance=context)

                 else:

                     return render_to_response(actual_template, val)

             return val

         return _closure

     return _decorator

 # http://www.djangosnippets.org/snippets/562/#c673

 class QuerySetManager(models.Manager):

     # http://docs.djangoproject.com/en/dev/topics/db/managers/#using-managers-for-related-object-access

     # Not working cause of:

     # http://code.djangoproject.com/ticket/9643

     use_for_related_fields = True

     def __init__(self, qs_class=models.query.QuerySet):

         self.queryset_class = qs_class

         super(QuerySetManager, self).__init__()

     def get_query_set(self):

         return self.queryset_class(self.model)

     def __getattr__(self, attr, *args):

         try:

             return getattr(self.__class__, attr, *args)

         except AttributeError:

             return getattr(self.get_query_set(), attr, *args)

 class QuerySet(models.query.QuerySet):

     """Base QuerySet class for adding custom methods that are made

     available on both the manager and subsequent cloned QuerySets"""

     @classmethod

     def as_manager(cls, ManagerClass=QuerySetManager):

         return ManagerClass(cls)

     def random(self):

         return self.order_by("?")

     def first(self):

         return self[0]