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
