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

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,58 @@
 
 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.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 +91,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 +144,24 @@ 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())
+
+    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 +173,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 +189,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 +215,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 +228,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: xml.sax.xmlreader.AttributesImpl) -> None:  # noqa: ignore=N802
         if name == self.tag_name:
             self.level += 1
             if self.layers_path:
@@ -238,40 +270,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 +317,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 +340,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))
 

c2cgeoportal_geoportal/lib/functionality.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 # Copyright (c) 2011-2021, Camptocamp SA
 # All rights reserved.
 
@@ -31,6 +29,7 @@
 import logging.config
 from typing import Any, Dict, List, Set, Union, cast
 
+import pyramid.request
 from sqlalchemy.orm import joinedload
 
 from c2cgeoportal_commons.models import main, static
@@ -42,13 +41,13 @@ CACHE_REGION_OBJ = get_region("obj")
 CACHE_REGION = get_region("std")
 
 
-@CACHE_REGION_OBJ.cache_on_arguments()
+@CACHE_REGION_OBJ.cache_on_arguments()  # type: ignore
 def _get_role(name: str) -> Dict[str, Any]:
     from c2cgeoportal_commons.models import DBSession  # pylint: disable=import-outside-toplevel
 
     role = (
-        DBSession.query(static.Role)
-        .filter(static.Role.name == name)
+        DBSession.query(main.Role)
+        .filter(main.Role.name == name)
         .options(joinedload(main.Role.functionalities))
         .one_or_none()
     )
@@ -56,19 +55,23 @@ def _get_role(name: str) -> Dict[str, Any]:
     return {"settings_functionalities": struct, "roles_functionalities": {name: struct}}
 
 
-def _user_to_struct(user):
+def _user_to_struct(user: static.User) -> Dict[str, Any]:
     return {
         "settings_functionalities": _role_to_struct(user.settings_role),
         "roles_functionalities": {role.name: _role_to_struct(role) for role in user.roles},
     }
 
 
-def _role_to_struct(role):
+def _role_to_struct(role: main.Role) -> List[Dict[str, Any]]:
     return [{"name": f.name, "value": f.value} for f in role.functionalities] if role else []
 
 
 def _get_db_functionality(
-    name, user: Dict[str, Any], types, request, errors
+    name: str,
+    user: Dict[str, Any],
+    types: Dict[str, Dict[str, Any]],
+    request: pyramid.request.Request,
+    errors: Set[str],
 ) -> List[Union[str, int, float, bool, List[Any], Dict[str, Any]]]:
     if types.get(name, {}).get("single", False):
         values = [
@@ -91,16 +94,17 @@ def _get_db_functionality(
     return [r for r in values if r is not None]
 
 
-@CACHE_REGION_OBJ.cache_on_arguments()
-def _get_functionalities_type(request):
+@CACHE_REGION_OBJ.cache_on_arguments()  # type: ignore
+def _get_functionalities_type(request: pyramid.request.Request) -> Dict[str, Dict[str, Any]]:
     return get_types_map(
         request.registry.settings.get("admin_interface", {}).get("available_functionalities", [])
     )
 
 
 def get_functionality(
-    name, request, is_intranet_
+    name: str, request: pyramid.request.Request, is_intranet_: bool
 ) -> List[Union[str, int, float, bool, List[Any], Dict[str, Any]]]:
+    """Get all the functionality for the current user."""
     result: List[Union[str, int, float, bool, List[Any], Dict[str, Any]]] = []
     errors: Set[str] = set()
 
@@ -135,12 +139,13 @@ def get_functionality(
             errors,
         )
 
-    if errors != set():  # pragma: no cover
+    if errors != set():
         LOG.error("\n".join(errors))
     return result
 
 
-def get_mapserver_substitution_params(request):
+def get_mapserver_substitution_params(request: pyramid.request.Request) -> Dict[str, str]:
+    """Get the parameters used by the mapserver substitution."""
     params: Dict[str, str] = {}
     mss = get_functionality("mapserver_substitution", request, is_intranet(request))
     if mss:
@@ -149,13 +154,11 @@ def get_mapserver_substitution_params(request):
             index = s.find("=")
             if index > 0:
                 attribute = "s_" + s[:index]
-                # fmt: off
-                value = s[index + 1:]
-                # fmt: on
+                value = s[index + 1 :]
                 if attribute in params:
                     params[attribute] += "," + value
                 else:
                     params[attribute] = value
             else:
-                LOG.warning("Mapserver Substitution '%s' does not " "respect pattern: <attribute>=<value>", s)
+                LOG.warning("Mapserver Substitution '%s' does not respect pattern: <attribute>=<value>", s)
     return params

c2cgeoportal_geoportal/lib/headers.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2013-2020, Camptocamp SA
+# Copyright (c) 2013-2021, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -29,16 +27,27 @@
 
 
 import re
+from typing import Callable
+
+import pyramid.registry
+import pyramid.request
+import pyramid.response
 
 
 class HeadersTween:
-    def __init__(self, handler, registry):
+    """Add the header on all the application."""
+
+    def __init__(
+        self,
+        handler: Callable[[pyramid.request.Request], pyramid.response.Response],
+        registry: pyramid.registry.Registry,
+    ) -> None:
         self.handler = handler
         self.settings = [
             (re.compile(e["pattern"]), e["headers"]) for e in registry.settings["global_headers"]
         ]
 
-    def __call__(self, request):
+    def __call__(self, request: pyramid.request.Request) -> pyramid.response.Response:
         response = self.handler(request)
 
         for pattern, headers in self.settings:

c2cgeoportal_geoportal/lib/i18n.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
@@ -29,11 +27,13 @@
 
 
 import os
+from typing import List
 
 LOCALE_PATH = "/etc/geomapfish/locale/"
 
 
-def available_locale_names(path=LOCALE_PATH):
+def available_locale_names(path: str = LOCALE_PATH) -> List[str]:
+    """Get the available locales."""
     if not os.path.exists(path):
         return []
     return [d for d in os.listdir(path) if os.path.isdir(os.path.join(path, d))]