def __init__(self, extra_vars_func=None, options=None): if 'jinja.environment' in options: self.env = options['jinja.environment'] else: opt = {} for key, value in options.iteritems(): if key.startswith('jinja.') and key != 'jinja.extension': opt[key[6:]] = value loader_func = opt.pop('loader_func', None) getmtime_func = opt.pop('getmtime_func', None) use_memcache = opt.pop('use_memcache', False) memcache_size = opt.pop('memcache_size', 40) cache_folder = opt.pop('cache_folder', None) auto_reload = opt.pop('auto_reload', True) if 'searchpath' in opt: opt['loader'] = FileSystemLoader(opt.pop('searchpath'), use_memcache, memcache_size, cache_folder, auto_reload) elif 'package' in opt: opt['loader'] = PackageLoader(opt.pop('package'), opt.pop('package_path', ''), use_memcache, memcache_size, cache_folder, auto_reload) elif loader_func is not None: opt['loader'] = FunctionLoader(loader_func, getmtime_func, use_memcache, memcache_size, cache_folder, auto_reload) self.env = Environment(**opt) self.extra_vars_func = extra_vars_func self.extension = options.pop('jinja.extension', 'html')
def create_template(self): env = Environment() env.loader = FileSystemLoader(DEFAULT_TEMPLATE_FOLDER) template = env.get_template(DEFAULT_TEMPLATE) output_text = template.render(self.__template_vars) output_report = open(self.__template_path, 'w') output_report.write(output_text) output_report.close()
def from_string(source): """ Create a template from the template source. """ global _from_string_env if _from_string_env is None: from jinja.environment import Environment _from_string_env = Environment() return _from_string_env.from_string(source)
class BuffetPlugin(object): """ Implements the Jinja buffet plugin. Well. It works for pylons and should work for TurboGears too if their plugin system would work. """ def __init__(self, extra_vars_func=None, options=None): if 'jinja.environment' in options: self.env = options['jinja.environment'] else: opt = {} for key, value in options.iteritems(): if key.startswith('jinja.') and key != 'jinja.extension': opt[key[6:]] = value loader_func = opt.pop('loader_func', None) getmtime_func = opt.pop('getmtime_func', None) use_memcache = opt.pop('use_memcache', False) memcache_size = opt.pop('memcache_size', 40) cache_folder = opt.pop('cache_folder', None) auto_reload = opt.pop('auto_reload', True) if 'searchpath' in opt: opt['loader'] = FileSystemLoader(opt.pop('searchpath'), use_memcache, memcache_size, cache_folder, auto_reload) elif 'package' in opt: opt['loader'] = PackageLoader(opt.pop('package'), opt.pop('package_path', ''), use_memcache, memcache_size, cache_folder, auto_reload) elif loader_func is not None: opt['loader'] = FunctionLoader(loader_func, getmtime_func, use_memcache, memcache_size, cache_folder, auto_reload) self.env = Environment(**opt) self.extra_vars_func = extra_vars_func self.extension = options.pop('jinja.extension', 'html') def load_template(self, templatename, template_string=None): if template_string is not None: return self.env.from_string(template_string) if templatename.startswith('!'): jinja_name = templatename[1:] else: jinja_name = templatename.replace('.', '/') + '.' + self.extension return self.env.get_template(jinja_name) def render(self, info, format='html', fragment=False, template=None): if isinstance(template, basestring): template = self.load_template(template) if self.extra_vars_func: info.update(self.extra_vars_func()) return template.render(info)
def render_template(self, branch): """ Render XML from the Jinja2 template """ from jinja import FileSystemLoader from jinja.environment import Environment env = Environment() env.loader = FileSystemLoader('templates') template = env.get_template(self.template_name) rendered_xml = template.render(git_repo=self.repo_url, git_branch=branch) return rendered_xml
def jinja_plugin_factory(options): """ Basic implementation of the `GeneralTemplateInterface`. Supports ``loader_func`` and ``getmtime_func``, as well as string and file loading but ignores ``mode`` since it's a text based template engine. All options passed to this function are forwarded to the jinja environment. Exceptions are the following keys: =================== ================================================= ``environment`` If this is provided it must be the only configuration value and it's used as jinja environment. ``searchpath`` If provided a new file system loader with this search path is instanciated. ``package`` Name of the python package containing the templates. If this and ``package_path`` is defined a `PackageLoader` is used. ``package_path`` Path to the templates inside of a package. ``loader_func`` Function that takes the name of the template to load. If it returns a string or unicode object it's used to load a template. If the return value is None it's considered missing. ``getmtime_func`` Function used to check if templates requires reloading. Has to return the UNIX timestamp of the last template change or 0 if this template does not exist or requires updates at any cost. ``use_memcache`` Set this to ``True`` to enable memory caching. This is usually a good idea in production mode, but disable it during development since it won't reload template changes automatically. This only works in persistent environments like FastCGI. ``memcache_size`` Number of template instance you want to cache. Defaults to ``40``. ``cache_folder`` Set this to an existing directory to enable caching of templates on the file system. Note that this only affects templates transformed into python code. Default is ``None`` which means that caching is disabled. ``auto_reload`` Set this to `False` for a slightly better performance. In that case of `getmtime_func` not being provided this won't have an effect. =================== ================================================= """ warn( DeprecationWarning('general plugin interface implementation ' 'deprecated because not an accepted ' 'standard.')) if 'environment' in options: env = options['environment'] if not len(options) == 1: raise TypeError('if environment provided no other ' 'arguments are allowed') else: loader_func = options.pop('loader_func', None) getmtime_func = options.pop('getmtime_func', None) use_memcache = options.pop('use_memcache', False) memcache_size = options.pop('memcache_size', 40) cache_folder = options.pop('cache_folder', None) auto_reload = options.pop('auto_reload', True) if 'searchpath' in options: options['loader'] = FileSystemLoader(options.pop('searchpath'), use_memcache, memcache_size, cache_folder, auto_reload) elif 'package' in options: options['loader'] = PackageLoader(options.pop('package'), options.pop('package_path', ''), use_memcache, memcache_size, cache_folder, auto_reload) elif loader_func is not None: options['loader'] = FunctionLoader(loader_func, getmtime_func, use_memcache, memcache_size, cache_folder, auto_reload) env = Environment(**options) def render_function(template, values, options): if options.get('is_string'): tmpl = env.from_string(template) else: try: tmpl = env.get_template(template) except TemplateNotFound: return return tmpl.render(**values) return render_function