c2cgeoportal-geoportal 2.6.0__py2.py3-none-any.whl → 2.7.1.156__py2.py3-none-any.whl

c2cgeoportal_geoportal/views/theme.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2011-2021, Camptocamp SA
+# Copyright (c) 2011-2022, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -27,33 +25,37 @@
 # of the authors and should not be interpreted as representing official policies,
 # either expressed or implied, of the FreeBSD Project.
 
-# pylint: disable=no-member
-
 
 import asyncio
 import gc
 import logging
+import os
 import re
 import sys
 import time
-import urllib.parse
 from collections import Counter
 from math import sqrt
-from typing import Any, Dict, List, Set, Union, cast
+from typing import Any, Dict, List, Optional, Set, Tuple, Union, cast
 
+import dogpile.cache.api
+import pyramid.request
 import requests
+import sqlalchemy
+import sqlalchemy.orm.query
 from c2cwsgiutils.auth import auth_view
 from defusedxml import lxml
+from lxml import etree  # nosec
 from owslib.wms import WebMapService
 from pyramid.view import view_config
 from sqlalchemy.orm import subqueryload
 from sqlalchemy.orm.exc import NoResultFound
 
 from c2cgeoportal_commons import models
-from c2cgeoportal_commons.lib.url import add_url_params, get_url2
+from c2cgeoportal_commons.lib.url import Url, get_url2
 from c2cgeoportal_commons.models import main
 from c2cgeoportal_geoportal.lib import get_roles_id, get_typed, get_types_map, is_intranet
-from c2cgeoportal_geoportal.lib.caching import PRIVATE_CACHE, get_region, set_common_headers
+from c2cgeoportal_geoportal.lib.caching import get_region
+from c2cgeoportal_geoportal.lib.common_headers import Cache, set_common_headers
 from c2cgeoportal_geoportal.lib.functionality import get_mapserver_substitution_params
 from c2cgeoportal_geoportal.lib.layers import (
     get_private_layers,
@@ -61,30 +63,38 @@ from c2cgeoportal_geoportal.lib.layers import (
     get_protected_layers_query,
 )
 from c2cgeoportal_geoportal.lib.wmstparsing import TimeInformation, parse_extent
-from c2cgeoportal_geoportal.views.layers import get_layer_metadatas
+from c2cgeoportal_geoportal.views import restrict_headers
+from c2cgeoportal_geoportal.views.layers import get_layer_metadata
 
 LOG = logging.getLogger(__name__)
 CACHE_REGION = get_region("std")
+TIMEOUT = int(os.environ.get("C2CGEOPORTAL_THEME_TIMEOUT", "300"))
+
+Metadata = Union[str, int, float, bool, List[Any], Dict[str, Any]]
 
 
-def get_http_cached(http_options, url, headers):
-    @CACHE_REGION.cache_on_arguments()
-    def do_get_http_cached(url):
-        response = requests.get(url, headers=headers, timeout=300, **http_options)
+def get_http_cached(http_options: Dict[str, Any], url: str, headers: Dict[str, str]) -> Tuple[bytes, str]:
+    """Get the content of the URL with a cash (dogpile)."""
+
+    @CACHE_REGION.cache_on_arguments()  # type: ignore
+    def do_get_http_cached(url: str) -> Tuple[bytes, str]:
+        response = requests.get(url, headers=headers, timeout=TIMEOUT, **http_options)
+        response.raise_for_status()
         LOG.info("Get url '%s' in %.1fs.", url, response.elapsed.total_seconds())
-        return response
+        return response.content, response.headers.get("Content-Type", "")
 
-    return do_get_http_cached(url)
+    return do_get_http_cached(url)  # type: ignore
 
 
 class DimensionInformation:
+    """Used to collect the dimensions information."""
 
     URL_PART_RE = re.compile(r"[a-zA-Z0-9_\-\+~\.]*$")
 
     def __init__(self) -> None:
         self._dimensions: Dict[str, str] = {}
 
-    def merge(self, layer, layer_node, mixed):
+    def merge(self, layer: main.Layer, layer_node: Dict[str, Any], mixed: bool) -> Set[str]:
         errors = set()
 
         dimensions: Dict[str, str] = {}
@@ -96,14 +106,11 @@ class DimensionInformation:
                 and not self.URL_PART_RE.match(dimension.value)
             ):
                 errors.add(
-                    "The layer '{}' has an unsupported dimension value '{}' ('{}').".format(
-                        layer.name, dimension.value, dimension.name
-                    )
+                    f"The layer '{layer.name}' has an unsupported dimension value "
+                    f"'{dimension.value}' ('{dimension.name}')."
                 )
             elif dimension.name in dimensions:  # pragma: nocover
-                errors.add(
-                    "The layer '{}' has a duplicated dimension name '{}'.".format(layer.name, dimension.name)
-                )
+                errors.add(f"The layer '{layer.name}' has a duplicated dimension name '{dimension.name}'.")
             else:
                 if dimension.field:
                     dimensions_filters[dimension.name] = {"field": dimension.field, "value": dimension.value}
@@ -120,20 +127,24 @@ class DimensionInformation:
                     self._dimensions[name] = value
                 elif self._dimensions[name] != value and value is not None:
                     errors.add(
-                        "The layer '{}' has a wrong dimension value '{}' for '{}', "
-                        "expected '{}' or empty.".format(layer.name, value, name, self._dimensions[name])
+                        f"The layer '{layer.name}' has a wrong dimension value '{value}' for '{name}', "
+                        f"expected '{self._dimensions[name]}' or empty."
                     )
         return errors
 
-    def get_dimensions(self):
+    def get_dimensions(self) -> Dict[str, str]:
         return self._dimensions
 
 
 class Theme:
-    def __init__(self, request):
+    """All the views concerning the themes."""
+
+    def __init__(self, request: pyramid.request.Request):
         self.request = request
         self.settings = request.registry.settings
-        self.http_options = self.request.registry.settings.get("http_options", {})
+        self.http_options = self.settings.get("http_options", {})
+        self.headers_whitelist = self.settings.get("headers_whitelist", [])
+        self.headers_blacklist = self.settings.get("headers_blacklist", [])
         self.metadata_type = get_types_map(
             self.settings.get("admin_interface", {}).get("available_metadata", [])
         )
@@ -145,8 +156,10 @@ class Theme:
         self._layergroup_cache = None
         self._themes_cache = None
 
-    def _get_metadata(self, item, metadata, errors):
-        metadatas = item.get_metadatas(metadata)
+    def _get_metadata(
+        self, item: main.TreeItem, metadata: str, errors: Set[str]
+    ) -> Union[None, str, int, float, bool, List[Any], Dict[str, Any]]:
+        metadatas = item.get_metadata(metadata)
         return (
             None
             if not metadatas
@@ -155,8 +168,9 @@ class Theme:
             )
         )
 
-    def _get_metadatas(self, item, errors):
-        metadatas = {}
+    def _get_metadata_list(self, item: main.TreeItem, errors: Set[str]) -> Dict[str, Metadata]:
+        metadatas: Dict[str, Metadata] = {}
+        metadata: main.Metadata
         for metadata in item.metadatas:
             value = get_typed(metadata.name, metadata.value, self.metadata_type, self.request, errors)
             if value is not None:
@@ -164,24 +178,25 @@ class Theme:
 
         return metadatas
 
-    async def _wms_getcap(self, ogc_server, preload=False):
-        url, content, errors = await self._wms_getcap_cached(ogc_server)
-
-        if errors or preload:
-            return None, errors
-
-        @CACHE_REGION.cache_on_arguments()
-        def build_web_map_service(ogc_server_id):
+    async def _wms_getcap(
+        self, ogc_server: main.OGCServer, preload: bool = False
+    ) -> Tuple[Optional[Dict[str, Dict[str, Any]]], Set[str]]:
+        @CACHE_REGION.cache_on_arguments()  # type: ignore
+        def build_web_map_service(ogc_server_id: int) -> Tuple[Optional[Dict[str, Dict[str, Any]]], Set[str]]:
             del ogc_server_id  # Just for cache
 
-            version = urllib.parse.parse_qs(urllib.parse.urlsplit(url).query)["VERSION"][0]
+            if url is None:
+                raise RuntimeError("Url is None")
+
+            version = url.query.get("VERSION", "1.1.1")
             layers = {}
             try:
                 wms = WebMapService(None, xml=content, version=version)
-            except Exception as e:  # pragma: no cover
+            except Exception as e:
                 error = (
-                    "WARNING! an error '{}' occurred while trying to read the mapfile and recover the themes."
-                    "\nURL: {}\n{}".format(e, url, content)
+                    f"WARNING! an error '{e!s}' occurred while trying to read the mapfile and "
+                    "recover the themes."
+                    f"\nURL: {url}\n{content.decode() if content else None}"
                 )
                 LOG.error(error, exc_info=True)
                 return None, {error}
@@ -191,8 +206,8 @@ class Theme:
                 resolution = self._get_layer_resolution_hint(wms_layer)
                 info = {
                     "name": wms_layer.name,
-                    "minResolutionHint": float("{:0.2f}".format(resolution[0])),
-                    "maxResolutionHint": float("{:0.2f}".format(resolution[1])),
+                    "minResolutionHint": float(f"{resolution[0]:0.2f}"),
+                    "maxResolutionHint": float(f"{resolution[1]:0.2f}"),
                 }
                 if hasattr(wms_layer, "queryable"):
                     info["queryable"] = wms_layer.queryable == 1
@@ -209,12 +224,30 @@ class Theme:
 
             return {"layers": layers}, set()
 
-        return build_web_map_service(ogc_server.id)
+        result = build_web_map_service.get(ogc_server.id)
+        if result != dogpile.cache.api.NO_VALUE:
+            return result  # type: ignore
+
+        try:
+            url, content, errors = await self._wms_getcap_cached(ogc_server)
+        except requests.exceptions.RequestException as exception:
+            error = (
+                f"Unable to get the WMS Capabilities for OGC server '{ogc_server.name}', "
+                f"return the error: {exception.response.status_code} {exception.response.reason}"
+            )
+            LOG.exception(error)
+            return None, {error}
+        if errors or preload:
+            return None, errors
+
+        return build_web_map_service(ogc_server.id)  # type: ignore
 
-    async def _wms_getcap_cached(self, ogc_server):
+    async def _wms_getcap_cached(
+        self, ogc_server: main.OGCServer
+    ) -> Tuple[Optional[Url], Optional[bytes], Set[str]]:
         errors: Set[str] = set()
-        url = get_url2("The OGC server '{}'".format(ogc_server.name), ogc_server.url, self.request, errors)
-        if errors or url is None:  # pragma: no cover
+        url = get_url2(f"The OGC server '{ogc_server.name}'", ogc_server.url, self.request, errors)
+        if errors or url is None:
             return url, None, errors
 
         # Add functionality params
@@ -222,15 +255,14 @@ class Theme:
             ogc_server.auth == main.OGCSERVER_AUTH_STANDARD
             and ogc_server.type == main.OGCSERVER_TYPE_MAPSERVER
         ):
-            url = add_url_params(url, get_mapserver_substitution_params(self.request))
+            url.add_query(get_mapserver_substitution_params(self.request))
 
-        url = add_url_params(
-            url,
+        url.add_query(
             {
                 "SERVICE": "WMS",
                 "VERSION": "1.1.1",
                 "REQUEST": "GetCapabilities",
-                "ROLE_ID": "0",
+                "ROLE_IDS": "0",
                 "USER_ID": "0",
             },
         )
@@ -245,47 +277,38 @@ class Theme:
             headers["sec-username"] = "root"
             headers["sec-roles"] = "root"
 
-        if urllib.parse.urlsplit(url).hostname != "localhost" and "Host" in headers:  # pragma: no cover
+        if url.hostname != "localhost" and "Host" in headers:
             headers.pop("Host")
 
+        headers = restrict_headers(headers, self.headers_whitelist, self.headers_blacklist)
+
         try:
-            response = await asyncio.get_event_loop().run_in_executor(
+            content, content_type = await asyncio.get_event_loop().run_in_executor(
                 None, get_http_cached, self.http_options, url, headers
             )
-        except Exception:  # pragma: no cover
-            error = "Unable to GetCapabilities from URL {}".format(url)
+        except Exception:
+            error = f"Unable to GetCapabilities from URL {url}"
             errors.add(error)
             LOG.error(error, exc_info=True)
             return url, None, errors
 
-        if not response.ok:  # pragma: no cover
-            error = "GetCapabilities from URL {} return the error: {:d} {}".format(
-                url, response.status_code, response.reason
-            )
-            errors.add(error)
-            LOG.error(error)
-            return url, None, errors
-
         # With wms 1.3 it returns text/xml also in case of error :-(
-        if response.headers.get("Content-Type", "").split(";")[0].strip() not in [
+        if content_type.split(";")[0].strip() not in [
             "application/vnd.ogc.wms_xml",
             "text/xml",
         ]:
-            error = "GetCapabilities from URL {} returns a wrong Content-Type: {}\n{}".format(
-                url, response.headers.get("Content-Type", ""), response.text
+            error = (
+                f"GetCapabilities from URL '{url}' returns a wrong Content-Type: {content_type}\n"
+                f"{content.decode()}"
             )
             errors.add(error)
             LOG.error(error)
             return url, None, errors
 
-        return url, response.content, errors
-
-    def _create_layer_query(self, interface):
-        """
-        Create an SQLAlchemy query for Layer and for the role
-        identified to by ``role_id``.
-        """
+        return url, content, errors
 
+    def _create_layer_query(self, interface: str) -> sqlalchemy.orm.query.Query:
+        """Create an SQLAlchemy query for Layer and for the role identified to by ``role_id``."""
         query = models.DBSession.query(main.Layer.name).filter(main.Layer.public.is_(True))
 
         if interface is not None:
@@ -305,7 +328,7 @@ class Theme:
 
         return query
 
-    def _get_layer_metadata_urls(self, layer):
+    def _get_layer_metadata_urls(self, layer: main.Layer) -> List[str]:
         metadata_urls: List[str] = []
         if layer.metadataUrls:
             metadata_urls = layer.metadataUrls
@@ -313,7 +336,7 @@ class Theme:
             metadata_urls.extend(self._get_layer_metadata_urls(child_layer))
         return metadata_urls
 
-    def _get_layer_resolution_hint_raw(self, layer):
+    def _get_layer_resolution_hint_raw(self, layer: main.Layer) -> Tuple[Optional[float], Optional[float]]:
         resolution_hint_min = None
         resolution_hint_max = None
         if layer.scaleHint:
@@ -345,40 +368,47 @@ class Theme:
 
         return (resolution_hint_min, resolution_hint_max)
 
-    def _get_layer_resolution_hint(self, layer):
+    def _get_layer_resolution_hint(self, layer: main.Layer) -> Tuple[float, float]:
         resolution_hint_min, resolution_hint_max = self._get_layer_resolution_hint_raw(layer)
         return (
             0.0 if resolution_hint_min is None else resolution_hint_min,
             999999999 if resolution_hint_max is None else resolution_hint_max,
         )
 
-    def _layer(self, layer, time_=None, dim=None, mixed=True):
+    async def _layer(
+        self,
+        layer: main.Layer,
+        time_: Optional[TimeInformation] = None,
+        dim: Optional[DimensionInformation] = None,
+        mixed: bool = True,
+    ) -> Tuple[Optional[Dict[str, Any]], Set[str]]:
         errors: Set[str] = set()
-        layer_info = {"id": layer.id, "name": layer.name, "metadata": self._get_metadatas(layer, errors)}
-        if re.search("[/?#]", layer.name):  # pragma: no cover
-            errors.add("The layer has an unsupported name '{}'.".format(layer.name))
-        if isinstance(layer, main.LayerWMS) and re.search("[/?#]", layer.layer):  # pragma: no cover
-            errors.add("The layer has an unsupported layers '{}'.".format(layer.layer))
+        layer_info = {"id": layer.id, "name": layer.name, "metadata": self._get_metadata_list(layer, errors)}
+        if re.search("[/?#]", layer.name):
+            errors.add(f"The layer has an unsupported name '{layer.name}'.")
+        if isinstance(layer, main.LayerWMS) and re.search("[/?#]", layer.layer):
+            errors.add(f"The layer has an unsupported layers '{layer.layer}'.")
         if layer.geo_table:
             errors |= self._fill_editable(layer_info, layer)
         if mixed:
             assert time_ is None
             time_ = TimeInformation()
         assert time_ is not None
+        assert dim is not None
 
         errors |= dim.merge(layer, layer_info, mixed)
 
         if isinstance(layer, main.LayerWMS):
-            wms, wms_errors = self._wms_layers(layer.ogc_server)
+            wms, wms_errors = await self._wms_layers(layer.ogc_server)
             errors |= wms_errors
             if wms is None:
                 return None if errors else layer_info, errors
             if layer.layer is None or layer.layer == "":
-                errors.add("The layer '{}' do not have any layers".format(layer.name))
+                errors.add(f"The layer '{layer.name}' do not have any layers")
                 return None, errors
             layer_info["type"] = "WMS"
             layer_info["layers"] = layer.layer
-            self._fill_wms(layer_info, layer, errors, mixed=mixed)
+            await self._fill_wms(layer_info, layer, errors, mixed=mixed)
             errors |= self._merge_time(time_, layer_info, layer, wms)
 
         elif isinstance(layer, main.LayerWMTS):
@@ -387,16 +417,18 @@ class Theme:
 
         elif isinstance(layer, main.LayerVectorTiles):
             layer_info["type"] = "VectorTiles"
-            self._vectortiles_layers(layer_info, layer)
+            self._vectortiles_layers(layer_info, layer, errors)
 
         return None if errors else layer_info, errors
 
     @staticmethod
-    def _merge_time(time_, layer_theme, layer, wms):
+    def _merge_time(
+        time_: TimeInformation, layer_theme: Dict[str, Any], layer: main.Layer, wms: Dict[str, Dict[str, Any]]
+    ) -> Set[str]:
         errors = set()
         wmslayer = layer.layer
 
-        def merge_time(wms_layer_obj):
+        def merge_time(wms_layer_obj: Dict[str, Any]) -> None:
             extent = parse_extent(wms_layer_obj["timepositions"], wms_layer_obj["defaulttimeposition"])
             time_.merge(layer_theme, extent, layer.time_mode, layer.time_widget)
 
@@ -420,17 +452,15 @@ class Theme:
 
                     if not has_time:
                         errors.add(
-                            "Error: time layer '{}' has no time information in capabilities".format(
-                                layer.name
-                            )
+                            f"Error: time layer '{layer.name}' has no time information in capabilities"
                         )
 
         except ValueError:  # pragma no cover
-            errors.add("Error while handling time for layer '{}': {}".format(layer.name, sys.exc_info()[1]))
+            errors.add(f"Error while handling time for layer '{layer.name}': {sys.exc_info()[1]}")
 
         return errors
 
-    def _fill_editable(self, layer_theme, layer):
+    def _fill_editable(self, layer_theme: Dict[str, Any], layer: main.Layer) -> Set[str]:
         errors = set()
         try:
             if self.request.user:
@@ -443,14 +473,19 @@ class Theme:
                     .count()
                 )
                 if count > 0:
-                    layer_theme["edit_columns"] = get_layer_metadatas(layer)
+                    layer_theme["edit_columns"] = get_layer_metadata(layer)
                     layer_theme["editable"] = True
         except Exception as exception:
             LOG.exception(str(exception))
             errors.add(str(exception))
         return errors
 
-    def _fill_child_layer(self, layer_theme, layer_name, wms):
+    def _fill_child_layer(
+        self,
+        layer_theme: Dict[str, Any],
+        layer_name: str,
+        wms: Dict[str, Dict[str, Any]],
+    ) -> None:
         wms_layer_obj = wms["layers"][layer_name]
         if not wms_layer_obj["children"]:
             layer_theme["childLayers"].append(wms["layers"][layer_name]["info"])
@@ -458,14 +493,16 @@ class Theme:
             for child_layer in wms_layer_obj["children"]:
                 self._fill_child_layer(layer_theme, child_layer, wms)
 
-    def _fill_wms(self, layer_theme, layer, errors, mixed):
-        wms, wms_errors = self._wms_layers(layer.ogc_server)
+    async def _fill_wms(
+        self, layer_theme: Dict[str, Any], layer: main.Layer, errors: Set[str], mixed: bool
+    ) -> None:
+        wms, wms_errors = await self._wms_layers(layer.ogc_server)
         errors |= wms_errors
         if wms is None:
             return
 
         layer_theme["imageType"] = layer.ogc_server.image_type
-        if layer.style:  # pragma: no cover
+        if layer.style:
             layer_theme["style"] = layer.style
 
         # now look at what is in the WMS capabilities doc
@@ -475,9 +512,8 @@ class Theme:
                 self._fill_child_layer(layer_theme, layer_name, wms)
             else:
                 errors.add(
-                    "The layer '{}' ({}) is not defined in WMS capabilities from '{}'".format(
-                        layer_name, layer.name, layer.ogc_server.name
-                    )
+                    f"The layer '{layer_name}' ({layer.name}) is not defined in WMS capabilities "
+                    f"from '{layer.ogc_server.name}'"
                 )
 
         if "minResolutionHint" not in layer_theme:
@@ -506,26 +542,9 @@ class Theme:
         if mixed:
             layer_theme["ogcServer"] = layer.ogc_server.name
 
-    @staticmethod
-    def _fill_legend_rule_query_string(layer_theme, layer, url):
-        if layer.legend_rule and url:
-            layer_theme["icon"] = add_url_params(
-                url,
-                {
-                    "SERVICE": "WMS",
-                    "VERSION": "1.1.1",
-                    "REQUEST": "GetLegendGraphic",
-                    "LAYER": layer.name,
-                    "FORMAT": "image/png",
-                    "TRANSPARENT": "TRUE",
-                    "RULE": layer.legend_rule,
-                },
-            )
-
-    def _fill_wmts(self, layer_theme, layer, errors):
-        layer_theme["url"] = get_url2(
-            "The WMTS layer '{}'".format(layer.name), layer.url, self.request, errors=errors
-        )
+    def _fill_wmts(self, layer_theme: Dict[str, Any], layer: main.Layer, errors: Set[str]) -> None:
+        url = get_url2(f"The WMTS layer '{layer.name}'", layer.url, self.request, errors=errors)
+        layer_theme["url"] = url.url() if url is not None else None
 
         if layer.style:
             layer_theme["style"] = layer.style
@@ -535,18 +554,18 @@ class Theme:
         layer_theme["layer"] = layer.layer
         layer_theme["imageType"] = layer.image_type
 
-    @staticmethod
-    def _vectortiles_layers(layer_theme, layer):
-        layer_theme["style"] = layer.style
+    def _vectortiles_layers(self, layer_theme: Dict[str, Any], layer: main.Layer, errors: Set[str]) -> None:
+        style = get_url2(f"The VectorTiles layer '{layer.name}'", layer.style, self.request, errors=errors)
+        layer_theme["style"] = style.url() if style is not None else None
         if layer.xyz:
             layer_theme["xyz"] = layer.xyz
 
     @staticmethod
-    def _layer_included(tree_item):
+    def _layer_included(tree_item: main.TreeItem) -> bool:
         return isinstance(tree_item, main.Layer)
 
-    def _get_ogc_servers(self, group, depth):
-        """Recurse on all children to get unique identifier for each child."""
+    def _get_ogc_servers(self, group: main.LayerGroup, depth: int) -> Set[Union[str, bool]]:
+        """Get unique identifier for each child by recursing on all the children."""
 
         ogc_servers: Set[Union[str, bool]] = set()
 
@@ -569,23 +588,23 @@ class Theme:
         return ogc_servers
 
     @staticmethod
-    def is_mixed(ogc_servers):
+    def is_mixed(ogc_servers: List[Union[str, bool]]) -> bool:
         return len(ogc_servers) != 1 or ogc_servers[0] is False
 
-    def _group(
+    async def _group(
         self,
-        path,
-        group,
-        layers,
-        depth=1,
-        min_levels=1,
-        mixed=True,
-        time_=None,
-        dim=None,
-        wms_layers=None,
-        layers_name=None,
-        **kwargs,
-    ):
+        path: str,
+        group: main.LayerGroup,
+        layers: List[str],
+        depth: int = 1,
+        min_levels: int = 1,
+        mixed: bool = True,
+        time_: Optional[TimeInformation] = None,
+        dim: Optional[DimensionInformation] = None,
+        wms_layers: Optional[List[str]] = None,
+        layers_name: Optional[List[str]] = None,
+        **kwargs: Any,
+    ) -> Tuple[Optional[Dict[str, Any]], Set[str]]:
         if wms_layers is None:
             wms_layers = []
         if layers_name is None:
@@ -593,12 +612,12 @@ class Theme:
         children = []
         errors = set()
 
-        if re.search("[/?#]", group.name):  # pragma: no cover
-            errors.add("The group has an unsupported name '{}'.".format(group.name))
+        if re.search("[/?#]", group.name):
+            errors.add(f"The group has an unsupported name '{group.name}'.")
 
         # escape loop
         if depth > 30:
-            errors.add("Too many recursions with group '{}'".format(group.name))
+            errors.add(f"Too many recursions with group '{group.name}'")
             return None, errors
 
         ogc_servers = None
@@ -613,8 +632,8 @@ class Theme:
 
         for tree_item in group.children:
             if isinstance(tree_item, main.LayerGroup):
-                group_theme, gp_errors = self._group(
-                    "{}/{}".format(path, tree_item.name),
+                group_theme, gp_errors = await self._group(
+                    f"{path}/{tree_item.name}",
                     tree_item,
                     layers,
                     depth=depth + 1,
@@ -635,14 +654,13 @@ class Theme:
                     if isinstance(tree_item, main.LayerWMS):
                         wms_layers.extend(tree_item.layer.split(","))
 
-                    layer_theme, l_errors = self._layer(tree_item, mixed=mixed, time_=time_, dim=dim)
+                    layer_theme, l_errors = await self._layer(tree_item, mixed=mixed, time_=time_, dim=dim)
                     errors |= l_errors
                     if layer_theme is not None:
                         if depth < min_levels:
                             errors.add(
-                                "The Layer '{}' is under indented ({:d}/{:d}).".format(
-                                    path + "/" + tree_item.name, depth, min_levels
-                                )
+                                f"The Layer '{path + '/' + tree_item.name}' is under indented "
+                                f"({depth:d}/{min_levels:d})."
                             )
                         else:
                             children.append(layer_theme)
@@ -652,7 +670,7 @@ class Theme:
                 "id": group.id,
                 "name": group.name,
                 "children": children,
-                "metadata": self._get_metadatas(group, errors),
+                "metadata": self._get_metadata_list(group, errors),
                 "mixed": False,
             }
             if not mixed:
@@ -660,14 +678,16 @@ class Theme:
                 for name, nb in Counter(layers_name).items():
                     if nb > 1:
                         errors.add(
-                            "The GeoMapFish layer name '{}', cannot be two times "
-                            "in the same block (first level group).".format(name)
+                            f"The GeoMapFish layer name '{name}', cannot be two times "
+                            "in the same block (first level group)."
                         )
 
             group_theme["mixed"] = mixed
             if org_depth == 1:
                 if not mixed:
-                    group_theme["ogcServer"] = cast(List, ogc_servers)[0]
+                    assert time_ is not None
+                    assert dim is not None
+                    group_theme["ogcServer"] = cast(List[Any], ogc_servers)[0]
                     if time_.has_time() and time_.layer is None:
                         group_theme["time"] = time_.to_dict()
 
@@ -676,13 +696,15 @@ class Theme:
             return group_theme, errors
         return None, errors
 
-    def _layers(self, interface):
+    def _layers(self, interface: str) -> List[str]:
         query = self._create_layer_query(interface=interface)
         return [name for (name,) in query.all()]
 
-    def _wms_layers(self, ogc_server):
+    async def _wms_layers(
+        self, ogc_server: main.OGCServer
+    ) -> Tuple[Optional[Dict[str, Dict[str, Any]]], Set[str]]:
         # retrieve layers metadata via GetCapabilities
-        wms, wms_errors = asyncio.run(self._wms_getcap(ogc_server))
+        wms, wms_errors = await self._wms_getcap(ogc_server)
         if wms_errors:
             return None, wms_errors
 
@@ -717,11 +739,10 @@ class Theme:
             .all()
         )
 
-    def _themes(self, interface="desktop", filter_themes=True, min_levels=1):
-        """
-        This function returns theme information for the role identified
-        by ``role_id``.
-        """
+    async def _themes(
+        self, interface: str = "desktop", filter_themes: bool = True, min_levels: int = 1
+    ) -> Tuple[List[Dict[str, Any]], Set[str]]:
+        """Return theme information for the role identified by ``role_id``."""
         self._load_tree_items()
         errors = set()
         layers = self._layers(interface)
@@ -744,17 +765,22 @@ class Theme:
         export_themes = []
         for theme in themes.all():
             if re.search("[/?#]", theme.name):
-                errors.add("The theme has an unsupported name '{}'.".format(theme.name))
+                errors.add(f"The theme has an unsupported name '{theme.name}'.")
                 continue
 
-            children, children_errors = self._get_children(theme, layers, min_levels)
+            children, children_errors = await self._get_children(theme, layers, min_levels)
             errors |= children_errors
 
             # Test if the theme is visible for the current user
             if children:
-                icon = (
-                    get_url2("The Theme '{}'".format(theme.name), theme.icon, self.request, errors)
+                url = (
+                    get_url2(f"The Theme '{theme.name}'", theme.icon, self.request, errors)
                     if theme.icon is not None and theme.icon
+                    else None
+                )
+                icon = (
+                    url.url()
+                    if url is not None
                     else self.request.static_url("/etc/geomapfish/static/images/blank.png")
                 )
 
@@ -764,14 +790,14 @@ class Theme:
                     "icon": icon,
                     "children": children,
                     "functionalities": self._get_functionalities(theme),
-                    "metadata": self._get_metadatas(theme, errors),
+                    "metadata": self._get_metadata_list(theme, errors),
                 }
                 export_themes.append(theme_theme)
 
         return export_themes, errors
 
     @staticmethod
-    def _get_functionalities(theme):
+    def _get_functionalities(theme: main.Theme) -> Dict[str, List[str]]:
         result: Dict[str, List[str]] = {}
         for functionality in theme.functionalities:
             if functionality.name in result:
@@ -780,19 +806,21 @@ class Theme:
                 result[functionality.name] = [functionality.value]
         return result
 
-    @view_config(route_name="invalidate", renderer="json")
-    def invalidate_cache(self):  # pragma: no cover
+    @view_config(route_name="invalidate", renderer="json")  # type: ignore
+    def invalidate_cache(self) -> Dict[str, bool]:
         auth_view(self.request)
-        main.cache_invalidate_cb()
+        models.cache_invalidate_cb()
         return {"success": True}
 
-    def _get_children(self, theme, layers, min_levels):
+    async def _get_children(
+        self, theme: main.Theme, layers: List[str], min_levels: int
+    ) -> Tuple[List[Dict[str, Any]], Set[str]]:
         children = []
         errors: Set[str] = set()
         for item in theme.children:
             if isinstance(item, main.LayerGroup):
-                group_theme, gp_errors = self._group(
-                    "{}/{}".format(theme.name, item.name), item, layers, min_levels=min_levels
+                group_theme, gp_errors = await self._group(
+                    f"{theme.name}/{item.name}", item, layers, min_levels=min_levels
                 )
                 errors |= gp_errors
                 if group_theme is not None:
@@ -800,19 +828,18 @@ class Theme:
             elif self._layer_included(item):
                 if min_levels > 0:
                     errors.add(
-                        "The Layer '{}' cannot be directly in the theme '{}' (0/{:d}).".format(
-                            item.name, theme.name, min_levels
-                        )
+                        f"The Layer '{item.name}' cannot be directly in the theme '{theme.name}' "
+                        f"(0/{min_levels:d})."
                     )
                 elif item.name in layers:
-                    layer_theme, l_errors = self._layer(item, dim=DimensionInformation())
+                    layer_theme, l_errors = await self._layer(item, dim=DimensionInformation())
                     errors |= l_errors
                     if layer_theme is not None:
                         children.append(layer_theme)
         return children, errors
 
-    @CACHE_REGION.cache_on_arguments()
-    def _get_layers_enum(self):
+    @CACHE_REGION.cache_on_arguments()  # type: ignore
+    def _get_layers_enum(self) -> Dict[str, Dict[str, str]]:
         layers_enum = {}
         if "enum" in self.settings.get("layers", {}):
             for layer_name, layer in list(self.settings["layers"]["enum"].items()):
@@ -827,75 +854,90 @@ class Theme:
                     )
         return layers_enum
 
-    def _get_role_ids(self):
+    def _get_role_ids(self) -> Optional[Set[int]]:
         return None if self.request.user is None else {role.id for role in self.request.user.roles}
 
-    async def _wms_get_features_type(self, wfs_url, preload=False):
+    async def _wfs_get_features_type(
+        self, wfs_url: Url, ogc_server_name: str, preload: bool = False
+    ) -> Tuple[Optional[etree.Element], Set[str]]:
         errors = set()
 
-        params = {
-            "SERVICE": "WFS",
-            "VERSION": "1.0.0",
-            "REQUEST": "DescribeFeatureType",
-            "ROLE_ID": "0",
-            "USER_ID": "0",
-        }
-        wfs_url = add_url_params(wfs_url, params)
+        wfs_url.add_query(
+            {
+                "SERVICE": "WFS",
+                "VERSION": "1.0.0",
+                "REQUEST": "DescribeFeatureType",
+                "ROLE_IDS": "0",
+                "USER_ID": "0",
+            }
+        )
 
-        LOG.debug("WFS DescribeFeatureType for base URL: %s", wfs_url)
+        LOG.debug("WFS DescribeFeatureType for the URL: %s", wfs_url)
 
         # forward request to target (without Host Header)
         headers = dict(self.request.headers)
-        if urllib.parse.urlsplit(wfs_url).hostname != "localhost" and "Host" in headers:
-            headers.pop("Host")  # pragma nocover
+        if wfs_url.hostname != "localhost" and "Host" in headers:
+            headers.pop("Host")
+
+        headers = restrict_headers(headers, self.headers_whitelist, self.headers_blacklist)
 
         try:
-            response = await asyncio.get_event_loop().run_in_executor(
+            content, _ = await asyncio.get_event_loop().run_in_executor(
                 None, get_http_cached, self.http_options, wfs_url, headers
             )
-        except Exception:  # pragma: no cover
-            errors.add("Unable to get DescribeFeatureType from URL {}".format(wfs_url))
-            return None, errors
-
-        if not response.ok:  # pragma: no cover
-            errors.add(
-                "DescribeFeatureType from URL {} return the error: {:d} {}".format(
-                    wfs_url, response.status_code, response.reason
+        except requests.exceptions.RequestException as exception:
+            error = (
+                f"Unable to get WFS DescribeFeatureType from the URL '{wfs_url.url()}' for "
+                f"OGC server {ogc_server_name}, "
+                + (
+                    f"return the error: {exception.response.status_code} {exception.response.reason}"
+                    if exception.response is not None
+                    else f"{exception}"
                 )
             )
+            errors.add(error)
+            LOG.exception(error)
+            return None, errors
+        except Exception:
+            error = (
+                f"Unable to get WFS DescribeFeatureType from the URL {wfs_url} for "
+                f"OGC server {ogc_server_name}"
+            )
+            errors.add(error)
+            LOG.exception(error)
             return None, errors
 
         if preload:
             return None, errors
 
         try:
-            return lxml.XML(response.text.encode("utf-8")), errors
-        except Exception as e:  # pragma: no cover
+            return lxml.XML(content), errors
+        except Exception as e:
             errors.add(
-                "Error '{}' on reading DescribeFeatureType from URL {}:\n{}".format(
-                    str(e), wfs_url, response.text
-                )
+                f"Error '{e!s}' on reading DescribeFeatureType from URL {wfs_url}:\n{content.decode()}"
             )
             return None, errors
 
-    def get_url_internal_wfs(self, ogc_server, errors):
+    def get_url_internal_wfs(
+        self, ogc_server: main.OGCServer, errors: Set[str]
+    ) -> Tuple[Optional[Url], Optional[Url], Optional[Url]]:
         # required to do every time to validate the url.
         if ogc_server.auth != main.OGCSERVER_AUTH_NOAUTH:
-            url = self.request.route_url("mapserverproxy", _query={"ogcserver": ogc_server.name})
-            url_wfs = url
+            url: Optional[Url] = Url(
+                self.request.route_url("mapserverproxy", _query={"ogcserver": ogc_server.name})
+            )
+            url_wfs: Optional[Url] = url
             url_internal_wfs = get_url2(
-                "The OGC server (WFS) '{}'".format(ogc_server.name),
+                f"The OGC server (WFS) '{ogc_server.name}'",
                 ogc_server.url_wfs or ogc_server.url,
                 self.request,
                 errors=errors,
             )
         else:
-            url = get_url2(
-                "The OGC server '{}'".format(ogc_server.name), ogc_server.url, self.request, errors=errors
-            )
+            url = get_url2(f"The OGC server '{ogc_server.name}'", ogc_server.url, self.request, errors=errors)
             url_wfs = (
                 get_url2(
-                    "The OGC server (WFS) '{}'".format(ogc_server.name),
+                    f"The OGC server (WFS) '{ogc_server.name}'",
                     ogc_server.url_wfs,
                     self.request,
                     errors=errors,
@@ -906,115 +948,170 @@ class Theme:
             url_internal_wfs = url_wfs
         return url_internal_wfs, url, url_wfs
 
-    async def preload(self, errors):
+    async def preload(self, errors: Set[str]) -> None:
         tasks = set()
         for ogc_server in models.DBSession.query(main.OGCServer).all():
-            url_internal_wfs, _, _ = self.get_url_internal_wfs(ogc_server, errors)
-            tasks.add(self._wms_get_features_type(url_internal_wfs, True))
-            tasks.add(self._wms_getcap(ogc_server, True))
+            # Don't load unused OGC servers, required for Landigpage, because the related OGC server
+            # will be on error in those functions.
+            nb_layers = (
+                models.DBSession.query(sqlalchemy.func.count(main.LayerWMS.id))
+                .filter(main.LayerWMS.ogc_server_id == ogc_server.id)
+                .one()
+            )
+            LOG.debug("%i layers for OGC server '%s'", nb_layers[0], ogc_server.name)
+            if nb_layers[0] > 0:
+                LOG.debug("Preload OGC server '%s'", ogc_server.name)
+                url_internal_wfs, _, _ = self.get_url_internal_wfs(ogc_server, errors)
+                if url_internal_wfs is not None:
+                    if ogc_server.wfs_support:
+                        tasks.add(self._wfs_get_features_type(url_internal_wfs, ogc_server.name, True))
+                    tasks.add(self._wms_getcap(ogc_server, True))
 
         await asyncio.gather(*tasks)
 
-    @CACHE_REGION.cache_on_arguments()
-    def _get_features_attributes(self, url_internal_wfs):
-        all_errors: Set[str] = set()
-        feature_type, errors = asyncio.run(self._wms_get_features_type(url_internal_wfs))
-        LOG.debug("Run garbage collection: %s", ", ".join([str(gc.collect(n)) for n in range(3)]))
-        if errors:
-            all_errors |= errors
-            return None, None, all_errors
-        namespace = feature_type.attrib.get("targetNamespace")
-        types = {}
-        elements = {}
-        for child in feature_type.getchildren():
-            if child.tag == "{http://www.w3.org/2001/XMLSchema}element":
-                name = child.attrib["name"]
-                type_namespace, type_ = child.attrib["type"].split(":")
-                if type_namespace not in child.nsmap:
-                    LOG.info(
-                        "The namespace '%s' of the type '%s' is not found in the available namespaces: %s",
-                        type_namespace,
+    async def _get_features_attributes(
+        self, url_internal_wfs: Url, ogc_server_name: str
+    ) -> Tuple[Optional[Dict[str, Dict[Any, Dict[str, Any]]]], Optional[str], Set[str]]:
+        @CACHE_REGION.cache_on_arguments()  # type: ignore
+        def _get_features_attributes_cache(
+            url_internal_wfs: Url, ogc_server_name: str
+        ) -> Tuple[Optional[Dict[str, Dict[Any, Dict[str, Any]]]], Optional[str], Set[str]]:
+            del url_internal_wfs  # Just for cache
+            all_errors: Set[str] = set()
+            LOG.debug("Run garbage collection: %s", ", ".join([str(gc.collect(n)) for n in range(3)]))
+            if errors:
+                all_errors |= errors
+                return None, None, all_errors
+            assert feature_type
+            namespace: str = feature_type.attrib.get("targetNamespace")
+            types: Dict[Any, Dict[str, Any]] = {}
+            elements = {}
+            for child in feature_type.getchildren():
+                if child.tag == "{http://www.w3.org/2001/XMLSchema}element":
+                    name = child.attrib["name"]
+                    type_namespace, type_ = child.attrib["type"].split(":")
+                    if type_namespace not in child.nsmap:
+                        LOG.info(
+                            "The namespace '%s' of the type '%s' is not found in the "
+                            "available namespaces: %s (OGC server: %s)",
+                            type_namespace,
+                            name,
+                            ", ".join([str(k) for k in child.nsmap.keys()]),
+                            ogc_server_name,
+                        )
+                    elif child.nsmap[type_namespace] != namespace:
+                        LOG.info(
+                            "The namespace '%s' of the type '%s' should be '%s' (OGC server: %s).",
+                            child.nsmap[type_namespace],
+                            name,
+                            namespace,
+                            ogc_server_name,
+                        )
+                    elements[name] = type_
+
+                if child.tag == "{http://www.w3.org/2001/XMLSchema}complexType":
+                    sequence = child.find(".//{http://www.w3.org/2001/XMLSchema}sequence")
+                    attrib = {}
+                    for children in sequence.getchildren():
+                        type_namespace = None
+                        type_ = children.attrib["type"]
+                        if len(type_.split(":")) == 2:
+                            type_namespace, type_ = type_.split(":")
+                        name = children.attrib["name"]
+                        attrib[name] = {"type": type_}
+                        if type_namespace in children.nsmap:
+                            type_namespace = children.nsmap[type_namespace]
+                            attrib[name]["namespace"] = type_namespace
+                        else:
+                            LOG.info(
+                                "The namespace '%s' of the type '%s' is not found in the "
+                                "available namespaces: %s (OGC server: %s)",
+                                type_namespace,
+                                name,
+                                ", ".join([str(k) for k in child.nsmap.keys()]),
+                                ogc_server_name,
+                            )
+                        for key, value in children.attrib.items():
+                            if key not in ("name", "type", "namespace"):
+                                attrib[name][key] = value
+                    types[child.attrib["name"]] = attrib
+            attributes: Dict[str, Dict[Any, Dict[str, Any]]] = {}
+            for name, type_ in elements.items():
+                if type_ in types:
+                    attributes[name] = types[type_]
+                elif (type_ == "Character") and (name + "Type") in types:
+                    LOG.debug(
+                        "Due MapServer strange result the type 'ms:Character' is fallbacked to type '%sType'"
+                        " for feature '%s', This is a strange comportement of MapServer when we use the "
+                        'METADATA "gml_types" "auto"',
                         name,
-                        ", ".join(child.nsmap.keys()),
-                    )
-                if child.nsmap[type_namespace] != namespace:
-                    LOG.info(
-                        "The namespace '%s' of the thye '%s' should be '%s'.",
-                        child.nsmap[type_namespace],
                         name,
-                        namespace,
                     )
-                elements[name] = type_
-
-            if child.tag == "{http://www.w3.org/2001/XMLSchema}complexType":
-                sequence = child.find(".//{http://www.w3.org/2001/XMLSchema}sequence")
-                attrib = {}
-                for children in sequence.getchildren():
-                    type_namespace = None
-                    type_ = children.attrib["type"]
-                    if len(type_.split(":")) == 2:
-                        type_namespace, type_ = type_.split(":")
-                    type_namespace = children.nsmap[type_namespace]
-                    name = children.attrib["name"]
-                    attrib[name] = {"namespace": type_namespace, "type": type_}
-                    for key, value in children.attrib.items():
-                        if key not in ("name", "type", "namespace"):
-                            attrib[name][key] = value
-                types[child.attrib["name"]] = attrib
-        attributes = {}
-        for name, type_ in elements.items():
-            if type_ in types:
-                attributes[name] = types[type_]
-            elif (type_ == "Character") and (name + "Type") in types:
-                LOG.debug(
-                    "Due mapserver strange result the type 'ms:Character' is fallbacked to type '%sType'"
-                    " for feature '%s', This is a strange comportement of mapserver when we use the "
-                    'METADATA "gml_types" "auto"',
-                    name,
-                    name,
-                )
-                attributes[name] = types[name + "Type"]
-            else:
-                LOG.warning(
-                    "The provided type '%s' does not exist, available types are %s.",
-                    type_,
-                    ", ".join(types.keys()),
-                )
+                    attributes[name] = types[name + "Type"]
+                else:
+                    LOG.warning(
+                        "The provided type '%s' does not exist, available types are %s.",
+                        type_,
+                        ", ".join(types.keys()),
+                    )
+
+            return attributes, namespace, all_errors
+
+        result = _get_features_attributes_cache.get(url_internal_wfs, ogc_server_name)
+        if result != dogpile.cache.api.NO_VALUE:
+            return result  # type: ignore
 
-        return attributes, namespace, all_errors
+        feature_type, errors = await self._wfs_get_features_type(url_internal_wfs, ogc_server_name)
+        return _get_features_attributes_cache(url_internal_wfs, ogc_server_name)  # type: ignore
 
-    @view_config(route_name="themes", renderer="json")
-    def themes(self):
+    @view_config(route_name="themes", renderer="json")  # type: ignore
+    def themes(self) -> Dict[str, Union[Dict[str, Dict[str, Any]], List[str]]]:
         interface = self.request.params.get("interface", "desktop")
         sets = self.request.params.get("set", "all")
         min_levels = int(self.request.params.get("min_levels", 1))
         group = self.request.params.get("group")
         background_layers_group = self.request.params.get("background")
 
-        set_common_headers(self.request, "themes", PRIVATE_CACHE)
+        set_common_headers(self.request, "themes", Cache.PRIVATE)
 
-        def get_theme():
+        async def get_theme() -> Dict[str, Union[Dict[str, Any], List[str]]]:
             export_themes = sets in ("all", "themes")
             export_group = group is not None and sets in ("all", "group")
             export_background = background_layers_group is not None and sets in ("all", "background")
 
-            result: Dict[str, Union[Dict[str, Dict[str, Any]], List[str]]] = {}
+            result: Dict[str, Union[Dict[str, Any], List[Any]]] = {}
             all_errors: Set[str] = set()
             LOG.debug("Start preload")
             start_time = time.time()
-            asyncio.run(self.preload(all_errors))
+            await self.preload(all_errors)
             LOG.debug("End preload")
             # Don't log if it looks to be already preloaded.
             if (time.time() - start_time) > 1:
                 LOG.info("Do preload in %.3fs.", time.time() - start_time)
             result["ogcServers"] = {}
             for ogc_server in models.DBSession.query(main.OGCServer).all():
+                nb_layers = (
+                    models.DBSession.query(sqlalchemy.func.count(main.LayerWMS.id))
+                    .filter(main.LayerWMS.ogc_server_id == ogc_server.id)
+                    .one()
+                )
+                if nb_layers[0] == 0:
+                    # QGIS Server langing page requires an OGC server that can't be used here.
+                    continue
+
                 url_internal_wfs, url, url_wfs = self.get_url_internal_wfs(ogc_server, all_errors)
 
                 attributes = None
                 namespace = None
-                if ogc_server.wfs_support:
-                    attributes, namespace, errors = self._get_features_attributes(url_internal_wfs)
+                if ogc_server.wfs_support and not url_internal_wfs:
+                    all_errors.add(
+                        f"The OGC server '{ogc_server.name}' is configured to support WFS "
+                        "but no internal WFS URL is found."
+                    )
+                if ogc_server.wfs_support and url_internal_wfs:
+                    attributes, namespace, errors = await self._get_features_attributes(
+                        url_internal_wfs, ogc_server.name
+                    )
                     # Create a local copy (don't modify the cache)
                     if attributes is not None:
                         attributes = dict(attributes)
@@ -1036,8 +1133,8 @@ class Theme:
                                 del attributes[name]
 
                 result["ogcServers"][ogc_server.name] = {
-                    "url": url,
-                    "urlWfs": url_wfs,
+                    "url": url.url() if url else None,
+                    "urlWfs": url_wfs.url() if url_wfs else None,
                     "type": ogc_server.type,
                     "credential": ogc_server.auth != main.OGCSERVER_AUTH_NOAUTH,
                     "imageType": ogc_server.image_type,
@@ -1047,19 +1144,19 @@ class Theme:
                     "attributes": attributes,
                 }
             if export_themes:
-                themes, errors = self._themes(interface, True, min_levels)
+                themes, errors = await self._themes(interface, True, min_levels)
 
                 result["themes"] = themes
                 all_errors |= errors
 
             if export_group:
-                exported_group, errors = self._get_group(group, interface)
+                exported_group, errors = await self._get_group(group, interface)
                 if exported_group is not None:
                     result["group"] = exported_group
                 all_errors |= errors
 
             if export_background:
-                exported_group, errors = self._get_group(background_layers_group, interface)
+                exported_group, errors = await self._get_group(background_layers_group, interface)
                 result["background_layers"] = exported_group["children"] if exported_group is not None else []
                 all_errors |= errors
 
@@ -1068,38 +1165,47 @@ class Theme:
                 LOG.info("Theme errors:\n%s", "\n".join(all_errors))
             return result
 
-        @CACHE_REGION.cache_on_arguments()
-        def get_theme_anonymous(intranet, interface, sets, min_levels, group, background_layers_group, host):
+        @CACHE_REGION.cache_on_arguments()  # type: ignore
+        def get_theme_anonymous(
+            intranet: bool,
+            interface: str,
+            sets: str,
+            min_levels: str,
+            group: str,
+            background_layers_group: str,
+            host: str,
+        ) -> Dict[str, Union[Dict[str, Dict[str, Any]], List[str]]]:
             # Only for cache key
             del intranet, interface, sets, min_levels, group, background_layers_group, host
-            return get_theme()
+            return asyncio.run(get_theme())
 
         if self.request.user is None:
-            return get_theme_anonymous(
-                is_intranet(self.request),
-                interface,
-                sets,
-                min_levels,
-                group,
-                background_layers_group,
-                self.request.headers.get("Host"),
+            return cast(
+                Dict[str, Union[Dict[str, Dict[str, Any]], List[str]]],
+                get_theme_anonymous(
+                    is_intranet(self.request),
+                    interface,
+                    sets,
+                    min_levels,
+                    group,
+                    background_layers_group,
+                    self.request.headers.get("Host"),
+                ),
             )
-        return get_theme()
+        return asyncio.run(get_theme())
 
-    def _get_group(self, group, interface):
+    async def _get_group(
+        self, group: main.LayerGroup, interface: main.Interface
+    ) -> Tuple[Optional[Dict[str, Any]], Set[str]]:
         layers = self._layers(interface)
         try:
             group_db = models.DBSession.query(main.LayerGroup).filter(main.LayerGroup.name == group).one()
-            return self._group(group_db.name, group_db, layers, depth=2, dim=DimensionInformation())
-        except NoResultFound:  # pragma: no cover
+            return await self._group(group_db.name, group_db, layers, depth=2, dim=DimensionInformation())
+        except NoResultFound:
             return (
                 None,
-                set(
-                    [
-                        "Unable to find the Group named: {}, Available Groups: {}".format(
-                            group,
-                            ", ".join([i[0] for i in models.DBSession.query(main.LayerGroup.name).all()]),
-                        )
-                    ]
-                ),
+                {
+                    f"Unable to find the Group named: {group}, Available Groups: "
+                    f"{', '.join([i[0] for i in models.DBSession.query(main.LayerGroup.name).all()])}"
+                },
             )