def value_from_settings(parser, token):
bits = token.split_contents()
if len(bits) < 2:
raise TemplateSyntaxError("'%s' takes at least one " \
"argument (settings constant to retrieve)" % bits[0])
settingsvar = bits[1]
settingsvar = settingsvar[1:-1] if settingsvar[0] == '"' else settingsvar
asvar = None
bits = bits[2:]
if len(bits) >= 2 and bits[-2] == 'as':
asvar = bits[-1]
bits = bits[:-2]
if len(bits):
raise TemplateSyntaxError("'value_from_settings' didn't recognise " \
"the arguments '%s'" % ", ".join(bits))
if settingsvar not in settings.TEMPLATE_ALLOWABLE_SETTINGS_VALUES:
raise TemplateSyntaxError("The settings Variable %s is not allowed to be acessed" % settingsvar)
return ValueFromSettings(settingsvar, asvar)
python类TemplateSyntaxError()的实例源码
def get_rows(self):
"""Return the row data for this table broken out by columns."""
rows = []
try:
for datum in self.filtered_data:
row = self._meta.row_class(self, datum)
if self.get_object_id(datum) == self.current_item_id:
self.selected = True
row.classes.append('current_selected')
rows.append(row)
except Exception:
# Exceptions can be swallowed at the template level here,
# re-raising as a TemplateSyntaxError makes them visible.
LOG.exception("Error while rendering table rows.")
exc_info = sys.exc_info()
raise six.reraise(template.TemplateSyntaxError, exc_info[1],
exc_info[2])
return rows
def do_get_available_languages(parser, token):
"""
This will store a list of available languages
in the context.
Usage::
{% get_available_languages as languages %}
{% for language in languages %}
...
{% endfor %}
This will just pull the LANGUAGES setting from
your setting file (or the default settings) and
put it into the named variable.
"""
# token.split_contents() isn't useful here because this tag doesn't accept variable as arguments
args = token.contents.split()
if len(args) != 3 or args[1] != 'as':
raise TemplateSyntaxError("'get_available_languages' requires 'as variable' (got %r)" % args)
return GetAvailableLanguagesNode(args[2])
def do_get_language_info_list(parser, token):
"""
This will store a list of language information dictionaries for the given
language codes in a context variable. The language codes can be specified
either as a list of strings or a settings.LANGUAGES style list (or any
sequence of sequences whose first items are language codes).
Usage::
{% get_language_info_list for LANGUAGES as langs %}
{% for l in langs %}
{{ l.code }}
{{ l.name }}
{{ l.name_translated }}
{{ l.name_local }}
{{ l.bidi|yesno:"bi-directional,uni-directional" }}
{% endfor %}
"""
args = token.split_contents()
if len(args) != 5 or args[1] != 'for' or args[3] != 'as':
raise TemplateSyntaxError("'%s' requires 'for sequence as variable' (got %r)" % (args[0], args[1:]))
return GetLanguageInfoListNode(parser.compile_filter(args[2]), args[4])
def do_get_current_language(parser, token):
"""
This will store the current language in the context.
Usage::
{% get_current_language as language %}
This will fetch the currently active language and
put it's value into the ``language`` context
variable.
"""
# token.split_contents() isn't useful here because this tag doesn't accept variable as arguments
args = token.contents.split()
if len(args) != 3 or args[1] != 'as':
raise TemplateSyntaxError("'get_current_language' requires 'as variable' (got %r)" % args)
return GetCurrentLanguageNode(args[2])
def do_get_current_language_bidi(parser, token):
"""
This will store the current language layout in the context.
Usage::
{% get_current_language_bidi as bidi %}
This will fetch the currently active language's layout and
put it's value into the ``bidi`` context variable.
True indicates right-to-left layout, otherwise left-to-right
"""
# token.split_contents() isn't useful here because this tag doesn't accept variable as arguments
args = token.contents.split()
if len(args) != 3 or args[1] != 'as':
raise TemplateSyntaxError("'get_current_language_bidi' requires 'as variable' (got %r)" % args)
return GetCurrentLanguageBidiNode(args[2])
def language(parser, token):
"""
This will enable the given language just for this block.
Usage::
{% language "de" %}
This is {{ bar }} and {{ boo }}.
{% endlanguage %}
"""
bits = token.split_contents()
if len(bits) != 2:
raise TemplateSyntaxError("'%s' takes one argument (language)" % bits[0])
language = parser.compile_filter(bits[1])
nodelist = parser.parse(('endlanguage',))
parser.delete_first_token()
return LanguageNode(nodelist, language)
def localtime_tag(parser, token):
"""
Forces or prevents conversion of datetime objects to local time,
regardless of the value of ``settings.USE_TZ``.
Sample usage::
{% localtime off %}{{ value_in_utc }}{% endlocaltime %}
"""
bits = token.split_contents()
if len(bits) == 1:
use_tz = True
elif len(bits) > 2 or bits[1] not in ('on', 'off'):
raise TemplateSyntaxError("%r argument should be 'on' or 'off'" %
bits[0])
else:
use_tz = bits[1] == 'on'
nodelist = parser.parse(('endlocaltime',))
parser.delete_first_token()
return LocalTimeNode(nodelist, use_tz)
def get_current_timezone_tag(parser, token):
"""
Stores the name of the current time zone in the context.
Usage::
{% get_current_timezone as TIME_ZONE %}
This will fetch the currently active time zone and put its name
into the ``TIME_ZONE`` context variable.
"""
# token.split_contents() isn't useful here because this tag doesn't accept variable as arguments
args = token.contents.split()
if len(args) != 3 or args[1] != 'as':
raise TemplateSyntaxError("'get_current_timezone' requires "
"'as variable' (got %r)" % args)
return GetCurrentTimezoneNode(args[2])
def localize_tag(parser, token):
"""
Forces or prevents localization of values, regardless of the value of
`settings.USE_L10N`.
Sample usage::
{% localize off %}
var pi = {{ 3.1415 }};
{% endlocalize %}
"""
use_l10n = None
bits = list(token.split_contents())
if len(bits) == 1:
use_l10n = True
elif len(bits) > 2 or bits[1] not in ('on', 'off'):
raise TemplateSyntaxError("%r argument should be 'on' or 'off'" % bits[0])
else:
use_l10n = bits[1] == 'on'
nodelist = parser.parse(('endlocalize',))
parser.delete_first_token()
return LocalizeNode(nodelist, use_l10n)
def do_macro(parser, token):
try:
args = token.split_contents()
tag_name, macro_name, args = args[0], args[1], args[2:]
except IndexError:
m = ("'%s' tag requires at least one argument (macro name)"
% token.contents.split()[0])
raise template.TemplateSyntaxError, m
# TODO: could do some validations here,
# for now, "blow your head clean off"
nodelist = parser.parse(('endkwacro', ))
parser.delete_first_token()
## Metadata of each macro are stored in a new attribute
## of 'parser' class. That way we can access it later
## in the template when processing 'usemacro' tags.
_setup_macros_dict(parser)
parser._macros[macro_name] = DefineMacroNode(macro_name, nodelist, args)
return parser._macros[macro_name]
def do_loadmacros(parser, token):
try:
tag_name, filename = token.split_contents()
except IndexError:
m = ("'%s' tag requires at least one argument (macro name)"
% token.contents.split()[0])
raise template.TemplateSyntaxError, m
if filename[0] in ('"', "'") and filename[-1] == filename[0]:
filename = filename[1:-1]
t = get_template(filename)
macros = t.nodelist.get_nodes_by_type(DefineMacroNode)
## Metadata of each macro are stored in a new attribute
## of 'parser' class. That way we can access it later
## in the template when processing 'usemacro' tags.
_setup_macros_dict(parser)
for macro in macros:
parser._macros[macro.name] = macro
return LoadMacrosNode()
def do_include_raw(parser, token):
"""
Performs a template include without parsing the context, just dumps
the template in.
Source: http://djangosnippets.org/snippets/1684/
"""
bits = token.split_contents()
if len(bits) != 2:
raise template.TemplateSyntaxError(
"%r tag takes one argument: the name of the template "
"to be included" % bits[0]
)
template_name = bits[1]
if (template_name[0] in ('"', "'") and
template_name[-1] == template_name[0]):
template_name = template_name[1:-1]
source, __ = get_template_source(template_name)
return template.base.TextNode(source)
def get_legalpages(parser, token):
"""
Retrieves all active LegalPage objects.
Populates the template context with them in a variable
whose name is defined by the ``as`` clause.
Syntax::
{% get_legalpages as context_name %}
"""
bits = token.split_contents()
syntax_message = ("%(tag_name)s expects a syntax of %(tag_name)s "
"as context_name" %
dict(tag_name=bits[0]))
if len(bits) == 3:
if bits[1] != 'as':
raise template.TemplateSyntaxError(syntax_message)
context_name = bits[2]
return LegalPageNode(context_name)
else:
raise template.TemplateSyntaxError(syntax_message)
def staticpage_url(parser, token):
"""Returns the internal URL for a static page based on its virtual path.
Syntax::
{% staticpage_url 'virtual/path' %}
"""
bits = token.split_contents()
syntax_message = ("%(tag_name)s expects a syntax of %(tag_name)s "
"'virtual/path'" %
dict(tag_name=bits[0]))
quote_message = "%s tag's argument should be in quotes" % bits[0]
if len(bits) == 2:
virtual_path = bits[1]
if (not (virtual_path[0] == virtual_path[-1] and
virtual_path[0] in ('"', "'"))):
raise template.TemplateSyntaxError(quote_message)
return StaticPageURLNode(virtual_path[1:-1])
raise template.TemplateSyntaxError(syntax_message)
def do_form_field(parser, token):
"""
Render a WTForms form field allowing optional HTML attributes.
Invocation looks like this:
{% form_field form.username class="big_text" onclick="alert('hello')" %}
where form.username is the path to the field value we want. Any number
of key="value" arguments are supported. Unquoted values are resolved as
template variables.
"""
parts = token.contents.split(' ', 2)
if len(parts) < 2:
error_text = '%r tag must have the form field name as the first value, followed by optional key="value" attributes.'
raise template.TemplateSyntaxError(error_text % parts[0])
html_attrs = {}
if len(parts) == 3:
raw_args = list(args_split(parts[2]))
if (len(raw_args) % 2) != 0:
raise template.TemplateSyntaxError('%r tag received the incorrect number of key=value arguments.' % parts[0])
for x in range(0, len(raw_args), 2):
html_attrs[str(raw_args[x])] = Variable(raw_args[x + 1])
return FormFieldNode(parts[1], html_attrs)
def do_form_field(parser, token):
"""
Render a WTForms form field allowing optional HTML attributes.
Invocation looks like this:
{% form_field form.username class="big_text" onclick="alert('hello')" %}
where form.username is the path to the field value we want. Any number
of key="value" arguments are supported. Unquoted values are resolved as
template variables.
"""
parts = token.contents.split(' ', 2)
if len(parts) < 2:
error_text = '%r tag must have the form field name as the first value, followed by optional key="value" attributes.'
raise template.TemplateSyntaxError(error_text % parts[0])
html_attrs = {}
if len(parts) == 3:
raw_args = list(args_split(parts[2]))
if (len(raw_args) % 2) != 0:
raise template.TemplateSyntaxError('%r tag received the incorrect number of key=value arguments.' % parts[0])
for x in range(0, len(raw_args), 2):
html_attrs[str(raw_args[x])] = Variable(raw_args[x + 1])
return FormFieldNode(parts[1], html_attrs)
def get_photo(parser, token):
"""Get a single photo from the photologue library and return the img tag to display it.
Takes 3 args:
- the photo to display. This can be either the slug of a photo, or a variable that holds either a photo instance or
a integer (photo id)
- the photosize to use.
- a CSS class to apply to the img tag.
"""
try:
# Split the contents of the tag, i.e. tag name + argument.
tag_name, photo, photosize, css_class = token.split_contents()
except ValueError:
msg = '%r tag requires 3 arguments' % token.contents[0]
raise template.TemplateSyntaxError(msg)
return PhotoNode(photo, photosize[1:-1], css_class[1:-1])
def get_rotating_photo(parser, token):
"""Pick at random a photo from a given photologue gallery and return the img tag to display it.
Takes 3 args:
- the gallery to pick a photo from. This can be either the slug of a gallery, or a variable that holds either a
gallery instance or a gallery slug.
- the photosize to use.
- a CSS class to apply to the img tag.
"""
try:
# Split the contents of the tag, i.e. tag name + argument.
tag_name, gallery, photosize, css_class = token.split_contents()
except ValueError:
msg = '%r tag requires 3 arguments' % token.contents[0]
raise template.TemplateSyntaxError(msg)
return PhotoGalleryNode(gallery, photosize[1:-1], css_class[1:-1])
def do_user_display(parser, token):
"""
Example usage::
{% user_display user %}
or if you need to use in a {% blocktrans %}::
{% user_display user as user_display}
{% blocktrans %}{{ user_display }} has sent you a gift.{% endblocktrans %}
"""
bits = token.split_contents()
if len(bits) == 2:
user = bits[1]
as_var = None
elif len(bits) == 4:
user = bits[1]
as_var = bits[3]
else:
raise template.TemplateSyntaxError("'%s' takes either two or four arguments" % bits[0])
return UserDisplayNode(user, as_var)
def do_form_field(parser, token):
"""
Render a WTForms form field allowing optional HTML attributes.
Invocation looks like this:
{% form_field form.username class="big_text" onclick="alert('hello')" %}
where form.username is the path to the field value we want. Any number
of key="value" arguments are supported. Unquoted values are resolved as
template variables.
"""
parts = token.contents.split(' ', 2)
if len(parts) < 2:
raise template.TemplateSyntaxError('%r tag must have the form field name as the first value, followed by optional key="value" attributes.' % parts[0])
html_attrs = {}
if len(parts) == 3:
raw_args = list(args_split(parts[2]))
if (len(raw_args) % 2) != 0:
raise template.TemplateSyntaxError('%r tag received the incorrect number of key=value arguments.' % parts[0])
for x in range(0, len(raw_args), 2):
html_attrs[str(raw_args[x])] = Variable(raw_args[x+1])
return FormFieldNode(parts[1], html_attrs)
def do_get_or_create_calendar_for_object(parser, token):
contents = token.split_contents()
if len(contents) > 2:
obj = contents[1]
if 'by' in contents:
by_index = contents.index('by')
distinction = contents[by_index + 1]
else:
distinction = None
if 'named' in contents:
named_index = contents.index('named')
name = contents[named_index + 1]
if name[0] == name[-1]:
name = name[1:-1]
else:
name = None
if 'as' in contents:
as_index = contents.index('as')
context_var = contents[as_index + 1]
else:
raise template.TemplateSyntaxError("%r tag requires an a context variable: %r <content_object> [named <calendar name>] [by <distinction>] as <context_var>" % (token.split_contents()[0], token.split_contents()[0]))
else:
raise template.TemplateSyntaxError("%r tag follows form %r <content_object> [named <calendar name>] [by <distinction>] as <context_var>" % (token.split_contents()[0], token.split_contents()[0]))
return CreateCalendarNode(obj, distinction, context_var, name)
def do_user_display(parser, token):
"""
Example usage::
{% user_display user %}
or if you need to use in a {% blocktrans %}::
{% user_display user as user_display}
{% blocktrans %}{{ user_display }} has sent you a gift.{% endblocktrans %}
"""
bits = token.split_contents()
if len(bits) == 2:
user = bits[1]
as_var = None
elif len(bits) == 4:
user = bits[1]
as_var = bits[3]
else:
raise template.TemplateSyntaxError("'{0}' takes either two or four arguments".format(bits[0]))
return UserDisplayNode(user, as_var)
def do_macro(parser, token):
try:
args = token.split_contents()
tag_name, macro_name, args = args[0], args[1], args[2:]
except IndexError:
m = ("'%s' tag requires at least one argument (macro name)"
% token.contents.split()[0])
raise template.TemplateSyntaxError(m)
# TODO: could do some validations here,
# for now, "blow your head clean off"
nodelist = parser.parse(('end__pypugjs_kwacro', ))
parser.delete_first_token()
## Metadata of each macro are stored in a new attribute
## of 'parser' class. That way we can access it later
## in the template when processing 'usemacro' tags.
_setup_macros_dict(parser)
parser._macros[macro_name] = DefineMacroNode(macro_name, nodelist, args)
return parser._macros[macro_name]
def do_loadmacros(parser, token):
try:
tag_name, filename = token.split_contents()
except IndexError:
m = ("'%s' tag requires at least one argument (macro name)"
% token.contents.split()[0])
raise template.TemplateSyntaxError(m)
if filename[0] in ('"', "'") and filename[-1] == filename[0]:
filename = filename[1:-1]
t = get_template(filename)
macros = t.nodelist.get_nodes_by_type(DefineMacroNode)
## Metadata of each macro are stored in a new attribute
## of 'parser' class. That way we can access it later
## in the template when processing 'usemacro' tags.
_setup_macros_dict(parser)
for macro in macros:
parser._macros[macro.name] = macro
return LoadMacrosNode()
def render(self, context):
"""returns html div element representing compass url
:param context: django context
:type context: django context object
:returns: html div element <div>Compass content</div>
:rtype: str
"""
global _urlcompass_ufl_container
_urlcompass_ufl_container=context['_urlcompass_ufl_container']
try:
view_url=_urlcompass_ufl_container[self.view]
except KeyError:
raise django_template.TemplateSyntaxError("{} view-key not found in {}"\
.format(self.view,
list(_urlcompass_ufl_container.keys())))
return view_url
def do_form_field(parser, token):
"""
Render a WTForms form field allowing optional HTML attributes.
Invocation looks like this:
{% form_field form.username class="big_text" onclick="alert('hello')" %}
where form.username is the path to the field value we want. Any number
of key="value" arguments are supported. Unquoted values are resolved as
template variables.
"""
parts = token.contents.split(' ', 2)
if len(parts) < 2:
error_text = '%r tag must have the form field name as the first value, followed by optional key="value" attributes.'
raise template.TemplateSyntaxError(error_text % parts[0])
html_attrs = {}
if len(parts) == 3:
raw_args = list(args_split(parts[2]))
if (len(raw_args) % 2) != 0:
raise template.TemplateSyntaxError('%r tag received the incorrect number of key=value arguments.' % parts[0])
for x in range(0, len(raw_args), 2):
html_attrs[str(raw_args[x])] = Variable(raw_args[x + 1])
return FormFieldNode(parts[1], html_attrs)
def get_articles(parser, token):
"""
Retrieves a list of Article objects for use in a template.
"""
args = token.split_contents()
argc = len(args)
try:
assert argc in (4,6) or (argc in (5,7) and args[-1].lower() in ('desc', 'asc'))
except AssertionError:
raise template.TemplateSyntaxError('Invalid get_articles syntax.')
# determine what parameters to use
order = 'desc'
count = start = end = varname = None
if argc == 4: t, count, a, varname = args
elif argc == 5: t, count, a, varname, order = args
elif argc == 6: t, start, t, end, a, varname = args
elif argc == 7: t, start, t, end, a, varname, order = args
return GetArticlesNode(count=count,
start=start,
end=end,
order=order,
varname=varname)
def get_page_url(parser, token):
"""
Determines the URL of a pagination page link based on the page from which
this tag is called.
"""
args = token.split_contents()
argc = len(args)
varname = None
try:
assert argc in (2, 4)
except AssertionError:
raise template.TemplateSyntaxError('get_page_url syntax: {% get_page_url page_num as varname %}')
if argc == 4: varname = args[3]
return GetPageURLNode(args[1], varname)
def fullurl(parser, token):
"""
Builds an absolute (full) URL from the given location and the variables available in the request.
If no location is specified, the absolute (full) URL is built on :py:meth:`django.http.HttpRequest.get_full_path`.
It is a wrapper around :py:meth:`django.http.HttpRequest.build_absolute_uri`. It requires ``request`` to be available
in the template context (for example, by using ``django.core.context_processors.request`` context processor).
Samply usage::
{% url path.to.some_view as the_url %}
{% fullurl the_url %}
"""
args = list(token.split_contents())
if len(args) > 2:
raise template.TemplateSyntaxError("'%s' tag requires at most one argument" % args[0])
if len(args) == 2:
url = parser.compile_filter(args[1])
else:
url = None
return FullUrlNode(url)
