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

c2cgeoportal_geoportal/lib/dbreflection.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2011-2021, Camptocamp SA
+# Copyright (c) 2011-2023, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -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,25 +166,29 @@ 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(
-        __table__=table,
-        __mapper_args__={"exclude_properties": exclude_properties},
-        __attributes_order__=attributes_order,
-        __enumerations_config__=enumerations_config,
-    )
+    attributes = {
+        "__table__": table,
+        "__mapper_args__": {"exclude_properties": exclude_properties},
+        "__attributes_order__": attributes_order,
+        "__enumerations_config__": enumerations_config,
+    }
     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 name
+    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)

c2cgeoportal_geoportal/lib/filter_capabilities.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2014-2020, Camptocamp SA
+# Copyright (c) 2014-2024, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -30,51 +28,59 @@
 
 import copy
 import logging
-import xml.sax.handler
+import xml.sax.handler  # nosec
 from io import StringIO
-from typing import Callable, Dict, List
-from urllib.parse import urlsplit
-from xml.sax.saxutils import XMLFilterBase, XMLGenerator
+from typing import Any, Callable, Dict, List, Optional, Set, Union
+from xml.sax.saxutils import XMLFilterBase, XMLGenerator  # nosec
 
 import defusedxml.expatreader
+import pyramid.httpexceptions
+import pyramid.request
 import requests
+from owslib.map.wms111 import ContentMetadata as ContentMetadata111
+from owslib.map.wms130 import ContentMetadata as ContentMetadata130
 from owslib.wms import WebMapService
 from pyramid.httpexceptions import HTTPBadGateway
 
-from c2cgeoportal_commons.lib.url import add_url_params
+from c2cgeoportal_commons.lib.url import Url
 from c2cgeoportal_geoportal.lib import caching, get_ogc_server_wfs_url_ids, get_ogc_server_wms_url_ids
 from c2cgeoportal_geoportal.lib.layers import get_private_layers, get_protected_layers, get_writable_layers
 
 CACHE_REGION = caching.get_region("std")
 LOG = logging.getLogger(__name__)
+ContentMetadata = Union[ContentMetadata111, ContentMetadata130]
 
 
-@CACHE_REGION.cache_on_arguments()
-def wms_structure(wms_url, host, request):
-    url = urlsplit(wms_url)
-    wms_url = add_url_params(wms_url, {"SERVICE": "WMS", "VERSION": "1.1.1", "REQUEST": "GetCapabilities"})
+@CACHE_REGION.cache_on_arguments()  # type: ignore
+def wms_structure(wms_url: Url, host: str, request: pyramid.request.Request) -> Dict[str, List[str]]:
+    """Get a simple serializable structure of the WMS capabilities."""
+    url = wms_url.clone().add_query({"SERVICE": "WMS", "VERSION": "1.1.1", "REQUEST": "GetCapabilities"})
 
     # Forward request to target (without Host Header)
-    headers = dict()
-    if url.hostname == "localhost" and host is not None:  # pragma: no cover
+    headers = {}
+    if url.hostname == "localhost" and host is not None:
         headers["Host"] = host
     try:
-        response = requests.get(wms_url, headers=headers, **request.registry.settings.get("http_options", {}))
-    except Exception:  # pragma: no cover
-        raise HTTPBadGateway("Unable to GetCapabilities from wms_url {0!s}".format(wms_url))
+        response = requests.get(
+            url.url(), headers=headers, **request.registry.settings.get("http_options", {})
+        )
+    except Exception:
+        LOG.exception("Unable to GetCapabilities from wms_url '%s'", wms_url)
+        raise HTTPBadGateway(  # pylint: disable=raise-missing-from
+            "Unable to GetCapabilities, see logs for details"
+        )
 
-    if not response.ok:  # pragma: no cover
+    if not response.ok:
         raise HTTPBadGateway(
-            "GetCapabilities from wms_url {0!s} return the error: {1:d} {2!s}".format(
-                wms_url, response.status_code, response.reason
-            )
+            f"GetCapabilities from wms_url {url.url()} return the error: "
+            f"{response.status_code:d} {response.reason}"
         )
 
     try:
         wms = WebMapService(None, xml=response.content)
         result: Dict[str, List[str]] = {}
 
-        def _fill(name, parent):
+        def _fill(name: str, parent: ContentMetadata) -> None:
             if parent is None:
                 return
             if parent.name not in result:
@@ -86,37 +92,48 @@ def wms_structure(wms_url, host, request):
             _fill(layer.name, layer.parent)
         return result
 
-    except AttributeError:  # pragma: no cover
+    except AttributeError:
         error = "WARNING! an error occurred while trying to read the mapfile and recover the themes."
-        error = "{0!s}\nurl: {1!s}\nxml:\n{2!s}".format(error, wms_url, response.text)
+        error = f"{error}\nurl: {wms_url}\nxml:\n{response.text}"
         LOG.exception(error)
-        raise HTTPBadGateway(error)
+        raise HTTPBadGateway(error)  # pylint: disable=raise-missing-from
 
-    except SyntaxError:  # pragma: no cover
+    except SyntaxError:
         error = "WARNING! an error occurred while trying to read the mapfile and recover the themes."
-        error = "{0!s}\nurl: {1!s}\nxml:\n{2!s}".format(error, wms_url, response.text)
+        error = f"{error}\nurl: {wms_url}\nxml:\n{response.text}"
         LOG.exception(error)
-        raise HTTPBadGateway(error)
+        raise HTTPBadGateway(error)  # pylint: disable=raise-missing-from
 
 
-def filter_capabilities(content, wms, url, headers, request):
+def filter_capabilities(
+    content: str, wms: bool, url: Url, headers: Dict[str, str], request: pyramid.request.Request
+) -> str:
+    """Filter the WMS/WFS capabilities."""
 
     wms_structure_ = wms_structure(url, headers.get("Host"), request)
 
     ogc_server_ids = (
-        get_ogc_server_wms_url_ids(request) if wms else get_ogc_server_wfs_url_ids(request)
-    ).get(url)
+        get_ogc_server_wms_url_ids(request, request.host)
+        if wms
+        else get_ogc_server_wfs_url_ids(request, request.host)
+    ).get(url.url())
     gmf_private_layers = copy.copy(get_private_layers(ogc_server_ids))
     for id_ in list(get_protected_layers(request, ogc_server_ids).keys()):
         if id_ in gmf_private_layers:
             del gmf_private_layers[id_]
 
     private_layers = set()
-    for gmflayer in list(gmf_private_layers.values()):
-        for ogclayer in gmflayer.layer.split(","):
-            private_layers.add(ogclayer)
-            if ogclayer in wms_structure_:
-                private_layers.update(wms_structure_[ogclayer])
+    for gmf_layer in list(gmf_private_layers.values()):
+        for ogc_layer in gmf_layer.layer.split(","):
+            private_layers.add(ogc_layer)
+            if ogc_layer in wms_structure_:
+                private_layers.update(wms_structure_[ogc_layer])
+
+    LOG.debug(
+        "Filter capabilities of OGC server %s\nprivate_layers: %s",
+        ", ".join([str(e) for e in ogc_server_ids]),
+        ", ".join(private_layers),
+    )
 
     parser = defusedxml.expatreader.create_parser(forbid_external=False)
     # skip inclusion of DTDs
@@ -128,15 +145,27 @@ def filter_capabilities(content, wms, url, headers, request):
     filter_handler = _CapabilitiesFilter(
         parser, downstream_handler, "Layer" if wms else "FeatureType", layers_blacklist=private_layers
     )
-    filter_handler.parse(StringIO(content))
+    filter_handler.parse(StringIO(content))  # type: ignore
     return result.getvalue()
 
 
-def filter_wfst_capabilities(content, wfs_url, request):
-    writable_layers: List[str] = []
-    ogc_server_ids = get_ogc_server_wfs_url_ids(request).get(wfs_url)
-    for gmflayer in list(get_writable_layers(request, ogc_server_ids).values()):
-        writable_layers += gmflayer.layer.split(",")
+def filter_wfst_capabilities(content: str, wfs_url: Url, request: pyramid.request.Request) -> str:
+    """Filter the WTS capabilities."""
+
+    writable_layers: Set[str] = set()
+    ogc_server_ids = get_ogc_server_wfs_url_ids(request, request.host).get(wfs_url.url())
+    if ogc_server_ids is None:
+        LOG.error("No OGC server found for WFS URL %s", wfs_url)
+        raise pyramid.httpexceptions.HTTPInternalServerError("No OGC server found for WFS URL")
+
+    for gmf_layer in list(get_writable_layers(request, ogc_server_ids).values()):
+        writable_layers |= set(gmf_layer.layer.split(","))
+
+    LOG.debug(
+        "Filter WFS-T capabilities of OGC server %s\nlayers: %s",
+        ", ".join([str(e) for e in ogc_server_ids]),
+        ", ".join(writable_layers),
+    )
 
     parser = defusedxml.expatreader.create_parser(forbid_external=False)
     # skip inclusion of DTDs
@@ -148,13 +177,13 @@ def filter_wfst_capabilities(content, wfs_url, request):
     filter_handler = _CapabilitiesFilter(
         parser, downstream_handler, "FeatureType", layers_whitelist=writable_layers
     )
-    filter_handler.parse(StringIO(content))
+    filter_handler.parse(StringIO(content))  # type: ignore
     return result.getvalue()
 
 
 class _Layer:
-    def __init__(self, self_hidden=False):
-        self.accumul: List[Callable] = []
+    def __init__(self, self_hidden: bool = False):
+        self.accumulator: List[Callable[[], None]] = []
         self.hidden = True
         self.self_hidden = self_hidden
         self.has_children = False
@@ -164,13 +193,20 @@ class _Layer:
 class _CapabilitiesFilter(XMLFilterBase):
     """
     SAX filter to show only the allowed layers in a GetCapabilities request.
-    The filter removes elements of type `tag_name` where the `name`
-    attribute is part of the set `layers_blacklist` (when `layers_blacklist`
-    is given) or is not part of the set `layers_whitelist` (when
+
+    The filter removes elements of type `tag_name` where the `name` attribute is part of the set
+    `layers_blacklist` (when `layers_blacklist` is given) or is not part of the set `layers_whitelist` (when
     `layers_whitelist` is given).
     """
 
-    def __init__(self, upstream, downstream, tag_name, layers_blacklist=None, layers_whitelist=None):
+    def __init__(
+        self,
+        upstream: XMLFilterBase,
+        downstream: XMLGenerator,
+        tag_name: str,
+        layers_blacklist: Optional[Set[str]] = None,
+        layers_whitelist: Optional[Set[str]] = None,
+    ):
         XMLFilterBase.__init__(self, upstream)
         self._downstream = downstream
         self._accumulator: List[str] = []
@@ -183,9 +219,9 @@ class _CapabilitiesFilter(XMLFilterBase):
         ), "only either layers_blacklist OR layers_whitelist can be set"
 
         if layers_blacklist is not None:
-            layers_blacklist = [layer.lower() for layer in layers_blacklist]
+            layers_blacklist = {layer.lower() for layer in layers_blacklist}
         if layers_whitelist is not None:
-            layers_whitelist = [layer.lower() for layer in layers_whitelist]
+            layers_whitelist = {layer.lower() for layer in layers_whitelist}
         self.layers_blacklist = layers_blacklist
         self.layers_whitelist = layers_whitelist
 
@@ -196,39 +232,39 @@ class _CapabilitiesFilter(XMLFilterBase):
 
     def _complete_text_node(self) -> None:
         if self._accumulator:
-            self._downstream.characters("".join(self._accumulator))
+            self._downstream.characters("".join(self._accumulator))  # type: ignore
             self._accumulator = []
 
-    def _do(self, action):
+    def _do(self, action: Callable[[], Any]) -> None:
         if self.layers_path:
-            self.layers_path[-1].accumul.append(action)
+            self.layers_path[-1].accumulator.append(action)
         else:
             self._complete_text_node()
             action()
 
-    def _add_child(self, layer):
+    def _add_child(self, layer: _Layer) -> None:
         if not layer.hidden and not (layer.has_children and layer.children_nb == 0):
-            for action in layer.accumul:
+            for action in layer.accumulator:
                 self._complete_text_node()
                 action()
-            layer.accumul = []
+            layer.accumulator = []
 
-    def setDocumentLocator(self, locator):  # noqa
-        self._downstream.setDocumentLocator(locator)
+    def setDocumentLocator(self, locator: str) -> None:  # noqa: ignore=N802
+        self._downstream.setDocumentLocator(locator)  # type: ignore
 
-    def startDocument(self):  # noqa
-        self._downstream.startDocument()
+    def startDocument(self) -> None:  # noqa: ignore=N802
+        self._downstream.startDocument()  # type: ignore
 
-    def endDocument(self):  # noqa
-        self._downstream.endDocument()
+    def endDocument(self) -> None:  # noqa: ignore=N802
+        self._downstream.endDocument()  # type: ignore
 
-    def startPrefixMapping(self, prefix, uri):  # pragma: no cover  # noqa
-        self._downstream.startPrefixMapping(prefix, uri)
+    def startPrefixMapping(self, prefix: str, uri: str) -> None:  # noqa: ignore=N802
+        self._downstream.startPrefixMapping(prefix, uri)  # type: ignore
 
-    def endPrefixMapping(self, prefix):  # pragma: no cover  # noqa
-        self._downstream.endPrefixMapping(prefix)
+    def endPrefixMapping(self, prefix: str) -> None:  # noqa: ignore=N802
+        self._downstream.endPrefixMapping(prefix)  # type: ignore
 
-    def startElement(self, name, attrs):  # noqa
+    def startElement(self, name: str, attrs: Dict[str, str]) -> None:  # noqa: ignore=N802
         if name == self.tag_name:
             self.level += 1
             if self.layers_path:
@@ -238,40 +274,40 @@ class _CapabilitiesFilter(XMLFilterBase):
                 layer = _Layer(parent_layer.self_hidden) if len(self.layers_path) > 1 else _Layer()
                 self.layers_path.append(layer)
 
-                parent_layer.accumul.append(lambda: self._add_child(layer))
+                parent_layer.accumulator.append(lambda: self._add_child(layer))
             else:
                 layer = _Layer()
                 self.layers_path.append(layer)
         elif name == "Name" and self.layers_path:
             self.in_name = True
 
-        self._do(lambda: self._downstream.startElement(name, attrs))
+        self._do(lambda: self._downstream.startElement(name, attrs))  # type: ignore
 
-    def endElement(self, name):  # noqa
-        self._do(lambda: self._downstream.endElement(name))
+    def endElement(self, name: str) -> None:  # noqa: ignore=N802
+        self._do(lambda: self._downstream.endElement(name))  # type: ignore
 
         if name == self.tag_name:
             self.level -= 1
             if self.level == 0 and not self.layers_path[0].hidden:
-                for action in self.layers_path[0].accumul:
+                for action in self.layers_path[0].accumulator:
                     self._complete_text_node()
                     action()
             self.layers_path.pop()
         elif name == "Name":
             self.in_name = False
 
-    def startElementNS(self, name, qname, attrs):  # pragma: no cover  # noqa
-        self._do(lambda: self._downstream.startElementNS(name, qname, attrs))
+    def startElementNS(self, name: str, qname: str, attrs: Dict[str, str]) -> None:  # noqa: ignore=N802
+        self._do(lambda: self._downstream.startElementNS(name, qname, attrs))  # type: ignore
 
-    def endElementNS(self, name, qname):  # pragma: no cover  # noqa
-        self._do(lambda: self._downstream.endElementNS(name, qname))
+    def endElementNS(self, name: str, qname: str) -> None:  # noqa: ignore=N802
+        self._do(lambda: self._downstream.endElementNS(name, qname))  # type: ignore
 
-    def _keep_layer(self, layer_name):
+    def _keep_layer(self, layer_name: str) -> bool:
         return (self.layers_blacklist is not None and layer_name not in self.layers_blacklist) or (
             self.layers_whitelist is not None and layer_name in self.layers_whitelist
         )
 
-    def characters(self, content):
+    def characters(self, content: str) -> None:
         if self.in_name and self.layers_path and not self.layers_path[-1].self_hidden is True:
             layer_name = normalize_typename(content)
             if self._keep_layer(layer_name):
@@ -285,19 +321,20 @@ class _CapabilitiesFilter(XMLFilterBase):
 
         self._do(lambda: self._accumulator.append(content))
 
-    def ignorableWhitespace(self, chars):  # pragma: no cover  # noqa
+    def ignorableWhitespace(self, chars: str) -> None:  # noqa: ignore=N802
         self._do(lambda: self._accumulator.append(chars))
 
-    def processingInstruction(self, target, data):  # pragma: no cover  # noqa
-        self._do(lambda: self._downstream.processingInstruction(target, data))
+    def processingInstruction(self, target: str, data: str) -> None:  # noqa: ignore=N802
+        self._do(lambda: self._downstream.processingInstruction(target, data))  # type: ignore
 
-    def skippedEntity(self, name):  # pragma: no cover  # noqa
-        self._downstream.skippedEntity(name)
+    def skippedEntity(self, name: str) -> None:  # noqa: ignore=N802
+        self._downstream.skippedEntity(name)  # type: ignore
 
 
-def normalize_tag(tag):
+def normalize_tag(tag: str) -> str:
     """
-    Drops the namespace from a tag and converts to lower case.
+    Drop the namespace from a tag and converts to lower case.
+
     e.g. '{https://....}TypeName' -> 'TypeName'
     """
     normalized = tag
@@ -307,9 +344,10 @@ def normalize_tag(tag):
     return normalized.lower()
 
 
-def normalize_typename(typename):
+def normalize_typename(typename: str) -> str:
     """
-    Drops the namespace from a type name and converts to lower case.
+    Drop the namespace from a type name and converts to lower case.
+
     e.g. 'tows:parks' -> 'parks'
     """
     normalized = typename

c2cgeoportal_geoportal/lib/fulltextsearch.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2020, Camptocamp SA
+# Copyright (c) 2020-2021, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -28,10 +26,13 @@
 # either expressed or implied, of the FreeBSD Project.
 
 import re
+from typing import Any, Dict
 
 
 class Normalize:
-    def __init__(self, config):
+    """Normalize a text for the Full text search."""
+
+    def __init__(self, config: Dict[str, Any]) -> None:
         split = config.get("split_regex")
         self.split_re = re.compile(split) if split is not None else None
 
@@ -39,7 +40,7 @@ class Normalize:
         for search_regex, text in config.get("replace", {}).items():
             self.word_replace.append((re.compile(search_regex), text))
 
-    def __call__(self, text):
+    def __call__(self, text: str) -> str:
         if self.split_re is not None:
             text = " ".join(self.split_re.split(text))