"""

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

    Prefixes 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 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 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 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)

# http://adam.gomaa.us/blog/2009/feb/16/subclassing-django-querysets/

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]