def renderer_factory(info):
path = info.name
registry = info.registry
settings = info.settings
lookup = registry.queryUtility(IMakoLookup)
if lookup is None:
reload_templates = settings.get('reload_templates', False)
directories = settings.get('mako.directories', None)
module_directory = settings.get('mako.module_directory', None)
input_encoding = settings.get('mako.input_encoding', 'utf-8')
error_handler = settings.get('mako.error_handler', None)
default_filters = settings.get('mako.default_filters', None)
imports = settings.get('mako.imports', None)
strict_undefined = settings.get('mako.strict_undefined', 'false')
if directories is None:
raise ConfigurationError(
'Mako template used without a ``mako.directories`` setting')
if not hasattr(directories, '__iter__'):
directories = filter(None, directories.splitlines())
directories = [ abspath_from_resource_spec(d) for d in directories ]
if module_directory is not None:
module_directory = abspath_from_resource_spec(module_directory)
if error_handler is not None:
dotted = DottedNameResolver(info.package)
error_handler = dotted.maybe_resolve(error_handler)
if default_filters is not None:
if not hasattr(default_filters, '__iter__'):
default_filters = filter(None, default_filters.splitlines())
if imports is not None:
if not hasattr(imports, '__iter__'):
imports = filter(None, imports.splitlines())
strict_undefined = asbool(strict_undefined)
lookup = PkgResourceTemplateLookup(directories=directories,
module_directory=module_directory,
input_encoding=input_encoding,
error_handler=error_handler,
default_filters=default_filters,
imports=imports,
filesystem_checks=reload_templates,
strict_undefined=strict_undefined)
registry_lock.acquire()
try:
registry.registerUtility(lookup, IMakoLookup)
finally:
registry_lock.release()
return MakoLookupTemplateRenderer(path, lookup)
def _add_jinja2_search_path(config, searchpath):
registry = config.registry
env = _get_or_build_default_environment(registry)
if isinstance(searchpath, basestring):
searchpath = [x.strip() for x in searchpath.split('\n') if x.strip()]
for d in searchpath:
env.loader.searchpath.append(abspath_from_resource_spec(d))
def renderer_factory(info):
path = info.name
registry = info.registry
settings = info.settings
lookup = registry.queryUtility(IMakoLookup)
if lookup is None:
reload_templates = settings.get('reload_templates', False)
directories = settings.get('mako.directories')
module_directory = settings.get('mako.module_directory')
input_encoding = settings.get('mako.input_encoding', 'utf-8')
error_handler = settings.get('mako.error_handler', None)
default_filters = settings.get('mako.default_filters', None)
imports = settings.get('mako.imports', [])
if directories is None:
raise ConfigurationError(
'Mako template used without a ``mako.directories`` setting')
directories = directories.splitlines()
directories = [ abspath_from_resource_spec(d) for d in directories ]
lookup = PkgResourceTemplateLookup(directories=directories,
module_directory=module_directory,
input_encoding=input_encoding,
error_handler=error_handler,
default_filters=default_filters,
imports=imports,
filesystem_checks=reload_templates)
registry_lock.acquire()
try:
registry.registerUtility(lookup, IMakoLookup)
finally:
registry_lock.release()
return MakoLookupTemplateRenderer(path, lookup)
def __init__(self, settings):
dirs = settings.get('genshi.directories', [])
paths = [abspath_from_resource_spec(p) for p in to_list(dirs)]
paths.insert(0, load_template) # enable Pyramid asset specifications
# http://genshi.edgewall.org/wiki/Documentation/i18n
# If genshi.translation_domain has a value,
# we set up a callback in the loader
domain = settings.get('genshi.translation_domain')
if domain:
from genshi.filters import Translator
from pyramid.i18n import get_localizer
from pyramid.threadlocal import get_current_request
def translate(text):
return get_localizer(get_current_request()) \
.translate(text, domain=domain)
def callback(template):
Translator(translate).setup(template)
else:
callback = None
from genshi.template import TemplateLoader
self.loader = TemplateLoader(
paths, callback=callback,
auto_reload=asbool(settings.get('pyramid.reload_templates')),
max_cache_size=int(settings.get('genshi.max_cache_size', 100)))
self.strip_whitespace = settings.get('genshi.strip_whitespace', True)
self.doctype = settings.get('genshi.doctype', 'html5')
self.method = settings.get('genshi.method', 'xhtml')
def __init__(self, settings):
from genshi.template import TemplateLoader
try:
dirs = settings['genshi.directories']
except KeyError:
raise KeyError('You need to configure genshi.directories.')
paths = [abspath_from_resource_spec(p) for p in to_list(dirs)]
# http://genshi.edgewall.org/wiki/Documentation/i18n.html
# If genshi.translation_domain is configured,
# we set up a callback in the loader
domain = settings.get('genshi.translation_domain')
if domain:
from genshi.filters import Translator
from pyramid.i18n import get_localizer
from pyramid.threadlocal import get_current_request
def translate(text):
return get_localizer(get_current_request()) \
.translate(text, domain=domain)
def callback(template):
Translator(translate).setup(template)
else:
callback = None
self.loader = TemplateLoader(paths,
auto_reload = asbool(settings.get('reload_templates')),
callback = callback)
self.strip_whitespace = settings.get('genshi.strip_whitespace', True)
self.encoding = settings.get('genshi.encoding', 'utf-8')
self.doctype = settings.get('genshi.doctype', 'html5')
self.method = settings.get('genshi.method', 'xhtml')
def renderer_factory(info):
registry = info.registry
settings = info.settings
environment = registry.queryUtility(IJinja2Environment)
if environment is None:
reload_templates = settings.get('reload_templates', False)
directories = settings.get('jinja2.directories')
input_encoding = settings.get('jinja2.input_encoding', 'utf-8')
autoescape = settings.get('jinja2.autoescape', True)
extensions = settings.get('jinja2.extensions', '')
filters = settings.get('jinja2.filters', '')
if directories is None:
raise ConfigurationError(
'Jinja2 template used without a ``jinja2.directories`` setting')
if isinstance(directories, basestring):
directories = splitlines(directories)
directories = [ abspath_from_resource_spec(d) for d in directories ]
loader = FileSystemLoader(directories, encoding=input_encoding)
autoescape = asbool(autoescape)
extensions = parse_extensions(extensions)
filters = parse_filters(filters)
environment = Environment(loader=loader,
auto_reload=reload_templates,
autoescape=autoescape,
extensions=extensions)
environment.filters.update(filters)
registry.registerUtility(environment, IJinja2Environment)
return Jinja2TemplateRenderer(info, environment)
def _add_jinja2_search_path(config, searchpath):
registry = config.registry
env = _get_or_build_default_environment(registry)
if isinstance(searchpath, basestring):
searchpath = [x.strip() for x in searchpath.split('\n') if x.strip()]
for d in searchpath:
env.loader.searchpath.append(abspath_from_resource_spec(d))
def __init__(self, settings):
dirs = settings.get('genshi.directories', [])
paths = [abspath_from_resource_spec(p) for p in to_list(dirs)]
paths.insert(0, load_template) # enable Pyramid asset specifications
# http://genshi.edgewall.org/wiki/Documentation/i18n
# If genshi.translation_domain has a value,
# we set up a callback in the loader
domain = settings.get('genshi.translation_domain')
if domain:
from genshi.filters import Translator
from pyramid.i18n import get_localizer
from pyramid.threadlocal import get_current_request
def translate(text):
return get_localizer(get_current_request()) \
.translate(text, domain=domain)
def callback(template):
Translator(translate).setup(template)
else:
callback = None
from genshi.template import TemplateLoader
self.loader = TemplateLoader(
paths,
callback=callback,
auto_reload=asbool(settings.get('pyramid.reload_templates')),
max_cache_size=int(settings.get('genshi.max_cache_size', 100)))
self.strip_whitespace = settings.get('genshi.strip_whitespace', True)
self.doctype = settings.get('genshi.doctype', 'html5')
self.method = settings.get('genshi.method', 'xhtml')
def renderer_factory(info):
"""*info* contains:
::
name = Attribute('The value passed by the user as the renderer name')
package = Attribute('The "current package" when the renderer '
'configuration statement was found')
type = Attribute('The renderer type name')
registry = Attribute('The "current" application registry when the '
'renderer was created')
settings = Attribute('The ISettings dictionary related to the '
'current app')
"""
registry = info.registry
settings = info.settings
if not hasattr(registry, 'kajiki_loader'):
from kajiki import FileLoader
registry.kajiki_loader = FileLoader(
base=abspath_from_resource_spec(settings['kajiki.directory']),
reload=asbool(settings.get('reload_templates')),
force_mode=asbool(settings.get('kajiki.force_mode')),
autoescape_text=asbool(settings.get('kajiki.autoescape')),
)
return KajikiTemplateRenderer(info)
def scan(self):
self.packages.append(self.package_name)
for p in self.packages:
self.config.scan(p)
locale_dir = abspath_from_resource_spec(p + ':locale')
if os.path.isdir(locale_dir):
self.config.add_translation_dirs(locale_dir)
# Make this method a noop for the future (scan only once)
self.scan = lambda: None
def scan(self):
self.packages.append(self.package_name)
for p in self.packages:
self.config.scan(p)
locale_dir = abspath_from_resource_spec(p + ':locale')
if os.path.isdir(locale_dir):
self.config.add_translation_dirs(locale_dir)
# Make this method a noop for the future (scan only once)
self.scan = lambda: None
def directory_loader_factory(settings):
input_encoding = settings.get('jinja2.input_encoding', 'utf-8')
directories = settings.get('jinja2.directories') or ''
if isinstance(directories, string_types):
directories = splitlines(directories)
directories = [abspath_from_resource_spec(d) for d in directories]
loader = SmartAssetSpecLoader(
directories, encoding=input_encoding,
debug=asbool(settings.get('debug_templates', False)))
return loader
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')
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)
defaults_prefix = 'jinja2.defaults.'
for k, v in settings.items():
if k.startswith(defaults_prefix):
kw[k[len(defaults_prefix):]] = v
environment = Environment(loader=loader,
auto_reload=reload_templates,
autoescape=autoescape,
extensions=extensions,
**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 _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 directory_loader_factory(settings):
input_encoding = settings.get('jinja2.input_encoding', 'utf-8')
directories = settings.get('jinja2.directories') or ''
if isinstance(directories, string_types):
directories = splitlines(directories)
directories = [abspath_from_resource_spec(d) for d in directories]
loader = SmartAssetSpecLoader(directories,
encoding=input_encoding,
debug=asbool(
settings.get('debug_templates', False)))
return loader
def import_(self, name, *a, **kw):
'''Overrides Loader.import_().
* Resolves the resource spec into an absolute path for the template.
* Checks the template modification time to decide whether to reload it.
'''
name = abspath_from_resource_spec(name)
if self.auto_reload and name in self.modules:
mtime = stat(name).st_mtime
if mtime > self._timestamps.get(name, 0):
del self.modules[name]
return super(PyramidKajikiLoader, self).import_(name, *a, **kw)
def import_(self, name, *a, **kw):
"""Overrides Loader.import_().
* Resolves the resource spec into an absolute path for the template.
* Checks the template modification time to decide whether to reload it.
"""
name = abspath_from_resource_spec(name)
if self.auto_reload and name in self.modules:
mtime = stat(name).st_mtime
if mtime > self._timestamps.get(name, 0):
del self.modules[name]
return super().import_(name, *a, **kw)
def serve_preloaded(
config, route_name, route_path, payload,
encoding=None, content_type=None,
):
"""Read a file (such as robots.txt or favicon.ini) into memory.
...then set up a view that serves it. Usage::
from bag.web.pyramid.views import serve_preloaded
serve_preloaded(
config,
route_name='robots',
route_path='robots.txt',
payload='my_package:static/robots.txt',
encoding='utf-8')
serve_preloaded(
config,
route_name='favicon',
route_path='favicon.ico',
payload='my_package:static/favicon.ico',
content_type='image/x-icon',
)
"""
from os.path import getmtime, getsize
from pyramid.resource import abspath_from_resource_spec
from pyramid.response import Response
path = abspath_from_resource_spec(payload)
if not content_type:
from mimetypes import guess_type
content_type = guess_type(path)[0] or 'application/octet-stream'
if encoding:
import codecs
stream = codecs.open(path, 'r', encoding='utf-8')
else:
stream = open(path, 'rb')
kwargs = dict(
content_type=content_type,
body=stream.read(),
last_modified=getmtime(path),
content_length=getsize(path),
)
stream.close()
def preloaded_view(request): # This closure is the view handler
return Response(**kwargs)
config.add_route(route_name, route_path)
config.add_view(preloaded_view, route_name=route_name)
def enable_robots(self, path='static/robots.txt'):
from mimetypes import guess_type
from pyramid.resource import abspath_from_resource_spec
path = abspath_from_resource_spec(
self.settings.get('robots', '{}:{}'.format(self.name, path)))
content_type = guess_type(path)[0]
import codecs
with codecs.open(path, 'r', encoding='utf-8') as f:
content = f.read()
from pyramid.response import Response
def robots_view(request):
return Response(content_type=content_type, app_iter=content)
self.config.add_route('robots', '/robots.txt')
self.config.add_view(robots_view, route_name='robots')
def enable_favicon(self, path='static/favicon.ico'):
'''Registers a view that serves /favicon.ico.
web_deps.PageDeps contains a favicon_tag() method that you can use to
create the link to it.
FileResponse appeared in Pyramid 1.3a9.
'''
path = abspath_from_resource_spec(self.package_name + ':' + path)
def favicon_view(request):
return FileResponse(path, request=request)
self.config.add_route('favicon', 'favicon.ico')
self.config.add_view(favicon_view, route_name='favicon')
def enable_favicon(self, path='static/favicon.ico'):
'''Registers a view that serves /favicon.ico.
web_deps.PageDeps contains a favicon_tag() method that you can use to
create the link to it.
FileResponse appeared in Pyramid 1.3a9.
'''
path = abspath_from_resource_spec(self.package_name + ':' + path)
def favicon_view(request):
return FileResponse(path, request=request)
self.config.add_route('favicon', 'favicon.ico')
self.config.add_view(favicon_view, route_name='favicon')
def load_template(asset):
"""Make the Genshi TemplateLoader work with typical Pyramid
asset specifications by passing this function to
the TemplateLoader constructor as one of the paths.
"""
# print('LOAD {}'.format(asset))
abspath = abspath_from_resource_spec(asset)
stream = open(abspath, 'r') # Genshi catches the possible IOError.
mtime = path.getmtime(abspath)
filename = path.basename(abspath)
def file_not_changed():
# debug = 'SAME' if mtime == path.getmtime(abspath) else 'MODIFIED'
# print(debug, abspath)
return mtime == path.getmtime(abspath)
return (abspath, filename, stream, file_not_changed)
def enable_robots(self, path="static/robots.txt"):
"""Reads robots.txt into memory, then sets up a view that serves it."""
from mimetypes import guess_type
path = abspath_from_resource_spec(self.settings.get("robots", "{}:{}".format(self.package_name, path)))
content_type = guess_type(path)[0]
import codecs
with codecs.open(path, "r", encoding="utf-8") as f:
content = f.read()
from pyramid.response import Response
def robots_view(request):
return Response(content_type=content_type, app_iter=content)
self.config.add_route("robots", "/robots.txt")
self.config.add_view(robots_view, route_name="robots")
def enable_robots(self, path='static/robots.txt'):
'''Reads robots.txt into memory, then sets up a view that serves it.'''
from mimetypes import guess_type
path = abspath_from_resource_spec(
self.settings.get('robots', '{}:{}'.format(self.package_name,
path)))
content_type = guess_type(path)[0]
import codecs
with codecs.open(path, 'r', encoding='utf-8') as f:
content = f.read()
from pyramid.response import Response
def robots_view(request):
return Response(content_type=content_type, app_iter=content)
self.config.add_route('robots', '/robots.txt')
self.config.add_view(robots_view, route_name='robots')
def load_template(asset):
'''Make the Genshi TemplateLoader work with typical Pyramid
asset specifications by passing this function to
the TemplateLoader constructor as one of the paths.
'''
# print('LOAD {}'.format(asset))
abspath = abspath_from_resource_spec(asset)
stream = open(abspath, 'r') # Genshi catches the possible IOError.
mtime = path.getmtime(abspath)
filename = path.basename(abspath)
def file_not_changed():
# debug = 'SAME' if mtime == path.getmtime(abspath) else 'MODIFIED'
# print(debug, abspath)
return mtime == path.getmtime(abspath)
return (abspath, filename, stream, file_not_changed)
def add_jinja2_search_path(config, searchpath):
"""
This function is added as a method of a :term:`Configurator`, and
should not be called directly. Instead it should be called like so after
``pyramid_jinja2`` has been passed to ``config.include``:
.. code-block:: python
config.add_jinja2_search_path('anotherpackage:templates/')
It will add the directory or :term:`asset spec` passed as ``searchpath``
to the current search path of the ``jinja2.environment.Environment`` used
by :mod:`pyramid_jinja2`.
"""
registry = config.registry
env = _get_or_build_default_environment(registry)
searchpath = parse_multiline(searchpath)
for d in searchpath:
env.loader.searchpath.append(abspath_from_resource_spec(d, config.package_name))
def renderer_factory(info):
path = info.name
registry = info.registry
settings = info.settings
lookup = registry.queryUtility(IMakoLookup)
if lookup is None:
reload_templates = settings.get('reload_templates', False)
directories = settings.get('mako.directories')
module_directory = settings.get('mako.module_directory')
input_encoding = settings.get('mako.input_encoding', 'utf-8')
if directories is None:
raise ConfigurationError(
'Mako template used without a ``mako.directories`` setting')
directories = directories.splitlines()
directories = [ abspath_from_resource_spec(d) for d in directories ]
lookup = PkgResourceTemplateLookup(directories=directories,
module_directory=module_directory,
input_encoding=input_encoding,
filesystem_checks=reload_templates)
registry.registerUtility(lookup, IMakoLookup)
return MakoLookupTemplateRenderer(path, lookup)
def renderer_factory(path):
from mako.lookup import TemplateLookup
registry = get_current_registry()
lookup = registry.queryUtility(IMakoLookup)
if lookup is None:
settings = get_settings() or {}
reload_templates = settings.get('reload_templates', False)
directories = settings.get('mako.directories')
module_directory = settings.get('mako.module_directory')
input_encoding = settings.get('mako.input_encoding', 'utf-8')
if directories is None:
raise ConfigurationError(
'Mako template used without a lookup path')
directories = directories.splitlines()
directories = [ abspath_from_resource_spec(d) for d in directories ]
lookup = TemplateLookup(directories=directories,
module_directory=module_directory,
input_encoding=input_encoding,
filesystem_checks=reload_templates)
registry.registerUtility(lookup, IMakoLookup)
_, path = resolve_resource_spec(path)
return MakoLookupTemplateRenderer(path, lookup)
def renderer_factory(info):
'''*info* contains::
name = Attribute('The value passed by the user as the renderer name')
package = Attribute('The "current package" when the renderer '
'configuration statement was found')
type = Attribute('The renderer type name')
registry = Attribute('The "current" application registry when the '
'renderer was created')
settings = Attribute('The ISettings dictionary related to the '
'current app')
'''
registry = info.registry
settings = info.settings
if not hasattr(registry, 'kajiki_loader'):
from kajiki import FileLoader
registry.kajiki_loader = FileLoader(
base=abspath_from_resource_spec(settings['kajiki.directory']),
reload=asbool(settings.get('reload_templates')),
force_mode=asbool(settings.get('kajiki.force_mode')),
autoescape_text=asbool(settings.get('kajiki.autoescape')),
)
return KajikiTemplateRenderer(info)
def get_paths(self):
paths = set()
root = self.registry['root']
request = _make_request('/', registry=self.registry)
if root:
excludes = self.siteconfig['site'].get('excludes', '').split('\n')
excludes.extend([
'.*',
'/config.py*',
'/site.cfg',
'/%s' % self.siteconfig['site']['outpath']])
relpaths = dirtools.Dir(
root.abspath,
excludes=excludes).files()
for relpath in relpaths:
traverse(root, relpath)
if root:
paths.add('/%s' % relpath)
visited_routes = set()
info = self.registry.queryUtility(IStaticURLInfo)
if info:
for (url, spec, route_name) in info._get_registrations(self.registry):
visited_routes.add(route_name)
path = abspath_from_resource_spec(spec)
relpaths = dirtools.Dir(path).files()
for relpath in relpaths:
paths.add(
request.route_path(route_name, subpath=relpath))
routelist = self.site.config.config.get_routes_mapper().routelist
for route in routelist:
if route.factory is not None:
matches = route.factory.matches(self.registry)
paths = paths.union(route.generate(x) for x in matches)
elif route.name not in visited_routes:
paths.add(route.generate({}))
visited_routes.add(route.name)
return list(sorted(paths))
def get_template(self, uri):
"""Fetch a template from the cache, or check the filesystem
for it
In addition to the basic filesystem lookup, this subclass will
use pkg_resource to load a file using the resource
specification syntax.
"""
isabs = os.path.isabs(uri)
if (not isabs) and (':' in uri):
try:
if self.filesystem_checks:
return self._check(uri, self._collection[uri])
else:
return self._collection[uri]
except KeyError:
pname, path = resolve_resource_spec(uri)
srcfile = abspath_from_resource_spec(path, pname)
if os.path.isfile(srcfile):
return self._load(srcfile, uri)
raise exceptions.TopLevelLookupException(
"Cant locate template for uri %r" % uri)
return TemplateLookup.get_template(self, uri)
def configure_favicon(self, path='static/icon/32.png'):
from mimetypes import guess_type
from pyramid.resource import abspath_from_resource_spec
self.settings['favicon'] = path = abspath_from_resource_spec(
self.settings.get('favicon', '{}:{}'.format(self.name, path)))
self.settings['favicon_content_type'] = guess_type(path)[0]
def _callFUT(self, spec, pname='__main__'):
from pyramid.resource import abspath_from_resource_spec
return abspath_from_resource_spec(spec, pname)
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)
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)
