from functools import wraps

from django.core.cache import cache

from django.shortcuts import render_to_response

from django.template import RequestContext

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

def iso8601(dt):

    "Format a datetime object as ISO8601"

    return dt.strftime("%Y-%m-%dT%H:%M:%SZ")

def cached_property(func):

    @wraps(func)

    def _closure(self):

        try:

            cache_key = self.get_cache_key()

        except Exception:

            cache_key = "%s.%s.%s(%s)" % (self.__class__.__module__,

                                          self.__class__.__name__,

                                          func.__name__,

                                          self.pk)

        val = cache.get(cache_key)

        if val is None:

            val = func(self)

            cache.set(cache_key, val)

        return val

    return property(_closure)

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)