How to use the jinja.exceptions.TemplateSyntaxError function in Jinja

def parse_subscript_expression(self, node):
        """
        Parse a subscript statement. Gets attributes and items from an
        object.
        """
        lineno = self.stream.lineno
        if self.stream.current.type == 'dot':
            self.stream.next()
            token = self.stream.current
            if token.type in ('name', 'integer'):
                arg = nodes.ConstantExpression(token.value, token.lineno,
                                               self.filename)
            else:
                raise TemplateSyntaxError('expected name or number',
                                          token.lineno, self.filename)
            self.stream.next()
        elif self.stream.current.type == 'lbracket':
            self.stream.next()
            args = []
            while self.stream.current.type != 'rbracket':
                if args:
                    self.stream.expect('comma')
                args.append(self.parse_subscribed_expression())
            self.stream.expect('rbracket')
            if len(args) == 1:
                arg = args[0]
            else:
                arg = nodes.TupleExpression(args, lineno, self.filename)
        else:
            raise TemplateSyntaxError('expected subscript expression',

parse = self.parse_expression
        args = []
        is_tuple = False
        while True:
            if args:
                self.stream.expect('comma')
            if self.stream.current.type in tuple_edge_tokens:
                break
            args.append(parse())
            if self.stream.current.type == 'comma':
                is_tuple = True
            else:
                break
        if not is_tuple and args:
            if enforce:
                raise TemplateSyntaxError('tuple expected', lineno,
                                          self.filename)
            return args[0]
        return nodes.TupleExpression(args, lineno, self.filename)

def _sanitize_tree(self, nodelist, stack, extends, body):
        """
        This is not a closure because python leaks memory if it is.  It's used
        by `parse()` to make sure blocks do not trigger unexpected behavior.
        """
        for node in nodelist:
            if extends is not None and \
                 node.__class__ is nodes.Block and \
                 stack[-1] is not body:
                for n in stack:
                    if n.__class__ is nodes.Block:
                        break
                else:
                    raise TemplateSyntaxError('misplaced block %r, '
                                              'blocks in child '
                                              'templates must be '
                                              'either top level or '
                                              'located in a block '
                                              'tag.' % node.name,
                                              node.lineno,
                                              self.filename)
            stack.append(node)
            self._sanitize_tree(node.get_child_nodes(), stack, extends, body)
            stack.pop()

def process_variable():
            var_name = self.stream.expect('name')
            if var_name.value not in replacements:
                raise TemplateSyntaxError('unregistered translation variable'
                                          " '%s'." % var_name.value,
                                          var_name.lineno, self.filename)
            buf.append('%%(%s)s' % var_name.value)

def parse_raw_directive(self):
        """
        Handle fake raw directive. (real raw directives are handled by
        the lexer. But if there are arguments to raw or the end tag
        is missing the parser tries to resolve this directive. In that
        case present the user a useful error message.
        """
        if self.stream:
            raise TemplateSyntaxError('raw directive does not support '
                                      'any arguments.', self.stream.lineno,
                                      self.filename)
        raise TemplateSyntaxError('missing end tag for raw directive.',
                                  self.stream.lineno, self.filename)

def parse_number_expression(self):
        """
        Parse a number literal.
        """
        token = self.stream.current
        if token.type not in ('integer', 'float'):
            raise TemplateSyntaxError('integer or float literal expected',
                                      token.lineno, self.filename)
        self.stream.next()
        return nodes.ConstantExpression(token.value, token.lineno, self.filename)

token.lineno, self.filename)
            self.stream.next()
        elif self.stream.current.type == 'lbracket':
            self.stream.next()
            args = []
            while self.stream.current.type != 'rbracket':
                if args:
                    self.stream.expect('comma')
                args.append(self.parse_subscribed_expression())
            self.stream.expect('rbracket')
            if len(args) == 1:
                arg = args[0]
            else:
                arg = nodes.TupleExpression(args, lineno, self.filename)
        else:
            raise TemplateSyntaxError('expected subscript expression',
                                      self.lineno, self.filename)
        return nodes.SubscriptExpression(node, arg, lineno, self.filename)