我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用jinja2.Environment()。
def render_and_write(template_dir, path, context): """Renders the specified template into the file. :param template_dir: the directory to load the template from :param path: the path to write the templated contents to :param context: the parameters to pass to the rendering engine """ env = Environment(loader=FileSystemLoader(template_dir)) template_file = os.path.basename(path) template = env.get_template(template_file) log('Rendering from template: %s' % template.name, level=DEBUG) rendered_content = template.render(context) if not rendered_content: log("Render returned None - skipping '%s'" % path, level=WARNING) return write(path, rendered_content.encode('utf-8').strip()) log('Wrote template %s' % path, level=DEBUG)
def __init__(self, templates_dir, openstack_release): if not os.path.isdir(templates_dir): log('Could not locate templates dir %s' % templates_dir, level=ERROR) raise OSConfigException self.templates_dir = templates_dir self.openstack_release = openstack_release self.templates = {} self._tmpl_env = None if None in [Environment, ChoiceLoader, FileSystemLoader]: # if this code is running, the object is created pre-install hook. # jinja2 shouldn't get touched until the module is reloaded on next # hook execution, with proper jinja2 bits successfully imported. apt_install('python-jinja2')
def template_file(in_file_path, out_file_path, **kwargs): """ Templates the given file with the keyword arguments. Args: in_file_path: The path to the template out_file_path: The path to output the templated file **kwargs: Variables to use in templating """ env = Environment(loader=FileSystemLoader(os.path.dirname(in_file_path)), keep_trailing_newline=True) template = env.get_template(os.path.basename(in_file_path)) output = template.render(**kwargs) with open(out_file_path, "w") as f: f.write(output)
def init_jinja2(app, **kw): logging.info('init jinja2...') options = { 'autoescape': kw.get('autoescape', True), 'block_start_string': kw.get('block_start_string', '{%'), 'block_end_string': kw.get('block_end_string', '%}'), 'variable_start_string': kw.get('variable_start_string', '{{'), 'variable_end_string': kw.get('variable_end_string', '}}'), 'auto_reload': kw.get('auto_reload', True) } path = kw.get('path', os.path.join(__path__[0], 'templates')) logging.info('set jinja2 template path: %s' % path) env = Environment(loader=FileSystemLoader(path), **options) filters = kw.get('filters') if filters is not None: for name, ftr in filters.items(): env.filters[name] = ftr app['__templating__'] = env
def setUp(self): self.template_env = jinja2.Environment( loader=jinja2.FileSystemLoader("config") ) # create working dir self.working_dir = os.path.join(build_path + "run", self.id()) if os.path.exists(self.working_dir): shutil.rmtree(self.working_dir) os.makedirs(self.working_dir) try: # update the last_run link if os.path.islink(build_path + "last_run"): os.unlink(build_path + "last_run") os.symlink(build_path + "run/{}".format(self.id()), build_path + "last_run") except: # symlink is best effort and can fail when # running tests in parallel pass
def get(self,theme): template_values = {} themes = os.listdir(os.path.join(os.path.dirname(__file__),'tpl', 'themes')) if theme in themes: path = os.path.join(theme, 'style.css') else: path = os.path.join('default', 'style.css') env = Environment(loader=FileSystemLoader(os.path.join(os.path.dirname(__file__),"tpl/themes"))) template = env.get_template(path) output = template.render(template_values) expires_date = datetime.datetime.now(pytz.timezone('Asia/Shanghai')) + datetime.timedelta(days=7) expires_str = expires_date.strftime("%d %b %Y %H:%M:%S GMT") self.add_header("Expires", expires_str) self.set_header('Cache-Control', 'max-age=120, must-revalidate') self.set_header('Content-type','text/css;charset=UTF-8') self.write(output)
def __init__(self, templates_dir, openstack_release): if not os.path.isdir(templates_dir): log('Could not locate templates dir %s' % templates_dir, level=ERROR) raise OSConfigException self.templates_dir = templates_dir self.openstack_release = openstack_release self.templates = {} self._tmpl_env = None if None in [Environment, ChoiceLoader, FileSystemLoader]: # if this code is running, the object is created pre-install hook. # jinja2 shouldn't get touched until the module is reloaded on next # hook execution, with proper jinja2 bits successfully imported. if six.PY2: apt_install('python-jinja2') else: apt_install('python3-jinja2')
def setup_pp_env(page=None, page_filters=[], no_loader=False): remote, path = get_page_where(page) if remote: logger.debug("Using remote template loader for page %s" % page) pp_env = jinja2.Environment(loader=jinja2.FunctionLoader(read_markdown_remote)) elif no_loader: logger.debug("Using a no-loader Jinja environment") pp_env = jinja2.Environment() else: logger.debug("Using FileSystemLoader for page %s" % page) pp_env = jinja2.Environment(loader=jinja2.FileSystemLoader(path)) # Pull exported values (& functions) from page filters into the pp_env for filter_name in page_filters: if filter_name not in config.filters.keys(): logger.debug("Skipping unloaded filter '%s'" % filter_name) continue if "export" in dir(config.filters[filter_name]): for key,val in config.filters[filter_name].export.items(): logger.debug("... pulling in filter_%s's exported key '%s'" % (filter_name, key)) pp_env.globals[key] = val return pp_env
def __init__(self): _LOGGER.debug("Begin setting up jinja2 environment") try: j2_loader = jinja2.FileSystemLoader(PySrcRenderer.TEMPLATES_PATH) j2_env = jinja2.Environment(loader=j2_loader, trim_blocks=True) except Exception as error: raise my_exceptions.CodeGenError( "Couldn't setup jinja environment using path {}".format( PySrcRenderer.TEMPLATES_PATH), error) else: _LOGGER.debug("Finished setting up jinja2 environment") _LOGGER.debug("Begin loading templates") self._parent_module_template = PySrcRenderer._load_template( j2_env, PySrcRenderer.PARENT_MODULE_TEMPLATE_NAME) self._sub_module_template = PySrcRenderer._load_template( j2_env, PySrcRenderer.SUB_MODULE_TEMPLATE_NAME) _LOGGER.debug("Finished loading templates")
def jinja_format(data, template_file): class GlobalFileLoader(jinja2.BaseLoader): def get_source(self, environment, template): if not os.path.exists(template): raise jinja2.TemplateNotFound(template) with open(template) as f: source = f.read().decode('utf-8') return source, template, lambda: False combined_credentials = combined_credential_pair_format(data) env = jinja2.Environment( loader=GlobalFileLoader(), keep_trailing_newline=True ) template = env.get_template(template_file) return template.render(secrets=combined_credentials['credentials'])
def main(args=sys.argv[1:]): acls, groups, aliases = process_acls(make_well_known_acls()) env = Environment( loader=FileSystemLoader(os.getcwd()), undefined=StrictUndefined, trim_blocks=True, ) env.filters['slugify'] = slugify_filter template = env.get_template(args[0]) values = dict( acls=acls, aliases=aliases, groups=groups, version=__version__, ) print(template.render(**values))
def create_airflow_cfg(path, tpl, filename='airflow.cfg', encoding='utf8'): """ create airflow.cfg :param path: root path :param tpl: template file :param filename: output filename :param encoding: Encoding(default:utf8) """ env = Environment(loader=FileSystemLoader(path, encoding=encoding)) cfg_tpl = env.get_template(tpl) cfg = cfg_tpl.render({env: os.environ.get(env) for env in ENVIRONMENTS}) file_path = '/'.join([path, filename]) if os.path.exists(file_path): os.remove(file_path) with open(file_path, 'w', encoding=encoding) as f: f.write(cfg) f.close()
def create_dockerfiles(self): kolla_version = version.version_info.cached_version_string() for path in self.docker_build_paths: template_name = "Dockerfile.j2" env = jinja2.Environment(loader=jinja2.FileSystemLoader(path)) template = env.get_template(template_name) values = {'base_distro': self.base, 'base_distro_tag': self.base_tag, 'install_metatype': self.install_metatype, 'image_prefix': self.image_prefix, 'install_type': self.install_type, 'namespace': self.namespace, 'tag': self.tag, 'maintainer': self.maintainer, 'kolla_version': kolla_version, 'rpm_setup': self.rpm_setup} if self.include_header: with open(self.include_header, 'r') as f: values['include_header'] = f.read() if self.include_footer: with open(self.include_footer, 'r') as f: values['include_footer'] = f.read() content = template.render(values) with open(os.path.join(path, 'Dockerfile'), 'w') as f: f.write(content)
def main(): parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument("template_dir", help="the absolute path to the template directory") parser.add_argument("username", help="your username on the VM in the cloud-platform") args = parser.parse_args() j2_env = Environment(loader=FileSystemLoader(args.template_dir), trim_blocks=True) with open("Makefile", "w") as f: f.write(j2_env.get_template("Makefile.template").render( username=str(args.username)))
def render(message, template_name, context={}): base_dir = os.path.join(os.getcwd(), 'templates') paths = [base_dir] # Include paths on settings # paths.extend(settings.TEMPLATES) env = Environment( loader=FileSystemLoader(paths), autoescape=select_autoescape(['html'])) template = env.get_template(template_name) default_context = { 'user': message.user } default_context.update(context) return template.render(**default_context)
def parse(self, md_file): """ Parse a md file into a post object """ # compile the templates when we parse the first post. This is needed to ensure that # plugins get a chance to modify the templates before we compile them. if not self.jinja2: self.jinja2 = jinja2.Environment(loader=jinja2.DictLoader(self.templates)) parsed_post = utils.dict_to_objdict() # parsing frontmatter and getting the md parsed_post.meta, parsed_post.md = frontmatter.parse(md_file) # parsing markdown and extractring info # NOTE: this must called before every parsing self.renderer.init(self.jinja2, self.code_formatter, self.config.plugin_data, self.site, parsed_post.meta) parsed_post.html = self.md_parser.parse(parsed_post.md) parsed_post.meta.statistics = self.renderer.get_stats() parsed_post.meta.toc = self.renderer.get_json_toc() parsed_post.elements = self.renderer.get_info() return parsed_post
def load_config(path='.boss.yml'): loader = j.FileSystemLoader('.') try: template = loader.load(j.Environment(), path, os.environ) yml = template.render() doc = yaml.load(yml) return transform_config(doc) except j.TemplateNotFound: error = 'Error loading {}: not found'.format(path) raise ConfigurationError(error) except j.TemplateSyntaxError as e: error = 'Error loading {}: {}, line {}'.format(path, e, e.lineno) raise ConfigurationError(error) except IOError as e: error = 'Error loading {}: {}'.format(path, e.strerror) raise ConfigurationError(error) except v.Invalid as e: error = 'Error validating {}: {}'.format(path, e) raise ConfigurationError(error)
def __init__(self, name, sol_file_path): assert name != None, 'A name identifier must be provided to create a new contract instance.' _name, _address = database.contract_exists(name=name) assert _name is None and _address is None node_info = json.loads(open(os.environ['NODE_INFO_JSON']).read()) self.web3 = Web3(Web3.HTTPProvider("http://127.0.0.1:{port}".format(port=node_info.get('rpcport')))) self.name = name self.is_deployed = None with open(sol_file_path) as f: self.sol = load_sol_file(f) self.template_json = Environment().from_string(database.input_json).render(name=self.name, sol=json.dumps(self.sol)) self.output_json = compile_standard(json.loads(self.template_json)) self.compiled_name = list(self.output_json['contracts'][self.name].keys())[0] self.contracts = self.output_json['contracts'][self.name][self.compiled_name] self.abi = self.contracts['abi'] self.metadata = self.contracts['metadata'] self.bytecode = self.contracts['evm']['deployedBytecode']['object'] self.gas_estimates = self.contracts['evm']['gasEstimates'] self.method_identifiers = self.contracts['evm']['methodIdentifiers'] # set in deploy self.address = None self.instance = None self.defaulAccount = None
def init_jinja2(app,**kw): logging.info('init jinja2...') options = dict( autoescape = kw.get('autoescape',True), block_start_string = kw.get('block_start_string','{%'), block_end_string = kw.get('block_end_string','%}'), variable_start_string = kw.get('variable_start_string','{{'), variable_end_string = kw.get('variable_end_string','}}'), auto_reload = kw.get('auto_reload',True) ) path = kw.get('path',None) if path is None: path = os.path.join(os.path.dirname(os.path.abspath(__file__)),'templates') logging.info('set jinja2 template path:%s ' % path) env = Environment(loader=FileSystemLoader(path),**options) filters = kw.get('filters',None) if filters is not None: for name,f in filters.items(): env.filters[name] = f app['__templating__'] = env # ??????
def generate(self, zone, json_data=None): # compute local script location to find template_dir me = os.path.realpath(__file__) template_dir = os.path.dirname(me) + '/.' self.d['domain'] = zone # override with json if json_data: self.d.update(json.loads(json_data)) env = Environment(loader=FileSystemLoader(template_dir)) # add to_json filer in jinja2 # so json can be dumped with in jinja2: {{ var | to_json }} env.filters['to_json'] = json.dumps template = env.get_template(self.zonetemplate) json_str = template.render(self.d) return json_str
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) # TODO store the loader or env on the tool factory for faster partial builds # (this would need to cope with new files) self._loader = FrontMatterFileSystemLoader(self._config.jinja_directories) self._env = Environment(loader=self._loader) self._env.filters['S'] = self.static_file_filter self._file_ctxs = {} self._initialise_templates() self._ctx = self._config.context self._library = self._config.find_library() self._library_files = walk(self._library) if self._library else [] self._extra_files = []
def render(search_root, project): template_paths = [] matrix_dirs = [] # traverse filesystem once and find out all matrix.yml and templates for cur_dir, dirs, files in os.walk(search_root): # TODO: hornor .gitignore for f in files: if f == 'matrix.yml': logger.info('Found matrix in %s', cur_dir) matrix_dirs.append(cur_dir) elif f.endswith('.jinja'): template_paths.append(os.path.join(cur_dir, f)) # register templates with jinja environment jinja2_env = jinja2.Environment(loader=FilesLoader(template_paths)) for maxtrix_dir in matrix_dirs: if project and os.path.basename(maxtrix_dir) != project: continue render_matrix(jinja2_env, maxtrix_dir)
def init_jinja2(app, **kwargs): logging.info('init jinja2...') options = dict( autoescape = kwargs.get('autoescape', True), block_start_string = kwargs.get('block_start_string', '{%'), block_end_string = kwargs.get('blcok_end_string', '%}'), variable_start_string = kwargs.get('variable_start_string', '{{'), variable_end_string = kwargs.get('variable_end_string', '}}'), auto_reload = kwargs.get('auto_reload', True) ) path = kwargs.get('path', None) if path is None: path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'templates') logging.info('set jinja2 template path: {}'.format(path)) env = Environment(loader = FileSystemLoader(path), **options) filters = kwargs.get('filters', None) if filters is not None: for name, f in filters.items(): env.filters[name] = f app['__templating__'] = env
def prepare_packer_template(config, template_name): """ Prepares a packer template JSON file according to configuration and writes it into a temporary location where packer later expects it. Uses jinja2 template syntax to generate the resulting JSON file. Templates are in templates/ and snippets in templates/snippets/. """ try: template_fd = resource_stream(__name__, 'templates/{}.json'.format(template_name)) except FileNotFoundError: print("Template doesn't exist: {}".format(template_name)) sys.exit(2) filepath = resource_filename(__name__, 'templates/') env = Environment(loader=FileSystemLoader(filepath), autoescape=False, trim_blocks=True, lstrip_blocks=True) template = env.get_template("{}.json".format(template_name)) # write to temporary file f = create_cachefd('{}.json'.format(template_name)) f.write(template.render(config)) # pylint: disable=no-member f.close() return f.name
def __init__(self, filepath, local_variables, global_variables=None): self.config = {} if global_variables: self.config.update(global_variables) new_local_variables = {} env = jinja2.Environment(undefined=jinja2.DebugUndefined) for key, value in local_variables.items(): if six.PY2: value = value.decode('utf8') template = env.from_string(value) new_local_variables[key] = template.render( GLOBALS=global_variables) self.config.update(new_local_variables) self.path = filepath
def __jinja_render_to_file(cls, template_path, template_file, module_name, temp_dir, module_path, **context): """ Create the module from a jinja template. :param template_file: name of the template file :param module_name: the destination file name :param temp_dir: a temporary working dir for jinja :param context: dict of substitution variables :return: None """ j2_tmpl_path = template_path j2_env = Environment(loader=FileSystemLoader(j2_tmpl_path), keep_trailing_newline=True) j2_tmpl = j2_env.get_template(template_file) rendered = j2_tmpl.render(dict(temp_dir=temp_dir, **context)) with open(os.path.normpath(os.path.join(module_path, module_name)), 'wb') as f: f.write(rendered.encode('utf8'))
def create_initial_app(self): #Create app directory os.makedirs('app') template_path = Path(__file__).ancestor(1).child('templates') #Create Jinja2 Environment env = Environment(autoescape=False, loader=FileSystemLoader(template_path)) #Get flask and zappa_settings templates flask_app_template = env.get_template('flask.py.jinja2') zappa_settings_template = env.get_template( 'zappa_settings.json.jinja2') #Create Flask app and zappa_settings.json files in the app directory with open('app/{app_name}.py'.format(app_name=self.app_name), 'w+') as f: f.write(flask_app_template.render(app_name=self.app_name, stage_name=self.stage_name)) with open('app/zappa_settings.json'.format(app_name=self.app_name), 'w+') as f: f.write(zappa_settings_template.render(app_name=self.app_name, stage_name=self.stage_name, function_bucket=self.function_bucket, aws_region_name=self.aws_region_name)) #Copy the HTML template to the app/templates directory shutil.copytree(template_path.child('templates'), 'app/templates')
def test_caching(self): changed = False class TestLoader(loaders.BaseLoader): def get_source(self, environment, template): return u'foo', None, lambda: not changed env = Environment(loader=TestLoader(), cache_size=-1) tmpl = env.get_template('template') assert tmpl is env.get_template('template') changed = True assert tmpl is not env.get_template('template') changed = False env = Environment(loader=TestLoader(), cache_size=0) assert env.get_template('template') \ is not env.get_template('template') env = Environment(loader=TestLoader(), cache_size=2) t1 = env.get_template('one') t2 = env.get_template('two') assert t2 is env.get_template('two') assert t1 is env.get_template('one') t3 = env.get_template('three') assert 'one' in env.cache assert 'two' not in env.cache assert 'three' in env.cache
def test_loop_controls(self): env = Environment(extensions=['jinja2.ext.loopcontrols']) tmpl = env.from_string(''' {%- for item in [1, 2, 3, 4] %} {%- if item % 2 == 0 %}{% continue %}{% endif -%} {{ item }} {%- endfor %}''') assert tmpl.render() == '13' tmpl = env.from_string(''' {%- for item in [1, 2, 3, 4] %} {%- if item > 2 %}{% break %}{% endif -%} {{ item }} {%- endfor %}''') assert tmpl.render() == '12'
def __init__(self): self.loader = FileSystemLoader(os.path.join(os.path.dirname(__file__), 'templates')) self.env = Environment(loader = self.loader)
def _get_tmpl_env(self): if not self._tmpl_env: loader = get_loader(self.templates_dir, self.openstack_release) self._tmpl_env = Environment(loader=loader)
def jinja(): here = os.path.dirname(__file__) template_path = '{}/flash_services/templates'.format(here) return jinja2.Environment(loader=jinja2.FileSystemLoader(template_path))
def generate_new_s3_lifecycle_policy_document(self, policyobj): ''' Generate a new S3 lifecycle policy document ''' searchpath = get_absolute_path_for_file("./") templatefile = "./templates/s3_lifecycle_policy.j2" now = datetime.datetime.now() timestamp = "%s%s" % (str(now.microsecond), str(now.second)) for rule in policyobj['rules']: if rule.get('id', None): rule['id'] = "rule-%s" % str(timestamp) print "policyobj: ", policyobj template_loader = jinja2.FileSystemLoader(searchpath=searchpath) env = jinja2.Environment(loader=template_loader, trim_blocks=False, lstrip_blocks=False) template = env.get_template(templatefile) data = template.render(policyobj) print "data: ", data jdata = json.loads(data) return jdata
def write_template(template, path, **kwargs): template = Environment().from_string(template) content = template.render(**kwargs) print(path) with open(path, "w+") as f: f.write(content)
