Python jinja2.TemplateNotFound方法代码示例

# 需要导入模块: import jinja2 [as 别名]
# 或者: from jinja2 import TemplateNotFound [as 别名]
def get_source(self, environment, template):
        """Get the template source, filename and reload helper for a template.
        It's passed the environment and template name and has to return a
        tuple in the form ``(source, filename, uptodate)`` or raise a
        `TemplateNotFound` error if it can't locate the template.

        The source part of the returned tuple must be the source of the
        template as unicode string or a ASCII bytestring.  The filename should
        be the name of the file on the filesystem if it was loaded from there,
        otherwise `None`.  The filename is used by python for the tracebacks
        if no loader extension is used.

        The last item in the tuple is the `uptodate` function.  If auto
        reloading is enabled it's always called to check if the template
        changed.  No arguments are passed so the function must store the
        old state somewhere (for example in a closure).  If it returns `False`
        the template will be reloaded.
        """
        if not self.has_source_access:
            raise RuntimeError('%s cannot provide access to the source' %
                               self.__class__.__name__)
        raise TemplateNotFound(template) 

# 需要导入模块: import jinja2 [as 别名]
# 或者: from jinja2 import TemplateNotFound [as 别名]
def render_template(self, template_name, **kwargs):
        template_dir = os.environ['TEMPLATE_FOLDER']

        env = Environment(loader=FileSystemLoader(template_dir))

        env.globals['css'] = css
        env.globals['script'] = script

        self.dict_object.update(**kwargs)

        try:
            template = env.get_template(template_name)
        except TemplateNotFound:
            raise TemplateNotFound(template_name)
        content = template.render(self.dict_object)
        return content 

# 需要导入模块: import jinja2 [as 别名]
# 或者: from jinja2 import TemplateNotFound [as 别名]
def get_source(
        self, environment: Environment, template: str
    ) -> Tuple[str, Optional[str], Callable]:
        """Returns the template source from the environment.

        This considers the loaders on the :attr:`app` and blueprints.
        """
        for loader in self._loaders():
            try:
                return loader.get_source(environment, template)
            except TemplateNotFound:
                continue
        raise TemplateNotFound(template) 

# 需要导入模块: import jinja2 [as 别名]
# 或者: from jinja2 import TemplateNotFound [as 别名]
def get_source(self, environment, template):
        for template_file in self.files:
            if os.path.basename(template_file) == template:
                with open(template_file) as f:
                    contents = f.read()
                mtime = os.path.getmtime(template_file)
                return (contents,
                        template_file,
                        lambda: mtime == os.path.getmtime(template_file))
        else:
            raise jinja2.TemplateNotFound(template) 

# 需要导入模块: import jinja2 [as 别名]
# 或者: from jinja2 import TemplateNotFound [as 别名]
def split_template_path(template):
    """Split a path into segments and perform a sanity check.  If it detects
    '..' in the path it will raise a `TemplateNotFound` error.
    """
    pieces = []
    for piece in template.split('/'):
        if path.sep in piece \
           or (path.altsep and path.altsep in piece) or \
           piece == path.pardir:
            raise TemplateNotFound(template)
        elif piece and piece != '.':
            pieces.append(piece)
    return pieces 

# 需要导入模块: import jinja2 [as 别名]
# 或者: from jinja2 import TemplateNotFound [as 别名]
def get_loader(self, template):
        try:
            prefix, name = template.split(self.delimiter, 1)
            loader = self.mapping[prefix]
        except (ValueError, KeyError):
            raise TemplateNotFound(template)
        return loader, name 

# 需要导入模块: import jinja2 [as 别名]
# 或者: from jinja2 import TemplateNotFound [as 别名]
def load(self, environment, name, globals=None):
        loader, local_name = self.get_loader(name)
        try:
            return loader.load(environment, local_name, globals)
        except TemplateNotFound:
            # re-raise the exception with the correct filename here.
            # (the one that includes the prefix)
            raise TemplateNotFound(name)