def __init__(self, func, *args, **kwargs):
""" Wrap func in a ArgCache. """
## Keep the original function's name and docstring
## If the original function has any more-complicated attrs,
## don't bother to maintain them; we have our own attrs,
## and merging custom stuff could be dangerous.
if hasattr(func, '__name__'):
self.__name__ = func.__name__
if hasattr(func, '__doc__'):
self.__doc__ = func.__doc__
import inspect
self.argspec = inspect.getargspec(func)
self.func = func
params = self.argspec[0]
extra_name = kwargs.pop('uid_extra', '')
name = describe_func(func) + extra_name
uid = get_uid(func) + extra_name
if self.argspec[1] is not None:
raise ESPError(), "ArgCache does not support varargs."
if self.argspec[2] is not None:
raise ESPError(), "ArgCache does not support keywords."
super(ArgCacheDecorator, self).__init__(name=name,
params=params,
uid=uid,
*args,
**kwargs)
def prepare_dec(func):
self.params, xx, xxx, defaults = getargspec(func)
self.cached_function = cache_function(func, uid_extra='*'+describe_func(func))
def actual_func(self, request, tl, one, two, module, extra, prog):
# Construct argument list
param_name_list = ['self', 'request', 'tl', 'one', 'two', 'module', 'extra', 'prog']
param_list = [self, request, tl, one, two, module, extra, prog]
args_for_func = []
for i in range(len(param_list)):
if param_name_list[i] in parent_obj.params:
args_for_func.append(param_list[i])
return parent_obj.cached_function(*args_for_func)
return actual_func
class InclusionNode(template.Node):
def __init__(in_self, takes_context, vars_to_resolve, kwargs):
in_self.vars_to_resolve = vars_to_resolve
def __str__(in_self):
return '<IN>'
def render_given_args(in_self, args):
dict = cached_function(*args)
if not getattr(in_self, 'nodelist', False):
from django.template.loader import get_template, select_template
if hasattr(file_name, '__iter__'):
t = select_template(file_name)
else:
t = get_template(file_name)
in_self.nodelist = t.nodelist
return in_self.nodelist.render(context_class(dict, autoescape=in_self._context.autoescape))
if not disable:
render_given_args = cache_function(render_given_args, uid_extra='*'+describe_func(func))
render_given_args.get_or_create_token(('args',))
def render_map(**kwargs):
# If the key set is empty, we can just flush everything.
if kwargs == {}:
result = {}
else:
# Otherwise, prepare a key set embedding the argument list in the 'args' key
result_args = []
for key in params:
if key in kwargs:
result_args.append(kwargs[key])
else:
result_args.append(None)
result = {'args': result_args}
# Flush everything if we got a wildcard
for key in kwargs:
if is_wildcard(kwargs[key]):
result = {}
return result
render_given_args.depend_on_cache(cached_function, render_map)
def render(in_self, context):
resolved_vars = []
for var in in_self.vars_to_resolve:
try:
resolved_vars.append(var.resolve(context))
except:
print 'Could not resolve %s' % var
resolved_vars.append(None)
if takes_context:
args = [context] + resolved_vars
else:
args = resolved_vars
in_self._context = context
return in_self.render_given_args(args)