libervia-backend: libervia/backend/tools/common/template.py comparison

comparison libervia/backend/tools/common/template.py @ 4270:0d7bb4df2343

Reformatted code base using black.

author	Goffi <goffi@goffi.org>
date	Wed, 19 Jun 2024 18:44:57 +0200
parents	81faa85c9cfa
children

comparison

equal deleted inserted replaced

-:64a85ce8be70
+:0d7bb4df2343
 "Missing module jinja2, please install it from http://jinja.pocoo.org or with "
 "pip install jinja2"
 )
 HTML_EXT = ("html", "xhtml")
 RE_ATTR_ESCAPE = re.compile(r"[^a-z_-]")
 SITE_RESERVED_NAMES = ("sat",)
 TPL_RESERVED_CHARS = r"()/."
 RE_TPL_RESERVED_CHARS = re.compile("[" + TPL_RESERVED_CHARS + "]")
 BROWSER_DIR = "_browser"
 BROWSER_META_FILE = "browser_meta.json"
-TemplateData = namedtuple("TemplateData", ['site', 'theme', 'path'])
+TemplateData = namedtuple("TemplateData", ["site", "theme", "path"])
 class TemplateLoader(jinja2.BaseLoader):
 """A template loader which handle site, theme and absolute paths"""
 # TODO: list_templates should be implemented
 def __init__(self, sites_paths, sites_themes, trusted=False):
 """
 @param trusted(bool): if True, absolue template paths will be allowed
 try:
 theme_end = template.index(")")
 except IndexError:
 raise ValueError("incorrect site/theme in template")
 theme_data = template[1:theme_end]
-theme_splitted = theme_data.split('/')
+theme_splitted = theme_data.split("/")
 if len(theme_splitted) == 1:
 site, theme = "", theme_splitted[0]
 elif len(theme_splitted) == 2:
 site, theme = theme_splitted
 else:
 raise ValueError("incorrect site/theme in template")
-template_path = template[theme_end+1:]
+template_path = template[theme_end + 1 :]
 if not template_path or template_path.startswith("/"):
 raise ValueError("incorrect template path")
 elif template.startswith("/"):
 # this is an absolute path, so we have no site and no theme
 site = None
 if site is not None:
 site = site.strip()
 if not site:
 site = ""
 elif site in SITE_RESERVED_NAMES:
-raise ValueError(_("{site} can't be used as site name, "
+raise ValueError(
-"it's reserved.").format(site=site))
+_("{site} can't be used as site name, " "it's reserved.").format(
+site=site
+)
+)
 if theme is not None:
 theme = theme.strip()
 if not theme:
 theme = C.TEMPLATE_THEME_DEFAULT
 if RE_TPL_RESERVED_CHARS.search(theme):
-raise ValueError(_("{theme} contain forbidden char. Following chars "
+raise ValueError(
-"are forbidden: {reserved}").format(
+_(
-theme=theme, reserved=TPL_RESERVED_CHARS))
+"{theme} contain forbidden char. Following chars "
+"are forbidden: {reserved}"
+).format(theme=theme, reserved=TPL_RESERVED_CHARS)
+)
 return TemplateData(site, theme, template_path)
 @staticmethod
 def get_sites_and_themes(
 site: str,
 theme: str,
 settings: Optional[dict] = None,
 ) -> List[Tuple[str, str]]:
 """Get sites and themes to check for template/file
 Will add default theme and default site in search list when suitable. Settings'
 `fallback` can be used to modify behaviour: themes in this list will then be used
 instead of default (it can also be empty list or None, in which case no fallback
 - opened template, or None if not found
 - absolute file path, or None if not found
 """
 if site is None:
 raise exceptions.InternalError(
-"_get_template_f must not be used with absolute path")
+"_get_template_f must not be used with absolute path"
-settings = self.sites_themes[site][theme]['settings']
+)
+settings = self.sites_themes[site][theme]["settings"]
 for site_to_check, theme_to_check in self.get_sites_and_themes(
-site, theme, settings):
+site, theme, settings
+):
 try:
 base_path = self.sites_paths[site_to_check]
 except KeyError:
-log.warning(_("Unregistered site requested: {site_to_check}").format(
+log.warning(
-site_to_check=site_to_check))
+_("Unregistered site requested: {site_to_check}").format(
+site_to_check=site_to_check
+)
+)
 filepath = os.path.join(
-base_path,
+base_path, C.TEMPLATE_TPL_DIR, theme_to_check, *path_elts
-C.TEMPLATE_TPL_DIR,
-theme_to_check,
-*path_elts
 )
-f = utils.open_if_exists(filepath, 'r')
+f = utils.open_if_exists(filepath, "r")
 if f is not None:
 return f, filepath
 return None, None
 def get_source(self, environment, template):
 site, theme, template_path = self.parse_template(template)
 if site is None:
 # we have an abolute template
 if theme is not None:
-raise exceptions.InternalError("We can't have a theme with absolute "
+raise exceptions.InternalError(
-"template.")
+"We can't have a theme with absolute " "template."
+)
 if not self.trusted:
-log.error(_("Absolute template used while unsecure is disabled, hack "
+log.error(
-"attempt? Template: {template}").format(template=template))
+_(
+"Absolute template used while unsecure is disabled, hack "
+"attempt? Template: {template}"
+).format(template=template)
+)
 raise exceptions.PermissionError("absolute template is not allowed")
 filepath = template_path
-f = utils.open_if_exists(filepath, 'r')
+f = utils.open_if_exists(filepath, "r")
 else:
 # relative path, we have to deal with site and theme
 assert theme and template_path
 path_elts = split_template_path(template_path)
 # if we have non default site, we check it first, else we only check default
 f, filepath = self._get_template_f(site, theme, path_elts)
 if f is None:
-if (site is not None and path_elts[0] == "error"
+if (
-and os.path.splitext(template_path)[1][1:] in HTML_EXT):
+site is not None
+and path_elts[0] == "error"
+and os.path.splitext(template_path)[1][1:] in HTML_EXT
+):
 # if an HTML error is requested but doesn't exist, we try again
 # with base error.
-f, filepath = self._get_template_f(
+f, filepath = self._get_template_f(site, theme, ("error", "base.html"))
-site, theme, ("error", "base.html"))
 if f is None:
 raise exceptions.InternalError("error/base.html should exist")
 else:
 raise TemplateNotFound(template)
 scripts = []
 tpl = "<script src={src} {attribute}></script>"
 for library, attribute in self.scripts:
 library_path = self.renderer.get_static_path(self.template_data, library)
 if library_path is None:
-log.warning(_("Can't find {libary} javascript library").format(
+log.warning(
-library=library))
+_("Can't find {libary} javascript library").format(library=library)
+)
 continue
 path = self.renderer.get_front_url(library_path)
 scripts.append(tpl.format(src=quoteattr(path), attribute=attribute))
 return safe("\n".join(scripts))
 class Environment(jinja2.Environment):
 def get_template(self, name, parent=None, globals=None):
-if name[0] not in ('/', '('):
+if name[0] not in ("/", "("):
 # if name is not an absolute path or a full template name (this happen on
 # extend or import during rendering), we convert it to a full template name.
 # This is needed to handle cache correctly when a base template is overriden.
 # Without that, we could not distinguish something like base/base.html if
 # it's launched from some_site/some_theme or from [default]/default
 name = "({site}/{theme}){template}".format(
 site=self._template_data.site,
 theme=self._template_data.theme,
-template=name)
+template=name,
+)
 return super(Environment, self).get_template(name, parent, globals)
 class Renderer(object):
 self.host = host
 self.trusted = trusted
 self.sites_paths = {
 "": os.path.dirname(sat_templates.__file__),
 }
-self.sites_themes = {
+self.sites_themes = {}
-}
 conf = config.parse_main_conf()
 public_sites = config.config_get(conf, None, "sites_path_public_dict", {})
 sites_data = [public_sites]
 if private:
 private_sites = config.config_get(conf, None, "sites_path_private_dict", {})
 sites_data.append(private_sites)
 for sites in sites_data:
 normalised = {}
 for name, path in sites.items():
 if RE_TPL_RESERVED_CHARS.search(name):
-log.warning(_("Can't add \"{name}\" site, it contains forbidden "
+log.warning(
-"characters. Forbidden characters are {forbidden}.")
+_(
-.format(name=name, forbidden=TPL_RESERVED_CHARS))
+'Can\'t add "{name}" site, it contains forbidden '
+"characters. Forbidden characters are {forbidden}."
+).format(name=name, forbidden=TPL_RESERVED_CHARS)
+)
 continue
 path = os.path.expanduser(os.path.normpath(path))
 if not path or not path.startswith("/"):
-log.warning(_("Can't add \"{name}\" site, it should map to an "
+log.warning(
-"absolute path").format(name=name))
+_(
+'Can\'t add "{name}" site, it should map to an '
+"absolute path"
+).format(name=name)
+)
 continue
 normalised[name] = path
 self.sites_paths.update(normalised)
 for site, site_path in self.sites_paths.items():
 for p in tpl_path.iterdir():
 if not p.is_dir():
 continue
 log.debug(f"theme found for {site or 'default site'}: {p.name}")
 theme_data = self.sites_themes.setdefault(site, {})[p.name] = {
-'path': p,
+"path": p,
-'settings': {}}
+"settings": {},
+}
 theme_settings = p / "settings.json"
 if theme_settings.is_file:
 try:
 with theme_settings.open() as f:
 settings = json.load(f)
 except Exception as e:
-log.warning(_(
+log.warning(
-"Can't load theme settings at {path}: {e}").format(
+_("Can't load theme settings at {path}: {e}").format(
-path=theme_settings, e=e))
+path=theme_settings, e=e
+)
+)
 else:
 log.debug(
-f"found settings for theme {p.name!r} at {theme_settings}")
+f"found settings for theme {p.name!r} at {theme_settings}"
+)
 fallback = settings.get("fallback")
 if fallback is None:
 settings["fallback"] = []
 elif isinstance(fallback, str):
 settings["fallback"] = [fallback]
 elif not isinstance(fallback, list):
 raise ValueError(
 'incorrect type for "fallback" in settings '
-f'({type(fallback)}) at {theme_settings}: {fallback}'
+f"({type(fallback)}) at {theme_settings}: {fallback}"
 )
-theme_data['settings'] = settings
+theme_data["settings"] = settings
 browser_path = p / BROWSER_DIR
 if browser_path.is_dir():
-theme_data['browser_path'] = browser_path
+theme_data["browser_path"] = browser_path
 browser_meta_path = browser_path / BROWSER_META_FILE
 if browser_meta_path.is_file():
 try:
 with browser_meta_path.open() as f:
-theme_data['browser_meta'] = json.load(f)
+theme_data["browser_meta"] = json.load(f)
 except Exception as e:
 log.error(
 f"Can't parse browser metadata at {browser_meta_path}: {e}"
 )
 continue
 self.env = Environment(
 loader=TemplateLoader(
 sites_paths=self.sites_paths,
 sites_themes=self.sites_themes,
-trusted=trusted
+trusted=trusted,
 ),
 autoescape=jinja2.select_autoescape(["html", "xhtml", "xml"]),
 trim_blocks=True,
 lstrip_blocks=True,
 extensions=["jinja2.ext.i18n"],
 self.env.filters["attr_escape"] = self.attr_escape
 self.env.filters["item_filter"] = self._item_filter
 self.env.filters["adv_format"] = self._adv_format
 self.env.filters["dict_ext"] = self._dict_ext
 self.env.filters["highlight"] = self.highlight
-self.env.filters["front_url"] = (self._front_url if front_url_filter is None
+self.env.filters["front_url"] = (
-else front_url_filter)
+self._front_url if front_url_filter is None else front_url_filter
+)
 self.env.filters["media_type_main"] = self.media_type_main
 self.env.filters["media_type_sub"] = self.media_type_sub
 # custom tests
 self.env.tests["in_the_past"] = self._in_the_past
 self.icons_path = os.path.join(host.media_dir, "fonts/fontello/svg")
 # policies
 self.env.policies["ext.i18n.trimmed"] = True
 self.env.policies["json.dumps_kwargs"] = {
 "sort_keys": True,
 # if object can't be serialised, we use None
-"default": lambda o: o.to_json() if hasattr(o, "to_json") else None
+"default": lambda o: o.to_json() if hasattr(o, "to_json") else None,
 }
 def get_front_url(self, template_data, path=None):
 """Give front URL (i.e. URL seen by end-user) of a path
 @param template_data[TemplateData]: data of current template
 @param path(unicode, None): relative path of file to get,
 if set, will remplate template_data.path
 """
-return self.env.filters["front_url"]({"template_data": template_data},
+return self.env.filters["front_url"](
-path or template_data.path)
+{"template_data": template_data}, path or template_data.path
+)
 def install_translations(self):
 # TODO: support multi translation
 #       for now, only translations in sat_templates are handled
 self.translations = {}
 for site_key, site_path in self.sites_paths.items():
-site_prefix = "[{}] ".format(site_key) if site_key else ''
+site_prefix = "[{}] ".format(site_key) if site_key else ""
 i18n_dir = os.path.join(site_path, "i18n")
 for lang_dir in os.listdir(i18n_dir):
 lang_path = os.path.join(i18n_dir, lang_dir)
 if not os.path.isdir(lang_path):
 continue
 else:
 translations.merge(support.Translations(f, "sat"))
 except EnvironmentError:
 log.error(
 _("Can't find template translation at {path}").format(
-path=po_path))
+path=po_path
+)
+)
 except UnknownLocaleError as e:
-log.error(_("{site}Invalid locale name: {msg}").format(
+log.error(
-site=site_prefix, msg=e))
+_("{site}Invalid locale name: {msg}").format(
+site=site_prefix, msg=e
+)
+)
 else:
-log.info(_("{site}loaded {lang} templates translations").format(
+log.info(
-site = site_prefix,
+_("{site}loaded {lang} templates translations").format(
-lang=lang_dir))
+site=site_prefix, lang=lang_dir
+)
+)
 default_locale = Locale.parse(self._locale_str)
 if default_locale not in self.translations:
 # default locale disable gettext,
 # so we can use None instead of a Translations instance
 self.translations[default_locale] = None
 self.env.install_null_translations(True)
 # we generate a tuple of locales ordered by display name that templates can access
 # through the "locales" variable
-self.locales = tuple(sorted(list(self.translations.keys()),
+self.locales = tuple(
-key=lambda l: l.language_name.lower()))
+sorted(list(self.translations.keys()), key=lambda l: l.language_name.lower())
+)
 def set_locale(self, locale_str):
 """set current locale
 change current translation locale and self self._locale and self._locale_str
 """
 # FIXME: check use in CLI frontend, and include site
 site, theme, __ = self.env.loader.parse_template(template)
 if site is None:
 # absolute template
-return  "", os.path.dirname(template)
+return "", os.path.dirname(template)
 try:
 site_root_dir = self.sites_paths[site]
 except KeyError:
 raise exceptions.NotFound
 return theme, os.path.join(site_root_dir, C.TEMPLATE_TPL_DIR, theme)
 return self.sites_themes[site_name]
 except KeyError:
 raise exceptions.NotFound(f"no theme found for {site_name}")
 def get_static_path(
-self,
+self, template_data: TemplateData, filename: str, settings: Optional[dict] = None
-template_data: TemplateData,
+) -> Optional[TemplateData]:
-filename: str,
-settings: Optional[dict]=None
-) -> Optional[TemplateData]:
 """Retrieve path of a static file if it exists with current theme or default
 File will be looked at <site_root_dir>/<theme_dir>/<static_dir>/filename,
 then <site_root_dir>/<default_theme_dir>/<static_dir>/filename anf finally
 <default_site>/<default_theme_dir>/<static_dir> (i.e. sat_templates).
 the relative path to the file, from theme root dir.
 None if not found.
 """
 if template_data.site is None:
 # we have an absolue path
-if (not template_data.theme is None
+if not template_data.theme is None or not template_data.path.startswith("/"):
-or not template_data.path.startswith('/')):
 raise exceptions.InternalError(
-"invalid template data, was expecting absolute URL")
+"invalid template data, was expecting absolute URL"
+)
 static_dir = os.path.dirname(template_data.path)
 file_path = os.path.join(static_dir, filename)
 if os.path.exists(file_path):
 return TemplateData(site=None, theme=None, path=file_path)
 else:
 return None
-sites_and_themes = TemplateLoader.get_sites_and_themes(template_data.site,
+sites_and_themes = TemplateLoader.get_sites_and_themes(
-template_data.theme,
+template_data.site, template_data.theme, settings
-settings)
+)
 for site, theme in sites_and_themes:
 site_root_dir = self.sites_paths[site]
 relative_path = os.path.join(C.TEMPLATE_STATIC_DIR, filename)
-absolute_path = os.path.join(site_root_dir, C.TEMPLATE_TPL_DIR,
+absolute_path = os.path.join(
-theme, relative_path)
+site_root_dir, C.TEMPLATE_TPL_DIR, theme, relative_path
+)
 if os.path.exists(absolute_path):
 return TemplateData(site=site, theme=theme, path=relative_path)
 return None
 def _append_css_paths(
 self,
 template_data: TemplateData,
 css_files: list,
 css_files_noscript: list,
 name_root: str,
-settings: dict
+settings: dict,
+) -> None:
-) -> None:
 """Append found css to css_files and css_files_noscript
 @param css_files: list to fill of relative path to found css file
 @param css_files_noscript: list to fill of relative path to found css file
 with "_noscript" suffix
 name = name_root + ".css"
 css_path = self.get_static_path(template_data, name, settings)
 if css_path is not None:
 css_files.append(self.get_front_url(css_path))
 noscript_name = name_root + "_noscript.css"
-noscript_path = self.get_static_path(
+noscript_path = self.get_static_path(template_data, noscript_name, settings)
-template_data, noscript_name, settings)
 if noscript_path is not None:
 css_files_noscript.append(self.get_front_url(noscript_path))
 def get_css_files(self, template_data):
 """Retrieve CSS files to use according template_data
 - front URLs of CSS files to use when scripts are not enabled
 """
 # TODO: some caching would be nice
 css_files = []
 css_files_noscript = []
-path_elems = template_data.path.split('/')
+path_elems = template_data.path.split("/")
 path_elems[-1] = os.path.splitext(path_elems[-1])[0]
 site = template_data.site
 if site is None:
 # absolute path
 settings = {}
 else:
-settings = self.sites_themes[site][template_data.theme]['settings']
+settings = self.sites_themes[site][template_data.theme]["settings"]
-css_path = self.get_static_path(template_data, 'fonts.css', settings)
+css_path = self.get_static_path(template_data, "fonts.css", settings)
 if css_path is not None:
 css_files.append(self.get_front_url(css_path))
-for name_root in ('styles', 'styles_extra', 'highlight'):
+for name_root in ("styles", "styles_extra", "highlight"):
 self._append_css_paths(
-template_data, css_files, css_files_noscript, name_root, settings)
+template_data, css_files, css_files_noscript, name_root, settings
+)
 for idx in range(len(path_elems)):
-name_root = "_".join(path_elems[:idx+1])
+name_root = "_".join(path_elems[: idx + 1])
 self._append_css_paths(
-template_data, css_files, css_files_noscript, name_root, settings)
+template_data, css_files, css_files_noscript, name_root, settings
+)
 return css_files, css_files_noscript
 ## custom filters ##
 def _front_url(self, ctx, relative_url):
 """Get front URL (URL seen by end-user) from a relative URL
 This default method return absolute full path
 """
-template_data = ctx['template_data']
+template_data = ctx["template_data"]
 if template_data.site is None:
 assert template_data.theme is None
 assert template_data.path.startswith("/")
 return os.path.join(os.path.dirname(template_data.path, relative_url))
 site_root_dir = self.sites_paths[template_data.site]
-return os.path.join(site_root_dir, C.TEMPLATE_TPL_DIR, template_data.theme,
+return os.path.join(
-relative_url)
+site_root_dir, C.TEMPLATE_TPL_DIR, template_data.theme, relative_url
+)
-def _bare_jid(self, full_jid: str|jid.JID) -> str:
+def _bare_jid(self, full_jid: str | jid.JID) -> str:
 """Return the bare JID"""
 return str(jid.JID(str(full_jid)).bare)
 @pass_context
 def _next_gidx(self, ctx, value):
 fmt: str = "short",
 date_only: bool = False,
 auto_limit: int = 7,
 auto_old_fmt: str = "short",
 auto_new_fmt: str = "relative",
-tz_name: Optional[str] = None
+tz_name: Optional[str] = None,
 ) -> str:
 if is_undefined(fmt):
 fmt = "short"
 try:
 return date_utils.date_fmt(
-timestamp, fmt, date_only, auto_limit, auto_old_fmt,
+timestamp,
-auto_new_fmt, locale_str = self._locale_str,
+fmt,
-tz_info=tz_name or date_utils.TZ_UTC
+date_only,
+auto_limit,
+auto_old_fmt,
+auto_new_fmt,
+locale_str=self._locale_str,
+tz_info=tz_name or date_utils.TZ_UTC,
 )
 except Exception as e:
 log.warning(_("Can't parse date: {msg}").format(msg=e))
 return str(timestamp)
 extra_attrs = " ".join(f'{k}="{html.escape(str(v))}"' for k, v in kwargs.items())
 return safe(
 '<svg class="svg-icon{cls}"{extra_attrs} xmlns="http://www.w3.org/2000/svg" '
 'viewBox="0 0 100 100">\n'
 '    <use href="#{name}"/>'
-'</svg>\n'.format(
+"</svg>\n".format(
 name=name,
 cls=(" " + cls) if cls else "",
-extra_attrs=" " + extra_attrs if extra_attrs else ""
+extra_attrs=" " + extra_attrs if extra_attrs else "",
 )
 )
 def _icon_from_client(self, client):
 """Get icon name to represent a disco client"""
 if client is None:
-return 'desktop'
+return "desktop"
-elif 'pc' in client:
+elif "pc" in client:
-return 'desktop'
+return "desktop"
-elif 'phone' in client:
+elif "phone" in client:
-return 'mobile'
+return "mobile"
-elif 'web' in client:
+elif "web" in client:
-return 'globe'
+return "globe"
-elif 'console' in client:
+elif "console" in client:
-return 'terminal'
+return "terminal"
 else:
-return 'desktop'
+return "desktop"
-def render(self, template, site=None, theme=None, locale=C.DEFAULT_LOCALE,
+def render(
-media_path="", css_files=None, css_inline=False, **kwargs):
+self,
+template,
+site=None,
+theme=None,
+locale=C.DEFAULT_LOCALE,
+media_path="",
+css_files=None,
+css_inline=False,
+**kwargs,
+):
 """Render a template
 @param template(unicode): template to render (e.g. blog/articles.html)
 @param site(unicode): site name
 None or empty string for defaut site (i.e. SàT templates)
 if not template:
 raise ValueError("template can't be empty")
 if site is not None or theme is not None:
 # user wants to set site and/or theme, so we add it to the template path
 if site is None:
-site = ''
+site = ""
 if theme is None:
 theme = C.TEMPLATE_THEME_DEFAULT
 if template[0] == "(":
 raise ValueError(
 "you can't specify site or theme in template path and in argument "
 "at the same time"
 )
 template_data = TemplateData(site, theme, template)
 template = "({site}/{theme}){template}".format(
-site=site, theme=theme, template=template)
+site=site, theme=theme, template=template
+)
 else:
 template_data = self.env.loader.parse_template(template)
 # we need to save template_data in environment, to load right templates when they
 # are referenced from other templates (e.g. import)
 kwargs["icon"] = self._icon_use
 kwargs["icon_from_client"] = self._icon_from_client
 if css_inline:
 css_contents = []
-for files, suffix in ((css_files, ""),
+for files, suffix in ((css_files, ""), (css_files_noscript, "_noscript")):
-(css_files_noscript, "_noscript")):
 site_root_dir = self.sites_paths[template_data.site]
 for css_file in files:
 css_file_path = os.path.join(site_root_dir, css_file)
 with open(css_file_path) as f:
 css_contents.append(f.read())
 css_files_noscript=css_files_noscript,
 locale=self._locale,
 locales=self.locales,
 gidx=Indexer(),
 script=scripts_handler,
-**kwargs
+**kwargs,
 )
 self.env._template_data = None
 return rendered

Mercurial > libervia-backend

comparison libervia/backend/tools/common/template.py @ 4270:0d7bb4df2343