c2cwsgiutils 6.2.0.dev74__py3-none-any.whl → 6.2.0.dev75__py3-none-any.whl

c2cwsgiutils/__init__.py

@@ -35,7 +35,8 @@ def _create_handlers(config: configparser.ConfigParser) -> dict[str, Any]:
     for hh in handlers:
         block = config[f"handler_{hh}"]
         if "args" in block:
-            raise ValueError(f"Can not parse args of handlers {hh}, use kwargs instead.")
+            message = f"Can not parse args of handlers {hh}, use kwargs instead."
+            raise ValueError(message)
         c = block["class"]
         if "." not in c:
             # classes like StreamHandler does not need the prefix in the ini so we add it here
@@ -116,10 +117,9 @@ def get_paste_config() -> str:
     for val in sys.argv:
         if next_one:
             return val
-        if val.startswith("--paste=") or val.startswith("--paster="):
+        if val.startswith(("--paste=", "--paster=")):
             return val.split("=")[1]
         if val in ["--paste", "--paster"]:
             next_one = True
 
-    fallback = os.environ.get("C2CWSGIUTILS_CONFIG", "production.ini")
-    return fallback
+    return os.environ.get("C2CWSGIUTILS_CONFIG", "production.ini")

c2cwsgiutils/acceptance/__init__.py

@@ -7,7 +7,10 @@ _LOG = logging.getLogger(__name__)
 
 
 def retry(
-    exception_to_check: typing.Any, tries: float = 3, delay: float = 0.5, backoff: float = 2
+    exception_to_check: typing.Any,
+    tries: float = 3,
+    delay: float = 0.5,
+    backoff: float = 2,
 ) -> typing.Callable[..., typing.Any]:
     """
     Retry calling the decorated function using an exponential backoff.

c2cwsgiutils/acceptance/connection.py

@@ -1,7 +1,8 @@
 import re
 from collections.abc import Mapping, MutableMapping
 from enum import Enum
-from typing import Any, Optional, Union
+from pathlib import Path
+from typing import Any
 
 import requests
 
@@ -32,10 +33,10 @@ class Connection:
         url: str,
         expected_status: int = 200,
         cors: bool = True,
-        headers: Optional[Mapping[str, str]] = None,
+        headers: Mapping[str, str] | None = None,
         cache_expected: CacheExpected = CacheExpected.NO,
         **kwargs: Any,
-    ) -> Optional[str]:
+    ) -> str | None:
         """Get the given URL (relative to the root of API)."""
         with self.session.get(self.base_url + url, headers=self._merge_headers(headers, cors), **kwargs) as r:
             check_response(r, expected_status, cache_expected=cache_expected)
@@ -46,7 +47,7 @@ class Connection:
         self,
         url: str,
         expected_status: int = 200,
-        headers: Optional[Mapping[str, str]] = None,
+        headers: Mapping[str, str] | None = None,
         cors: bool = True,
         cache_expected: CacheExpected = CacheExpected.NO,
         **kwargs: Any,
@@ -61,7 +62,7 @@ class Connection:
         self,
         url: str,
         expected_status: int = 200,
-        headers: Optional[Mapping[str, str]] = None,
+        headers: Mapping[str, str] | None = None,
         cors: bool = True,
         cache_expected: CacheExpected = CacheExpected.NO,
         **kwargs: Any,
@@ -75,9 +76,9 @@ class Connection:
     def get_xml(
         self,
         url: str,
-        schema: Optional[str] = None,
+        schema: Path | None = None,
         expected_status: int = 200,
-        headers: Optional[Mapping[str, str]] = None,
+        headers: Mapping[str, str] | None = None,
         cors: bool = True,
         cache_expected: CacheExpected = CacheExpected.NO,
         **kwargs: Any,
@@ -96,7 +97,7 @@ class Connection:
             r.raw.decode_content = True
             doc = etree.parse(r.raw)  # noqa: S320
             if schema is not None:
-                with open(schema, encoding="utf-8") as schema_file:
+                with schema.open(encoding="utf-8") as schema_file:
                     xml_schema = etree.XMLSchema(etree.parse(schema_file))  # noqa: S320
                 xml_schema.assertValid(doc)
             return doc
@@ -105,14 +106,16 @@ class Connection:
         self,
         url: str,
         expected_status: int = 200,
-        headers: Optional[Mapping[str, str]] = None,
+        headers: Mapping[str, str] | None = None,
         cors: bool = True,
         cache_expected: CacheExpected = CacheExpected.NO,
         **kwargs: Any,
     ) -> Any:
         """POST the given URL (relative to the root of API)."""
         with self.session.post(
-            self.base_url + url, headers=self._merge_headers(headers, cors), **kwargs
+            self.base_url + url,
+            headers=self._merge_headers(headers, cors),
+            **kwargs,
         ) as r:
             check_response(r, expected_status, cache_expected=cache_expected)
             self._check_cors(cors, r)
@@ -122,14 +125,16 @@ class Connection:
         self,
         url: str,
         expected_status: int = 200,
-        headers: Optional[Mapping[str, str]] = None,
+        headers: Mapping[str, str] | None = None,
         cors: bool = True,
         cache_expected: CacheExpected = CacheExpected.NO,
         **kwargs: Any,
     ) -> Any:
         """POST files to the the given URL (relative to the root of API)."""
         with self.session.post(
-            self.base_url + url, headers=self._merge_headers(headers, cors), **kwargs
+            self.base_url + url,
+            headers=self._merge_headers(headers, cors),
+            **kwargs,
         ) as r:
             check_response(r, expected_status, cache_expected)
             self._check_cors(cors, r)
@@ -139,14 +144,16 @@ class Connection:
         self,
         url: str,
         expected_status: int = 200,
-        headers: Optional[Mapping[str, str]] = None,
+        headers: Mapping[str, str] | None = None,
         cors: bool = True,
         cache_expected: CacheExpected = CacheExpected.NO,
         **kwargs: Any,
-    ) -> Optional[str]:
+    ) -> str | None:
         """POST the given URL (relative to the root of API)."""
         with self.session.post(
-            self.base_url + url, headers=self._merge_headers(headers, cors), **kwargs
+            self.base_url + url,
+            headers=self._merge_headers(headers, cors),
+            **kwargs,
         ) as r:
             check_response(r, expected_status, cache_expected)
             self._check_cors(cors, r)
@@ -156,7 +163,7 @@ class Connection:
         self,
         url: str,
         expected_status: int = 200,
-        headers: Optional[Mapping[str, str]] = None,
+        headers: Mapping[str, str] | None = None,
         cors: bool = True,
         cache_expected: CacheExpected = CacheExpected.NO,
         **kwargs: Any,
@@ -171,14 +178,16 @@ class Connection:
         self,
         url: str,
         expected_status: int = 200,
-        headers: Optional[Mapping[str, str]] = None,
+        headers: Mapping[str, str] | None = None,
         cors: bool = True,
         cache_expected: CacheExpected = CacheExpected.NO,
         **kwargs: Any,
     ) -> Any:
         """PATCH the given URL (relative to the root of API)."""
         with self.session.patch(
-            self.base_url + url, headers=self._merge_headers(headers, cors), **kwargs
+            self.base_url + url,
+            headers=self._merge_headers(headers, cors),
+            **kwargs,
         ) as r:
             check_response(r, expected_status, cache_expected)
             self._check_cors(cors, r)
@@ -188,14 +197,16 @@ class Connection:
         self,
         url: str,
         expected_status: int = 204,
-        headers: Optional[Mapping[str, str]] = None,
+        headers: Mapping[str, str] | None = None,
         cors: bool = True,
         cache_expected: CacheExpected = CacheExpected.NO,
         **kwargs: Any,
     ) -> requests.Response:
         """DELETE the given URL (relative to the root of API)."""
         with self.session.delete(
-            self.base_url + url, headers=self._merge_headers(headers, cors), **kwargs
+            self.base_url + url,
+            headers=self._merge_headers(headers, cors),
+            **kwargs,
         ) as r:
             check_response(r, expected_status, cache_expected)
             self._check_cors(cors, r)
@@ -205,13 +216,15 @@ class Connection:
         self,
         url: str,
         expected_status: int = 200,
-        headers: Optional[Mapping[str, str]] = None,
+        headers: Mapping[str, str] | None = None,
         cache_expected: CacheExpected = CacheExpected.NO,
         **kwargs: Any,
     ) -> requests.Response:
         """Get the given URL (relative to the root of API)."""
         with self.session.options(
-            self.base_url + url, headers=self._merge_headers(headers, False), **kwargs
+            self.base_url + url,
+            headers=self._merge_headers(headers, cors=False),
+            **kwargs,
         ) as r:
             check_response(r, expected_status, cache_expected=cache_expected)
             return r
@@ -219,8 +232,7 @@ class Connection:
     def _cors_headers(self, cors: bool) -> Mapping[str, str]:
         if cors:
             return {"Origin": self.origin}
-        else:
-            return {}
+        return {}
 
     def _check_cors(self, cors: bool, r: requests.Response) -> None:
         if cors:
@@ -230,8 +242,10 @@ class Connection:
                 assert r.headers["Access-Control-Allow-Origin"] == "*"
 
     def _merge_headers(
-        self, headers: Optional[Mapping[str, Union[str, bytes]]], cors: bool
-    ) -> MutableMapping[str, Union[str, bytes]]:
+        self,
+        headers: Mapping[str, str | bytes] | None,
+        cors: bool,
+    ) -> MutableMapping[str, str | bytes]:
         merged = dict(headers) if headers is not None else {}
         if self.session.headers is not None:
             merged.update(self.session.headers)
@@ -265,9 +279,8 @@ def check_response(
 def _get_json(r: requests.Response) -> Any:
     if r.status_code == 204:
         return None
-    else:
-        content_type = r.headers["Content-Type"].split(";")[0]
-        assert content_type == "application/json" or content_type.endswith("+json"), (
-            f"{r.status_code}, {content_type}, {r.text}"
-        )
-        return r.json()
+    content_type = r.headers["Content-Type"].split(";")[0]
+    assert content_type == "application/json" or content_type.endswith("+json"), (
+        f"{r.status_code}, {content_type}, {r.text}"
+    )
+    return r.json()

c2cwsgiutils/acceptance/image.py

@@ -1,7 +1,7 @@
 import json
-import os
 import subprocess  # nosec
-from typing import TYPE_CHECKING, Any, Optional
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
 
 import numpy as np  # pylint: disable=import-error
 import skimage.color  # pylint: disable=import-error
@@ -10,7 +10,7 @@ import skimage.metrics  # pylint: disable=import-error
 import skimage.transform  # pylint: disable=import-error
 
 if TYPE_CHECKING:
-    from typing_extensions import TypeAlias
+    from typing import TypeAlias
 
     NpNdarrayInt: TypeAlias = np.ndarray[np.uint8, Any]
 else:
@@ -18,9 +18,9 @@ else:
 
 
 def check_image_file(
-    result_folder: str,
-    image_filename_to_check: str,
-    expected_filename: str,
+    result_folder: str | Path,
+    image_filename_to_check: str | Path,
+    expected_filename: str | Path,
     level: float = 1.0,
     generate_expected_image: bool = False,
     use_mask: bool = True,
@@ -40,7 +40,7 @@ def check_image_file(
     we use it as a mask.
     """
     result = skimage.io.imread(image_filename_to_check)
-    assert result is not None, "Wrong image: " + image_filename_to_check
+    assert result is not None, f"Wrong image: {image_filename_to_check}"
     check_image(result_folder, result, expected_filename, level, generate_expected_image, use_mask)
 
 
@@ -59,9 +59,9 @@ def normalize_image(image: NpNdarrayInt) -> NpNdarrayInt:
 
 
 def check_image(  # pylint: disable=too-many-locals,too-many-statements
-    result_folder: str,
+    result_folder: str | Path,
     image_to_check: NpNdarrayInt,
-    expected_filename: str,
+    expected_filename: str | Path,
     level: float = 1.0,
     generate_expected_image: bool = False,
     use_mask: bool = True,
@@ -92,18 +92,18 @@ def check_image(  # pylint: disable=too-many-locals,too-many-statements
 
     """
     assert image_to_check is not None, "Image required"
-    image_file_basename = os.path.splitext(os.path.basename(expected_filename))[0]
-    mask_filename: Optional[str] = None
+    result_folder = Path(result_folder)
+    expected_filename = Path(expected_filename)
+    image_file_basename = expected_filename.stem
+    mask_filename: Path | None = None
     if image_file_basename.endswith(".expected"):
-        image_file_basename = os.path.splitext(image_file_basename)[0]
+        image_file_basename = Path(image_file_basename).stem
         if use_mask:
-            mask_filename = os.path.join(
-                os.path.dirname(expected_filename), image_file_basename + ".mask.png"
-            )
-            if not os.path.isfile(mask_filename):
+            mask_filename = expected_filename.with_name(image_file_basename + ".mask.png")
+            if not mask_filename.is_file():
                 mask_filename = None
-    result_filename = os.path.join(result_folder, f"{image_file_basename}.actual-masked.png")
-    diff_filename = os.path.join(result_folder, f"{image_file_basename}.diff.png")
+    result_filename = result_folder / f"{image_file_basename}.actual-masked.png"
+    diff_filename = result_folder / f"{image_file_basename}.diff.png"
 
     image_to_check = normalize_image(image_to_check)
 
@@ -112,13 +112,15 @@ def check_image(  # pylint: disable=too-many-locals,too-many-statements
         background_color = [255, 255, 255]
         for color in range(3):
             img_hist, _ = skimage.exposure.histogram(
-                image_to_check[..., color], nbins=256, source_range="dtype"
+                image_to_check[..., color],
+                nbins=256,
+                source_range="dtype",
             )
             background_color[color] = np.argmax(img_hist)
 
         mask = skimage.io.imread(mask_filename)
 
-        assert mask is not None, "Wrong mask: " + mask_filename
+        assert mask is not None, "Wrong mask: " + str(mask_filename)
 
         # Normalize the mask
         if len(mask.shape) == 3 and mask.shape[2] == 3:
@@ -135,25 +137,25 @@ def check_image(  # pylint: disable=too-many-locals,too-many-statements
         # Convert to boolean
         mask = mask == 0
 
-        assert mask.shape[0] == image_to_check.shape[0] and mask.shape[1] == image_to_check.shape[1], (
+        assert mask.shape[0] == image_to_check.shape[0] and mask.shape[1] == image_to_check.shape[1], (  # noqa: PT018
             f"Mask and image should have the same shape ({mask.shape} != {image_to_check.shape})"
         )
         image_to_check[mask] = background_color
 
-    if not os.path.exists(result_folder):
-        os.makedirs(result_folder)
+    if not result_folder.exists():
+        result_folder.mkdir(parents=True)
     if generate_expected_image:
         skimage.io.imsave(expected_filename, image_to_check)
         return
-    if not os.path.isfile(expected_filename):
+    if not expected_filename.is_file():
         skimage.io.imsave(expected_filename, image_to_check)
-        raise AssertionError("Expected image not found: " + expected_filename)
+        raise AssertionError("Expected image not found: " + str(expected_filename))
     expected = skimage.io.imread(expected_filename)
-    assert expected is not None, "Wrong image: " + expected_filename
+    assert expected is not None, "Wrong image: " + str(expected_filename)
     expected = normalize_image(expected)
 
     if mask is not None:
-        assert expected.shape[0] == mask.shape[0] and expected.shape[1] == mask.shape[1], (
+        assert expected.shape[0] == mask.shape[0] and expected.shape[1] == mask.shape[1], (  # noqa: PT018
             f"Mask and expected image should have the same shape ({mask.shape} != {expected.shape})"
         )
         expected[mask] = background_color
@@ -162,7 +164,11 @@ def check_image(  # pylint: disable=too-many-locals,too-many-statements
         f"Images have different shapes expected {expected.shape} != actual {image_to_check.shape}"
     )
     score, diff = skimage.metrics.structural_similarity(
-        expected, image_to_check, multichannel=True, full=True, channel_axis=2
+        expected,
+        image_to_check,
+        multichannel=True,
+        full=True,
+        channel_axis=2,
     )
     diff = (255 - diff * 255).astype("uint8")
 
@@ -179,13 +185,13 @@ def check_image(  # pylint: disable=too-many-locals,too-many-statements
 
 def check_screenshot(
     url: str,
-    result_folder: str,
-    expected_filename: str,
+    result_folder: str | Path,
+    expected_filename: str | Path,
     width: int = 800,
     height: int = 600,
     sleep: int = 100,
-    headers: Optional[dict[str, str]] = None,
-    media: Optional[list[dict[str, str]]] = None,
+    headers: dict[str, str] | None = None,
+    media: list[dict[str, str]] | None = None,
     level: float = 1.0,
     generate_expected_image: bool = False,
     use_mask: bool = True,
@@ -216,15 +222,15 @@ def check_screenshot(
     if media is None:
         media = []
 
-    if not os.path.exists(os.path.join(os.path.dirname(__file__), "node_modules")):
-        subprocess.run(["npm", "install"], cwd=os.path.dirname(__file__), check=True)  # nosec
+    if not Path(__file__).parent.joinpath("node_modules").exists():
+        subprocess.run(["npm", "install"], cwd=Path(__file__).parent, check=True)  # nosec
 
-    image_file_basename = os.path.splitext(os.path.basename(expected_filename))[0]
+    image_file_basename = Path(expected_filename).stem
     if image_file_basename.endswith(".expected"):
-        image_file_basename = os.path.splitext(image_file_basename)[0]
+        image_file_basename = Path(image_file_basename).stem
 
-    result_folder = os.path.abspath(result_folder)
-    actual_filename = os.path.join(result_folder, f"{image_file_basename}.actual.png")
+    result_folder = Path(result_folder).resolve()
+    actual_filename = result_folder / f"{image_file_basename}.actual.png"
     subprocess.run(  # nosec
         [
             "node",
@@ -237,7 +243,7 @@ def check_screenshot(
             f"--media={json.dumps(media)}",
             f"--output={actual_filename}",
         ],
-        cwd=os.path.dirname(__file__),
+        cwd=Path(__file__).parent,
         check=True,
     )
     check_image(

c2cwsgiutils/acceptance/print.py

@@ -1,7 +1,7 @@
 import functools
 import json
 import logging
-from typing import Any, Optional
+from typing import Any
 
 import requests
 
@@ -56,7 +56,7 @@ class PrintConnection(connection.Connection):
         assert report.headers["Content-Type"] == "application/pdf"
         return report
 
-    def _check_completion(self, ref: str) -> Optional[Any]:
+    def _check_completion(self, ref: str) -> Any | None:
         status = self.get_json(f"status/{ref}.json")
         if status["done"]:
             return status

c2cwsgiutils/acceptance/utils.py

@@ -1,6 +1,7 @@
 import logging
 import time
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 import pytest
 import requests
@@ -18,8 +19,7 @@ def wait_url(url: str, timeout: float = _DEFAULT_TIMEOUT) -> None:
         if r.status_code == 200:
             _LOG.info("%s service started", url)
             return True
-        else:
-            return False
+        return False
 
     retry_timeout(what, timeout=timeout)
 
@@ -43,7 +43,7 @@ def retry_timeout(what: Callable[[], Any], timeout: float = _DEFAULT_TIMEOUT, in
                 return ret
         except NameError:
             raise
-        except Exception as e:  # pylint: disable=broad-except
+        except Exception as e:  # pylint: disable=broad-exception-caught
             error = str(e)
             _LOG.info("  Failed: %s", e)
         if time.perf_counter() > timeout:

c2cwsgiutils/auth.py

@@ -2,7 +2,7 @@ import hashlib
 import logging
 from collections.abc import Mapping
 from enum import Enum
-from typing import Any, Optional, TypedDict, cast
+from typing import Any, TypedDict, cast
 
 import jwt
 import pyramid.request
@@ -51,15 +51,15 @@ class AuthConfig(TypedDict, total=False):
     """Configuration of the authentication."""
 
     # The repository to check access to (<organization>/<repository>).
-    github_repository: Optional[str]
+    github_repository: str | None
     # The type of access to check (admin|push|pull).
-    github_access_type: Optional[str]
+    github_access_type: str | None
 
 
 def get_expected_secret(request: pyramid.request.Request) -> str:
     """Return the secret expected from the client."""
     settings = request.registry.settings
-    return cast(str, env_or_settings(settings, SECRET_ENV, SECRET_PROP, False))
+    return cast(str, env_or_settings(settings, SECRET_ENV, SECRET_PROP, default=False))
 
 
 def _hash_secret(secret: str) -> str:
@@ -80,10 +80,7 @@ def _is_auth_secret(request: pyramid.request.Request) -> bool:
     secret = request.params.get("secret")
     if secret is None:
         secret = request.headers.get("X-API-Key")
-    if secret is None:
-        secret_hash = request.cookies.get(SECRET_ENV)
-    else:
-        secret_hash = _hash_secret(secret)
+    secret_hash = request.cookies.get(SECRET_ENV) if secret is None else _hash_secret(secret)
 
     if secret_hash is not None:
         if secret_hash == "" or secret == "":  # nosec
@@ -94,7 +91,12 @@ def _is_auth_secret(request: pyramid.request.Request) -> bool:
             return False
         # Login or refresh the cookie
         request.response.set_cookie(
-            SECRET_ENV, secret_hash, max_age=_COOKIE_AGE, httponly=True, secure=True, samesite="Strict"
+            SECRET_ENV,
+            secret_hash,
+            max_age=_COOKIE_AGE,
+            httponly=True,
+            secure=True,
+            samesite="Strict",
         )
         # Since this could be used from outside c2cwsgiutils views, we cannot set the path to c2c
         return True
@@ -158,7 +160,8 @@ def is_auth(request: pyramid.request.Request) -> bool:
 def auth_view(request: pyramid.request.Request) -> None:
     """Get the authentication view."""
     if not is_auth(request):
-        raise HTTPForbidden("Missing or invalid secret (parameter, X-API-Key header or cookie)")
+        message = "Missing or invalid secret (parameter, X-API-Key header or cookie)"
+        raise HTTPForbidden(message)
 
 
 class AuthenticationType(Enum):
@@ -172,7 +175,7 @@ class AuthenticationType(Enum):
     GITHUB = 2
 
 
-def auth_type(settings: Optional[Mapping[str, Any]]) -> Optional[AuthenticationType]:
+def auth_type(settings: Mapping[str, Any] | None) -> AuthenticationType | None:
     """Get the authentication type."""
     if env_or_settings(settings, SECRET_ENV, SECRET_PROP, "") != "":
         return AuthenticationType.SECRET
@@ -198,7 +201,9 @@ def auth_type(settings: Optional[Mapping[str, Any]]) -> Optional[AuthenticationT
 
 
 def check_access(
-    request: pyramid.request.Request, repo: Optional[str] = None, access_type: Optional[str] = None
+    request: pyramid.request.Request,
+    repo: str | None = None,
+    access_type: str | None = None,
 ) -> bool:
     """
     Check if the user has access to the resource.
@@ -274,7 +279,9 @@ def check_access_config(request: pyramid.request.Request, auth_config: AuthConfi
 
 
 def is_enabled(
-    config: pyramid.config.Configurator, env_name: Optional[str] = None, config_name: Optional[str] = None
+    config: pyramid.config.Configurator,
+    env_name: str | None = None,
+    config_name: str | None = None,
 ) -> bool:
     """Is the authentication enable."""
     return (