Python jinja2 模块,FileSystemLoader() 实例源码
我们从Python开源项目中,提取了以下50个代码示例,用于说明如何使用jinja2.FileSystemLoader()。
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 create_app(loop=None):
app = web.Application(
middlewares=[
session_middleware(EncryptedCookieStorage(settings.COOKIE_SECRET)),
error_middleware],
loop=loop if loop is not None else settings.loop)
aiohttp_jinja2.setup(
app,
loader=jinja2.FileSystemLoader(settings.TEMPLATES_PATH))
for route in routes.routes:
app.router.add_route(*route[0], **route[1])
if settings.DEBUG:
app.router.add_static(settings.STATIC_URL, settings.STATIC_PATH)
return app
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 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.
if six.PY2:
apt_install('python-jinja2')
else:
apt_install('python3-jinja2')
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.
if six.PY2:
apt_install('python-jinja2')
else:
apt_install('python3-jinja2')
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 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.
if six.PY2:
apt_install('python-jinja2')
else:
apt_install('python3-jinja2')
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 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 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.
if six.PY2:
apt_install('python-jinja2')
else:
apt_install('python3-jinja2')
def renderTemplate(script_path, time_file_path, dimensions=(24, 80), templatename=DEFAULT_TEMPLATE):
with copen(script_path, encoding='utf-8', errors='replace', newline='\r\n') as scriptf:
# with open(script_path) as scriptf:
with open(time_file_path) as timef:
timing = getTiming(timef)
json = scriptToJSON(scriptf, timing)
fsl = FileSystemLoader(dirname(templatename), 'utf-8')
e = Environment()
e.loader = fsl
templatename = basename(templatename)
rendered = e.get_template(templatename).render(json=json,
dimensions=dimensions)
return rendered
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 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 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 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 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_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 create_module_file(package, module, opts):
# type: (unicode, unicode, Any) -> None
"""Generate RST for a top-level module (i.e., not part of a package)"""
if not opts.noheadings:
text = format_heading(1, '%s module' % module)
else:
text = ''
# text += format_heading(2, ':mod:`%s` Module' % module)
text += format_directive(module, package)
if opts.templates:
template_loader = FileSystemLoader(opts.templates)
template_env = SandboxedEnvironment(loader=template_loader)
try:
mod_ns = _get_mod_ns(
name=module, fullname=module,
includeprivate=opts.includeprivate)
template = template_env.get_template('module.rst')
text = template.render(**mod_ns)
except ImportError as e:
_warn('failed to import %r: %s' % (module, e))
write_file(makename(package, module), text, opts)
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 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.
if six.PY2:
apt_install('python-jinja2')
else:
apt_install('python3-jinja2')
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 __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 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 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 get_app():
redis = await aioredis.create_redis(('localhost', 6379,), db=1)
app = web.Application()
app['redis'] = redis
aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('templates/'),
context_processors=(static_processor,))
app.router.add_route('GET', '/', handlers.index)
app.router.add_route('GET', '/login', handlers.login_task)
app.router.add_route('POST', '/login', handlers.login)
app.router.add_static('/static', 'static')
async def close_redis(app):
app['redis'].close()
app.on_shutdown.append(close_redis)
return app
def jinja2_environment(template_dir, typ):
env = Environment(loader=FileSystemLoader(template_dir),
variable_start_string="@{",
variable_end_string="}@",
trim_blocks=True)
env.globals['xline'] = rst_xline
if typ == 'rst':
env.filters['convert_symbols_to_format'] = rst_ify
env.filters['html_ify'] = html_ify
env.filters['fmt'] = rst_fmt
env.filters['xline'] = rst_xline
template = env.get_template('plugin.rst.j2')
outputname = "%s_module.rst"
else:
raise Exception("unknown module format type: %s" % typ)
return env, template, outputname
def __init__(self):
super(Environment, self).__init__(
loader=jinja2.FileSystemLoader(path.join(path.dirname(__file__), 'ui/templates')),
extensions=[jinja2.ext.with_],
auto_reload=options.debug,
autoescape=True,
trim_blocks=True,
undefined=Undefined)
globals()[self.__class__.__name__] = lambda: self # singleton
self.globals['vj4'] = vj4
self.globals['static_url'] = lambda s: options.cdn_prefix + staticmanifest.get(s)
self.globals['paginate'] = misc.paginate
self.filters['nl2br'] = misc.nl2br
self.filters['markdown'] = misc.markdown
self.filters['json'] = json.encode
self.filters['gravatar_url'] = misc.gravatar_url
self.filters['format_size'] = misc.format_size
self.filters['format_seconds'] = misc.format_seconds
self.filters['base64_encode'] = misc.base64_encode
def jinja_render(path, context, functions=(), ignore_undefined=False):
kwargs = {}
if ignore_undefined:
kwargs['undefined'] = SilentUndefined
else:
kwargs['undefined'] = jinja2.StrictUndefined
env = jinja2.Environment(loader=jinja2.FileSystemLoader(
os.path.dirname(path)), **kwargs)
env.filters['host'] = get_host
# FIXME: gethostbyname should be only used during config files render
env.filters['gethostbyname'] = lambda x: x
for func in functions:
env.globals[func.__name__] = func
env.globals['raise_exception'] = j2raise
content = env.get_template(os.path.basename(path)).render(context)
return content
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.
if six.PY2:
apt_install('python-jinja2')
else:
apt_install('python3-jinja2')
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 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.
if six.PY2:
apt_install('python-jinja2')
else:
apt_install('python3-jinja2')
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 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.
if six.PY2:
apt_install('python-jinja2')
else:
apt_install('python3-jinja2')