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

c2cgeoportal_geoportal/lib/__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
@@ -32,10 +30,13 @@ import datetime
 import ipaddress
 import json
 import logging
+import re
 from string import Formatter
-from typing import Any, Dict, List, Set, Union
+from typing import Any, Dict, Iterable, List, Optional, Set, Tuple, Union, cast
 
 import dateutil
+import pyramid.request
+import pyramid.response
 from pyramid.interfaces import IRoutePregenerator
 from zope.interface import implementer
 
@@ -48,18 +49,25 @@ CACHE_REGION = get_region("std")
 CACHE_REGION_OBJ = get_region("obj")
 
 
-def get_types_map(types_array):
+def get_types_map(types_array: List[Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
+    """Get the type name of a metadata or a functionality."""
     return {type_["name"]: type_ for type_ in types_array}
 
 
 def get_typed(
-    name, value, types, request, errors, layer_name=None
+    name: str,
+    value: str,
+    types: Dict[str, Any],
+    request: pyramid.request.Request,
+    errors: Set[str],
+    layer_name: Optional[str] = None,
 ) -> Union[str, int, float, bool, None, List[Any], Dict[str, Any]]:
-    prefix = "Layer '{}': ".format(layer_name) if layer_name is not None else ""
+    """Get the typed (parsed) value of a metadata or a functionality."""
+    prefix = f"Layer '{layer_name}': " if layer_name is not None else ""
     type_ = {"type": "not init"}
     try:
         if name not in types:
-            errors.add("{}Type '{}' not defined.".format(prefix, name))
+            errors.add(f"{prefix}Type '{name}' not defined.")
             return None
         type_ = types[name]
         if type_.get("type", "string") == "string":
@@ -73,8 +81,8 @@ def get_typed(
             if value in ["no", "n", "off", "0", "false"]:
                 return False
             errors.add(
-                "{}The boolean attribute '{}'='{}' is not in "
-                "[yes, y, on, 1, true, no, n, off, 0, false].".format(prefix, name, value.lower())
+                f"{prefix}The boolean attribute '{name}'='{value.lower()}' is not in "
+                "[yes, y, on, 1, true, no, n, off, 0, false]."
             )
         elif type_["type"] == "integer":
             return int(value)
@@ -83,43 +91,47 @@ def get_typed(
         elif type_["type"] == "date":
             date = dateutil.parser.parse(value, default=datetime.datetime(1, 1, 1, 0, 0, 0))  # type: ignore
             if date.time() != datetime.time(0, 0, 0):
-                errors.add(
-                    "{}The date attribute '{}'='{}' should not have any time".format(prefix, name, value)
-                )
+                errors.add(f"{prefix}The date attribute '{name}'='{value}' should not have any time")
             else:
                 return datetime.date.strftime(date.date(), "%Y-%m-%d")
         elif type_["type"] == "time":
             date = dateutil.parser.parse(value, default=datetime.datetime(1, 1, 1, 0, 0, 0))  # type: ignore
             if date.date() != datetime.date(1, 1, 1):
-                errors.add(
-                    "{}The time attribute '{}'='{}' should not have any date".format(prefix, name, value)
-                )
+                errors.add(f"{prefix}The time attribute '{name}'='{value}' should not have any date")
             else:
                 return datetime.time.strftime(date.time(), "%H:%M:%S")
         elif type_["type"] == "datetime":
             date = dateutil.parser.parse(value, default=datetime.datetime(1, 1, 1, 0, 0, 0))  # type: ignore
             return datetime.datetime.strftime(date, "%Y-%m-%dT%H:%M:%S")
         elif type_["type"] == "url":
-            return get_url2("{}The attribute '{}'".format(prefix, name), value, request, errors)
+            url = get_url2(f"{prefix}The attribute '{name}'", value, request, errors)
+            return url.url() if url else ""
         elif type_["type"] == "json":
             try:
-                return json.loads(value)
+                return cast(Dict[str, Any], json.loads(value))
             except Exception as e:
-                errors.append(
-                    "{}The attribute '{}'='{}' has an error: {}".format(prefix, name, value, str(e))
+                errors.add(f"{prefix}The attribute '{name}'='{value}' has an error: {str(e)}")
+        elif type_["type"] == "regex":
+            pattern = type_["regex"]
+            if re.match(pattern, value) is None:
+                errors.add(
+                    f"{prefix}The regex attribute '{name}'='{value}' "
+                    f"does not match expected pattern '{pattern}'."
                 )
+            else:
+                return value
         else:
-            errors.add("{}Unknown type '{}'.".format(prefix, type_["type"]))
+            errors.add(f"{prefix}Unknown type '{type_['type']}'.")
     except Exception as e:
         errors.add(
-            "{}Unable to parse the attribute '{}'='{}' with the type '{}', error:\n{}".format(
-                prefix, name, value, type_.get("type", "string"), str(e)
-            )
+            f"{prefix}Unable to parse the attribute '{name}'='{value}' with the type "
+            f"'{type_.get('type', 'string')}', error:\n{e!s}"
         )
     return None
 
 
-def get_setting(settings, path, default=None):
+def get_setting(settings: Any, path: Iterable[str], default: Any = None) -> Any:
+    """Get the settings."""
     value = settings
     for p in path:
         if value and p in value:
@@ -129,42 +141,48 @@ def get_setting(settings, path, default=None):
     return value if value else default
 
 
-@CACHE_REGION_OBJ.cache_on_arguments()
-def get_ogc_server_wms_url_ids(request):
+@CACHE_REGION_OBJ.cache_on_arguments()  # type: ignore
+def get_ogc_server_wms_url_ids(request: pyramid.request.Request, host: str) -> Dict[str, List[int]]:
+    """Get the OGCServer ids mapped on the WMS URL."""
     from c2cgeoportal_commons.models import DBSession  # pylint: disable=import-outside-toplevel
     from c2cgeoportal_commons.models.main import OGCServer  # pylint: disable=import-outside-toplevel
 
+    del host  # used for cache
     errors: Set[str] = set()
     servers: Dict[str, List[int]] = {}
     for ogc_server in DBSession.query(OGCServer).all():
         url = get_url2(ogc_server.name, ogc_server.url, request, errors)
         if url is not None:
-            servers.setdefault(url, []).append(ogc_server.id)
+            servers.setdefault(url.url(), []).append(ogc_server.id)
     return servers
 
 
-@CACHE_REGION_OBJ.cache_on_arguments()
-def get_ogc_server_wfs_url_ids(request):
+@CACHE_REGION_OBJ.cache_on_arguments()  # type: ignore
+def get_ogc_server_wfs_url_ids(request: pyramid.request.Request, host: str) -> Dict[str, List[int]]:
+    """Get the OGCServer ids mapped on the WFS URL."""
     from c2cgeoportal_commons.models import DBSession  # pylint: disable=import-outside-toplevel
     from c2cgeoportal_commons.models.main import OGCServer  # pylint: disable=import-outside-toplevel
 
+    del host  # used for cache
     errors: Set[str] = set()
     servers: Dict[str, List[int]] = {}
     for ogc_server in DBSession.query(OGCServer).all():
         url = get_url2(ogc_server.name, ogc_server.url_wfs or ogc_server.url, request, errors)
         if url is not None:
-            servers.setdefault(url, []).append(ogc_server.id)
+            servers.setdefault(url.url(), []).append(ogc_server.id)
     return servers
 
 
 @implementer(IRoutePregenerator)
-class C2CPregenerator:  # pragma: no cover
-    def __init__(self, version=True, role=False):
+class C2CPregenerator:
+    """The custom pyramid pregenerator that manage the cache version."""
+
+    def __init__(self, version: bool = True, role: bool = False):
         self.version = version
         self.role = role
 
-    def __call__(self, request, elements, kw):
-        query = kw.get("_query", {})
+    def __call__(self, request: pyramid.request.Request, elements: Any, kw: Any) -> Tuple[Any, Any]:
+        query = {**kw.get("_query", {})}
 
         if self.version:
             query["cache_version"] = get_cache_version()
@@ -182,22 +200,26 @@ class C2CPregenerator:  # pragma: no cover
 _formatter = Formatter()
 
 
-@CACHE_REGION_OBJ.cache_on_arguments()
-def _get_intranet_networks(request):
+@CACHE_REGION_OBJ.cache_on_arguments()  # type: ignore
+def _get_intranet_networks(
+    request: pyramid.request.Request,
+) -> List[Union[ipaddress.IPv4Network, ipaddress.IPv6Network]]:
     return [
         ipaddress.ip_network(network, strict=False)
         for network in request.registry.settings.get("intranet", {}).get("networks", [])
     ]
 
 
-@CACHE_REGION.cache_on_arguments()
-def get_role_id(name):
+@CACHE_REGION.cache_on_arguments()  # type: ignore
+def get_role_id(name: str) -> int:
+    """Get the role ID."""
     from c2cgeoportal_commons.models import DBSession, main  # pylint: disable=import-outside-toplevel
 
-    return DBSession.query(main.Role.id).filter(main.Role.name == name).one()[0]
+    return cast(int, DBSession.query(main.Role.id).filter(main.Role.name == name).one()[0])
 
 
-def get_roles_id(request):
+def get_roles_id(request: pyramid.request.Request) -> List[int]:
+    """Get the user roles ID."""
     result = [get_role_id(request.get_organization_role("anonymous"))]
     if is_intranet(request):
         result.append(get_role_id(request.get_organization_role("intranet")))
@@ -207,7 +229,8 @@ def get_roles_id(request):
     return result
 
 
-def get_roles_name(request):
+def get_roles_name(request: pyramid.request.Request) -> pyramid.response.Response:
+    """Get the user roles name."""
     result = [request.get_organization_role("anonymous")]
     if is_intranet(request):
         result.append(request.get_organization_role("intranet"))
@@ -217,7 +240,8 @@ def get_roles_name(request):
     return result
 
 
-def is_intranet(request):
+def is_intranet(request: pyramid.request.Request) -> bool:
+    """Get if it's an intranet user."""
     address = ipaddress.ip_address(request.client_addr)
     for network in _get_intranet_networks(request):
         if address in network:

c2cgeoportal_geoportal/lib/authentication.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2014-2021, Camptocamp SA
+# Copyright (c) 2014-2023, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -31,8 +29,11 @@
 import binascii
 import json
 import logging
+import os
 import time
+from typing import Any, Callable, Dict, List, Optional, cast
 
+import pyramid.request
 from Crypto.Cipher import AES  # nosec
 from pyramid.authentication import (
     AuthTktAuthenticationPolicy,
@@ -51,13 +52,17 @@ LOG = logging.getLogger(__name__)
 
 
 @implementer(IAuthenticationPolicy)
-class UrlAuthenticationPolicy(CallbackAuthenticationPolicy):
-    def __init__(self, aes_key, callback=None, debug=False):
+class UrlAuthenticationPolicy(CallbackAuthenticationPolicy):  # type: ignore
+    """An authentication policy based on information given in the URL."""
+
+    def __init__(
+        self, aes_key: str, callback: Optional[Callable[[str, Any], List[str]]] = None, debug: bool = False
+    ):
         self.aeskey = aes_key
         self.callback = callback
         self.debug = debug
 
-    def unauthenticated_userid(self, request):
+    def unauthenticated_userid(self, request: pyramid.request.Request) -> Optional[str]:
         if not request.method == "GET" or "auth" not in request.params:
             return None
         auth_enc = request.params.get("auth")
@@ -65,14 +70,14 @@ class UrlAuthenticationPolicy(CallbackAuthenticationPolicy):
             return None
         try:
             if self.aeskey is None:  # pragma: nocover
-                raise Exception("urllogin is not configured")
+                raise Exception("urllogin is not configured")  # pylint: disable=broad-exception-raised
             now = int(time.time())
             data = binascii.unhexlify(auth_enc.encode("ascii"))
             nonce = data[0:16]
             tag = data[16:32]
             ciphertext = data[32:]
             cipher = AES.new(self.aeskey.encode("ascii"), AES.MODE_EAX, nonce)
-            auth = json.loads(cipher.decrypt_and_verify(ciphertext, tag).decode("utf-8"))  # type: ignore
+            auth = json.loads(cipher.decrypt_and_verify(ciphertext, tag).decode("utf-8"))
 
             if "t" in auth and "u" in auth and "p" in auth:
                 timestamp = int(auth["t"])
@@ -80,33 +85,35 @@ class UrlAuthenticationPolicy(CallbackAuthenticationPolicy):
                 if now < timestamp and request.registry.validate_user(request, auth["u"], auth["p"]):
                     headers = remember(request, auth["u"])
                     request.response.headerlist.extend(headers)
-                    return auth["u"]
+                    return cast(str, auth["u"])
 
         except Exception as e:
             LOG.error("URL login error: %s.", e, exc_info=True)
 
         return None
 
-    def remember(self, request, userid, **kw):  # pylint: disable=no-self-use
-        """A no-op."""
+    def remember(self, request: pyramid.request.Request, userid: str, **kw: Any) -> List[Dict[str, str]]:
+        """Do no-op."""
         del request, userid, kw
         return []
 
-    def forget(self, request):  # pylint: disable= no-self-use
-        """A no-op."""
+    def forget(self, request: pyramid.request.Request) -> List[Dict[str, str]]:
+        """Do no-op."""
         del request
         return []
 
 
 @implementer(IAuthenticationPolicy)
-class OAuth2AuthenticationPolicy(CallbackAuthenticationPolicy):
+class OAuth2AuthenticationPolicy(CallbackAuthenticationPolicy):  # type: ignore
+    """The oauth2 authentication policy."""
+
     @staticmethod
-    def unauthenticated_userid(request):
+    def unauthenticated_userid(request: pyramid.request.Request) -> Optional[str]:
         route_url = ""
         try:
-            route_url = request.current_route_url(_query=request.GET)
+            route_url = request.current_route_url(_query={**request.GET})
         except ValueError:
-            route_url = request.route_url("base", _query=request.GET)
+            route_url = request.route_url("base", _query={**request.GET})
 
         LOG.debug(
             "Call OAuth verify_request with:\nurl: %s\nmethod: %s\nbody:\n%s",
@@ -125,21 +132,33 @@ class OAuth2AuthenticationPolicy(CallbackAuthenticationPolicy):
         if valid:
             request.user_ = oauth2_request.user
 
-            return request.user_.username
+            return cast(str, request.user.username)
         return None
 
-    def remember(self, request, userid, **kw):  # pylint: disable=no-self-use
-        """A no-op."""
+    def remember(self, request: pyramid.request.Request, userid: str, **kw: Any) -> List[Dict[str, str]]:
+        """Do no-op."""
         del request, userid, kw
         return []
 
-    def forget(self, request):  # pylint: disable= no-self-use
-        """A no-op."""
+    def forget(self, request: pyramid.request.Request) -> List[Dict[str, str]]:
+        """Do no-op."""
         del request
         return []
 
 
-def create_authentication(settings):
+@implementer(IAuthenticationPolicy)
+class DevAuthenticationPolicy(CallbackAuthenticationPolicy):  # type: ignore
+    """An authentication policy for the dev base on an environment variable."""
+
+    @staticmethod
+    def unauthenticated_userid(request: pyramid.request.Request) -> Optional[str]:
+        """Get the user name from the environment variable."""
+        del request
+        return os.environ["DEV_LOGINNAME"]
+
+
+def create_authentication(settings: Dict[str, Any]) -> MultiAuthenticationPolicy:
+    """Create all the authentication policies."""
     timeout = settings.get("authtkt_timeout")
     timeout = None if timeout is None or timeout.lower() == "none" else int(timeout)
     reissue_time = settings.get("authtkt_reissue_time")
@@ -154,7 +173,7 @@ def create_authentication(settings):
     secret = settings["authtkt_secret"]
     basicauth = settings.get("basicauth", "False").lower() in ("true", "yes", "1")
     if len(secret) < 64:
-        raise Exception(
+        raise Exception(  # pylint: disable=broad-exception-raised
             '"authtkt_secret should be at least 64 characters.'
             "See https://docs.pylonsproject.org/projects/pyramid/en/latest/api/session.html"
         )
@@ -188,17 +207,22 @@ def create_authentication(settings):
     if basicauth:
         if settings["authentication"].get("two_factor", False):
             LOG.warning(
-                "Basic auth and tow factor auth should not be anhable toogether, "
+                "Basic auth and two factor auth should not be enable together, "
                 "you should use OAuth2 instead of Basic auth"
             )
 
         basic_authentication_policy = BasicAuthAuthenticationPolicy(c2cgeoportal_check)
         policies.append(basic_authentication_policy)
 
+    # Consider empty string as not configured
+    if "DEV_LOGINNAME" in os.environ and os.environ["DEV_LOGINNAME"]:
+        policies.append(DevAuthenticationPolicy())
+
     return MultiAuthenticationPolicy(policies)
 
 
-def c2cgeoportal_check(username, password, request):  # pragma: no cover
+def c2cgeoportal_check(username: str, password: str, request: pyramid.request.Request) -> Optional[List[str]]:
+    """Check the user authentication."""
     if request.registry.validate_user(request, username, password):
         return defaultgroupsfinder(username, request)
     return None

c2cgeoportal_geoportal/lib/bashcolor.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
@@ -27,16 +25,22 @@
 # of the authors and should not be interpreted as representing official policies,
 # either expressed or implied, of the FreeBSD Project.
 
+from enum import Enum
+
+
+class Color(Enum):
+    """The available colors."""
 
-BLACK = 0
-RED = 1
-GREEN = 2
-YELLOW = 3
-BLUE = 4
-MAGENTA = 5
-CYAN = 6
-WHITE = 7
+    BLACK = 0
+    RED = 1
+    GREEN = 2
+    YELLOW = 3
+    BLUE = 4
+    MAGENTA = 5
+    CYAN = 6
+    WHITE = 7
 
 
-def colorize(text, color):  # pragma: no cover
-    return "\x1b[01;3{0:d}m{1!s}\x1b[0m".format(color, text)
+def colorize(text: str, color: Color) -> str:
+    """Colorize a text for the bash."""
+    return f"\x1b[01;3{color.value}m{text}\x1b[0m"

c2cgeoportal_geoportal/lib/cacheversion.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 # Copyright (c) 2011-2021, Camptocamp SA
 # All rights reserved.
 
@@ -29,22 +27,28 @@
 
 
 import uuid
+from typing import Any, Callable, Dict, Tuple
 from urllib.parse import urljoin
 
 import pyramid.registry
+import pyramid.request
+import pyramid.response
 
 from c2cgeoportal_geoportal.lib.caching import get_region
 
 CACHE_REGION = get_region("std")
 
 
-@CACHE_REGION.cache_on_arguments()
-def get_cache_version():
-    """Return a cache version that is regenerate after each cache invalidation"""
+@CACHE_REGION.cache_on_arguments()  # type: ignore
+def get_cache_version() -> str:
+    """Return a cache version that is regenerate after each cache invalidation."""
     return uuid.uuid4().hex
 
 
-def version_cache_buster(request, subpath, kw):  # pragma: no cover
+def version_cache_buster(
+    request: pyramid.request.Request, subpath: str, kw: Dict[str, Any]
+) -> Tuple[str, Dict[str, Any]]:
+    """Join the cash buster version with the sub path."""
     del request  # unused
     return urljoin(get_cache_version() + "/", subpath), kw
 
@@ -52,11 +56,15 @@ def version_cache_buster(request, subpath, kw):  # pragma: no cover
 class CachebusterTween:
     """Get back the cachebuster URL."""
 
-    def __init__(self, handler, registry: pyramid.registry.Registry):
+    def __init__(
+        self,
+        handler: Callable[[pyramid.request.Request], pyramid.response.Response],
+        registry: pyramid.registry.Registry,
+    ):
         self.handler = handler
         self.cache_path = registry.settings["cache_path"]
 
-    def __call__(self, request):
+    def __call__(self, request: pyramid.request.Request) -> pyramid.response.Response:
         path = request.path_info.split("/")
         if len(path) > 1 and path[1] in self.cache_path:
             # remove the cache buster