def __init__(self, parser, token): # noqa D102
bits = token.split_contents()
if len(bits) < 4:
raise TemplateSyntaxError(
"{} accepts at least 3 arguments (bound_field, 'groupname'"
" 'attr_name'), got: {}".format(bits[0], ','.join(bits[1:])))
if len(bits) > 5:
raise TemplateSyntaxError(
"{} accepts at mast 4 arguments (bound_field, 'groupname'"
" 'attr_name' action ), got: {}".format(
bits[0], ','.join(bits[1:])))
if len(bits) >= 5 and bits[4] not in ['append', 'override']:
raise TemplateSyntaxError(
"{} unknown action {} should be 'append'"
" of 'override'".format(bits[0], ','.join(bits[4])))
self.field = Variable(bits[1])
self.group = Variable(bits[2])
self.attr = bits[3]
self.action = bits[4] if len(bits) >= 5 else 'override'
self.nodelist = parser.parse(('end{}'.format(bits[0])))
parser.delete_first_token()
def __init__(self, parser, token): # noqa D102
bits = token.split_contents()
if len(bits) > 5:
raise TemplateSyntaxError(
"%r accepts at most 4 arguments (part_id, section,"
" asvar, varname), got: {}".format(bits[0],
','.join(bits[1:])))
self.part_id = Variable(bits[1])
self.section = bits[2] if len(bits) >= 3 else None
self.varname = None
if len(bits) > 3:
if bits[3] != 'asvar':
raise TemplateSyntaxError(
'Forth argument should be asvar," " got {}'.format(
bits[3]))
if len(bits) < 4:
raise TemplateSyntaxError('Variable name not provided')
else:
self.varname = Variable(bits[4])
self.nodelist = parser.parse(('end{}'.format(bits[0]), ))
parser.delete_first_token()
def __init__(self, parser, token): # noqa D102
bits = token.split_contents()
if len(bits) < 3:
raise TemplateSyntaxError(
"%r accepts at least 2 arguments (bound_field,"
" 'groupname'), got: {}".format(bits[0], ','.join(bits[1:])))
if len(bits) > 5:
raise TemplateSyntaxError(
"%r accepts at mast 4 arguments (bound_field, 'groupname'"
" default attrs_dict ), got: {}".format(
bits[0], ','.join(bits[1:])))
if len(bits) > 3 and bits[3] != 'default':
raise TemplateSyntaxError(
"%r 3d argument should be 'default' (bound_field, 'groupname'"
" default attrs_dict ), got: {}".format(
bits[0], ','.join(bits[1:])))
self.field = Variable(bits[1])
self.group = Variable(bits[2])
self.widget_attrs = Variable(bits[4]) if len(bits) >= 5 else None
self.nodelist = parser.parse(('end{}'.format(bits[0])))
parser.delete_first_token()
def test_variable_parsing(self):
c = {"article": {"section": "News"}}
self.assertEqual(Variable("article.section").resolve(c), "News")
self.assertEqual(Variable('"News"').resolve(c), "News")
self.assertEqual(Variable("'News'").resolve(c), "News")
# Translated strings are handled correctly.
self.assertEqual(Variable("_(article.section)").resolve(c), "News")
self.assertEqual(Variable('_("Good News")').resolve(c), "Good News")
self.assertEqual(Variable("_('Better News')").resolve(c), "Better News")
# Escaped quotes work correctly as well.
self.assertEqual(
Variable(r'"Some \"Good\" News"').resolve(c), 'Some "Good" News'
)
self.assertEqual(
Variable(r"'Some \'Better\' News'").resolve(c), "Some 'Better' News"
)
# Variables should reject access of attributes beginning with
# underscores.
msg = "Variables and attributes may not begin with underscores: 'article._hidden'"
with self.assertRaisesMessage(TemplateSyntaxError, msg):
Variable("article._hidden")
# Variables should raise on non string type
with self.assertRaisesMessage(TypeError, "Variable must be a string or number, got <class 'dict'>"):
Variable({})
def __init__(self,var_name,fmt_name=settings.DEFAULT_TIME_FORMAT,
tz_var=None):
self.var_name = Variable(var_name)
if tz_var is None:
self.tz_var = None
else:
self.tz_var = Variable(tz_var)
self.fmt_name = fmt_name
def render(self, context):
try:
user = Variable(self.request).resolve(context)
obj = Variable(self.obj).resolve(context)
field = getattr(obj, self.field_name)
except template.VariableDoesNotExist:
return ''
try:
vote = field.get_rating_for_user(user)
context[self.context_var] = vote
except ObjectDoesNotExist:
context[self.context_var] = 0
return ''
def render(self, context):
try:
request = Variable(self.request).resolve(context)
obj = Variable(self.obj).resolve(context)
field = getattr(obj, self.field_name)
except (template.VariableDoesNotExist, AttributeError):
return ''
try:
vote = field.get_rating_for_user(request.user,
request.META['REMOTE_ADDR'],
request.COOKIES)
context[self.context_var] = vote
except ObjectDoesNotExist:
context[self.context_var] = 0
return ''
def render(self, context):
if self not in context.render_context:
context.render_context[self] = (
Variable(self.form),
Variable(self.helper) if self.helper else None
)
form, helper = context.render_context[self]
actual_form = form.resolve(context)
if self.helper is not None:
helper = helper.resolve(context)
else:
helper = actual_form.helper
template = get_template(helper.template_name)
c = self.get_render(context)
return template.render(c)
def __init__(self, parser, token):
bits = token.split_contents()
if len(bits) == 0:
raise TemplateSyntaxError(
"%r received invalid args, expected one element for render. Got: %r" %
(bits[0], bits[1:]))
remaining_bits = bits[2:]
self.kwargs = token_kwargs(remaining_bits, parser)
if remaining_bits:
raise TemplateSyntaxError("%r received an invalid token: %r" %
(bits[0], remaining_bits[0]))
for key in self.kwargs:
if key not in ('template', 'widget'):
raise TemplateSyntaxError("%r received an invalid key: %r" %
(bits[0], key))
self.kwargs[key] = self.kwargs[key]
self.nodelist = parser.parse(('end{}'.format(bits[0]),))
parser.delete_first_token()
self.element = Variable(bits[1])
def hash(object,attr):
pseudo_context={'object':object}
try:
value = Variable('object.%s' % attr).resolve(pseudo_context)
except VariableDoesNotExist:
value = None
return value
def do_map(list, var):
try:
iter(list)
except TypeError:
# Not iterable, return an empty array
return []
return map(lambda item: Variable(var).resolve(item), list)
def _property_resolver(arg):
try:
float(arg)
except ValueError:
return Variable(arg).resolve
else:
return itemgetter(arg)
def render(self, context):
# our main context
storage = Context()
# stash the whole context if needed
if getattr(settings, 'PHASED_KEEP_CONTEXT', False):
storage.update(flatten_context(context))
# but check if there are variables specifically wanted
for var_name in self.var_names:
if var_name[0] in ('"', "'") and var_name[-1] == var_name[0]:
var_name = var_name[1:-1]
try:
storage[var_name] = Variable(var_name).resolve(context)
except VariableDoesNotExist:
raise TemplateSyntaxError(
'"phased" tag got an unknown variable: %r' % var_name)
storage = backup_csrf_token(context, storage)
# lastly return the pre phased template part
return u'%(delimiter)s%(content)s%(pickled)s%(delimiter)s' % {
'content': self.content,
'delimiter': settings.PHASED_SECRET_DELIMITER,
'pickled': pickle_context(storage),
}
def push_media(self, context):
if self.prev_context_hash == context.__hash__():
if DEBUG:
log.debug('same context: {0} == {1}'.format(
self.prev_context_hash, context.__hash__()))
return
self.prev_context_hash = context.__hash__()
cache = get_from_context_root(context, INSERT_TAG_KEY)
reqset = cache.get(self.container_name, None)
if not reqset:
reqset = []
cache[self.container_name] = reqset
insert_content = None
if self.insert_line == None:
if self.subnodes == None:
raise AttributeError(
'insert_line or subnodes must be specified')
insert_content = self.subnodes.render(context)
else:
if self.subnodes != None:
raise AttributeError(
'insert_line or subnodes must be specified, not both')
var = True
insert_content = Variable(self.insert_line).resolve(context)
reqset.append(OrderedItem(insert_content))
def get_theme(self, context):
# Get the current theme:
try:
request = Variable('request').resolve(context)
except VariableDoesNotExist:
request = None
return get_theme(request)
def resolve_var(
self,
varname: Union[str, 'TreeItemBase', FilterExpression],
context: Context = None
) -> Any:
"""Resolves name as a variable in a given context.
If no context specified page context is considered as context.
:param varname:
:param context:
"""
context = context or self.current_page_context
if isinstance(varname, FilterExpression):
varname = varname.resolve(context)
else:
varname = varname.strip()
try:
varname = Variable(varname).resolve(context)
except VariableDoesNotExist:
varname = varname
return varname
def render(self, context):
"""Add the tournament in the context to the arguments, then render as
usual."""
# In order to take advantage of the superclass's method, the easiest
# thing to do is to grab the string we want to insert, and turn it into
# a (literal) Variable for the superclass. This is a little roundabout,
# since we're creating a variable only for it to be turned back into
# the string again, but it's better than copy-pasting the superclass's
# method itself.
try:
tournament_slug = context['tournament'].slug
except KeyError:
raise TemplateSyntaxError(
"tournamenturl can only be used in contexts with a tournament rtf "
)
tournament_slug = Variable("'" + tournament_slug + "'")
self.args = list(
self._args
) # make a copy in case render() gets called multiple times
self.kwargs = dict(self._kwargs)
if self.kwargs:
self.kwargs['tournament_slug'] = tournament_slug
else:
self.args.insert(0, tournament_slug)
return super().render(context)
def render(self, context):
try:
value = Variable(self.var_value).resolve(context)
except VariableDoesNotExist as notexisterr:
value = ""
context[self.var_name] = value
return ""
def serialize_opportunistically(context, expressions):
"""
:param context: A template context
:param expressions: A list of strings that refer to the context, e.g. "foo.bar" or "baz.1"
:return: A string containing a JSON dump of a dictionary representing the parts of the
context that are referred to in the expressions, resolved to their final values.
In other words, a snapshot of the current context, limited to the listed names.
"""
ctx = {}
for expression in expressions:
try:
value = Variable(expression).resolve(context)
except VariableDoesNotExist:
logger.debug(
"JSX block refers to ctx.%s, but there's no variable by that name "
"in the Django template context.", expression)
if context.template:
string_if_invalid = context.template.engine.string_if_invalid
else:
string_if_invalid = ''
if '%s' in string_if_invalid:
value = string_if_invalid % expression
else:
value = string_if_invalid
set_nested(ctx, expression, value)
ctx = json.dumps(ctx)
return ctx
def ifnumbrefloat(value, n):
if value == None:
return 'None'
else:
try:
return round(float(value), int(n))
except ValueError:
return Variable(value).resolve
def render(self, context):
"""Add the round to the arguments, then render as usual."""
# Similar comment as for TournamentURLNode.render()
round = self.round.resolve(context) if self.round else context['round']
tournament_slug = Variable("'" + round.tournament.slug + "'")
round_seq = Variable("'%d'" % round.seq)
self.args = list(self._args) # make a copy in case render() gets called multiple times
self.kwargs = dict(self._kwargs)
if self.kwargs:
self.kwargs['tournament_slug'] = tournament_slug
self.kwargs['round_seq'] = round_seq
else:
self.args = [tournament_slug, round_seq] + self.args
return super().render(context)
def render(self, context):
try:
var = Variable(self.varname).resolve(context)
except:
var = 0
#deep = len(context.dicts)-1
context.dicts[0][self.varname] = var + 1
return ''
def test_nonliterals(self):
"""Variable names that aren't resolved as literals."""
var_names = []
for var in ('inf', 'infinity', 'iNFiniTy', 'nan'):
var_names.extend((var, '-' + var, '+' + var))
for var in var_names:
with self.subTest(var=var):
self.assertIsNone(Variable(var).literal)
def render(self, context):
num_spaces = Variable(self.num_spaces).resolve(context)
try:
num_spaces = int(num_spaces)
except ValueError:
raise TemplateSyntaxError('do_spaces tag\'s num_spaces argument '
'must be an int')
return ' ' * num_spaces
def sfpirg_pagination(context, token):
parts = token.split_contents()[1:]
for part in parts:
recordlist = Variable(part).resolve(context)
break
context['recordlist'] = recordlist
t = get_template('include/pagination.html')
return t.render(Context(context))
def dictsortreversed(value, arg):
"""
Takes a list of dicts, returns that list sorted in reverse order by the
property given in the argument.
"""
try:
return sorted(value, key=Variable(arg).resolve, reverse=True)
except (TypeError, VariableDoesNotExist):
return ''
def render_get_params(context):
"""Docstring."""
req = Variable("request").resolve(context)
data = req.GET.copy().urlencode()
if data:
return "?%s" % data
else:
return ""
def render(self, context):
dict = Variable(self.dict).resolve(context)
key = context.get(self.key, self.key)
default = context.get(self.default, self.default)
if dict:
context[self.context_key] = dict.get(key, default)
else:
context[self.context_key] = default
return ''
def dictsort(value, arg):
"""
Takes a list of dicts, returns that list sorted by the property given in
the argument.
"""
var_resolve = Variable(arg).resolve
decorated = [(var_resolve(item), item) for item in value]
decorated.sort()
return [item[1] for item in decorated]
def dictsort(value, arg):
"""
Takes a list of dicts, returns that list sorted by the property given in
the argument.
"""
try:
return sorted(value, key=Variable(arg).resolve)
except (TypeError, VariableDoesNotExist):
return u''
