def _get_template_engine(ctx):
"""
Initialize the template engine environment
"""
global engine_cache
if engine_cache is not None:
return engine_cache
loader_map = {}
loader_map[""] = FileSystemLoader(
os.path.join(Project.get().project_path, "templates"))
for name, module in Project.get().modules.items():
template_dir = os.path.join(module._path, "templates")
if os.path.isdir(template_dir):
loader_map[name] = FileSystemLoader(template_dir)
# init the environment
env = Environment(loader=PrefixLoader(loader_map),
undefined=jinja2.StrictUndefined)
env.context_class = ResolverContext
# register all plugins as filters
for name, cls in ctx.get_compiler().get_plugins().items():
def curywrapper(func):
def safewrapper(*args):
return JinjaDynamicProxy.return_value(func(*args))
return safewrapper
env.filters[name.replace("::", ".")] = curywrapper(cls)
engine_cache = env
return env
def get_jloader():
import frappe
if not getattr(frappe.local, 'jloader', None):
from jinja2 import ChoiceLoader, PackageLoader, PrefixLoader
if frappe.local.flags.in_setup_help:
apps = ['frappe']
else:
apps = frappe.get_hooks('template_apps')
if not apps:
apps = frappe.local.flags.web_pages_apps or frappe.get_installed_apps(sort=True)
apps.reverse()
if not "frappe" in apps:
apps.append('frappe')
frappe.local.jloader = ChoiceLoader(
# search for something like app/templates/...
[PrefixLoader(dict(
(app, PackageLoader(app, ".")) for app in apps
))]
# search for something like templates/...
+ [PackageLoader(app, ".") for app in apps]
)
return frappe.local.jloader
def __init__(self,
settings,
output_dir,
theme=None,
template_file="index.html",
output_file="index.html"):
self.settings = settings
self.output_dir = os.path.abspath(output_dir)
self.theme = theme or settings['theme']
self.template_file = template_file
self.output_file = output_file
self.logger = logging.getLogger(__name__)
# optionally add index.html to the URLs
self.url_ext = self.output_file if settings['index_in_url'] else ''
# search the theme in sigal/theme if the given one does not exists
if not os.path.exists(self.theme):
self.theme = os.path.join(THEMES_PATH, self.theme)
if not os.path.exists(self.theme):
raise Exception("Impossible to find the theme %s" % self.theme)
self.logger.info("Theme : %s", self.theme)
theme_relpath = os.path.join(self.theme, 'templates')
default_loader = FileSystemLoader(
os.path.join(THEMES_PATH, 'default', 'templates'))
# setup jinja env
env_options = {'trim_blocks': True}
try:
if tuple(int(x) for x in jinja2.__version__.split('.')) >= (2, 7):
env_options['lstrip_blocks'] = True
except ValueError:
pass
env = Environment(
loader=ChoiceLoader([
FileSystemLoader(theme_relpath),
default_loader, # implicit inheritance
PrefixLoader({'!default': default_loader}) # explicit one
]),
**env_options)
try:
self.template = env.get_template(self.template_file)
except TemplateNotFound:
self.logger.error('The index.html template was not found.')
sys.exit(1)
self.copy_assets()
self.ctx = {
'sigal_link': sigal_link,
'theme': {
'name': os.path.basename(self.theme)
},
'medias': [],
'albums': [],
'breadcrumb': ''
}
def __init__(self, *args, **kwargs):
for idx, item in enumerate(
('context', 'settings', 'path', 'theme', 'output_path', 'markup')):
setattr(self, item, args[idx])
for arg, value in kwargs.items():
setattr(self, arg, value)
# templates cache
self._templates = {}
self._templates_path = os.path.expanduser(
os.path.join(self.theme, 'templates'))
theme_path = os.path.dirname(os.path.abspath(__file__))
simple_loader = FileSystemLoader(
os.path.join(theme_path, "themes", "simple", "templates"))
self.env = Environment(
loader=ChoiceLoader([
FileSystemLoader(self._templates_path),
simple_loader, # implicit inheritance
PrefixLoader({'!simple': simple_loader}) # explicit one
]),
extensions=self.settings.get('JINJA_EXTENSIONS', []),
)
logger.debug('template list: {0}'.format(self.env.list_templates()))
# get custom Jinja filters from user settings
custom_filters = self.settings.get('JINJA_FILTERS', {})
self.env.filters.update(custom_filters)
def __init__(self, backend, debug=False):
# Debug mode means printing stack trace on errors
self.debug = debug
self.env = Environment(
loader=PrefixLoader({
'blocks-'+backend: PackageLoader('dematik', 'blocks-'+backend),
'macros-'+backend: PackageLoader('dematik', 'macros-'+backend)
}),
autoescape=select_autoescape(['j2']),
undefined=StrictUndefined
)
self.env.globals = {
"now": datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"),
"get_text" : self.get_text,
"get_md_text" : self.get_md_text,
"get_items" : self.get_items,
"get_rows" : self.get_rows,
"get_columns" : self.get_columns,
"get_varname" : self.get_varname,
"get_id" : self.get_id,
"get_date_min" : self.get_date_min,
"get_date_is_futur" : self.get_date_is_futur,
"get_date_max" : self.get_date_max,
"get_date_in_past" : self.get_date_in_past,
"get_date_can_be_today" : self.get_date_can_be_today,
"is_in_listing" : self.is_in_listing,
"is_in_filters" : self.is_in_filters,
}
self.fields_data = FieldData()
self.blocks = Blocks(self.env, ['blocks-'+backend])
self.reset()
def make_template_loader(app_config, package_name):
loader_mapping = {
p: PackageLoader(f"{package_name}.concepts.{p}")
for p in app_config.concepts
}
template_loader = PrefixLoader(loader_mapping)
return template_loader
def get_env(path=None):
path = path or './'
_loader = ChoiceLoader([
FileSystemLoader(path),
PrefixLoader({
'sys':
ChoiceLoader([
FileSystemLoader(data_path + '/static'),
FileSystemLoader(data_path + '/templates')
]),
'user':
ChoiceLoader([
FileSystemLoader('data/templates'),
FileSystemLoader('data/user/templates'),
])
}),
ChoiceLoader([
FileSystemLoader('data/templates'),
FileSystemLoader('data/user/templates'),
FileSystemLoader(data_path + '/static'),
FileSystemLoader(data_path + '/templates'),
])
])
env = Environment(loader=_loader)
return env
def get_notebook_jinja2_loader(nbapp):
"""Return the appropriate jinja2 template loader for the notebook app.
This is confusing but necessary to meet the following criteria:
- Templates in geonotebook/templates will override those in core notebook
templates
- Core notebook templates can still be referred to/extended by referring
to them as [email protected]
The ChoiceLoader tries each of the loaders in turn until one of them
provides the right template.
The PrefixLoader allows us to refer to core templates using the core@
prefix, this is necessary
because we want to extend templates of the same name while referring to
templates in a different loader (core).
The PackageLoader lets us put our templates ahead in priority of the
notebooks templates.
The core_loader is last which falls back to the original loader the
notebook uses.
This implementation is weird, but should be compatible/composable with
other notebook extensions and fairly future proof.
:param nbapp: NotebookApp instance
:returns: A jinja2 loader designed to work with our notebook templates
:rtype: jinja2.ChoiceLoader
"""
return ChoiceLoader([
PrefixLoader({'core': nbapp.web_app.settings['jinja2_env'].loader},
delimiter='@'),
PackageLoader('geonotebook'),
nbapp.web_app.settings['jinja2_env'].loader
])
def HTML \
( version = "html/5.jnj"
, load_path = ()
, loader = None
, globals = {}
, encoding = "utf-8"
, i18n = False
, Media_Parameters = None
, GTW = None
, prefixes = {}
, ** kw
) :
jnj_loader = FileSystemLoader (sos.path.dirname (__file__), "utf-8")
loaders = []
if loader :
loaders.append (loader)
if load_path :
loaders.append (FileSystemLoader (load_path, encoding))
loaders.append (jnj_loader)
if prefixes :
sk = lambda x : (- len (x [1]), x [1])
for prefix, lp in sorted (pyk.iteritems (prefixes), key = sk) :
loaders.append \
( PrefixLoader
({prefix : FileSystemLoader (lp, encoding)}, delimiter='::')
)
loaders.append (PrefixLoader (dict (STD = jnj_loader), delimiter='::'))
loader = ChoiceLoader (loaders)
extensions = (kw.pop ("extensions", []) + Default_Extensions)
if i18n :
extensions.append ("jinja2.ext.i18n")
result = Environment \
( extensions = uniq (extensions), loader = loader, ** kw)
if GTW is None :
GTW = JNJ.GTW (result)
result.globals.update \
( globals
, GTW = GTW
, html_version = version
)
result.Media_Parameters = Media_Parameters
result.encoding = encoding
result.static_handler = None
if i18n :
result.install_gettext_translations (TFL.I18N)
return result
def register_loader(self, loader, prefix=None, replace=False):
if not isinstance(self.environment.loader, MacroLoader):
raise Exception("The macro system requires the Jinja loader to be wrapped using an instance of MacroLoader")
if prefix:
loader = PrefixLoader(dict([(prefix, loader)]))
self.environment.loader.macro_loaders.append(loader)
for tpl in loader.list_templates():
self.register_from_template("__macros__/" + tpl, replace)
def get_module_environment(name):
module_path = pkg_modules_dir + '/' + name
_loader = ChoiceLoader([
FileSystemLoader(module_path),
PrefixLoader({'pkg': FileSystemLoader(pkg_data_path)})
])
env = Environment(loader=_loader)
return env
def test_correct_prefix_loader_name(self):
env = Environment(loader=PrefixLoader({'foo': DictLoader({})}))
try:
env.get_template('foo/bar.html')
except TemplateNotFound as e:
assert e.name == 'foo/bar.html'
else:
assert False, 'expected error here'
def __init__(self, settings, index_title=''):
self.settings = settings
self.output_dir = settings['destination']
self.theme = settings['theme']
self.index_title = index_title
self.logger = logging.getLogger(__name__)
# search the theme in sigal/theme if the given one does not exists
if not os.path.exists(self.theme) or \
not os.path.exists(os.path.join(self.theme, 'templates')):
self.theme = os.path.join(THEMES_PATH, self.theme)
if not os.path.exists(self.theme):
raise Exception("Impossible to find the theme %s" % self.theme)
self.logger.info("Theme : %s", self.theme)
theme_relpath = os.path.join(self.theme, 'templates')
default_loader = FileSystemLoader(
os.path.join(THEMES_PATH, 'default', 'templates'))
# setup jinja env
env_options = {'trim_blocks': True, 'autoescape': True}
try:
if tuple(int(x) for x in jinja2.__version__.split('.')) >= (2, 7):
env_options['lstrip_blocks'] = True
except ValueError:
pass
env = Environment(
loader=ChoiceLoader([
FileSystemLoader(theme_relpath),
default_loader, # implicit inheritance
PrefixLoader({'!default': default_loader}) # explicit one
]),
**env_options)
# handle optional filters.py
filters_py = os.path.join(self.theme, 'filters.py')
if os.path.exists(filters_py):
mod = importlib.import_module(filters_py)
for name in dir(mod):
if isinstance(getattr(mod, name), types.FunctionType):
env.filters[name] = getattr(mod, name)
try:
self.template = env.get_template(self.template_file)
except TemplateNotFound:
self.logger.error(
'The template %s was not found in template folder %s.',
self.template_file, theme_relpath)
sys.exit(1)
# Copy the theme files in the output dir
self.theme_path = os.path.join(self.output_dir, 'static')
if os.path.isdir(self.theme_path):
shutil.rmtree(self.theme_path)
# FIXME: use dirs_exist_ok when minimum Python is 3.8
shutil.copytree(os.path.join(self.theme, 'static'), self.theme_path)
def register_templates(app):
multi_loader = ChoiceLoader([
app.jinja_loader,
PrefixLoader({
'govuk-jinja-components':
PackageLoader('govuk-jinja-components')
})
])
app.jinja_loader = multi_loader
def __init__(self, context, settings, path, theme, output_path,
readers_cache_name='', **kwargs):
self.context = context
self.settings = settings
self.path = path
self.theme = theme
self.output_path = output_path
for arg, value in kwargs.items():
setattr(self, arg, value)
self.readers = Readers(self.settings, readers_cache_name)
# templates cache
self._templates = {}
self._templates_path = list(self.settings['THEME_TEMPLATES_OVERRIDES'])
theme_templates_path = os.path.expanduser(
os.path.join(self.theme, 'templates'))
self._templates_path.append(theme_templates_path)
theme_loader = FileSystemLoader(theme_templates_path)
simple_theme_path = os.path.dirname(os.path.abspath(__file__))
simple_loader = FileSystemLoader(
os.path.join(simple_theme_path, "themes", "simple", "templates"))
self.env = Environment(
loader=ChoiceLoader([
FileSystemLoader(self._templates_path),
simple_loader, # implicit inheritance
PrefixLoader({
'!simple': simple_loader,
'!theme': theme_loader
}) # explicit ones
]),
**self.settings['JINJA_ENVIRONMENT']
)
logger.debug('Template list: %s', self.env.list_templates())
# provide utils.strftime as a jinja filter
self.env.filters.update({'strftime': DateFormatter()})
# get custom Jinja filters from user settings
custom_filters = self.settings['JINJA_FILTERS']
self.env.filters.update(custom_filters)
# get custom Jinja globals from user settings
custom_globals = self.settings['JINJA_GLOBALS']
self.env.globals.update(custom_globals)
# get custom Jinja tests from user settings
custom_tests = self.settings['JINJA_TESTS']
self.env.tests.update(custom_tests)
signals.generator_init.send(self)
def do_GET(self):
if self.path=='/':
myself = {'self': FileSystemLoader(os.path.dirname(__file__)) }
loader = PrefixLoader(myself)
env = Environment(loader=loader)
env.filters.update({'server_to_list': server_to_list})
template = env.get_template('self/dashboard.html')
buf = template.render(config=self.conf)
self.send_response(200)
self.send_header("Content-Type","text/html ; encoding=UTF-8")
self.send_header("Content-Length", str(len(buf)))
self.end_headers()
self.wfile.write(buf.encode('utf-8'))
return
elif self.path.startswith('/all'):
pr = urlparse(self.path)
params = parse_qs(pr.query)
val = []
co = None
ct = None
k = 'server'
if 'server[]' in params:
k = 'server[]'
for server in params[k]:
try:
with urllib.request.urlopen(server, context=ssl.SSLContext()) as obj:
val.append( obj.read() )
co = obj.getcode()
if 'content-type' in obj.info():
ct = obj.info()['content-type']
except:
val.append(None)
if len(val)==1 and val[0] is None:
self.send_response(500)
self.end_headers()
return
elif len(val)==1:
self.send_response(co)
if ct:
self.send_header("Content-Type",obj.info()['content-type'])
self.send_header("Content-Length", str(len(val[0])))
self.end_headers()
self.wfile.write(val[0])
return
else: # value of values to return
# Only json is supported
buf = json.dumps([v and json.loads(v) for v in val]).encode('latin-1')
self.send_response(200)
self.send_header("Content-Type","application/json")
self.send_header("Content-Length", str(len(buf)))
self.end_headers()
self.wfile.write(buf)
return
return super().do_GET()
def _initialize_template_engine(self):
resources_path = 'cnchi://{}'.format(os.path.join(self.PAGES_DIR, 'resources'))
tpl_map = {
pdir: FileSystemLoader(os.path.join(self.PAGES_DIR, pdir)) for pdir in self._page_dirs
}
tpl_map['pages'] = FileSystemLoader(self.PAGES_DIR)
self._tpl = Environment(loader=PrefixLoader(tpl_map), lstrip_blocks=True, trim_blocks=True)
self._tpl.globals['RESOURCES_DIR'] = resources_path
self._tpl.add_extension('jinja2.ext.do')
self._tpl.add_extension('jinja2.ext.i18n')
self._tpl.install_null_translations(newstyle=True)
def get_site_environment(name):
site_path = pkg_sites_dir + '/' + name
_loader = ChoiceLoader([
FileSystemLoader(site_path),
PrefixLoader({
'pkg': FileSystemLoader(pkg_data_path),
'modules': FileSystemLoader(pkg_modules_dir),
'parts': FileSystemLoader(pkg_parts_dir),
})
])
env = Environment(loader=_loader)
return env
def __init__(self, name, config, host):
super().__init__(name, config, host)
self.app = web.Application()
if aiohttp_jinja2:
# Empty mapping by default, other hooks can add to this via add_loader().
self._loader = PrefixLoader({})
self._jinja = aiohttp_jinja2.setup(self.app, loader=self._loader)
self._jinja.filters["json"] = json.dumps
self._jinja.globals["immp"] = immp
self._jinja.globals["host"] = self.host
self._runner = web.AppRunner(self.app)
self._site = None
self._contexts = {}
def __init__(self):
loaders = {}
for resource in ctx.get_implementations(IResourceManager, instances=True):
loaders[resource.resource_name] = FileSystemLoader(resource.templates_path)
loader = ChoiceLoader([FileSystemLoader(ctx.cfg['templates.path']),
PrefixLoader(loaders)])
cache_obj = None
if ctx.cfg['templates.use_cache']:
if ctx.cfg['templates.use_memcached_cache']:
cache_obj = MemcachedBytecodeCache(
client=inyoka_cache,
timeout=ctx.cfg['caching.timeout']
)
elif ctx.cfg['templates.use_filesystem_cache']:
cache_obj = FileSystemBytecodeCache(
directory=ctx.cfg['caching.filesystem_cache_path'],
)
Environment.__init__(self,
loader=loader,
extensions=['jinja2.ext.i18n', 'jinja2.ext.do', 'jinja2.ext.with_',
'jinja2.ext.autoescape'],
auto_reload=ctx.cfg['templates.auto_reload'],
undefined=StrictUndefined,
cache_size=-1,
bytecode_cache=cache_obj,
autoescape=True
)
self.globals.update(
INYOKA_REVISION=INYOKA_REVISION,
PYTHON_VERSION='%d.%d.%d' % sys.version_info[:3],
DEBUG=ctx.cfg['debug'],
href=href,
)
self.filters.update(
jsonencode=json.dumps,
datetimeformat=l10n.format_datetime,
dateformat=l10n.format_date,
timeformat=l10n.format_time,
timedelta=l10n.timedeltaformat,
monthformat=l10n.format_month,
dayformatshort=l10n.format_day_short,
humanize=l10n.humanize_number,
)
self.install_gettext_translations(
i18n.get_translations(),
newstyle=True
)
def __init__(self,
context,
settings,
path,
theme,
output_path,
readers_cache_name='',
**kwargs):
self.context = context
self.settings = settings
self.path = path
self.theme = theme
self.output_path = output_path
for arg, value in kwargs.items():
setattr(self, arg, value)
self.readers = Readers(self.settings, readers_cache_name)
# templates cache
self._templates = {}
self._templates_path = []
self._templates_path.append(
os.path.expanduser(os.path.join(self.theme, 'templates')))
self._templates_path += self.settings['EXTRA_TEMPLATES_PATHS']
theme_path = os.path.dirname(os.path.abspath(__file__))
simple_loader = FileSystemLoader(
os.path.join(theme_path, "themes", "simple", "templates"))
self.env = Environment(
trim_blocks=True,
lstrip_blocks=True,
loader=ChoiceLoader([
FileSystemLoader(self._templates_path),
simple_loader, # implicit inheritance
PrefixLoader({'!simple': simple_loader}) # explicit one
]),
extensions=self.settings['JINJA_EXTENSIONS'],
)
logger.debug('template list: {0}'.format(self.env.list_templates()))
# provide utils.strftime as a jinja filter
self.env.filters.update({'strftime': DateFormatter()})
# get custom Jinja filters from user settings
custom_filters = self.settings['JINJA_FILTERS']
self.env.filters.update(custom_filters)
signals.generator_init.send(self)
def __init__(self, templates: List[FileSystemPath],
cache_dir: FileSystemPath):
self.prefix_map = {}
self.directories = templates
self.cache_dir = cache_dir
self.ctx = None
self.globals = {}
self.loaders = [
FileSystemLoader(self.directories),
PrefixLoader(self.prefix_map),
]
self.reset_environment()
def initialize(self, argv=None):
super().initialize(argv)
if self.generate_config:
print(self.generate_config_file())
sys.exit(0)
if self.config_file:
self.load_config_file(self.config_file)
# Totally confused by traitlets logging
self.log.parent.setLevel(self.log.level)
self.init_queue()
self.init_ssl_context()
base_path = self._template_paths_default()[0]
if base_path not in self.template_paths:
self.template_paths.append(base_path)
loader = ChoiceLoader([
PrefixLoader({'templates': FileSystemLoader([base_path])}, '/'),
FileSystemLoader(self.template_paths),
])
with open(self.cookie_secret_file) as f:
cookie_secret_text = f.read().strip()
cookie_secret = binascii.a2b_hex(cookie_secret_text)
self.settings = {
"cookie_secret": cookie_secret,
"static_path": os.path.join(self.data_files_path, "static"),
"static_url_prefix": url_path_join(self.service_prefix, "static/")
}
self.app = web.Application([
(self.service_prefix, AnnouncementViewHandler,
dict(queue=self.queue,
fixed_message=self.fixed_message,
loader=loader), "view"),
(self.service_prefix + r"oauth_callback", HubOAuthCallbackHandler),
(self.service_prefix + r"latest", AnnouncementLatestHandler,
dict(queue=self.queue, allow_origin=self.allow_origin)),
(self.service_prefix + r"update", AnnouncementUpdateHandler,
dict(queue=self.queue)),
(self.service_prefix + r"static/(.*)", web.StaticFileHandler,
dict(path=self.settings["static_path"])),
(self.service_prefix + r"logo", LogoHandler, {
"path": self.logo_file
})
], **self.settings)
def _build_tf_module(self):
"""
Creates a Terraform configuration for this Spawner
:return: rendered module_tf content
"""
tf_jinja_env = Environment(loader=ChoiceLoader([
PrefixLoader(
{'templates': PackageLoader('terraformspawner', 'templates')}),
FileSystemLoader(os.path.join(self.tf_dir, 'templates')),
PackageLoader('terraformspawner', 'templates'),
]))
tf_template = tf_jinja_env.get_or_select_template('singleuser.tf')
return tf_template.render(spawner=self)
def initialize(self, argv=None):
super().initialize(argv)
self.init_ssl_context()
base_path = self._template_paths_default()[0]
if base_path not in self.template_paths:
self.template_paths.append(base_path)
print("Base Path " + base_path)
print('Data Path ' + DATA_FILES_PATH)
loader = ChoiceLoader([
PrefixLoader({'templates': FileSystemLoader([base_path])}, '/'),
FileSystemLoader(self.template_paths),
])
self.settings = {
"service_prefix":
self.service_prefix,
"static_path":
os.path.join(self.data_files_path, "static"),
"static_url_prefix":
url_path_join(self.service_prefix, "static/"),
"storage":
FileStorage(
os.path.join(self.storage_path,
"{user[0]}/{user}.{type}.json"))
}
self.app = web.Application(
[
# (self.service_prefix, ViewHandler, dict(loader=loader), "view")
(self.service_prefix, ViewHandler, dict(loader=loader)),
(self.service_prefix + r"update", APIUserSelectionHandler),
(self.service_prefix + r"user/(.+)/(.+)",
APIUserSelectionHandler),
(self.service_prefix + r"envs/user/(.+)", APICondaHandler),
(self.service_prefix + r"scripts/user/(.+)", APIScriptHandler),
(self.service_prefix + r"static/(.*)", web.StaticFileHandler,
dict(path=self.settings["static_path"])),
(self.service_prefix + r"logo", LogoHandler, {
"path": self.logo_file
}),
(self.service_prefix + r"images/user/(.+)",
APIShifterImageHandler,
dict(shifter_api_token=self.shifter_api_token,
shifter_api_host=self.shifter_api_host))
],
**self.settings)
def _create_app_jinja_loader() -> PrefixLoader:
"""
Create a Jinja environment's template sources
Creates a Jinja prefix loader to load shared and application specific templates together. A prefix (namespace) is
used to select which set of templates to use. Templates are loaded from relevant Python modules
:rtype PrefixLoader
:return: Jinja prefix loader
"""
return PrefixLoader(
{
"app": PackageLoader("scar_add_metadata_toolbox"),
"bas_style_kit": PackageLoader("bas_style_kit_jinja_templates"),
}
)
def __init__(self, settings, index_title=''):
self.settings = settings
self.output_dir = settings['destination']
self.theme = settings['theme']
self.index_title = index_title
self.logger = logging.getLogger(__name__)
# search the theme in sigal/theme if the given one does not exists
if not os.path.exists(self.theme) or \
not os.path.exists(os.path.join(self.theme, 'templates')):
self.theme = os.path.join(THEMES_PATH, self.theme)
if not os.path.exists(self.theme):
raise Exception("Impossible to find the theme %s" % self.theme)
self.logger.info("Theme : %s", self.theme)
theme_relpath = os.path.join(self.theme, 'templates')
default_loader = FileSystemLoader(os.path.join(THEMES_PATH, 'default',
'templates'))
# setup jinja env
env_options = {'trim_blocks': True, 'autoescape': True}
try:
if tuple(int(x) for x in jinja2.__version__.split('.')) >= (2, 7):
env_options['lstrip_blocks'] = True
except ValueError:
pass
env = Environment(
loader=ChoiceLoader([
FileSystemLoader(theme_relpath),
default_loader, # implicit inheritance
PrefixLoader({'!default': default_loader}) # explicit one
]),
**env_options
)
try:
self.template = env.get_template(self.template_file)
except TemplateNotFound:
self.logger.error('The index.html template was not found.')
sys.exit(1)
# Copy the theme files in the output dir
self.theme_path = os.path.join(self.output_dir, 'static')
copy_tree(os.path.join(self.theme, 'static'), self.theme_path)
async def home_page(request):
global CONF
myself = {'self': FileSystemLoader(os.path.dirname(__file__))}
loader = PrefixLoader(myself)
env = Environment(loader=loader)
env.filters.update({'server_to_list': server_to_list})
template = env.get_template('self/dashboard.html')
nb = 0
if CONF:
for r in CONF['rows']:
for c in r['cells']:
if c['type'] in ['gauge', 'histogram']:
nb += 1
timeout = max(4000, min(10000, 300 * nb))
buf = template.render(config=CONF, timeout=timeout)
# logging.debug(buf)
return web.Response(status=200, text=buf, content_type='text/html')
def __init__(self, source_path, design_path, output_path, extensions,
filters):
super().__init__(trim_blocks=True,
lstrip_blocks=True,
keep_trailing_newline=True,
extensions=extensions,
autoescape=True,
loader=PrefixLoader({
'design':
FileSystemLoader(design_path),
'source':
FileSystemLoader(source_path),
}),
auto_reload=False)
self.filters.update(filters)
self.globals['design_path'] = design_path
self.globals['source_path'] = source_path
self.globals['output_path'] = output_path
def setupFlaskApp( app, context={}, plot_funcs = {}, database_file="database.sqlite" ):
"""Call this function to set up your custom flask app. This is an advanced function, probably you want to use runWebserver instead"""
from flask import g
def get_db():
db = getattr(g, '_database', None)
if db is None:
db = g._database = sqlite3.connect( database_file )
return db
app.jinja_loader = ChoiceLoader( [ FileSystemLoader('.'),
PrefixLoader( { 'waLBerla' : PackageLoader ('waLBerla', 'tools', 'report', 'templates') } ) ] )
app.jinja_env.add_extension( MatplotlibExtension)
app.jinja_env.database_file = database_file
app.jinja_env.database_getter = get_db
app.jinja_env.plot_funcs = plot_funcs
