c2cwsgiutils 5.1.7.dev20230901073305__py3-none-any.whl → 5.2.1.dev197__py3-none-any.whl

c2cwsgiutils/__init__.py

@@ -4,12 +4,12 @@ import os
 import re
 import sys
 from configparser import SectionProxy
-from typing import Any, Dict, Set
+from typing import Any
 
 LOG = logging.getLogger(__name__)
 
 
-def get_config_defaults() -> Dict[str, str]:
+def get_config_defaults() -> dict[str, str]:
     """
     Get the environment variables as defaults for configparser.
 
@@ -18,8 +18,8 @@ def get_config_defaults() -> Dict[str, str]:
 
     configparser interpretate the % then we need to escape them
     """
-    result: Dict[str, str] = {}
-    lowercase_keys: Set[str] = set()
+    result: dict[str, str] = {}
+    lowercase_keys: set[str] = set()
     for key, value in os.environ.items():
         if key.lower() in lowercase_keys:
             LOG.warning("The environment variable '%s' is duplicated with different case, ignoring", key)
@@ -29,15 +29,15 @@ def get_config_defaults() -> Dict[str, str]:
     return result
 
 
-def _create_handlers(config: configparser.ConfigParser) -> Dict[str, Any]:
+def _create_handlers(config: configparser.ConfigParser) -> dict[str, Any]:
     handlers = [k.strip() for k in config["handlers"]["keys"].split(",")]
-    d_handlers: Dict[str, Any] = {}
+    d_handlers: dict[str, Any] = {}
     stream_re = re.compile(r"\((.*?),\)")
     for hh in handlers:
         block = config[f"handler_{hh}"]
         stream_match = stream_re.match(block["args"])
         if stream_match is None:
-            raise Exception(f"Could not parse args of handler {hh}")
+            raise Exception(f"Could not parse args of handler {hh}")  # pylint: disable=broad-exception-raised
         args = stream_match.groups()[0]
         c = block["class"]
         if "." not in c:
@@ -53,8 +53,8 @@ def _create_handlers(config: configparser.ConfigParser) -> Dict[str, Any]:
     return d_handlers
 
 
-def _filter_logger(block: SectionProxy) -> Dict[str, Any]:
-    out: Dict[str, Any] = {"level": block["level"]}
+def _filter_logger(block: SectionProxy) -> dict[str, Any]:
+    out: dict[str, Any] = {"level": block["level"]}
     handlers = block.get("handlers", "")
     if handlers != "":
         out["handlers"] = [block["handlers"]]
@@ -65,7 +65,7 @@ def _filter_logger(block: SectionProxy) -> Dict[str, Any]:
 # logging configuration
 # https://docs.python.org/3/library/logging.config.html#logging-config-dictschema
 ###
-def get_logconfig_dict(filename: str) -> Dict[str, Any]:
+def get_logconfig_dict(filename: str) -> dict[str, Any]:
     """
     Create a logconfig dictionary based on the provided ini file.
 
@@ -76,8 +76,8 @@ def get_logconfig_dict(filename: str) -> Dict[str, Any]:
     loggers = [k.strip() for k in config["loggers"]["keys"].split(",")]
     formatters = [k.strip() for k in config["formatters"]["keys"].split(",")]
 
-    d_loggers: Dict[str, Any] = {}
-    root: Dict[str, Any] = {}
+    d_loggers: dict[str, Any] = {}
+    root: dict[str, Any] = {}
     for ll in loggers:
         block = config[f"logger_{ll}"]
         if ll == "root":
@@ -86,7 +86,7 @@ def get_logconfig_dict(filename: str) -> Dict[str, Any]:
         qualname = block["qualname"]
         d_loggers[qualname] = _filter_logger(block)
 
-    d_formatters: Dict[str, Any] = {}
+    d_formatters: dict[str, Any] = {}
     for ff in formatters:
         block = config[f"formatter_{ff}"]
         d_formatters[ff] = {

c2cwsgiutils/acceptance/connection.py

@@ -1,9 +1,9 @@
 import re
+from collections.abc import Mapping, MutableMapping
 from enum import Enum
-from typing import Any, Mapping, MutableMapping, Optional, Union
+from typing import Any, Optional, Union
 
 import requests
-from lxml import etree  # nosec
 
 COLON_SPLIT_RE = re.compile(r"\s*,\s*")
 
@@ -82,6 +82,9 @@ class Connection:
         **kwargs: Any,
     ) -> Any:
         """Get the given URL (relative to the root of API)."""
+
+        from lxml import etree  # nosec
+
         with self.session.get(
             self.base_url + url,
             headers=self._merge_headers(headers, cors),

c2cwsgiutils/acceptance/image.py

@@ -1,4 +1,6 @@
+import json
 import os
+import subprocess  # nosec
 from typing import TYPE_CHECKING, Any, Optional
 
 import numpy as np
@@ -8,7 +10,9 @@ import skimage.metrics
 import skimage.transform
 
 if TYPE_CHECKING:
-    NpNdarrayInt = np.ndarray[np.uint8, Any]
+    from typing import TypeAlias
+
+    NpNdarrayInt: TypeAlias = np.ndarray[np.uint8, Any]
 else:
     NpNdarrayInt = np.ndarray
 
@@ -40,6 +44,20 @@ def check_image_file(
     check_image(result_folder, result, expected_filename, level, generate_expected_image, use_mask)
 
 
+def normalize_image(image: NpNdarrayInt) -> NpNdarrayInt:
+    """
+    Normalize the image to be comparable.
+
+    - Remove the alpha channel
+    - Convert to uint8
+    """
+    if len(image.shape) == 3 and image.shape[2] == 4:
+        image = skimage.color.rgba2rgb(image)
+    if np.issubdtype(image.dtype, np.floating):
+        image = (image * 255).astype("uint8")
+    return image
+
+
 def check_image(
     result_folder: str,
     image_to_check: NpNdarrayInt,
@@ -78,11 +96,30 @@ def check_image(
     result_filename = os.path.join(result_folder, f"{image_file_basename}.result.png")
     diff_filename = os.path.join(result_folder, f"{image_file_basename}.diff.png")
 
+    image_to_check = normalize_image(image_to_check)
+
     mask = None
     if mask_filename is not None:
         mask = skimage.io.imread(mask_filename)
+
         assert mask is not None, "Wrong mask: " + mask_filename
-        image_to_check[mask == 0] = [255, 255, 255]
+
+        # Normalize the mask
+        if len(mask.shape) == 3 and mask.shape[2] == 3:
+            mask = skimage.color.rgb2gray(mask)
+
+        if len(mask.shape) == 3 and mask.shape[2] == 4:
+            mask = skimage.color.rgba2gray(mask)
+
+        if np.issubdtype(mask.dtype, np.floating):
+            mask = (mask * 255).astype("uint8")
+
+        assert ((0 < mask) & (mask < 255)).sum() == 0, "Mask should be only black and white image"
+
+        # Convert to boolean
+        mask = mask == 0
+
+        image_to_check[mask] = [255, 255, 255]
 
     if not os.path.exists(result_folder):
         os.makedirs(result_folder)
@@ -95,12 +132,13 @@ def check_image(
         assert False, "Expected image not found: " + expected_filename
     expected = skimage.io.imread(expected_filename)
     assert expected is not None, "Wrong image: " + expected_filename
+    expected = normalize_image(expected)
 
     if mask is not None:
-        expected[mask == 0] = [255, 255, 255]
+        expected[mask] = [255, 255, 255]
 
     score, diff = skimage.metrics.structural_similarity(
-        expected, image_to_check, multichannel=True, full=True
+        expected, image_to_check, multichannel=True, full=True, channel_axis=2
     )
     diff = (255 - diff * 255).astype("uint8")
 
@@ -113,3 +151,59 @@ def check_image(
         assert (
             score >= level
         ), f"{result_filename} != {expected_filename} => {diff_filename} ({score} < {level})"
+
+
+def check_screenshot(
+    url: str,
+    result_folder: str,
+    expected_filename: str,
+    width: int = 800,
+    height: int = 600,
+    headers: Optional[dict[str, str]] = None,
+    media: Optional[list[dict[str, str]]] = None,
+    level: float = 1.0,
+    generate_expected_image: bool = False,
+    use_mask: bool = True,
+) -> None:
+    """
+    Test that the screenshot of the `url` corresponds to the image `expected_filename`.
+
+    Requires nodejs with puppeteer and commander to be installed.
+    """
+
+    if headers is None:
+        headers = {}
+    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
+
+    image_file_basename = os.path.splitext(os.path.basename(expected_filename))[0]
+    if image_file_basename.endswith(".expected"):
+        image_file_basename = os.path.splitext(image_file_basename)[0]
+
+    result_folder = os.path.abspath(result_folder)
+    actual_filename = os.path.join(result_folder, f"{image_file_basename}.actual.png")
+    subprocess.run(  # nosec
+        [
+            "node",
+            "screenshot.js",
+            f"--url={url}",
+            f"--width={width}",
+            f"--height={height}",
+            f"--headers={json.dumps(headers)}",
+            f"--media={json.dumps(media)}",
+            f"--output={actual_filename}",
+        ],
+        cwd=os.path.dirname(__file__),
+        check=True,
+    )
+    check_image(
+        result_folder,
+        skimage.io.imread(actual_filename)[:, :, :3],
+        expected_filename,
+        level,
+        generate_expected_image,
+        use_mask,
+    )