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)