def __init__(self, environment): super(FlagsExtension, self).__init__(environment) self.environment.globals.update( { "flag_enabled": pass_context(flag_enabled), "flag_disabled": pass_context(flag_disabled), } )
def __init__(self, environment): super().__init__(environment) self.environment.globals.update({ "wagtailuserbar": jinja2.pass_context(wagtailuserbar), })
def __init__(self, environment): super().__init__(environment) self.environment.globals.update({ "pageurl": jinja2.pass_context(pageurl), "slugurl": jinja2.pass_context(slugurl), "wagtail_site": jinja2.pass_context(wagtail_site), "wagtail_version": wagtail_version, }) self.environment.filters.update({ "richtext": richtext, })
def __init__(self, hass, limited=False, strict=False): """Initialise template environment.""" if not strict: undefined = LoggingUndefined else: undefined = jinja2.StrictUndefined super().__init__(undefined=undefined) self.hass = hass self.template_cache = weakref.WeakValueDictionary() self.filters["round"] = forgiving_round self.filters["multiply"] = multiply self.filters["log"] = logarithm self.filters["sin"] = sine self.filters["cos"] = cosine self.filters["tan"] = tangent self.filters["asin"] = arc_sine self.filters["acos"] = arc_cosine self.filters["atan"] = arc_tangent self.filters["atan2"] = arc_tangent2 self.filters["sqrt"] = square_root self.filters["as_datetime"] = dt_util.parse_datetime self.filters["as_timestamp"] = forgiving_as_timestamp self.filters["as_local"] = dt_util.as_local self.filters["timestamp_custom"] = timestamp_custom self.filters["timestamp_local"] = timestamp_local self.filters["timestamp_utc"] = timestamp_utc self.filters["to_json"] = to_json self.filters["from_json"] = from_json self.filters["is_defined"] = fail_when_undefined self.filters["max"] = max self.filters["min"] = min self.filters["random"] = random_every_time self.filters["base64_encode"] = base64_encode self.filters["base64_decode"] = base64_decode self.filters["ordinal"] = ordinal self.filters["regex_match"] = regex_match self.filters["regex_replace"] = regex_replace self.filters["regex_search"] = regex_search self.filters["regex_findall_index"] = regex_findall_index self.filters["bitwise_and"] = bitwise_and self.filters["bitwise_or"] = bitwise_or self.filters["ord"] = ord self.globals["log"] = logarithm self.globals["sin"] = sine self.globals["cos"] = cosine self.globals["tan"] = tangent self.globals["sqrt"] = square_root self.globals["pi"] = math.pi self.globals["tau"] = math.pi * 2 self.globals["e"] = math.e self.globals["asin"] = arc_sine self.globals["acos"] = arc_cosine self.globals["atan"] = arc_tangent self.globals["atan2"] = arc_tangent2 self.globals["float"] = forgiving_float self.globals["as_datetime"] = dt_util.parse_datetime self.globals["as_local"] = dt_util.as_local self.globals["as_timestamp"] = forgiving_as_timestamp self.globals["relative_time"] = relative_time self.globals["timedelta"] = timedelta self.globals["strptime"] = strptime self.globals["urlencode"] = urlencode self.globals["max"] = max self.globals["min"] = min self.tests["match"] = regex_match self.tests["search"] = regex_search if hass is None: return # We mark these as a context functions to ensure they get # evaluated fresh with every execution, rather than executed # at compile time and the value stored. The context itself # can be discarded, we only need to get at the hass object. def hassfunction(func): """Wrap function that depend on hass.""" @wraps(func) def wrapper(*args, **kwargs): return func(hass, *args[1:], **kwargs) return contextfunction(wrapper) self.globals["device_entities"] = hassfunction(device_entities) self.filters["device_entities"] = pass_context( self.globals["device_entities"]) if limited: # Only device_entities is available to limited templates, mark other # functions and filters as unsupported. def unsupported(name): def warn_unsupported(*args, **kwargs): raise TemplateError( f"Use of '{name}' is not supported in limited templates" ) return warn_unsupported hass_globals = [ "closest", "distance", "expand", "is_state", "is_state_attr", "state_attr", "states", "utcnow", "now", ] hass_filters = ["closest", "expand"] for glob in hass_globals: self.globals[glob] = unsupported(glob) for filt in hass_filters: self.filters[filt] = unsupported(filt) return self.globals["expand"] = hassfunction(expand) self.filters["expand"] = pass_context(self.globals["expand"]) self.globals["closest"] = hassfunction(closest) self.filters["closest"] = pass_context(hassfunction(closest_filter)) self.globals["distance"] = hassfunction(distance) self.globals["is_state"] = hassfunction(is_state) self.globals["is_state_attr"] = hassfunction(is_state_attr) self.globals["state_attr"] = hassfunction(state_attr) self.globals["states"] = AllStates(hass) self.globals["utcnow"] = hassfunction(utcnow) self.globals["now"] = hassfunction(now)
def faker(): def inner(*args, **kwargs): return fake_dt return pass_context(inner)
def __init__(self, project, load_plugins=True, extra_flags=None): self.project = project self.root_path = os.path.abspath(project.tree) self.theme_paths = [ os.path.join(self.root_path, "themes", theme) for theme in self.project.themes ] if not self.theme_paths: # load the directories in the themes directory as the themes try: for fname in os.listdir(os.path.join(self.root_path, "themes")): f = os.path.join(self.root_path, "themes", fname) if os.path.isdir(f): self.theme_paths.append(f) except OSError: pass template_paths = [ os.path.join(path, "templates") for path in [self.root_path] + self.theme_paths ] self.jinja_env = CustomJinjaEnvironment( autoescape=self.select_jinja_autoescape, extensions=["jinja2.ext.do"], loader=jinja2.FileSystemLoader(template_paths), ) from lektor.db import F, get_alts # pylint: disable=import-outside-toplevel self.jinja_env.filters.update( tojson=tojson_filter, latformat=lambda x, secs=True: format_lat_long(lat=x, secs=secs), longformat=lambda x, secs=True: format_lat_long(long=x, secs=secs), latlongformat=lambda x, secs=True: format_lat_long(secs=secs, *x), # By default filters need to be side-effect free. This is not # the case for this one, so we need to make it as a dummy # context filter so that jinja2 will not inline it. url=jinja2.pass_context(lambda ctx, *a, **kw: url_to(*a, **kw)), asseturl=jinja2.pass_context( lambda ctx, *a, **kw: get_asset_url(*a, **kw)), markdown=jinja2.pass_context( lambda ctx, *a, **kw: Markdown(*a, **kw)), ) self.jinja_env.globals.update( F=F, url_to=url_to, site=site_proxy, config=config_proxy, bag=lookup_from_bag, get_alts=get_alts, get_random_id=lambda: uuid.uuid4().hex, ) self.jinja_env.filters.update( datetimeformat=_pass_locale(dates.format_datetime), dateformat=_pass_locale(dates.format_date), timeformat=_pass_locale(dates.format_time), ) # pylint: disable=import-outside-toplevel from lektor.types import builtin_types self.types = builtin_types.copy() self.publishers = builtin_publishers.copy() # The plugins that are loaded for this environment. This is # modified by the plugin controller and registry methods on the # environment. self.plugin_controller = PluginController(self, extra_flags) self.plugins = {} self.plugin_ids_by_class = {} self.build_programs = [] self.special_file_assets = {} self.special_file_suffixes = {} self.custom_url_resolvers = [] self.custom_generators = [] self.virtual_sources = {} if load_plugins: self.load_plugins() # pylint: disable=import-outside-toplevel from lektor.db import siblings_resolver self.virtualpathresolver("siblings")(siblings_resolver)
@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 try: from jinja2 import pass_context except ImportError: from jinja2 import contextfunction as pass_context library.global_function(pass_context(assets_js)) library.global_function(pass_context(assets_css)) library.global_function(pass_context(assets)) except ImportError: pass