def setup(self, app):
self.app = app
TEMPLATE_PATH[:] = [self.template_path]
Jinja2Template.settings = {
'autoescape':
True,
'filters': {
'datetimeformat': datetimeformat,
'time_passed': time_passed,
'ternary': ternary
},
'bytecode_cache':
FileSystemBytecodeCache(app.config['site.jinja2_cache'],
'%s.cache')
}
Jinja2Template.defaults = {
'request': request,
'view_name': view_name,
'url_for': url_for,
'view_func': view_func,
'config': app.config,
'debug': DEBUG
}
async def web_server(port, host='0.0.0.0', ssl_context=None):
"""http web server"""
try:
app = web.Application(middlewares=[error_middleware])
web_root_dir = os.path.split(os.path.abspath(__file__))[0]
cache_path = os.path.join(web_root_dir, '.cache')
static_path = os.path.join(web_root_dir, 'templates', 'static')
if not os.path.exists(cache_path):
os.mkdir(cache_path)
aiohttp_jinja2.setup(
app=app,
loader=FileSystemLoader(os.path.join(web_root_dir, 'templates')),
bytecode_cache=FileSystemBytecodeCache(directory=cache_path, pattern='%s.cache'),
extensions=['jinja2_time.TimeExtension'],
)
# add routes
app.router.add_get('/', page_index)
app.router.add_get('/index.html', page_index)
app.router.add_get('/started.html', page_started)
app.router.add_get('/dashboard.html', page_dashboard)
app.router.add_get('/explorer.html', page_explorer)
app.router.add_get('/connection.html', page_connection)
app.router.add_get('/status.html', page_status)
app.router.add_get('/terms.html', page_terms)
app.router.add_static('/static', static_path)
# start server
runner = web.AppRunner(app)
await runner.setup()
site = web.TCPSite(runner, host=host, port=port, ssl_context=ssl_context)
await site.start()
log.info(f"start web server {host}:{port} ssl={bool(ssl_context)}")
except Exception:
log.error("web server exception", exc_info=True)
def initialize(cls):
cls._environment = Environment(
undefined=StrictUndefined,
autoescape=select_autoescape(enabled_extensions=()),
loader=FileSystemLoader(TEMPLATES_DIRECTORY_PATH),
bytecode_cache=FileSystemBytecodeCache(
directory=TEMPLATES_BYTECODE_CACHE_DIRECTORY_PATH))
def __init__(self, templates_dir):
self.templates_dir = templates_dir
self.jinja2_env = Environment(
loader=FileSystemLoader(self.templates_dir),
bytecode_cache=FileSystemBytecodeCache(self.templates_dir),
auto_reload=False,
optimized=True,
autoescape=select_autoescape(['htm', 'html', 'xml', 'json']))
def __init__(self, template_path, extensions=()):
self.template_path = template_path
self._loader = FileSystemLoader(template_path)
self._bytecode_cache = FileSystemBytecodeCache()
self._environment = Environment(loader=self._loader,
cache_size=-1,
line_statement_prefix='##',
extensions=extensions,
autoescape=True,
bytecode_cache=self._bytecode_cache)
def get_jinja_env_options():
return dict(loader=CkanFileSystemLoader(config['computed_template_paths']),
autoescape=True,
extensions=[
'jinja2.ext.do', 'jinja2.ext.with_', SnippetExtension,
CkanExtend, CkanInternationalizationExtension,
LinkForExtension, ResourceExtension, UrlForStaticExtension,
UrlForExtension
],
bytecode_cache=FileSystemBytecodeCache())
def _get_or_build_default_environment(registry):
environment = registry.queryUtility(IJinja2Environment)
if environment is not None:
return environment
settings = registry.settings
kw = {}
package = _caller_package(('pyramid_jinja2', 'jinja2', 'pyramid.config'))
reload_templates = asbool(settings.get('reload_templates', False))
autoescape = asbool(settings.get('jinja2.autoescape', True))
domain = settings.get('jinja2.i18n.domain', 'messages')
debug = asbool(settings.get('debug_templates', False))
input_encoding = settings.get('jinja2.input_encoding', 'utf-8')
extensions = parse_multiline(settings.get('jinja2.extensions', ''))
if 'jinja2.ext.i18n' not in extensions:
extensions.append('jinja2.ext.i18n')
undefined = parse_undefined(settings.get('jinja2.undefined', ''))
directories = parse_multiline(settings.get('jinja2.directories') or '')
directories = [abspath_from_resource_spec(d, package) for d in directories]
loader = SmartAssetSpecLoader(directories,
encoding=input_encoding,
debug=debug)
# bytecode caching
bytecode_caching = asbool(settings.get('jinja2.bytecode_caching', True))
bytecode_caching_directory = settings.get(
'jinja2.bytecode_caching_directory', None)
if bytecode_caching:
kw['bytecode_cache'] = FileSystemBytecodeCache(
bytecode_caching_directory)
environment = Environment(loader=loader,
auto_reload=reload_templates,
autoescape=autoescape,
extensions=extensions,
undefined=undefined,
**kw)
# register pyramid i18n functions
wrapper = GetTextWrapper(domain=domain)
environment.install_gettext_callables(wrapper.gettext, wrapper.ngettext)
# register global repository for templates
if package is not None:
environment._default_package = package.__name__
filters = parse_filters(settings.get('jinja2.filters', ''))
environment.filters.update(filters)
registry.registerUtility(environment, IJinja2Environment)
return registry.queryUtility(IJinja2Environment)
def environment(**options: Any) -> Environment:
cache_path = Path("./cache/")
cache_path.mkdir(exist_ok=True)
fsbc = FileSystemBytecodeCache(cache_path)
options["trim_blocks"] = True
options["lstrip_blocks"] = True
options["bytecode_cache"] = fsbc
env = Environment(**options)
env.globals.update({"static": static, "url": reverse, "DEBUG": settings.DEBUG, "page_url": page_url, "is_current": is_current})
env.globals.update(settings.TEMPLATE_ENVS)
return env
def __init__(self, conf: appconf.Conf, assets_url: str):
self._dir_metadata = {}
self._cache = FileSystemBytecodeCache(
conf.template_cache_dir) if conf.template_cache_dir else None
self._assets_url = assets_url
self._template_env: Environment = Environment(
loader=FileSystemLoader(
os.path.realpath(
os.path.join(os.path.dirname(__file__), 'templates'))),
bytecode_cache=self._cache,
trim_blocks=True,
lstrip_blocks=True)
def __init__(self, root_directory, cache_path=None, cache_size=-1,
auto_reload=False,
autoescape=True, **kwargs):
super(Jinja2Loader, self).__init__(root_directory, **kwargs)
bcc = None
if cache_path:
# if not os.path.exists(cache_path):
# os.makedirs(cache_path)
bcc = FileSystemBytecodeCache(directory=cache_path)
self.env = Environment(loader=FileSystemLoader(self.root), bytecode_cache=bcc,
auto_reload=auto_reload,
cache_size=cache_size,
autoescape=autoescape)
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, templatefile):
self._has_newline = False
self.templateFile = templatefile
if not os.path.isdir(CACHE_DIR):
os.mkdir(CACHE_DIR)
cache = FileSystemBytecodeCache(CACHE_DIR, "%s.cache")
templateName = os.path.basename(templatefile)
loader = FileSystemLoader(os.path.dirname(templatefile))
self.env = Environment(trim_blocks=True,
lstrip_blocks=True,
loader=loader,
bytecode_cache=cache,
keep_trailing_newline=True)
self.template = self.env.get_template(templateName)
def JINJA_ENV(self):
from engineer.filters import format_datetime, markdown_filter, localtime, naturaltime, compress
from engineer.processors import preprocess_less
from engineer.themes import ThemeManager
# Configure Jinja2 environment
logger.debug("Configuring the Jinja environment.")
# Helper function to look up a URL by name
def urlname(name, *args):
url = settings.URLS.get(name, settings.HOME_URL)
if isfunction(url):
return url(*args)
else:
return url
env = Environment(
loader=ChoiceLoader([
FileSystemLoader([self.TEMPLATE_DIR]),
ThemeManager.current_theme().template_loader,
#self.ENGINEER.THEMES_DIR / 'base_templates',
FileSystemLoader([self.ENGINEER.TEMPLATE_DIR])
]),
extensions=[
'jinja2.ext.with_',
],
#'compressinja.html.HtmlCompressor'],
bytecode_cache=FileSystemBytecodeCache(
directory=self.JINJA_CACHE_DIR),
trim_blocks=True)
# Filters
env.filters['compress'] = compress
env.filters['date'] = format_datetime
env.filters['localtime'] = localtime
env.filters['naturaltime'] = naturaltime
env.filters['markdown'] = markdown_filter
env.filters['typogrify_no_widont'] = typogrify_no_widont
register(env) # register typogrify filters
# Globals
env.globals['theme'] = ThemeManager.current_theme()
env.globals['urlname'] = urlname
env.globals['preprocess_less'] = preprocess_less
# env.globals['url'] = url
env.globals['STATIC_URL'] = self.STATIC_URL
env.globals['DEBUG'] = self.DEBUG
env.globals['settings'] = self
return env
def _setup_bytecode_cache(self):
cache_type = config.get('jinja_bytecode_cache_type')
bcc = None
try:
if cache_type == 'memcached' and config.get('memcached_host'):
import pylibmc
from jinja2 import MemcachedBytecodeCache
client = pylibmc.Client([config['memcached_host']])
bcc = MemcachedBytecodeCache(client)
elif cache_type == 'filesystem':
from jinja2 import FileSystemBytecodeCache
bcc = FileSystemBytecodeCache()
except:
log.exception("Error encountered while setting up a" +
" %s-backed bytecode cache for Jinja" % cache_type)
return bcc
def environment(**options):
'''
Setup Jinja2 environment:
'''
# Init environment
env = Environment(**options)
# Use template with some common context
env.template_class = ContextTemplate
# Add our custom filters
env.filters.update({
'addcss': addcss,
'total_time': total_time,
'convert_speed': convert_speed,
'convert_speed_kmh': convert_speed_kmh,
'total_distance': total_distance,
})
# Add constants from settings
keys = [
'DEBUG',
'PIWIK_HOST',
'PIWIK_ID',
'FACEBOOK_ID',
'LANGUAGES',
'PAYMILL_PUBLIC',
'HELP_URL',
'PAYMENTS_ENABLED',
'VERSION',
]
env.globals.update(dict([(k, getattr(settings, k, None)) for k in keys]))
# Setup translations
translation = import_module('django.utils.translation')
env.install_gettext_translations(translation, newstyle=False)
# In Prod, skip auto_reload
# and setup bytecode cache
if not settings.DEBUG:
env.auto_reload = False
cache_dir = os.path.join(settings.HOME, 'templates_cached')
if not os.path.exists(cache_dir):
os.mkdir(cache_dir)
env.bytecode_cache = FileSystemBytecodeCache(cache_dir, 'rr.%s.cache')
return env
def init(self, layoutdir, cachedir):
self.jinja2 = J2Environemnt(
loader=ExtendedFileSystemLoader(layoutdir),
bytecode_cache=FileSystemBytecodeCache(cachedir))
# jinja2 is stupid and can't import any module during runtime
import time, datetime, urllib
for module in (time, datetime, urllib):
self.jinja2.globals[module.__name__] = module
for name in dir(module):
if name.startswith('_'):
continue
if callable(getattr(module, name)):
self.jinja2.filters[module.__name__ + '.' +
name] = getattr(module, name)
def reset_environment(self, cls: Type[Environment] = Environment):
"""Reset the Jinja environment."""
self.env = cls(
autoescape=False,
line_statement_prefix="#!",
keep_trailing_newline=True,
loader=ChoiceLoader(self.loaders),
bytecode_cache=FileSystemBytecodeCache(str(self.cache_dir)),
extensions=[
DebugExtension,
ExprStmtExtension,
LoopControlExtension,
],
)
setattr(self.env, "_beet_template_manager", self)
self.env.context_class = FallbackContext
def view(tpl_path):
if not tpl_path:
return None
jinja2_env = Environment(
loader=FileSystemLoader(tpl_path),
bytecode_cache=FileSystemBytecodeCache(tpl_path),
auto_reload=False,
optimized=True,
autoescape=select_autoescape(['htm', 'html', 'xml', 'json']))
def render(tpl_file, variable):
engine = jinja2_env.get_template(tpl_file)
result = engine.render(variable)
return str(result)
return render
def _setup_bytecode_cache(cls):
cache_type = config.get('jinja_bytecode_cache_type')
bcc = None
try:
if cache_type == 'memcached' and config.get('memcached_host'):
import pylibmc
from jinja2 import MemcachedBytecodeCache
client = pylibmc.Client([config['memcached_host']])
bcc_prefix = 'jinja2/{}/'.format(jinja2.__version__)
if six.PY3:
bcc_prefix += 'py{}{}/'.format(sys.version_info.major, sys.version_info.minor)
bcc = MemcachedBytecodeCache(client, prefix=bcc_prefix)
elif cache_type == 'filesystem':
from jinja2 import FileSystemBytecodeCache
bcc = FileSystemBytecodeCache(pattern='__jinja2_{}_%s.cache'.format(jinja2.__version__))
except Exception:
log.exception("Error encountered while setting up a" +
" %s-backed bytecode cache for Jinja" % cache_type)
return bcc
def run(self):
logger.debug("screen_out_score_plot.py, ScorePlot, run()")
if not os.path.exists("./cache"):
os.mkdir("./cache")
env = Environment(loader=FileSystemLoader('./templates',
encoding='utf8'),
bytecode_cache=FileSystemBytecodeCache(
directory="./cache", pattern="%s.cache"))
tpl = env.get_template('index.html')
data = {
"protain_names": self.name,
"acc": self.acc,
"score": self.score,
"seq": self.sequence,
"threshold": config.threshold_val,
"percentage": self.succeed_score_rate,
}
html = tpl.render(data=data)
with open("./index.html", "w") as f:
print(str(html), file=f)
webbrowser.open_new_tab(os.path.abspath("./index.html"))
def email(self, mail_list, rd_list, wdata, module_name):
status, output = commands.getstatusoutput('date -d-1day "+%Y%m%d"')
filename = "../data/%s_%s" % (module_name, output)
(key_target, detail) = self.data2template(wdata)
f = codecs.open(filename, 'w', "gbk")
from jinja2 import Environment, FileSystemLoader, FileSystemBytecodeCache
env = Environment(loader=FileSystemLoader('../template/'),
bytecode_cache=FileSystemBytecodeCache(
'../template/', '%s.cache'))
tmpl_jinja = env.get_template('testjinja2.html')
template = tmpl_jinja.render(key_target=key_target, detail=detail)
print >> f, template
f.close()
(status, output) = commands.getstatusoutput(
'cat %s |formail -I "From: [email protected]" -I "To:%s" -I "MIME-Version:1.0" -I "Content-type:text/html;charset=gb2312" -I "Subject:%s"|/usr/sbin/sendmail -oi %s'
% (filename, mail_list, os.path.basename(
self.parameter[2]), mail_list))
#(status, output) = commands.getstatusoutput('cat %s | mail -s "%s" %s'%(filename,os.path.basename(self.parameter[2]),mail_list))
print output
return status
def __init__(self, layoutdir, cachedir):
self.templates = {}
self.loader = ExtendedFileSystemLoader(layoutdir)
self._jinja2 = J2Environemnt(
loader=self.loader,
bytecode_cache=FileSystemBytecodeCache(cachedir))
# jinja2 is stupid and can't import any module during runtime
import time, datetime, urllib
for module in (time, datetime, urllib):
self._jinja2.globals[module.__name__] = module
for name in dir(module):
if name.startswith('_'):
continue
obj = getattr(module, name)
if hasattr(obj, '__class__') and callable(obj):
self._jinja2.filters[module.__name__ + '.' + name] = obj
def __init__(self, templates: List[FileSystemPath],
cache_dir: FileSystemPath):
self.prefix_map = {}
self.directories = templates
self.loaders = [
FileSystemLoader(self.directories),
PrefixLoader(self.prefix_map),
]
self.env = Environment(
autoescape=False,
line_statement_prefix="#!",
keep_trailing_newline=True,
loader=ChoiceLoader(self.loaders),
bytecode_cache=FileSystemBytecodeCache(cache_dir),
extensions=[
DebugExtension,
ExprStmtExtension,
LoopControlExtension,
WithExtension,
DedentExtension,
],
)
#!/usr/bin/env python # -*- coding: utf-8 -*- # # @author [email protected] # @date 2016-1-9 # import os from jinja2 import Environment, FileSystemLoader, FileSystemBytecodeCache from tornado.template import Loader from tornadopy.settings_manager import settings from jinja2.defaults import * from jinja2.runtime import Undefined _CACHE = FileSystemBytecodeCache() _LOADER = FileSystemLoader([]) cfg = settings.TEMPLATE_CONFIG _JINJA_ENV = Environment(bytecode_cache=_CACHE, autoescape=cfg.get('autoescape', False), cache_size=cfg.get('cache_size', 50), auto_reload=cfg.get('filesystem_checks', True), loader=_LOADER, block_start_string=cfg.get('block_start_string', BLOCK_START_STRING), block_end_string=cfg.get('block_end_string', BLOCK_END_STRING), variable_start_string=cfg.get('variable_start_string', VARIABLE_START_STRING), variable_end_string=cfg.get('variable_end_string', VARIABLE_END_STRING), comment_start_string=cfg.get('comment_start_string',
from settings import URL
# from django.template import RequestContext
loader_array = []
for pth in getattr(settings, 'TEMPLATE_DIRS', ()):
loader_array.append(FileSystemLoader(pth))
for app in settings.INSTALLED_APPS:
loader_array.append(PackageLoader(app))
default_mimetype = getattr(settings, 'DEFAULT_CONTENT_TYPE')
global_exts = getattr(settings, 'JINJA_EXTS', ())
bcc = FileSystemBytecodeCache(settings.DIR_ROOT + '/tmp', 'sorema_%s.cache')
env = Environment(extensions=global_exts,
loader=ChoiceLoader(loader_array),
bytecode_cache=bcc)
global_imports = getattr(settings, 'JINJA_GLOBALS', ())
for imp in global_imports:
method = get_callable(imp)
method_name = getattr(method, 'jinja_name', None)
if not method_name == None:
env.globals[method_name] = method
else:
env.globals[method.__name__] = method
global_filters = getattr(settings, 'JINJA_FILTERS', ())
for imp in global_filters:
from typing import Optional, Tuple
from jinja2 import Environment, FileSystemLoader, FileSystemBytecodeCache
from .errors import UnknownTypeError, TooBigEntityError
from .config import conf
from .ext.const import work_directory, ws_magic_string
template_path = conf.get("template", "template_path")
cache_path = conf.get("template", "cache_path")
loader = FileSystemLoader(template_path)
if conf.get("template", "use_fs_cache"):
if not os.path.exists(cache_path):
os.mkdir(cache_path)
bc_cache = FileSystemBytecodeCache(
os.path.join(work_directory, cache_path), "%s.cache")
else:
bc_cache = None
env = Environment(loader=loader,
bytecode_cache=bc_cache,
enable_async=False,
autoescape=True)
# "--" + self.bound + "\r\n" + http_like_data + "\r\n"
class PostDataManager:
def __init__(self,
request,
reader: asyncio.StreamReader,
buf_size=16384,
limit=10485760): # 10M
def configure(self, site, engine=None):
"""
Uses the site object to initialize the jinja environment.
"""
self.site = site
self.engine = engine
self.preprocessor = (engine.preprocessor if hasattr(
engine, 'preprocessor') else None)
self.loader = HydeLoader(self.sitepath, site, self.preprocessor)
default_extensions = [
IncludeText, Spaceless, Asciidoc, Markdown, restructuredText,
Syntax, Reference, Refer, YamlVar, 'jinja2.ext.do',
'jinja2.ext.loopcontrols', 'jinja2.ext.with_'
]
defaults = {
'line_statement_prefix': '$$$',
'trim_blocks': True,
}
settings = dict()
settings.update(defaults)
settings['extensions'] = list()
settings['extensions'].extend(default_extensions)
conf = {}
try:
conf = attrgetter('config.jinja2')(site).to_dict()
except AttributeError:
pass
settings.update(
dict([(key, conf[key]) for key in defaults if key in conf]))
extensions = conf.get('extensions', [])
if isinstance(extensions, list):
settings['extensions'].extend(extensions)
else:
settings['extensions'].append(extensions)
self.env = Environment(
loader=self.loader,
undefined=SilentUndefined,
line_statement_prefix=settings['line_statement_prefix'],
trim_blocks=True,
bytecode_cache=FileSystemBytecodeCache(),
extensions=settings['extensions'])
self.env.globals['media_url'] = media_url
self.env.globals['content_url'] = content_url
self.env.globals['full_url'] = full_url
self.env.globals['engine'] = engine
self.env.globals['deps'] = {}
self.env.filters['urlencode'] = urlencode
self.env.filters['urldecode'] = urldecode
self.env.filters['asciidoc'] = asciidoc
self.env.filters['markdown'] = markdown
self.env.filters['restructuredtext'] = restructuredtext
self.env.filters['syntax'] = syntax
self.env.filters['date_format'] = date_format
self.env.filters['xmldatetime'] = xmldatetime
self.env.filters['islice'] = islice
self.env.filters['top'] = top
config = {}
if hasattr(site, 'config'):
config = site.config
self.env.extend(config=config)
try:
from typogrify.templatetags import jinja2_filters
except ImportError:
jinja2_filters = False
if jinja2_filters:
jinja2_filters.register(self.env)
def parse_env_options_from_settings(
settings,
prefix,
maybe_dotted,
package,
defaults=None,
):
""" Parse options for use with the Jinja2 Environment."""
def sget(name, default=None):
return settings.get(prefix + name, default)
if defaults is None:
defaults = _JINJA2_ENVIRONMENT_DEFAULTS
opts = {}
reload_templates = sget('reload_templates')
if reload_templates is None:
reload_templates = settings.get('pyramid.reload_templates')
opts['auto_reload'] = asbool(reload_templates)
# set string settings
for key_name in ('block_start_string', 'block_end_string',
'variable_start_string', 'variable_end_string',
'comment_start_string', 'comment_end_string',
'line_statement_prefix', 'line_comment_prefix',
'newline_sequence'):
value = sget(key_name, defaults.get(key_name))
if value is not None:
opts[key_name] = value
# boolean settings
for key_name in ('autoescape', 'trim_blocks', 'optimized'):
value = sget(key_name, defaults.get(key_name))
if value is not None:
opts[key_name] = asbool(value)
# integer settings
for key_name in ('cache_size', ):
value = sget(key_name, defaults.get(key_name))
if value is not None:
opts[key_name] = int(value)
opts['undefined'] = parse_undefined(sget('undefined', ''))
# get supplementary jinja2 settings
domain = sget('i18n.domain', package and package.__name__ or 'messages')
gettext_wrapper = sget('i18n.gettext', GetTextWrapper)
if not issubclass(gettext_wrapper, GetTextWrapper):
gettext_wrapper = maybe_dotted(gettext_wrapper)
opts['gettext'] = gettext_wrapper(domain=domain)
# get jinja2 extensions
extensions = parse_multiline(sget('extensions', ''))
if 'jinja2.ext.i18n' not in extensions:
extensions.append('jinja2.ext.i18n')
opts['extensions'] = extensions
# get jinja2 bytecode caching settings and set up bytecaching
bytecode_caching = sget('bytecode_caching', False)
if isinstance(bytecode_caching, BytecodeCache):
opts['bytecode_cache'] = bytecode_caching
elif asbool(bytecode_caching):
bytecode_caching_directory = sget('bytecode_caching_directory', None)
opts['bytecode_cache'] = FileSystemBytecodeCache(
bytecode_caching_directory)
# should newstyle gettext calls be enabled?
opts['newstyle'] = asbool(sget('newstyle', False))
# Do we have a finalize function?
finalize = sget('finalize')
if finalize is not None:
opts['finalize'] = maybe_dotted(finalize)
# add custom jinja2 filters
opts['filters'] = parse_named_assetspecs(sget('filters', ''), maybe_dotted)
# add custom jinja2 tests
opts['tests'] = parse_named_assetspecs(sget('tests', ''), maybe_dotted)
# add custom jinja2 functions
opts['globals'] = parse_named_assetspecs(sget('globals', ''), maybe_dotted)
return opts
PREFIX = config.get('webui', 'prefix')
if PREFIX:
PREFIX = PREFIX.rstrip("/")
if not PREFIX.startswith("/"):
PREFIX = "/" + PREFIX
DEBUG = config.get("general",
"debug_mode") or "-d" in sys.argv or "--debug" in sys.argv
bottle.debug(DEBUG)
cache = join("tmp", "jinja_cache")
if not exists(cache):
makedirs(cache)
bcc = FileSystemBytecodeCache(cache, '%s.cache')
loader = FileSystemLoader([THEME_DIR, join(THEME_DIR, THEME)])
env = Environment(loader=loader,
extensions=['jinja2.ext.i18n', 'jinja2.ext.autoescape'],
trim_blocks=True,
auto_reload=False,
bytecode_cache=bcc)
from filters import quotepath, path_make_relative, path_make_absolute, truncate, date
env.filters['quotepath'] = quotepath
env.filters['truncate'] = truncate
env.filters['date'] = date
env.filters['path_make_relative'] = path_make_relative
def _get_or_build_default_environment(registry):
environment = registry.queryUtility(IJinja2Environment)
if environment is not None:
return environment
settings = registry.settings
kw = {}
package = _caller_package(('pyramid_jinja2', 'jinja2', 'pyramid.config'))
debug = asbool(settings.get('debug_templates', False))
# get basic environment jinja2 settings
kw.update(_parse_config_for_settings(settings))
reload_templates = settings.get('reload_templates', None)
if reload_templates is None:
# since version 1.5, both settings are supported
reload_templates = settings.get('pyramid.reload_templates', False)
reload_templates = asbool(reload_templates)
undefined = parse_undefined(settings.get('jinja2.undefined', ''))
# get supplementary junja2 settings
input_encoding = settings.get('jinja2.input_encoding', 'utf-8')
domain = settings.get('jinja2.i18n.domain', package and package.__name__
or 'messages')
# get jinja2 extensions
extensions = parse_multiline(settings.get('jinja2.extensions', ''))
if 'jinja2.ext.i18n' not in extensions:
extensions.append('jinja2.ext.i18n')
# get jinja2 directories
directories = parse_multiline(settings.get('jinja2.directories') or '')
directories = [abspath_from_resource_spec(d, package) for d in directories]
loader = SmartAssetSpecLoader(directories,
encoding=input_encoding,
debug=debug)
# get jinja2 bytecode caching settings and set up bytecaching
bytecode_caching = asbool(settings.get('jinja2.bytecode_caching', True))
bytecode_caching_directory = \
settings.get('jinja2.bytecode_caching_directory', None)
if bytecode_caching:
kw['bytecode_cache'] = \
FileSystemBytecodeCache(bytecode_caching_directory)
# clear cache on exit
atexit.register(kw['bytecode_cache'].clear)
# should newstyle gettext calls be enabled?
newstyle = asbool(settings.get('jinja2.newstyle', False))
environment = Environment(loader=loader,
auto_reload=reload_templates,
extensions=extensions,
undefined=undefined,
**kw)
# register pyramid i18n functions
wrapper = GetTextWrapper(domain=domain)
environment.install_gettext_callables(wrapper.gettext,
wrapper.ngettext,
newstyle=newstyle)
# register global repository for templates
if package is not None:
environment._default_package = package.__name__
#add custom jinja2 filters
filters = parse_config(settings.get('jinja2.filters', ''))
environment.filters.update(filters)
#add custom jinja2 tests
tests = parse_config(settings.get('jinja2.tests', ''))
environment.tests.update(tests)
# add custom jinja2 functions
jinja_globals = parse_config(settings.get('jinja2.globals', ''))
environment.globals.update(jinja_globals)
registry.registerUtility(environment, IJinja2Environment)
return registry.queryUtility(IJinja2Environment)