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 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 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 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)