def __init__(self, environment): super(PaginationExtension, self).__init__(environment) self.environment.globals.update({ 'paginate_list': jinja2.contextfunction(paginate_list), 'pager': jinja2.contextfunction(pager), })
def __init__(self, environment): super(V1Extension, self).__init__(environment) self.environment.globals.update({ 'category_label': ref.category_label, 'choices_for_page_type': ref.choices_for_page_type, 'email_popup': email_popup, 'fcm_label': ref.fcm_label, 'get_menu_items': get_menu_items, 'get_snippets': get_snippets, 'get_unique_id': get_unique_id, 'image_alt_value': image_alt_value, 'is_blog': ref.is_blog, 'is_report': ref.is_report, 'is_filter_selected': contextfunction(is_filter_selected), 'render_stream_child': contextfunction(render_stream_child), })
def init(self, builder, theme=None, dirs=None): # create a chain of paths to search if theme: # the theme's own dir and its bases' dirs chain = theme.get_dirchain() # then the theme parent paths chain.extend(theme.themepath) elif dirs: chain = list(dirs) else: chain = [] # prepend explicit template paths self.templatepathlen = len(builder.config.templates_path) if builder.config.templates_path: chain[0:0] = [path.join(builder.confdir, tp) for tp in builder.config.templates_path] # store it for use in newest_template_mtime self.pathchain = chain # make the paths into loaders self.loaders = map(SphinxFileSystemLoader, chain) use_i18n = builder.app.translator is not None extensions = use_i18n and ['jinja2.ext.i18n'] or [] self.environment = SandboxedEnvironment(loader=self, extensions=extensions) self.environment.filters['tobool'] = _tobool self.environment.globals['debug'] = contextfunction(pformat) self.environment.globals['accesskey'] = contextfunction(accesskey) self.environment.globals['idgen'] = idgen if use_i18n: self.environment.install_gettext_translations( builder.app.translator)
def init(self, builder, theme=None, dirs=None): # create a chain of paths to search if theme: # the theme's own dir and its bases' dirs chain = theme.get_dirchain() # then the theme parent paths chain.extend(theme.themepath) elif dirs: chain = list(dirs) else: chain = [] # prepend explicit template paths self.templatepathlen = len(builder.config.templates_path) if builder.config.templates_path: chain[0:0] = [ path.join(builder.confdir, tp) for tp in builder.config.templates_path ] # store it for use in newest_template_mtime self.pathchain = chain # make the paths into loaders self.loaders = map(SphinxFileSystemLoader, chain) use_i18n = builder.translator is not None extensions = use_i18n and ['jinja2.ext.i18n'] or [] self.environment = SandboxedEnvironment(loader=self, extensions=extensions) self.environment.filters['tobool'] = _tobool self.environment.globals['debug'] = contextfunction(pformat) self.environment.globals['accesskey'] = contextfunction(accesskey) if use_i18n: self.environment.install_gettext_translations(builder.translator)
def __init__(self, environment): super(FlagsExtension, self).__init__(environment) self.environment.globals.update({ 'flag_enabled': contextfunction(flag_enabled), 'flag_disabled': contextfunction(flag_disabled), })
def environment(**options): env = Environment(**options) env.globals.update({ 'static': static, 'url': reverse, 'main_menu': jinja2.contextfunction(main_menu), 'sub_menu': jinja2.contextfunction(sub_menu), }) return env
def __init__(self, environment): super(WagtailCoreExtension, self).__init__(environment) self.environment.globals.update({ 'pageurl': jinja2.contextfunction(pageurl), 'slugurl': jinja2.contextfunction(slugurl), 'wagtail_version': wagtail_version, }) self.environment.filters.update({ 'richtext': richtext, })
def __init__(self, environment): super().__init__(environment) self.environment.globals.update({ 'pageurl': jinja2.contextfunction(pageurl), 'slugurl': jinja2.contextfunction(slugurl), 'wagtail_version': wagtail_version, }) self.environment.filters.update({ 'richtext': richtext, })
def __init__(self, environment): """Update the environment to include `main_menu` and `sub_menu` from the wagtailmenus library. """ super().__init__(environment) environment.globals.update({ 'main_menu': jinja2.contextfunction(main_menu), 'sub_menu': jinja2.contextfunction(sub_menu) })
def _preloading_env(self): """ A "stripped" jinja environment. """ ctx = self.env.globals try: ctx['random_model'] = lambda *a, **kw: None ctx['random_models'] = lambda *a, **kw: None yield self.env finally: ctx['random_model'] = jinja2.contextfunction(random_model) ctx['random_models'] = jinja2.contextfunction(random_models)
def init(self, builder: "Builder", theme: Theme = None, dirs: List[str] = None) -> None: # create a chain of paths to search if theme: # the theme's own dir and its bases' dirs pathchain = theme.get_theme_dirs() # the loader dirs: pathchain + the parent directories for all themes loaderchain = pathchain + [path.join(p, '..') for p in pathchain] elif dirs: pathchain = list(dirs) loaderchain = list(dirs) else: pathchain = [] loaderchain = [] # prepend explicit template paths self.templatepathlen = len(builder.config.templates_path) if builder.config.templates_path: cfg_templates_path = [ path.join(builder.confdir, tp) for tp in builder.config.templates_path ] pathchain[0:0] = cfg_templates_path loaderchain[0:0] = cfg_templates_path # store it for use in newest_template_mtime self.pathchain = pathchain # make the paths into loaders self.loaders = [SphinxFileSystemLoader(x) for x in loaderchain] use_i18n = builder.app.translator is not None extensions = ['jinja2.ext.i18n'] if use_i18n else [] self.environment = SandboxedEnvironment(loader=self, extensions=extensions) self.environment.filters['tobool'] = _tobool self.environment.filters['toint'] = _toint self.environment.filters['todim'] = _todim self.environment.filters['slice_index'] = _slice_index self.environment.globals['debug'] = contextfunction(pformat) self.environment.globals['warning'] = warning self.environment.globals['accesskey'] = contextfunction(accesskey) self.environment.globals['idgen'] = idgen if use_i18n: self.environment.install_gettext_translations( builder.app.translator)
def closure(orig_func): func = orig_func name_ = name or getattr(func, '_decorated_function', func).__name__ if template: def wrapper(*args, **kwargs): from django.template import engines t = engines["GINGER"].get_template(template) values = orig_func(*args, **kwargs) result = t.render(values) result = jinja2.Markup(result) return result func = functools.update_wrapper(wrapper, func) elif mark_safe: def wrapper(*args, **kwargs): result = orig_func(*args, **kwargs) return jinja2.Markup(result) func = functools.update_wrapper(wrapper, func) if takes_context: func = jinja2.contextfunction(func) global_function(name_, func) return orig_func
def __init__(self, environment): super(WagtailUserbarExtension, self).__init__(environment) self.environment.globals.update({ 'wagtailuserbar': jinja2.contextfunction(wagtailuserbar), })
def closure(orig_func): func = orig_func wrapper = None name_ = name or getattr(func, '_decorated_function', func).__name__ if template: def wrapper(*args, **kwargs): from django.template.loader import get_template t = get_template(template) ctx = orig_func(*args, **kwargs) result = t.render(ctx) result = jinja2.Markup(result) return result elif mark_safe: def wrapper(*args, **kwargs): result = orig_func(*args, **kwargs) return jinja2.Markup(result) if wrapper: func = functools.update_wrapper(wrapper, func) if takes_context: func = jinja2.contextfunction(func) library.functions[name_] = func return orig_func
def __init__(self, environment): super().__init__(environment) self.environment.globals.update({ "pageurl": jinja2.contextfunction(pageurl), "slugurl": jinja2.contextfunction(slugurl), "wagtail_site": jinja2.contextfunction(wagtail_site), "wagtail_version": wagtail_version, }) self.environment.filters.update({ "richtext": richtext, })
def __init__(self, environment): super(TuiuiuUserbarExtension, self).__init__(environment) self.environment.globals.update({ 'tuiuiuuserbar': jinja2.contextfunction(tuiuiuuserbar), })
def __init__(self, environment): super().__init__(environment) self.environment.globals.update({ 'get_mega_menu_content': contextfunction(get_mega_menu_content), })
def __init__(self, environment): super().__init__(environment) self.environment.globals.update({ "wagtailuserbar": jinja2.contextfunction(wagtailuserbar), })
def init_app(self,app): app.config.setdefault('ANGULARJS_VERSION','1.5') app.context_processor(self.renderer) def inject_context(c): return c self.app.jinja_env.globals['inject_context'] = jinja2.contextfunction(inject_context) self.global_keys = self.app.jinja_env.globals.keys()
def hassfunction(func): """Wrap function that depend on hass.""" @wraps(func) def wrapper(*args, **kwargs): return func(hass, *args[1:], **kwargs) return contextfunction(wrapper)
def __init__(self, environment): super(LongClawBasketExtension, self).__init__(environment) self.environment.globals.update({ 'basket': jinja2.contextfunction(get_basket_items), 'add_to_basket_btn': add_to_basket_btn, })
def oppfunction(func): """Wrap function that depend on opp.""" @wraps(func) def wrapper(*args, **kwargs): return func(opp, *args[1:], **kwargs) return contextfunction(wrapper)
def wrapper(fn): fn = _inject(fn, inject) if safe: fn = _make_safe(fn) if pass_context: fn = jinja2.contextfunction(fn) self._defer(lambda app: app.add_template_global(fn, name=name)) return fn
def __init__(self, environment): super(RegulationsExtension, self).__init__(environment) self.environment.globals.update({ 'routablepageurl': jinja2.contextfunction(routablepageurl), }) self.environment.filters.update({ 'regdown': regdown_filter, })
def create_jinja2_url_for(url_for): def jinja2_url_for(context, path, language=None): """Returns URL of the page with `path` in a specified language. If language isn't specified, then it's taken from current template context. """ language = language or context.resolve('LANGUAGE') return url_for(path, language=language) return jinja2.contextfunction(jinja2_url_for)
def init(self, builder, theme=None, dirs=None): # type: (Builder, Theme, List[unicode]) -> None # create a chain of paths to search if theme: # the theme's own dir and its bases' dirs pathchain = theme.get_dirchain() # then the theme parent paths loaderchain = pathchain + theme.themepath elif dirs: pathchain = list(dirs) loaderchain = list(dirs) else: pathchain = [] loaderchain = [] # prepend explicit template paths self.templatepathlen = len(builder.config.templates_path) if builder.config.templates_path: cfg_templates_path = [ path.join(builder.confdir, tp) for tp in builder.config.templates_path ] pathchain[0:0] = cfg_templates_path loaderchain[0:0] = cfg_templates_path # store it for use in newest_template_mtime self.pathchain = pathchain # make the paths into loaders self.loaders = [SphinxFileSystemLoader(x) for x in loaderchain] use_i18n = builder.app.translator is not None extensions = use_i18n and ['jinja2.ext.i18n'] or [] self.environment = SandboxedEnvironment(loader=self, extensions=extensions) self.environment.filters['tobool'] = _tobool self.environment.filters['toint'] = _toint self.environment.filters['slice_index'] = _slice_index self.environment.globals['debug'] = contextfunction(pformat) self.environment.globals['accesskey'] = contextfunction(accesskey) self.environment.globals['idgen'] = idgen if use_i18n: self.environment.install_gettext_translations( builder.app.translator) # type: ignore # NOQA
def init(self, builder, theme=None, dirs=None): # type: (Builder, Theme, List[unicode]) -> None # create a chain of paths to search if theme: # the theme's own dir and its bases' dirs pathchain = theme.get_theme_dirs() # the loader dirs: pathchain + the parent directories for all themes loaderchain = pathchain + [path.join(p, '..') for p in pathchain] elif dirs: pathchain = list(dirs) loaderchain = list(dirs) else: pathchain = [] loaderchain = [] # prepend explicit template paths self.templatepathlen = len(builder.config.templates_path) if builder.config.templates_path: cfg_templates_path = [path.join(builder.confdir, tp) for tp in builder.config.templates_path] pathchain[0:0] = cfg_templates_path loaderchain[0:0] = cfg_templates_path # store it for use in newest_template_mtime self.pathchain = pathchain # make the paths into loaders self.loaders = [SphinxFileSystemLoader(x) for x in loaderchain] use_i18n = builder.app.translator is not None extensions = use_i18n and ['jinja2.ext.i18n'] or [] self.environment = SandboxedEnvironment(loader=self, extensions=extensions) self.environment.filters['tobool'] = _tobool self.environment.filters['toint'] = _toint self.environment.filters['todim'] = _todim self.environment.filters['slice_index'] = _slice_index self.environment.globals['debug'] = contextfunction(pformat) self.environment.globals['warning'] = warning self.environment.globals['accesskey'] = contextfunction(accesskey) self.environment.globals['idgen'] = idgen if use_i18n: self.environment.install_gettext_translations(builder.app.translator) # type: ignore # NOQA
def register(cls, name=None, **init_kwargs): def wrapper(context, *args, **kwargs): ctx = init_kwargs.copy() ctx.update(context) ctx.update(kwargs) return cls(*args, **ctx).render() if name is None: name = camel_to_underscore(cls.__name__) global_function(name, jinja2.contextfunction(wrapper)) return wrapper
def __init__(self, environment): super(RegulationsExtension, self).__init__(environment) self.environment.globals.update({ 'routablepageurl': jinja2.contextfunction(routablepageurl), 'ap_date': ap_date, }) self.environment.filters.update({ 'regdown': regdown_filter, })
def _ensure_env(self, env: Union[jinja2.Environment, None]): """ Make sure the jinja environment is minimally configured. """ if not env: env = jinja2.Environment() if not env.loader: env.loader = jinja2.FunctionLoader( lambda filename: self._cache[filename]) if 'faker' not in env.globals: faker = Faker() faker.seed(1234) env.globals['faker'] = faker if 'random_model' not in env.globals: env.globals['random_model'] = jinja2.contextfunction(random_model) if 'random_models' not in env.globals: env.globals['random_models'] = jinja2.contextfunction( random_models) return env
def __init__(self, environment): super(V1Extension, self).__init__(environment) self.environment.globals.update({ 'category_label': ref.category_label, 'choices_for_page_type': ref.choices_for_page_type, 'email_popup': email_popup, 'collect_outage_banner': collect_outage_banner, 'complaint_issue_banner': complaint_issue_banner, 'complaint_maintenance_banner': complaint_maintenance_banner, 'omwi_salesforce_outage_banner': omwi_salesforce_outage_banner, 'get_menu_items': get_menu_items, 'get_model': get_model, 'get_unique_id': get_unique_id, 'hmda_outage_banner': hmda_outage_banner, 'image_alt_value': image_alt_value, 'is_blog': ref.is_blog, 'is_event': ref.is_event, 'is_report': ref.is_report, 'is_filter_selected': contextfunction(is_filter_selected), 'render_stream_child': contextfunction(render_stream_child), 'app_url': app_url, 'app_page_url': app_page_url, })
def wrapper(fn): fn_ = fn name_ = name or getattr(fn,'_decorated_function',fn).__name__ if template: def func(ctx,*args,**kwargs): t = env.get_template(template) if takes_context: values = fn_(ctx,*args,**kwargs) else: values = fn_(*args,**kwargs) for k in ('request','user','STATIC_URL', 'csrf_token','MEDIA_URL','site','TIME_ZONE','messages'): if k in ctx: values[k] = ctx[k] return t.render( values ) fn = jinja2.contextfunction(functools.update_wrapper(func,fn_)) else : if takes_context: fn = jinja2.contextfunction(fn) env.globals[name_] = fn return fn_
def _ensure_env(self, env: Union[jinja2.Environment, None]): """ Make sure the jinja environment is minimally configured. """ if not env: env = jinja2.Environment() if not env.loader: env.loader = jinja2.FunctionLoader( lambda path: self._file_cache[path]) if 'faker' not in env.globals: faker = Faker() faker.seed_instance(1234) env.globals['faker'] = faker env.globals.setdefault('hash_password', hash_password) env.globals.setdefault('random_model', jinja2.contextfunction(random_model)) env.globals.setdefault('random_models', jinja2.contextfunction(random_models)) return env
def __init__(self, environment): super(V1Extension, self).__init__(environment) self.environment.globals.update({ 'category_label': ref.category_label, 'choices_for_page_type': ref.choices_for_page_type, 'email_popup': email_popup, 'complaint_issue_banner': complaint_issue_banner, 'complaint_maintenance_banner': complaint_maintenance_banner, 'fcm_label': ref.fcm_label, 'get_menu_items': get_menu_items, 'get_model': get_model, 'get_unique_id': get_unique_id, 'hmda_outage_banner': hmda_outage_banner, 'image_alt_value': image_alt_value, 'is_blog': ref.is_blog, 'is_event': ref.is_event, 'is_report': ref.is_report, 'is_filter_selected': contextfunction(is_filter_selected), 'render_stream_child': contextfunction(render_stream_child), 'app_url': app_url, 'app_page_url': app_page_url, })
def _register_options(self): # Add Context Functions for name, method in self.context_functions.items(): self._env.globals[name] = jinja2.contextfunction(method) # Add Context Filters for name, method in self.context_filters.items(): self._env.filters[name] = jinja2.contextfilter(method) # Add Filters for name, method in self.filters.items(): self._env.filters[name] = method # Add Tests for name, method in self.tests.items(): self._env.tests[name] = method
def create_jinja2_environment(language): env = Environment(loader=FileSystemLoader('layouts'), extensions=['jinja2.ext.i18n']) if language == 'ru': translations = gettext.GNUTranslations(open('messages.mo')) env.install_gettext_translations(translations, newstyle=True) # Hack: globals_gettext = env.globals['gettext'] env.globals['gettext'] = contextfunction( lambda context, s: unicode(globals_gettext(context, s).decode('utf-8'))) elif language == 'en': env.install_null_translations(newstyle=False) env.globals.update(url_for=url_for, LANGUAGE=language) return env
def closure(orig_func): func = orig_func name_ = name or getattr(func,'_decorated_function',func).__name__ if template: def wrapper(*args, **kwargs): t = get_template(template) values = orig_func(*args,**kwargs) result = t.render( values ) result = jinja2.Markup(result) return result func = functools.update_wrapper(wrapper, func) elif mark_safe: def wrapper(*args, **kwargs): result = orig_func(*args, **kwargs) return jinja2.Markup(result) func = functools.update_wrapper(wrapper, func) if takes_context: func = jinja2.contextfunction(func) library.global_function(name_, func) return orig_func
def build_env(constructor): env = constructor( loader=FileSystemLoader(basepath), trim_blocks=True, lstrip_blocks=True, keep_trailing_newline=True, undefined=JerikanUndefined, extensions=[ErrorExtension, "jinja2.ext.do"] ) # Use some filters from Ansible for mod, fs in _imported_jinjafilters: for f in fs: try: fn, name = f except ValueError: fn, name = f, f env.filters[name] = getattr(mod, fn) # Register our own filters for f in _registered_jinjafilters: env.filters[f.__name__] = f env.filters["store"] = self._store_set # Register custom global functions env.globals["bgpq3"] = contextfunction( lambda ctx, *args: bgpq3(ctx.parent["os"], LruCacheIgnore(cache), *args)) env.globals["peeringdb"] = lambda *args: peeringdb( LruCacheIgnore(cache), *args) env.globals["scope"] = classifier.scope env.globals["lookup"] = self._lookup env.globals["devices"] = self._devices env.globals["store"] = self._store_get env.globals["interface_description"] = self._interface_description return env
return str(key) def unicode_thing(context, key): return unicode(key) def type_thing(context, key): return type(key) def len_thing(context, key): return len(key) def enumerate_thing(context, key): return enumerate(key) # add some functions to jinja app.jinja_env.globals['sorted'] = contextfunction(sorted_thing) app.jinja_env.globals['int'] = contextfunction(int_thing) app.jinja_env.globals['str'] = contextfunction(str_thing) app.jinja_env.globals['unicode'] = contextfunction(unicode_thing) app.jinja_env.globals['type'] = contextfunction(type_thing) app.jinja_env.globals['len'] = contextfunction(len_thing) app.jinja_env.globals['enumerate'] = contextfunction(enumerate_thing) class RegexConverter(BaseConverter): def __init__(self, url_map, *items): super(RegexConverter, self).__init__(url_map) self.regex = items[0] # regular expressions inside url routing app.url_map.converters['regex'] = RegexConverter
@contextfunction def cms_default_block(context, label, *args, **kwargs): kwargs['default'] = label rendered = get_rendered_block(label, *args, **process_kwargs(context, kwargs)) return conditional_escape(rendered) @contextfunction def cms_image(context, *args, **kwargs): rendered = get_rendered_image(*args, **process_kwargs(context, kwargs)) return conditional_escape(rendered) @contextfunction def cms_video(context, *args, **kwargs): rendered = get_rendered_video(*args, **process_kwargs(context, kwargs)) return conditional_escape(rendered) template_globals = { 'cms_block': cms_block, 'cms_default_block': cms_default_block, 'cms_image': cms_image, 'cms_video': cms_video, 'cms_editor': contextfunction(lambda c: mark_safe(cms_editor(c))), 'cms_editing': is_editing, }
def _register(self): django_jinja.library.global_function(name=self.name, fn=jinja2.contextfunction(self))
def _register(self): django_jinja.library.global_function( name=self.name, fn=jinja2.contextfunction(self))
def register_global(func, name=None, ctx=False): name = name or func.__name__ if ctx: func = contextfunction(func) JINJA_GLOBALS[name] = func
asset_sources += get_asset_sources(asset, unused, asset_type, render) else: asset_sources += get_asset_sources(asset, unused, asset_type, render) return "".join(asset_sources) @register.simple_tag(takes_context=True) def assets_js(context, *asset_list): return mark_safe(assets_by_type(context, "js", *asset_list)) @register.simple_tag(takes_context=True) def assets_css(context, *asset_list): return mark_safe(assets_by_type(context, "css", *asset_list)) @register.simple_tag(takes_context=True) def assets(context, *asset_list): return mark_safe(assets_css(context, *asset_list) + assets_js(context, *asset_list)) try: from django_jinja import library from jinja2 import contextfunction library.global_function(contextfunction(assets_js)) library.global_function(contextfunction(assets_css)) library.global_function(contextfunction(assets)) except ImportError: pass
def str_thing(context, key): return str(key) def unicode_thing(context, key): return unicode(key) def type_thing(context, key): return type(key) def len_thing(context, key): return len(key) def enumerate_thing(context, key): return enumerate(key) # add some functions to jinja app.jinja_env.globals['sorted'] = contextfunction(sorted_thing) app.jinja_env.globals['int'] = contextfunction(int_thing) app.jinja_env.globals['str'] = contextfunction(str_thing) app.jinja_env.globals['unicode'] = contextfunction(unicode_thing) app.jinja_env.globals['type'] = contextfunction(type_thing) app.jinja_env.globals['len'] = contextfunction(len_thing) app.jinja_env.globals['enumerate'] = contextfunction(enumerate_thing) if __name__ == '__main__': app.run(host='0.0.0.0', port=PORT)