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

c2cgeoportal_geoportal/lib/__init__.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2011-2020, Camptocamp SA
+# Copyright (c) 2011-2024, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -32,14 +30,17 @@ import datetime
 import ipaddress
 import json
 import logging
+import re
 from string import Formatter
-from typing import Any, Dict, List, Optional, Set, Union
-import urllib.parse
+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
 
+from c2cgeoportal_commons.lib.url import get_url2
 from c2cgeoportal_geoportal.lib.cacheversion import get_cache_version
 from c2cgeoportal_geoportal.lib.caching import get_region
 
@@ -48,72 +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_url2(name, url, request, errors) -> Optional[str]:
-    url_split = urllib.parse.urlsplit(url)
-    if url_split.scheme == "":
-        if url_split.netloc == "" and url_split.path not in ("", "/"):
-            # Relative URL like: /dummy/static/url or dummy/static/url
-            return urllib.parse.urlunsplit(url_split)
-        errors.add("{}='{}' is not an URL.".format(name, url))
-        return None
-    if url_split.scheme in ("http", "https"):
-        if url_split.netloc == "":
-            errors.add("{}='{}' is not a valid URL.".format(name, url))
-            return None
-        return urllib.parse.urlunsplit(url_split)
-    if url_split.scheme == "static":
-        if url_split.path in ("", "/"):
-            errors.add("{}='{}' cannot have an empty path.".format(name, url))
-            return None
-        proj = url_split.netloc
-        package = request.registry.settings["package"]
-        if proj in ("", "static"):
-            proj = "/etc/geomapfish/static"
-        elif ":" not in proj:
-            if proj == "static-ngeo":
-                errors.add(
-                    "{}='{}' static-ngeo shouldn't be used out of webpack because it don't has "
-                    "cache bustering.".format(name, url)
-                )
-            proj = "{}_geoportal:{}".format(package, proj)
-        return request.static_url("{}{}".format(proj, url_split.path))
-    if url_split.scheme == "config":
-        if url_split.netloc == "":
-            errors.add("{}='{}' cannot have an empty netloc.".format(name, url))
-            return None
-        server = request.registry.settings.get("servers", {}).get(url_split.netloc)
-        if server is None:
-            errors.add(
-                "{}: The server '{}' ({}) is not found in the config: [{}]".format(
-                    name,
-                    url_split.netloc,
-                    url,
-                    ", ".join(request.registry.settings.get("servers", {}).keys()),
-                )
-            )
-            return None
-        if url_split.path != "":
-            if server[-1] != "/":
-                server += "/"
-            url = urllib.parse.urljoin(server, url_split.path[1:])
-        else:
-            url = server
-        return url if not url_split.query else "{}?{}".format(url, url_split.query)
-    return None
-
-
 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":
@@ -127,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)
@@ -137,59 +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 add_url_params(url: str, params: Optional[Dict[str, str]]) -> str:
-    if not params:
-        return url
-    return add_spliturl_params(urllib.parse.urlsplit(url), params)
-
-
-def add_spliturl_params(spliturl, params):
-    query = {k: v[-1] for k, v in list(urllib.parse.parse_qs(spliturl.query).items())}
-    for key, value in list(params.items()):
-        query[key] = value
-
-    return urllib.parse.urlunsplit(
-        (spliturl.scheme, spliturl.netloc, spliturl.path, urllib.parse.urlencode(query), spliturl.fragment)
-    )
-
-
-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:
@@ -199,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()
@@ -252,42 +200,48 @@ 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):
-    result = [get_role_id("anonymous")]
+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("intranet"))
+        result.append(get_role_id(request.get_organization_role("intranet")))
     if request.user is not None:
-        result.append(get_role_id("registered"))
+        result.append(get_role_id(request.get_organization_role("registered")))
         result.extend([r.id for r in request.user.roles])
     return result
 
 
-def get_roles_name(request):
-    result = ["anonymous"]
+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("intranet")
+        result.append(request.get_organization_role("intranet"))
     if request.user is not None:
-        result.append("registered")
+        result.append(request.get_organization_role("registered"))
         result.extend([r.name for r in request.user.roles])
     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-2020, Camptocamp SA
+# Copyright (c) 2014-2021, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -28,17 +26,143 @@
 # either expressed or implied, of the FreeBSD Project.
 
 
+import binascii
+import json
 import logging
+import os
+import time
+from typing import Any, Callable, Dict, List, Optional, cast
 
-from pyramid.authentication import AuthTktAuthenticationPolicy, BasicAuthAuthenticationPolicy
+import pyramid.request
+from Crypto.Cipher import AES  # nosec
+from pyramid.authentication import (
+    AuthTktAuthenticationPolicy,
+    BasicAuthAuthenticationPolicy,
+    CallbackAuthenticationPolicy,
+)
+from pyramid.interfaces import IAuthenticationPolicy
+from pyramid.security import remember
 from pyramid_multiauth import MultiAuthenticationPolicy
+from zope.interface import implementer
 
+from c2cgeoportal_geoportal.lib import oauth2
 from c2cgeoportal_geoportal.resources import defaultgroupsfinder
 
 LOG = logging.getLogger(__name__)
 
 
-def create_authentication(settings):
+@implementer(IAuthenticationPolicy)
+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: pyramid.request.Request) -> Optional[str]:
+        if not request.method == "GET" or "auth" not in request.params:
+            return None
+        auth_enc = request.params.get("auth")
+        if auth_enc is None:
+            return None
+        try:
+            if self.aeskey is None:  # pragma: nocover
+                raise Exception("urllogin is not configured")
+            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
+
+            if "t" in auth and "u" in auth and "p" in auth:
+                timestamp = int(auth["t"])
+
+                if now < timestamp and request.registry.validate_user(request, auth["u"], auth["p"]):
+                    headers = remember(request, auth["u"])
+                    request.response.headerlist.extend(headers)
+                    return cast(str, auth["u"])
+
+        except Exception as e:
+            LOG.error("URL login error: %s.", e, exc_info=True)
+
+        return None
+
+    def remember(  # pylint: disable=no-self-use
+        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: pyramid.request.Request) -> List[Dict[str, str]]:  # pylint: disable=no-self-use
+        """Do no-op."""
+        del request
+        return []
+
+
+@implementer(IAuthenticationPolicy)
+class OAuth2AuthenticationPolicy(CallbackAuthenticationPolicy):  # type: ignore
+    """The oauth2 authentication policy."""
+
+    @staticmethod
+    def unauthenticated_userid(request: pyramid.request.Request) -> Optional[str]:
+        route_url = ""
+        try:
+            route_url = request.current_route_url(_query={**request.GET})
+        except ValueError:
+            route_url = request.route_url("base", _query={**request.GET})
+
+        LOG.debug(
+            "Call OAuth verify_request with:\nurl: %s\nmethod: %s\nbody:\n%s",
+            route_url,
+            request.method,
+            request.body,
+        )
+        valid, oauth2_request = oauth2.get_oauth_client(request.registry.settings).verify_request(
+            route_url,
+            request.method,
+            request.body,
+            request.headers,
+            [],
+        )
+        LOG.debug("OAuth verify_request: %s", valid)
+        if valid:
+            request.user_ = oauth2_request.user
+
+            return cast(str, request.user_.username)
+        return None
+
+    def remember(  # pylint: disable=no-self-use
+        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: pyramid.request.Request) -> List[Dict[str, str]]:  # pylint: disable=no-self-use
+        """Do no-op."""
+        del request
+        return []
+
+
+@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")
@@ -58,26 +182,51 @@ def create_authentication(settings):
             "See https://docs.pylonsproject.org/projects/pyramid/en/latest/api/session.html"
         )
 
-    cookie_authentication_policy = AuthTktAuthenticationPolicy(
-        secret,
-        callback=defaultgroupsfinder,
-        cookie_name=settings["authtkt_cookie_name"],
-        samesite=None if samesite == "" else samesite,
-        timeout=timeout,
-        max_age=max_age,
-        reissue_time=reissue_time,
-        hashalg="sha512",
-        http_only=http_only,
-        secure=secure,
+    policies = []
+
+    policies.append(
+        UrlAuthenticationPolicy(
+            settings.get("urllogin", {}).get("aes_key"),
+            defaultgroupsfinder,
+        )
+    )
+
+    policies.append(
+        AuthTktAuthenticationPolicy(
+            secret,
+            callback=defaultgroupsfinder,
+            cookie_name=settings["authtkt_cookie_name"],
+            samesite=None if samesite == "" else samesite,
+            timeout=timeout,
+            max_age=max_age,
+            reissue_time=reissue_time,
+            hashalg="sha512",
+            http_only=http_only,
+            secure=secure,
+        )
     )
-    if not basicauth:
-        return cookie_authentication_policy
-    basic_authentication_policy = BasicAuthAuthenticationPolicy(c2cgeoportal_check)
-    policies = [cookie_authentication_policy, basic_authentication_policy]
+
+    policies.append(OAuth2AuthenticationPolicy())
+
+    if basicauth:
+        if settings["authentication"].get("two_factor", False):
+            LOG.warning(
+                "Basic auth and tow factor auth should not be enable toogether, "
+                "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,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2011-2019, Camptocamp SA
+# Copyright (c) 2011-2021, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -28,35 +26,45 @@
 # either expressed or implied, of the FreeBSD Project.
 
 
-from urllib.parse import urljoin
 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
 
 
 class CachebusterTween:
-    """ Get back the cachebuster URL. """
+    """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