我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用django.template.TemplateSyntaxError()。
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)
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 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 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)
def ifusergroup(parser, token): """ Check to see if the currently logged in user belongs to one or more groups Requires the Django authentication contrib app and middleware. Usage: {% ifusergroup Admins %} ... {% endifusergroup %}, or {% ifusergroup Admins Clients Programmers Managers %} ... {% else %} ... {% endifusergroup %} """ try: tokens = token.split_contents() groups = [] groups += tokens[1:] except ValueError: raise template.TemplateSyntaxError("Tag 'ifusergroup' requires at least 1 argument.") nodelist_true = parser.parse(('else', 'endifusergroup')) token = parser.next_token() if token.contents == 'else': nodelist_false = parser.parse(('endifusergroup',)) parser.delete_first_token() else: nodelist_false = template.NodeList() return GroupCheckNode(groups, nodelist_true, nodelist_false)
def ifappexists(parser, token): """ Conditional Django template tag to check if one or more apps exist. Usage: {% ifappexists tag %} ... {% endifappexists %}, or {% ifappexists tag inventory %} ... {% else %} ... {% endifappexists %} """ try: tokens = token.split_contents() apps = [] apps += tokens[1:] except ValueError: raise template.TemplateSyntaxError("Tag 'ifappexists' requires at least 1 argument.") nodelist_true = parser.parse(('else', 'endifappexists')) token = parser.next_token() if token.contents == 'else': nodelist_false = parser.parse(('endifappexists',)) parser.delete_first_token() else: nodelist_false = template.NodeList() return AppCheckNode(apps, nodelist_true, nodelist_false)
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 urlize_html(html): """ Returns urls found in an (X)HTML text node element as urls via Django urlize filter. """ try: from bs4 import BeautifulSoup except ImportError: if settings.DEBUG: raise template.TemplateSyntaxError( "Error in urlize_html The Python BeautifulSoup libraries aren't installed.") return html else: soup = BeautifulSoup(html, 'html.parser') text_nodes = soup.find_all(text=True) for text_node in text_nodes: urlized_text = urlize(text_node) text_node.replace_with(BeautifulSoup(urlized_text, 'html.parser')) return mark_safe(str(soup))
