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

c2cgeoportal_geoportal/lib/checker.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 # Copyright (c) 2011-2021, Camptocamp SA
 # All rights reserved.
 
@@ -32,17 +30,21 @@ import logging
 import os
 import subprocess
 from time import sleep
-from typing import Dict
+from typing import Any, Dict, List, Mapping, Optional, Union, cast
 from urllib.parse import urljoin
 
 import c2cwsgiutils.health_check
+import pyramid.config
+import pyramid.request
 import requests
 
 LOG = logging.getLogger(__name__)
 
 
-def build_url(name, path, request, headers=None):
-    """Build an URL and headers for the checkers"""
+def build_url(
+    name: str, path: str, request: pyramid.request.Request, headers: Optional[Dict[str, str]] = None
+) -> Dict[str, Union[str, Dict[str, str]]]:
+    """Build an URL and headers for the checkers."""
     base_internal_url = request.registry.settings["checker"]["base_internal_url"]
     url = urljoin(base_internal_url, path)
 
@@ -55,7 +57,9 @@ def build_url(name, path, request, headers=None):
     return {"url": url, "headers": headers}
 
 
-def _build_headers(request, headers=None):
+def _build_headers(
+    request: pyramid.request.Request, headers: Optional[Dict[str, str]] = None
+) -> Dict[str, str]:
     if headers is None:
         headers = {}
     headers["Cache-Control"] = "no-cache"
@@ -67,45 +71,43 @@ def _build_headers(request, headers=None):
     return headers
 
 
-def _routes(settings, health_check):
+def _routes(settings: Dict[str, Any], health_check: c2cwsgiutils.health_check.HealthCheck) -> None:
     routes_settings = settings["routes"]
     for route in routes_settings["routes"]:
         if route.get("checker_name", route["name"]) not in routes_settings["disable"]:
             name = "checker_routes_" + route.get("checker_name", route["name"])
 
             class GetRequest:
-                """
-                Get the request information about the current route name
-                """
+                """Get the request information about the current route name."""
 
-                def __init__(self, route_name, type_):
+                def __init__(self, route_name: str, type_: str) -> None:
                     self.route_name = route_name
                     self.type = type_
 
-                def __call__(self, request):
+                def __call__(self, request: pyramid.request.Request) -> Union[str, Dict[str, str]]:
                     return build_url("route", request.route_path(self.route_name), request)[self.type]
 
             health_check.add_url_check(
-                url=GetRequest(route["name"], "url"),
+                url=GetRequest(route["name"], "url"),  # type: ignore
                 name=name,
                 params=route.get("params", None),
-                headers=GetRequest(route["name"], "headers"),
+                headers=GetRequest(route["name"], "headers"),  # type: ignore
                 level=route["level"],
                 timeout=30,
             )
 
 
-def _pdf3(settings, health_check):
+def _pdf3(settings: Dict[str, Any], health_check: c2cwsgiutils.health_check.HealthCheck) -> None:
     print_settings = settings["print"]
     if "spec" not in print_settings:
         return
 
-    def check(request):
+    def check(request: pyramid.request.Request) -> None:
         path = request.route_path("printproxy_report_create", format="pdf")
         url_headers = build_url("Check the printproxy request (create)", path, request)
 
         session = requests.session()
-        resp = session.post(json=print_settings["spec"], timeout=30, **url_headers)
+        resp = session.post(json=print_settings["spec"], timeout=30, **url_headers)  # type: ignore
         resp.raise_for_status()
 
         job = resp.json()
@@ -115,44 +117,44 @@ def _pdf3(settings, health_check):
         done = False
         while not done:
             sleep(1)
-            resp = session.get(timeout=30, **url_headers)
+            resp = session.get(timeout=30, **url_headers)  # type: ignore
             resp.raise_for_status()
 
             status = resp.json()
             if "error" in status:
-                raise Exception("Failed to do the printing: {0!s}".format(status["error"]))
+                raise Exception(f"Failed to do the printing: {status['error']}")
             done = status["done"]
 
         path = request.route_path("printproxy_report_get", ref=job["ref"])
         url_headers = build_url("Check the printproxy pdf retrieve", path, request)
-        resp = session.get(timeout=30, **url_headers)
+        resp = session.get(timeout=30, **url_headers)  # type: ignore
         resp.raise_for_status()
 
     health_check.add_custom_check(name="checker_print", check_cb=check, level=print_settings["level"])
 
 
-def _fts(settings, health_check):
+def _fts(settings: Dict[str, Any], health_check: c2cwsgiutils.health_check.HealthCheck) -> None:
     fts_settings = settings["fulltextsearch"]
     if fts_settings.get("disable", False):
         return
 
-    def get_both(request):
+    def get_both(request: pyramid.request.Request) -> Dict[str, Union[str, Dict[str, str]]]:
         return build_url("Check the fulltextsearch", request.route_path("fulltextsearch"), request)
 
-    def check(_request, response):
+    def check(_request: pyramid.request.Request, response: pyramid.response.Response) -> None:
         assert response.json()["features"], "No result"
 
     health_check.add_url_check(
         name="checker_fulltextsearch",
-        url=lambda r: get_both(r)["url"],
-        headers=lambda r: get_both(r)["headers"],
+        url=lambda r: get_both(r)["url"],  # type: ignore
+        headers=lambda r: get_both(r)["headers"],  # type: ignore
         params={"query": fts_settings["search"], "limit": "1"},
         check_cb=check,
         level=fts_settings["level"],
     )
 
 
-def _themes_errors(settings, health_check):
+def _themes_errors(settings: Dict[str, Any], health_check: c2cwsgiutils.health_check.HealthCheck) -> None:
     from c2cgeoportal_commons.models import DBSession  # pylint: disable=import-outside-toplevel
     from c2cgeoportal_commons.models.main import Interface  # pylint: disable=import-outside-toplevel
 
@@ -160,7 +162,7 @@ def _themes_errors(settings, health_check):
     default_params = themes_settings.get("params", {})
     interfaces_settings = themes_settings["interfaces"]
 
-    def check(request):
+    def check(request: pyramid.request.Request) -> None:
         path = request.route_path("themes")
         session = requests.session()
         for (interface,) in DBSession.query(Interface.name).all():
@@ -171,52 +173,51 @@ def _themes_errors(settings, health_check):
 
             interface_url_headers = build_url("checker_themes " + interface, path, request)
 
-            response = session.get(params=params, timeout=120, **interface_url_headers)
+            response = session.get(params=params, timeout=120, **interface_url_headers)  # type: ignore
             response.raise_for_status()
 
             result = response.json()
             if result["errors"]:
                 raise c2cwsgiutils.health_check.JsonCheckException(
-                    "Interface '{}' has error in Theme.".format(interface), result["errors"]
+                    f"Interface '{interface}' has error in Theme.", result["errors"]
                 )
 
     health_check.add_custom_check(name="checker_themes", check_cb=check, level=themes_settings["level"])
 
 
-def _lang_files(global_settings, settings, health_check):
+def _lang_files(
+    global_settings: Dict[str, Any],
+    settings: Dict[str, Any],
+    health_check: c2cwsgiutils.health_check.HealthCheck,
+) -> None:
     lang_settings = settings["lang"]
     available_locale_names = global_settings["available_locale_names"]
 
     default_name = global_settings["default_locale_name"]
-    assert (
-        default_name in available_locale_names
-    ), "default_locale_name '{}' not in available_locale_names: {}".format(
-        default_name, ", ".join(available_locale_names)
+    assert default_name in available_locale_names, (
+        f"default_locale_name '{default_name}' not in available_locale_names: "
+        f"{', '.join(available_locale_names)}"
     )
 
     for type_ in lang_settings.get("files", []):
         for lang in available_locale_names:
             if type_ == "ngeo":
-                url = "/etc/geomapfish/static/{lang}.json"
+                url = f"/etc/geomapfish/static/{lang}.json"
             else:
-                raise Exception(
-                    "Your language type value '%s' is not valid, " "available values [ngeo]" % type_
-                )
+                raise Exception(f"Your language type value '{type_}' is not valid, available values [ngeo]")
 
-            name = "checker_lang_{}_{}".format(type_, lang)
+            name = f"checker_lang_{type_}_{lang}"
 
             class GetRequest:
-                """
-                Get the request information about the current route name
-                """
+                """Get the request information about the current route name."""
 
-                def __init__(self, name, url, lang, type_):
+                def __init__(self, name: str, url: str, lang: str, type_: str) -> None:
                     self.name = name
                     self.url = url
                     self.lang = lang
                     self.type = type_
 
-                def __call__(self, request):
+                def __call__(self, request: pyramid.request.Request) -> Union[str, Mapping[str, str]]:
                     return build_url(
                         self.name,
                         request.static_path(
@@ -227,27 +228,27 @@ def _lang_files(global_settings, settings, health_check):
 
             health_check.add_url_check(
                 name=name,
-                url=GetRequest(name, url, lang, "url"),
-                headers=GetRequest(name, url, lang, "headers"),
+                url=GetRequest(name, url, lang, "url"),  # type: ignore
+                headers=GetRequest(name, url, lang, "headers"),  # type: ignore
                 level=lang_settings["level"],
             )
 
 
-def _phantomjs(settings, health_check):
+def _phantomjs(settings: Dict[str, Any], health_check: c2cwsgiutils.health_check.HealthCheck) -> None:
     phantomjs_settings = settings["phantomjs"]
     for route in phantomjs_settings["routes"]:
         if route.get("checker_name", route["name"]) in phantomjs_settings["disable"]:
             continue
 
         class _Check:
-            def __init__(self, route):
+            def __init__(self, route: Dict[str, Any]) -> None:
                 self.route = route
 
-            def __call__(self, request):
+            def __call__(self, request: pyramid.request.Request) -> None:
                 path = request.route_path(self.route["name"], _query=self.route.get("params", {}))
-                url = build_url("Check", path, request)["url"]
+                url: str = cast(str, build_url("Check", path, request)["url"])
 
-                cmd = ["node", "/usr/bin/check-example.js", url]
+                cmd: List[str] = ["node", "/usr/bin/check-example.js", url]
                 env = dict(os.environ)
                 for name, value in self.route.get("environment", {}).items():
                     if isinstance(value, (list, dict)):
@@ -260,26 +261,23 @@ def _phantomjs(settings, health_check):
                     subprocess.check_output(cmd, env=env, timeout=70)
                 except subprocess.CalledProcessError as exception:
                     raise Exception(
-                        "{} exit with code: {}\n{}".format(
-                            " ".join(exception.cmd), exception.returncode, exception.output.decode("utf-8")
-                        )
-                    )
+                        f"{' '.join(exception.cmd)} exit with code: {exception.returncode}\n"
+                        f"{exception.output.decode('utf-8')[:10000]}"
+                    ) from exception
                 except subprocess.TimeoutExpired as exception:
                     raise Exception(
-                        """Timeout:
-command: {}
+                        f"""Timeout:
+command: {' '.join(exception.cmd)}
 output:
-{}""".format(
-                            " ".join(exception.cmd), exception.output.decode("utf-8")
-                        )
-                    )
+{exception.output.decode('utf-8')}"""
+                    ) from exception
 
         name = "checker_phantomjs_" + route.get("checker_name", route["name"])
         health_check.add_custom_check(name=name, check_cb=_Check(route), level=route["level"])
 
 
-def init(config, health_check):
-    """Init the ckeckers"""
+def init(config: pyramid.config.Configurator, health_check: c2cwsgiutils.health_check.HealthCheck) -> None:
+    """Initialize the checkers."""
     global_settings = config.get_settings()
     if "checker" not in global_settings:
         return

c2cgeoportal_geoportal/lib/common_headers.py

@@ -0,0 +1,170 @@
+# Copyright (c) 2012-2021, Camptocamp SA
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# The views and conclusions contained in the software and documentation are those
+# of the authors and should not be interpreted as representing official policies,
+# either expressed or implied, of the FreeBSD Project.
+
+
+import logging
+from enum import Enum
+from typing import Any, Dict, List, Optional, cast
+
+import pyramid.request
+import pyramid.response
+
+from c2cgeoportal_geoportal.lib import is_intranet
+
+_LOG = logging.getLogger(__name__)
+
+
+class Cache(Enum):
+    """Enumeration for the possible cache values."""
+
+    # For responses that do not depend on authentication
+    PUBLIC = 0
+    # For responses that do not depends on authentication
+    # We use a small cache (e.g. 10s) instead of no cache to protect the service against too high traffic.
+    PUBLIC_NO = 1
+    # For responses that can depend on authentication
+    PRIVATE = 2
+    # See PUBLIC_NO and PRIVATE
+    PRIVATE_NO = 3
+
+
+CORS_METHODS = "HEAD, GET, POST, PUT, DELETE"
+
+
+def _set_cors_headers(
+    request: pyramid.request.Request,
+    response: pyramid.response.Response,
+    service_name: str,
+    service_headers_settings: Dict[str, Any],
+    credentials: bool,
+) -> None:
+    """Handle CORS requests, as specified in https://www.w3.org/TR/cors/."""
+    response.vary = (response.vary or ()) + ("Origin",)
+
+    if "Origin" not in request.headers:
+        return  # Not a CORS request if this header is missing
+    origin = request.headers["Origin"]
+
+    if request.method == "OPTIONS" and "Access-Control-Request-Method" not in request.headers:
+        _LOG.warning("CORS preflight query missing the Access-Control-Request-Method header")
+        return
+
+    allowed_origins = cast(List[str], service_headers_settings.get("access_control_allow_origin", []))
+    if origin not in allowed_origins:
+        if "*" in allowed_origins:
+            origin = "*"
+            credentials = False  # Force no credentials
+        else:
+            _LOG.warning("CORS query not allowed for origin=%s, service=%s", origin, service_name)
+            return
+
+    response.headers.update(
+        {"Access-Control-Allow-Origin": origin, "Access-Control-Allow-Methods": CORS_METHODS}
+    )
+
+    max_age = service_headers_settings.get("access_control_max_age", 3600)
+    response.headers["Access-Control-Max-Age"] = str(max_age)
+
+    if credentials:
+        response.headers["Access-Control-Allow-Credentials"] = "true"
+
+    if request.method != "OPTIONS":
+        return
+
+    response.cache_control.max_age = max_age
+
+    if not service_headers_settings or "access_control_allow_origin" not in service_headers_settings:
+        _LOG.warning("CORS query not configured for service=%s", service_name)
+        return
+
+    requested_headers = request.headers.get("Access-Control-Request-Headers", False)
+    if requested_headers:
+        # For the moment, we allow all requested headers
+        response.headers["Access-Control-Allow-Headers"] = requested_headers
+
+    # If we start using headers in responses, we'll have to add
+    # Access-Control-Expose-Headers
+
+
+def _set_common_headers(
+    request: pyramid.request.Request,
+    response: pyramid.response.Response,
+    service_headers_settings: Dict[str, Dict[str, str]],
+    cache: Cache,
+    content_type: Optional[str],
+) -> pyramid.response.Response:
+    """Set the common headers."""
+
+    response.headers.update(service_headers_settings.get("headers", {}))
+
+    if cache in (Cache.PRIVATE, Cache.PRIVATE_NO):
+        response.vary = (response.vary or ()) + ("Cookie",)
+
+    maxage = (
+        service_headers_settings.get("cache_control_max_age", 3600)
+        if cache in (Cache.PUBLIC, Cache.PRIVATE)
+        else service_headers_settings.get("cache_control_max_age_nocache", 10)
+    )
+    response.cache_control.max_age = maxage
+    if maxage == 0:
+        response.cache_control.no_cache = True
+        response.cache_control.no_store = True
+    elif cache in (Cache.PUBLIC, Cache.PUBLIC_NO):
+        response.cache_control.public = True
+    elif cache in (Cache.PRIVATE, Cache.PRIVATE_NO):
+        if hasattr(request, "user") and request.user is not None or is_intranet(request):
+            response.cache_control.private = True
+        else:
+            response.cache_control.public = True
+    else:
+        raise Exception("Invalid cache type")
+
+    if content_type is not None:
+        response.content_type = content_type
+
+    return response
+
+
+def set_common_headers(
+    request: pyramid.request.Request,
+    service_name: str,
+    cache: Cache,
+    response: pyramid.response.Response = None,
+    credentials: bool = True,
+    content_type: Optional[str] = None,
+) -> pyramid.response.Response:
+    """Set the common headers."""
+    if response is None:
+        response = request.response
+
+    headers_settings = request.registry.settings.get("headers", {})
+    service_headers_settings = headers_settings.get(service_name, {})
+
+    _set_cors_headers(request, response, service_name, service_headers_settings, credentials)
+    if request.method == "OPTIONS":
+        return response
+    return _set_common_headers(request, response, service_headers_settings, cache, content_type)

c2cgeoportal_geoportal/lib/dbreflection.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 # Copyright (c) 2011-2021, Camptocamp SA
 # All rights reserved.
 
@@ -26,15 +24,18 @@
 # The views and conclusions contained in the software and documentation are those
 # of the authors and should not be interpreted as representing official policies,
 # either expressed or implied, of the FreeBSD Project.
+
+import random
 import threading
 import warnings
-from typing import Dict, Tuple  # noqa, pylint: disable=unused-import
+from typing import Dict, Iterable, List, Optional, Tuple, Union
 
+import sqlalchemy.ext.declarative
 from papyrus.geo_interface import GeoInterface
 from sqlalchemy import Column, Integer, MetaData, Table
 from sqlalchemy.exc import SAWarning
-from sqlalchemy.ext.declarative.api import DeclarativeMeta  # noqa, pylint: disable=unused-import
 from sqlalchemy.orm import relationship
+from sqlalchemy.orm.session import Session
 from sqlalchemy.orm.util import class_mapper
 
 from c2cgeoportal_geoportal.lib.caching import get_region
@@ -53,13 +54,17 @@ SQL_GEOMETRY_COLUMNS = """
 class _AssociationProxy:
     # A specific "association proxy" implementation
 
-    def __init__(self, target, value_attr, nullable=True, order_by=None):
+    def __init__(self, target: str, value_attr: str, nullable: bool = True, order_by: Optional[str] = None):
         self.target = target
         self.value_attr = value_attr
         self.nullable = nullable
         self.order_by = order_by
 
-    def __get__(self, obj, type_=None):
+    def __get__(
+        self,
+        obj: sqlalchemy.ext.declarative.ConcreteBase,
+        type_: sqlalchemy.ext.declarative.DeclarativeMeta = None,
+    ) -> Optional[Union["_AssociationProxy", str]]:
         if obj is None:
             # For "hybrid" descriptors that work both at the instance
             # and class levels we could return an SQL expression here.
@@ -69,7 +74,7 @@ class _AssociationProxy:
         target = getattr(obj, self.target)
         return getattr(target, self.value_attr) if target else None
 
-    def __set__(self, obj, val):
+    def __set__(self, obj: str, val: str) -> None:
         from c2cgeoportal_commons.models import DBSession  # pylint: disable=import-outside-toplevel
 
         o = getattr(obj, self.target)
@@ -83,7 +88,7 @@ class _AssociationProxy:
             setattr(obj, self.target, o)
 
 
-def _get_schema(tablename):
+def _get_schema(tablename: str) -> Tuple[str, str]:
     if "." in tablename:
         schema, tablename = tablename.split(".", 1)
     else:
@@ -95,7 +100,13 @@ def _get_schema(tablename):
 _get_table_lock = threading.RLock()
 
 
-def get_table(tablename, schema=None, session=None, primary_key=None):
+def get_table(
+    tablename: str,
+    schema: Optional[str] = None,
+    session: Optional[Session] = None,
+    primary_key: Optional[str] = None,
+) -> Table:
+    """Build an SQLAlchemy table."""
     if schema is None:
         tablename, schema = _get_schema(tablename)
 
@@ -103,8 +114,8 @@ def get_table(tablename, schema=None, session=None, primary_key=None):
         engine = session.bind.engine
         metadata = MetaData(bind=engine)
     else:
+        from c2cgeoportal_commons.models import Base  # pylint: disable=import-outside-toplevel
         from c2cgeoportal_commons.models import DBSession  # pylint: disable=import-outside-toplevel
-        from c2cgeoportal_commons.models.main import Base  # pylint: disable=import-outside-toplevel
 
         engine = DBSession.bind.engine
         metadata = Base.metadata
@@ -121,21 +132,21 @@ def get_table(tablename, schema=None, session=None, primary_key=None):
     return table
 
 
-@CACHE_REGION_OBJ.cache_on_arguments()
+@CACHE_REGION_OBJ.cache_on_arguments()  # type: ignore
 def get_class(
-    tablename,
-    exclude_properties=None,
-    primary_key=None,
-    attributes_order=None,
-    enumerations_config=None,
-    readonly_attributes=None,
-):
+    tablename: str,
+    exclude_properties: Optional[List[str]] = None,
+    primary_key: Optional[str] = None,
+    attributes_order: Optional[List[str]] = None,
+    enumerations_config: Optional[Dict[str, str]] = None,
+    readonly_attributes: Optional[List[str]] = None,
+) -> sqlalchemy.ext.declarative.DeclarativeMeta:
     """
-    Get the SQLAlchemy mapped class for "tablename". If no class exists
-    for "tablename" one is created, and added to the cache. "tablename"
-    must reference a valid string. If there is no table identified by
-    tablename in the database a NoSuchTableError SQLAlchemy exception
-    is raised.
+    Get the SQLAlchemy mapped class for "tablename".
+
+    If no class exists for "tablename" one is created, and added to the cache. "tablename" must reference a
+    valid string. If there is no table identified by tablename in the database a NoSuchTableError SQLAlchemy
+    exception is raised.
     """
 
     tablename, schema = _get_schema(tablename)
@@ -155,14 +166,14 @@ def get_class(
 
 
 def _create_class(
-    table,
-    exclude_properties=None,
-    attributes_order=None,
-    enumerations_config=None,
-    readonly_attributes=None,
-    pk_name=None,
-):
-    from c2cgeoportal_commons.models.main import Base  # pylint: disable=import-outside-toplevel
+    table: Table,
+    exclude_properties: Optional[Iterable[str]] = None,
+    attributes_order: Optional[List[str]] = None,
+    enumerations_config: Optional[Dict[str, str]] = None,
+    readonly_attributes: Optional[List[str]] = None,
+    pk_name: Optional[str] = None,
+) -> sqlalchemy.ext.declarative.DeclarativeMeta:
+    from c2cgeoportal_commons.models import Base  # pylint: disable=import-outside-toplevel
 
     exclude_properties = exclude_properties or ()
     attributes = dict(
@@ -173,7 +184,11 @@ def _create_class(
     )
     if pk_name is not None:
         attributes[pk_name] = Column(Integer, primary_key=True)
-    cls = type(table.name.capitalize(), (GeoInterface, Base), attributes)
+    # The randint is to fix the SAWarning: This declarative base already contains a class with the same
+    # class name and module nam
+    cls = type(
+        f"{table.name.capitalize()}_{random.randint(0, 9999999)}", (GeoInterface, Base), attributes  # nosec
+    )
 
     for col in table.columns:
         if col.name in (readonly_attributes or []):
@@ -184,8 +199,10 @@ def _create_class(
     return cls
 
 
-def _add_association_proxy(cls, col):
-    if len(col.foreign_keys) != 1:  # pragma: no cover
+def _add_association_proxy(
+    cls: sqlalchemy.ext.declarative.DeclarativeMeta, col: sqlalchemy.sql.schema.Column
+) -> None:
+    if len(col.foreign_keys) != 1:
         raise NotImplementedError
 
     fk = next(iter(col.foreign_keys))
@@ -193,10 +210,8 @@ def _add_association_proxy(cls, col):
     child_cls = get_class(child_tablename)
 
     try:
-        # fmt: off
-        proxy = col.name[0:col.name.rindex("_id")]
-        # fmt: on
-    except ValueError:  # pragma: no cover
+        proxy = col.name[0 : col.name.rindex("_id")]
+    except ValueError:
         proxy = col.name + "_"
 
     # The following is a workaround for a bug in the geojson lib. The
@@ -204,7 +219,7 @@ def _add_association_proxy(cls, col):
     # (this is a GeoJSON keyword), and produces a UnicodeEncodeError
     # if the property includes non-ascii characters.
     if proxy == "type":
-        proxy = "type_"  # pragma: no cover
+        proxy = "type_"
 
     rel = proxy + "_"
     primaryjoin = getattr(cls, col.name) == getattr(child_cls, child_pk)