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

c2cgeoportal_geoportal/__init__.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2011-2021, Camptocamp SA
+# Copyright (c) 2011-2024, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -30,15 +28,22 @@
 import importlib
 import logging
 import os
+from functools import partial
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, cast
 from urllib.parse import urlsplit
 
 import c2cgeoform
 import c2cwsgiutils
 import c2cwsgiutils.db
 import c2cwsgiutils.index
+import pyramid.config
+import pyramid.renderers
+import pyramid.request
+import pyramid.response
 import pyramid.security
 import zope.event.classhandler
 from c2cgeoform import Form, translator
+from c2cwsgiutils.broadcast import decorator
 from c2cwsgiutils.health_check import HealthCheck
 from c2cwsgiutils.metrics import MemoryMapProvider, add_provider
 from dogpile.cache import register_backend
@@ -54,7 +59,7 @@ import c2cgeoportal_geoportal.views
 from c2cgeoportal_commons.models import InvalidateCacheEvent
 from c2cgeoportal_geoportal.lib import C2CPregenerator, caching, check_collector, checker
 from c2cgeoportal_geoportal.lib.cacheversion import version_cache_buster
-from c2cgeoportal_geoportal.lib.caching import NO_CACHE, set_common_headers
+from c2cgeoportal_geoportal.lib.common_headers import Cache, set_common_headers
 from c2cgeoportal_geoportal.lib.i18n import available_locale_names
 from c2cgeoportal_geoportal.lib.metrics import (
     MemoryCacheSizeProvider,
@@ -62,7 +67,11 @@ from c2cgeoportal_geoportal.lib.metrics import (
     TotalPythonObjectMemoryProvider,
 )
 from c2cgeoportal_geoportal.lib.xsd import XSD
-from c2cgeoportal_geoportal.views.entry import Entry
+from c2cgeoportal_geoportal.views.entry import Entry, canvas_view
+
+if TYPE_CHECKING:
+    from c2cgeoportal_commons.models import static  # pylint: disable=ungrouped-imports,useless-suppression
+
 
 LOG = logging.getLogger(__name__)
 
@@ -72,54 +81,132 @@ GEOJSON_CONTENT_TYPE = r"Content-Type:application/geo\+json"
 
 
 class AssetRendererFactory:
-    def __init__(self, info):
+    """Get a renderer for the assets."""
+
+    def __init__(self, info: Any):
         del info  # unused
         self.resolver = AssetResolver("c2cgeoportal_geoportal")
 
-    def __call__(self, value, system):
+    def __call__(self, value: Any, system: Dict[str, str]) -> bytes:
+        del value
         asset = self.resolver.resolve(system["renderer_name"])
-        return asset.stream().read()
+        return cast(bytes, asset.stream().read())
 
 
 INTERFACE_TYPE_NGEO = "ngeo"
+INTERFACE_TYPE_CANVAS = "canvas"
 
 
-def add_interface(
-    config, interface_name="desktop", interface_type=INTERFACE_TYPE_NGEO, default=False, **kwargs
-):  # pragma: no cover
-    del interface_type  # unused
-    route = "/" if default else "/{}".format(interface_name)
-    add_interface_ngeo(
+def add_interface_config(config: pyramid.config.Configurator, interface_config: Dict[str, Any]) -> None:
+    """Add the interface (desktop, mobile, ...) views and routes with only the config."""
+    add_interface(
         config,
-        route_name=interface_name,
-        route=route,
-        renderer="/etc/static-ngeo/{}.html".format(interface_name),
-        **kwargs,
+        interface_config["name"],
+        interface_config.get("type", INTERFACE_TYPE_NGEO),
+        interface_config,
+        default=interface_config.get("default", False),
     )
 
 
-def add_interface_ngeo(config, route_name, route, renderer=None, permission=None):  # pragma: no cover
+def add_interface(
+    config: pyramid.config.Configurator,
+    interface_name: str = "desktop",
+    interface_type: str = INTERFACE_TYPE_NGEO,
+    interface_config: Optional[Dict[str, Any]] = None,
+    default: bool = False,
+    **kwargs: Any,
+) -> None:
+    """Add the interface (desktop, mobile, ...) views and routes."""
+    route = "/" if default else f"/{interface_name}"
+    if interface_type == INTERFACE_TYPE_NGEO:
+        add_interface_ngeo(
+            config,
+            route_name=interface_name,
+            route=route,
+            renderer=f"/etc/static-ngeo/{interface_name}.html",
+            **kwargs,
+        )
+    elif interface_type == INTERFACE_TYPE_CANVAS:
+        assert interface_config is not None
+        add_interface_canvas(
+            config,
+            route_name=interface_name,
+            route=route,
+            interface_config=interface_config,
+            **kwargs,
+        )
+    else:
+        LOG.error(
+            "Unknown interface type '%s', should be '%s' or '%s'.",
+            interface_type,
+            INTERFACE_TYPE_NGEO,
+            INTERFACE_TYPE_CANVAS,
+        )
+
+
+def add_interface_ngeo(
+    config: pyramid.config.Configurator,
+    route_name: str,
+    route: str,
+    renderer: Optional[str] = None,
+    permission: Optional[str] = None,
+) -> None:
+    """Add the ngeo interfaces views and routes."""
 
     config.add_route(route_name, route, request_method="GET")
-    config.add_view(
-        Entry, attr="get_ngeo_index_vars", route_name=route_name, renderer=renderer, permission=permission
-    )
     # Permalink theme: recover the theme for generating custom viewer.js url
     config.add_route(
-        "{}theme".format(route_name),
-        "{}{}theme/{{themes}}".format(route, "" if route[-1] == "/" else "/"),
+        f"{route_name}theme",
+        f"{route}{'' if route[-1] == '/' else '/'}theme/{{themes}}",
         request_method="GET",
     )
+    config.add_view(
+        Entry, attr="get_ngeo_index_vars", route_name=route_name, renderer=renderer, permission=permission
+    )
     config.add_view(
         Entry,
         attr="get_ngeo_index_vars",
-        route_name="{}theme".format(route_name),
+        route_name=f"{route_name}theme",
         renderer=renderer,
         permission=permission,
     )
 
 
-def add_admin_interface(config):
+def add_interface_canvas(
+    config: pyramid.config.Configurator,
+    route_name: str,
+    route: str,
+    interface_config: Dict[str, Any],
+    permission: Optional[str] = None,
+) -> None:
+    """Add the ngeo interfaces views and routes."""
+
+    renderer = f"/etc/geomapfish/interfaces/{route_name}.html.mako"
+    config.add_route(route_name, route, request_method="GET")
+    # Permalink theme: recover the theme for generating custom viewer.js URL
+    config.add_route(
+        f"{route_name}theme",
+        f"{route}{'' if route[-1] == '/' else '/'}theme/{{themes}}",
+        request_method="GET",
+    )
+    view = partial(canvas_view, interface_config=interface_config)
+    view.__module__ = canvas_view.__module__
+    config.add_view(
+        view,
+        route_name=route_name,
+        renderer=renderer,
+        permission=permission,
+    )
+    config.add_view(
+        view,
+        route_name=f"{route_name}theme",
+        renderer=renderer,
+        permission=permission,
+    )
+
+
+def add_admin_interface(config: pyramid.config.Configurator) -> None:
+    """Add the administration interface views and routes."""
     if config.get_settings().get("enable_admin_interface", False):
         config.add_request_method(
             lambda request: c2cgeoportal_commons.models.DBSession(),
@@ -131,7 +218,8 @@ def add_admin_interface(config):
         config.include("c2cgeoportal_admin")
 
 
-def add_getitfixed(config):
+def add_getitfixed(config: pyramid.config.Configurator) -> None:
+    """Add the get it fixed views and routes."""
     if config.get_settings()["getitfixed"].get("enabled", False):
         for route_name, pattern in (
             ("getitfixed_add_ending_slash", "/getitfixed"),
@@ -144,8 +232,9 @@ def add_getitfixed(config):
         Form.set_zpt_renderer(c2cgeoform.default_search_paths, translator=translator)
 
 
-def locale_negotiator(request):
-    lang = request.params.get("lang")
+def locale_negotiator(request: pyramid.request.Request) -> str:
+    """Get the current language."""
+    lang: str = request.params.get("lang")
     if lang is None:
         lang = request.cookies.get("_LOCALE_")
     else:
@@ -159,43 +248,48 @@ def locale_negotiator(request):
     return lang
 
 
-def _match_url_start(reference, value):
-    """
-    Checks that the val URL starts like the ref URL.
-    """
+def _match_url_start(reference: str, value: List[str]) -> bool:
+    """Check that the val URL starts like the ref URL."""
     reference_parts = reference.rstrip("/").split("/")
-    # fmt: off
-    value_parts = value[0:len(reference_parts)]
-    # fmt: on
+    value_parts = value[0 : len(reference_parts)]
     return reference_parts == value_parts
 
 
-def is_valid_referer(request, settings=None):
-    if request.referer is not None:
-        referer = urlsplit(request.referer)._replace(query="", fragment="").geturl().rstrip("/").split("/")
+def is_valid_referrer(request: pyramid.request.Request, settings: Optional[Dict[str, Any]] = None) -> bool:
+    """Check if the referrer is valid."""
+    if request.referrer is not None:
+        referrer = urlsplit(request.referrer)._replace(query="", fragment="").geturl().rstrip("/").split("/")
         if settings is None:
             settings = request.registry.settings
         list_ = settings.get("authorized_referers", [])
-        return any(_match_url_start(e, referer) for e in list_)
+        return any(_match_url_start(e, referrer) for e in list_)
     return True
 
 
-def create_get_user_from_request(settings):
-    def get_user_from_request(request, username=None):
-        """Return the User object for the request.
+def create_get_user_from_request(
+    settings: Dict[str, Any]
+) -> Callable[[pyramid.request.Request, Optional[str]], Optional["static.User"]]:
+    """Get the get_user_from_request function."""
+
+    def get_user_from_request(
+        request: pyramid.request.Request, username: Optional[str] = None
+    ) -> Optional["static.User"]:
+        """
+        Return the User object for the request.
 
         Return ``None`` if:
         * user is anonymous
         * it does not exist in the database
-        * the referer is invalid
+        * it has been deactivated
+        * the referrer is invalid
         """
         from c2cgeoportal_commons.models import DBSession  # pylint: disable=import-outside-toplevel
         from c2cgeoportal_commons.models.static import User  # pylint: disable=import-outside-toplevel
 
         if not hasattr(request, "is_valid_referer"):
-            request.is_valid_referer = is_valid_referer(request, settings)
+            request.is_valid_referer = is_valid_referrer(request, settings)
         if not request.is_valid_referer:
-            LOG.debug("Invalid referer for %s: %s", request.path_qs, repr(request.referer))
+            LOG.debug("Invalid referrer for %s: %s", request.path_qs, repr(request.referrer))
             return None
 
         if not hasattr(request, "user_"):
@@ -206,16 +300,22 @@ def create_get_user_from_request(settings):
                 # We know we will need the role object of the
                 # user so we use joined loading
                 request.user_ = (
-                    DBSession.query(User).filter_by(username=username).options(joinedload("roles")).first()
+                    DBSession.query(User)
+                    .filter_by(username=username, deactivated=False)
+                    .options(joinedload("roles"))
+                    .first()
                 )
 
-        return request.user_
+        return cast(User, request.user_)
 
     return get_user_from_request
 
 
-def set_user_validator(config, user_validator):
-    """Call this function to register a user validator function.
+def set_user_validator(
+    config: pyramid.config.Configurator, user_validator: Callable[[pyramid.request.Request, str, str], str]
+) -> None:
+    """
+    Call this function to register a user validator function.
 
     The validator function is passed three arguments: ``request``,
     ``username``, and ``password``. The function should return the
@@ -231,11 +331,12 @@ def set_user_validator(config, user_validator):
     config.action("user_validator", register)
 
 
-def default_user_validator(request, username, password):
+def default_user_validator(request: pyramid.request.Request, username: str, password: str) -> Optional[str]:
     """
-    Validate the username/password. This is c2cgeoportal's
-    default user validator.
-    Return None if we are anonymous, the string to remember otherwise.
+    Validate the username/password.
+
+    This is c2cgeoportal's default user validator. Return None if we are anonymous, the string to remember
+    otherwise.
     """
     del request  # unused
     from c2cgeoportal_commons.models import DBSession  # pylint: disable=import-outside-toplevel
@@ -243,7 +344,7 @@ def default_user_validator(request, username, password):
 
     user = DBSession.query(User).filter_by(username=username).first()
     if user is None:
-        LOG.info('Unknow user "%s" tried to log in', username)
+        LOG.info('Unknown user "%s" tried to log in', username)
         return None
     if user.deactivated:
         LOG.info('Deactivated user "%s" tried to log in', username)
@@ -258,49 +359,52 @@ def default_user_validator(request, username, password):
 
 
 class MapserverproxyRoutePredicate:
-    """Serve as a custom route predicate function for mapserverproxy.
-    If the hide_capabilities setting is set and is true then we want to
-    return 404s on GetCapabilities requests."""
+    """
+    Serve as a custom route predicate function for mapserverproxy.
 
-    def __init__(self, val, config):
-        pass
+    If the hide_capabilities setting is set and is true then we want to return 404s on GetCapabilities
+    requests.
+    """
 
-    def __call__(self, context, request):
+    def __init__(self, val: Any, config: pyramid.config.Configurator) -> None:
+        del val, config
+
+    def __call__(self, context: Any, request: pyramid.request.Request) -> bool:
+        del context
         hide_capabilities = request.registry.settings.get("hide_capabilities")
         if not hide_capabilities:
             return True
-        params = dict((k.lower(), v.lower()) for k, v in request.params.items())
+        params = {k.lower(): v.lower() for k, v in request.params.items()}
         return "request" not in params or params["request"] not in ("getcapabilities", "capabilities")
 
     @staticmethod
-    def text():
+    def text() -> str:
         return "mapserverproxy"
 
     phash = text
 
 
-def add_cors_route(config, pattern, service):
-    """
-    Add the OPTIONS route and view need for services supporting CORS.
-    """
+def add_cors_route(config: pyramid.config.Configurator, pattern: str, service: str) -> None:
+    """Add the OPTIONS route and view need for services supporting CORS."""
 
-    def view(request):  # pragma: no cover
-        return set_common_headers(request, service, NO_CACHE)
+    def view(request: pyramid.request.Request) -> pyramid.response.Response:
+        return set_common_headers(request, service, Cache.PRIVATE_NO)
 
     name = pattern + "_options"
     config.add_route(name, pattern, request_method="OPTIONS")
     config.add_view(view, route_name=name)
 
 
-def error_handler(http_exception, request):  # pragma: no cover
-    """
-    View callable for handling all the exceptions that are not already handled.
-    """
+def error_handler(
+    http_exception: HTTPException, request: pyramid.request.Request
+) -> pyramid.response.Response:
+    """View callable for handling all the exceptions that are not already handled."""
     LOG.warning("%s returned status code %s", request.url, http_exception.status_code)
-    return caching.set_common_headers(request, "error", caching.NO_CACHE, http_exception)
+    return set_common_headers(request, "error", Cache.PRIVATE_NO, http_exception)
 
 
-def call_hook(settings, name, *args, **kwargs):
+def call_hook(settings: pyramid.config.Configurator, name: str, *args: Any, **kwargs: Any) -> None:
+    """Call the hook defined in the settings."""
     hooks = settings.get("hooks", {})
     hook = hooks.get(name)
     if hook is None:
@@ -311,11 +415,8 @@ def call_hook(settings, name, *args, **kwargs):
     function_(*args, **kwargs)
 
 
-def includeme(config: pyramid.config.Configurator):
-    """
-    This function returns a Pyramid WSGI application.
-    """
-
+def includeme(config: pyramid.config.Configurator) -> None:
+    """Get the Pyramid WSGI application."""
     settings = config.get_settings()
 
     if "available_locale_names" not in settings:
@@ -327,7 +428,7 @@ def includeme(config: pyramid.config.Configurator):
     config.add_request_method(get_user_from_request, name="user", property=True)
     config.add_request_method(get_user_from_request, name="get_user")
     # Be able for an organization to override the method to use alternate:
-    # - Organization roles name for the standard roles 'anonymous', 'registred' and 'intranet'.
+    # - Organization roles name for the standard roles 'anonymous', 'registered' and 'intranet'.
     config.add_request_method(lambda request, role_type: role_type, name="get_organization_role")
     # - Organization print URL
     config.add_request_method(
@@ -339,6 +440,7 @@ def includeme(config: pyramid.config.Configurator):
     # Configure 'locale' dir as the translation dir for c2cgeoportal app
     config.add_translation_dirs("c2cgeoportal_geoportal:locale/")
 
+    config.include("pyramid_mako")
     config.include("c2cwsgiutils.pyramid.includeme")
     health_check = HealthCheck(config)
     config.registry["health_check"] = health_check
@@ -355,8 +457,8 @@ def includeme(config: pyramid.config.Configurator):
     if metrics_config["total_python_object_memory"]:
         add_provider(TotalPythonObjectMemoryProvider())
 
-    # Initialise DBSessions
-    init_dbsessions(settings, config, health_check)
+    # Initialize DBSessions
+    init_db_sessions(settings, config, health_check)
 
     checker.init(config, health_check)
     check_collector.init(config, health_check)
@@ -370,17 +472,19 @@ def includeme(config: pyramid.config.Configurator):
         for name, cache_config in settings["cache"].items():
             caching.init_region(cache_config, name)
 
-            @zope.event.classhandler.handler(InvalidateCacheEvent)
-            def handle(event: InvalidateCacheEvent):  # pylint: disable=unused-variable
-                del event
-                caching.invalidate_region()
-                if caching.MEMORY_CACHE_DICT:
-                    caching.get_region("std").delete_multi(list(caching.MEMORY_CACHE_DICT.keys()))
-                caching.MEMORY_CACHE_DICT.clear()
+        @zope.event.classhandler.handler(InvalidateCacheEvent)  # type: ignore
+        def handle(event: InvalidateCacheEvent) -> None:
+            del event
+            caching.invalidate_region("ogc-server")
+            caching.invalidate_region("std")
+            caching.invalidate_region("obj")
+            if caching.MEMORY_CACHE_DICT:
+                caching.get_region("std").delete_multi(list(caching.MEMORY_CACHE_DICT.keys()))
+            caching.MEMORY_CACHE_DICT.clear()
 
     # Register a tween to get back the cache buster path.
     if "cache_path" not in config.get_settings():
-        config.get_settings()["cache_path"] = ["static"]
+        config.get_settings()["cache_path"] = ["static", "static-geomapfish"]
     config.add_tween("c2cgeoportal_geoportal.lib.cacheversion.CachebusterTween")
     config.add_tween("c2cgeoportal_geoportal.lib.headers.HeadersTween")
 
@@ -398,8 +502,10 @@ def includeme(config: pyramid.config.Configurator):
     config.add_directive("set_user_validator", set_user_validator)
     config.set_user_validator(default_user_validator)
 
+    config.add_route("oauth2introspect", "/oauth/introspect", request_method="POST")
     config.add_route("oauth2token", "/oauth/token", request_method="POST")
     config.add_route("oauth2loginform", "/oauth/login", request_method="GET")
+    config.add_route("oauth2revoke_token", "/oauth/revoke_token", request_method="GET")
     config.add_route("notlogin", "/notlogin", request_method="GET")
 
     config.add_route("dynamic", "/dynamic.json", request_method="GET")
@@ -420,6 +526,22 @@ def includeme(config: pyramid.config.Configurator):
         pregenerator=C2CPregenerator(role=True),
         request_method="POST",
     )
+    # The tow next views are used to serve the application on the URL /mapserv_proxy/<ogc server name>
+    # instead of /mapserv_proxy?ogcserver=<ogc server name>, required for QGIS server landing page
+    config.add_route(
+        "mapserverproxy_get_path",
+        "/mapserv_proxy/{ogcserver}/*path",
+        mapserverproxy=True,
+        pregenerator=C2CPregenerator(role=True),
+        request_method="GET",
+    )
+    config.add_route(
+        "mapserverproxy_post_path",
+        "/mapserv_proxy/{ogcserver}/*path",
+        mapserverproxy=True,
+        pregenerator=C2CPregenerator(role=True),
+        request_method="POST",
+    )
     add_cors_route(config, "/mapserv_proxy", "mapserver")
 
     # Add route to the tinyows proxy
@@ -444,14 +566,15 @@ def includeme(config: pyramid.config.Configurator):
     config.add_renderer(".css", AssetRendererFactory)
     config.add_renderer(".ico", AssetRendererFactory)
     config.add_route("localejson", "/locale.json", request_method="GET")
+    config.add_route("localepot", "/locale.pot", request_method="GET")
 
-    def add_static_route(name: str, attr: str, path: str, renderer: str):
+    def add_static_route(name: str, attr: str, path: str, renderer: str) -> None:
         config.add_route(name, path, request_method="GET")
         config.add_view(Entry, attr=attr, route_name=name, renderer=renderer)
 
     add_static_route("favicon", "favicon", "/favicon.ico", "/etc/geomapfish/static/images/favicon.ico")
     add_static_route("robot.txt", "robot_txt", "/robot.txt", "/etc/geomapfish/static/robot.txt")
-    add_static_route("apijs", "apijs", "/api.js", "/etc/static-ngeo/api.js")
+    config.add_route("apijs", "/api.js", request_method="GET")
     add_static_route("apijsmap", "apijsmap", "/api.js.map", "/etc/static-ngeo/api.js.map")
     add_static_route("apicss", "apicss", "/api.css", "/etc/static-ngeo/api.css")
     add_static_route("apihelp", "apihelp", "/apihelp/index.html", "/etc/geomapfish/static/apihelp/index.html")
@@ -491,6 +614,13 @@ def includeme(config: pyramid.config.Configurator):
     add_cors_route(config, "/profile.json", "profile")
     config.add_route("profile.json", "/profile.json", request_method="POST")
 
+    # Access to vector tiles
+    add_cors_route(config, "/vector_tiles", "vector_tiles")
+    config.add_route("vector_tiles", "/vector_tiles/{layer_name}/{z}/{x}/{y}.pbf", request_method="GET")
+    # There is no view corresponding to that route, it is to be used from
+    # mako templates to get the root of the "vector_tiles" web service
+    config.add_route("vector_tiles_root", "/vector_tiles", request_method="HEAD")
+
     # Shortener
     add_cors_route(config, "/short/create", "shortener")
     config.add_route("shortener_create", "/short/create", request_method="POST")
@@ -544,6 +674,8 @@ def includeme(config: pyramid.config.Configurator):
     # Used memory in caches
     config.add_route("memory", "/memory", request_method="GET")
 
+    config.add_route("ogc_server_clear_cache", "clear-ogc-server-cache/{id}", request_method="GET")
+
     # Scan view decorator for adding routes
     config.scan(
         ignore=[
@@ -571,6 +703,21 @@ def includeme(config: pyramid.config.Configurator):
         cache_max_age=int(config.get_settings()["default_max_age"]),
     )
 
+    # Add the c2cgeoportal static view with cache buster
+    config.add_static_view(
+        name="static-geomapfish",
+        path="c2cgeoportal_geoportal:static",
+        cache_max_age=int(config.get_settings()["default_max_age"]),
+    )
+    config.add_cache_buster("c2cgeoportal_geoportal:static", version_cache_buster)
+
+    # Add the project static view without cache buster
+    config.add_static_view(
+        name="static-ngeo-dist",
+        path="/opt/c2cgeoportal/geoportal/node_modules/ngeo/dist",
+        cache_max_age=int(config.get_settings()["default_max_age"]),
+    )
+
     # Handles the other HTTP errors raised by the views. Without that,
     # the client receives a status=200 without content.
     config.add_view(error_handler, context=HTTPException)
@@ -603,7 +750,10 @@ def includeme(config: pyramid.config.Configurator):
     c2cwsgiutils.index.additional_noauth.append("</div></div><hr>")
 
 
-def init_dbsessions(settings: dict, config: Configurator, health_check: HealthCheck = None) -> None:
+def init_db_sessions(
+    settings: Dict[str, Any], config: Configurator, health_check: Optional[HealthCheck] = None
+) -> None:
+    """Initialize the database sessions."""
     db_chooser = settings.get("db_chooser", {})
     master_paths = [i.replace("//", "/") for i in db_chooser.get("master", [])]
     slave_paths = [i.replace("//", "/") for i in db_chooser.get("slave", [])]
@@ -644,7 +794,7 @@ def init_dbsessions(settings: dict, config: Configurator, health_check: HealthCh
                         version_schema=settings["schema_static"],
                         level=1,
                     )
-            else:  # pragma: no cover
+            else:
 
                 def check(session_: Session) -> None:
                     session_.execute("SELECT 1")