python类StrictUndefined()的实例源码

def render_from_string(template, **kwargs):
    env = Environment(undefined=StrictUndefined,
                      trim_blocks=True)
    template = env.from_string(template)
    return template.render(**kwargs)

def generate_wiki(self, data, wiki_template):
        """generates wiki file based on data file and wiki template"""
        env = Environment(loader=FileSystemLoader(TEMPLATES_PATH),
                          undefined=StrictUndefined, trim_blocks=True)
        for b in data.get('builds', []):
            b['issues'] = convert_bugs_to_links(b['issues'])
        template = env.get_template(wiki_template)
        return template.render(**data)

def get_parsed_lines(self):
        ''' Returns a set of lines with all variables filed in '''
        try:
            return Template(self.profile, undefined=StrictUndefined).render(self.variables)
        except UndefinedError as e:
            raise Exception(e)

def build(staticdatadir, outdir, templatedir, input_file):
    try:
        shutil.rmtree(outdir)
    except Exception:
        pass
    os.makedirs(outdir)

    data = {ident: load_data(os.path.join(staticdatadir, filename))
            for ident, filename in STATIC_DATA_FILES.items()}
    data['schema'] = registered_properties

    data['results'] = results = {}
    for filename in input_file:
        result = load_data(filename)
        try:
            result = dict(result)
        except ValueError:
            raise ValueError('Data needs to be a mapping: ', filename)
        if not set(result.keys()).isdisjoint(results.keys()):
            raise ValueError('Overwriting data: ', filename)
        results.update(result)

    loader = jinja2.FileSystemLoader(templatedir)
    template_env = jinja2.Environment(
        loader=loader,
        undefined=jinja2.StrictUndefined,
        )

    def render(out_name, template_name, **env):
        template = template_env.get_template(template_name)
        result = template.render(data=data, **env)
        output_filename = os.path.join(outdir, out_name)
        dirname = os.path.dirname(output_filename)
        try:
            os.makedirs(dirname)
        except OSError:
            pass
        print('Writing:', output_filename)
        with open(output_filename, 'w') as file:
            file.write(result)

    # Render all the pages
    render('index.html', 'index.html', breadcrumbs=())

    for name, testcase in data['results'].items():
        render('cases/{}.html'.format(name), 'testcase.html',
               testcase_name=name, testcase=testcase,
               breadcrumbs=[
                   ('Network Test Report', '../index.html'),
                   (name, None),
               ])

    print('Wrote to', os.path.abspath(outdir))

def _template(self, filename, filters=None, alternate_marking=False):
        """ Open a template file

        """
        def filter_wordwrap(value, width=79):
            return '\n\n'.join([textwrap.fill(str, width) for str in value.split('\n\n')])

        def filter_indent(value, level=0, prefix=""):
            return ('\n' + '\t' * level + prefix).join(value.split('\n'))

        def global_abort_helper(msg):
            raise BuilderException(msg)

        if filename.startswith('#'):
            name = filename[1:]
            loader = jinja2.PackageLoader('pando', 'resources')
        else:
            # if not os.path.isabs(filename):
            #   relpath = os.path.dirname(os.path.abspath(__file__))
            #   path = os.path.join(relpath, path)
            path = os.path.dirname(filename)
            name = os.path.basename(filename)
            loader = jinja2.FileSystemLoader(path)

        if alternate_marking:
            environment = jinja2.Environment(
                block_start_string='<%',
                block_end_string='%>',
                variable_start_string='<<',
                variable_end_string='>>',
                comment_start_string='<#',
                comment_end_string='#>',

                line_statement_prefix='##',
                line_comment_prefix='###',

                loader=loader,
                undefined=jinja2.StrictUndefined,
                extensions=["jinja2.ext.loopcontrols"])
        else:
            environment = jinja2.Environment(
                line_statement_prefix='##',
                line_comment_prefix='###',

                loader=loader,
                undefined=jinja2.StrictUndefined,
                extensions=["jinja2.ext.loopcontrols"])
        environment.filters['xpcc.wordwrap'] = filter_wordwrap
        environment.filters['xpcc.indent'] = filter_indent

        environment.globals['abort'] = global_abort_helper
        if filters:
            environment.filters.update(filters)
        template = environment.get_template(name, globals=self.globals)
        return template

def render_template(self, name_or_statement, context=None, by_name=False):

        if by_name:
            if name_or_statement not in self._templates:
                raise ValueError("No such template of name: '{}'.".format(name_or_statement))
            statement = self._templates[name_or_statement]
        else:
            statement = name_or_statement

        try:
            from sqlalchemy.sql.base import Executable
            if isinstance(statement, Executable):
                statement = str(statement.compile(compile_kwargs={"literal_binds": True}))
        except ImportError:
            pass

        if context is None or context is False:
            context = {}

        template_context = {}
        template_context.update(self._template_context)  # default context
        template_context.update(context)  # context passed in
        intersection = set(self._template_context.keys()) & set(context.keys())
        if intersection:
            logger.warning(
                "The following default template context keys have been overridden "
                "by the local context: {}."
                .format(intersection)
            )

        # Substitute in any other named statements recursively
        while '{{{' in statement or '{{%' in statement:
            statement = Template(statement,
                                 block_start_string='{{%',
                                 block_end_string='%}}',
                                 variable_start_string='{{{',
                                 variable_end_string='}}}',
                                 comment_start_string='{{#',
                                 comment_end_string='#}}',
                                 undefined=StrictUndefined).render(getattr(self, '_templates', {}))

        return Template(statement, undefined=StrictUndefined).render(template_context)