Python exceptions.TemplateNotFound方法代码示例

# 需要导入模块: from jinja2 import exceptions [as 别名]
# 或者: from jinja2.exceptions 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) 

# 需要导入模块: from jinja2 import exceptions [as 别名]
# 或者: from jinja2.exceptions import TemplateNotFound [as 别名]
def test_list_fields(self, mytemplater):
        # invalid template names
        invalid_names = [None, True, False]
        for invalid_name in invalid_names:
            with pytest.raises(BadValue):
                mytemplater.listFields(invalid_name)

        # nonexistent template names
        fake_names = ["fake_name1", "fake_name2"]
        for fake_name in fake_names:
            with pytest.raises(jinja2_excp.TemplateNotFound):
                mytemplater.listFields(fake_name)

        # existent template
        fields = mytemplater.listFields(utils_test.template_name)
        fields_set = set(["severity", "title", "teamArea",
                          "description", "filedAgainst", "priority",
                          "ownedBy", "plannedFor"])
        assert fields == fields_set 

# 需要导入模块: from jinja2 import exceptions [as 别名]
# 或者: from jinja2.exceptions import TemplateNotFound [as 别名]
def get_jinja_template(templates_dir, template_name):
    """ Gets the jinja template specified

        Args:
            templates_dir ('str'): Templates directory
            template_name ('str'): Template name

        Returns:
            ('obj') jinja template
            None

        Raises:
            None
    """
    env = jinja2.Environment(
        loader=jinja2.FileSystemLoader(searchpath=templates_dir),
        undefined=jinja2.StrictUndefined
    )

    try:
        template = env.get_template(template_name)
    except TemplateNotFound:
        return

    return template 

# 需要导入模块: from jinja2 import exceptions [as 别名]
# 或者: from jinja2.exceptions import TemplateNotFound [as 别名]
def generate_by_context(self, context):
        if context is None:
            raise RuntimeError('Can\'t generate templates from None context')

        templates = self._preprocess_templates(context.get('templates', []))
        if len(templates) == 0:
            templates = context.get('kubectl', [])
            if len(templates) == 0:
                return

        output = []
        for template in self._iterate_entries(templates):
            try:
                path = self._generate_file(template, settings.TEMP_DIR, context)
                log.info('File "{}" successfully generated'.format(path))
                output.append(path)
            except TemplateNotFound as e:
                raise TemplateRenderingError(
                    "Processing {}: template {} hasn't been found".format(template['template'], e.name))
            except (UndefinedError, TemplateSyntaxError) as e:
                raise TemplateRenderingError('Unable to render {}, due to: {}'.format(template, e))
        return output 

# 需要导入模块: from jinja2 import exceptions [as 别名]
# 或者: from jinja2.exceptions 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 

# 需要导入模块: from jinja2 import exceptions [as 别名]
# 或者: from jinja2.exceptions 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