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

c2cwsgiutils/acceptance/package.json

@@ -0,0 +1,7 @@
+{
+  "dependencies": {
+    "commander": "11.0.0",
+    "puppeteer": "21.3.5"
+  },
+  "type": "module"
+}

c2cwsgiutils/acceptance/print.py

@@ -1,7 +1,7 @@
 import functools
 import json
 import logging
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 import requests
 
@@ -23,7 +23,7 @@ class PrintConnection(connection.Connection):
             origin: The origin and referrer to include in the requests
         """
         super().__init__(base_url=base_url, origin=origin)
-        self.session.headers["Referer"] = origin
+        self.session.headers["Referrer"] = origin
 
     def wait_ready(self, timeout: int = 60, app: str = "default") -> None:
         """Wait the print instance to be ready."""
@@ -32,14 +32,14 @@ class PrintConnection(connection.Connection):
     def get_capabilities(self, app: str) -> Any:
         return self.get_json(app + "/capabilities.json", cache_expected=connection.CacheExpected.YES)
 
-    def get_example_requests(self, app: str) -> Dict[str, Any]:
+    def get_example_requests(self, app: str) -> dict[str, Any]:
         samples = self.get_json(app + "/exampleRequest.json", cache_expected=connection.CacheExpected.YES)
         out = {}
         for name, value in samples.items():
             out[name] = json.loads(value)
         return out
 
-    def get_pdf(self, app: str, request: Dict[str, Any], timeout: int = 60) -> requests.Response:
+    def get_pdf(self, app: str, request: dict[str, Any], timeout: int = 60) -> requests.Response:
         create_report = self.post_json(app + "/report.pdf", json=request)
         LOG.debug("create_report=%s", create_report)
         ref = create_report["ref"]

c2cwsgiutils/acceptance/screenshot.js

@@ -0,0 +1,62 @@
+import puppeteer from 'puppeteer';
+import { program } from 'commander';
+
+program
+  .option('--url <char>', 'The URL')
+  .option('--output <char>', 'The output filename')
+  .option('--width <int>', 'The page width', 800)
+  .option('--height <int>', 'The page height', 600)
+  .option('--headers <str>', 'The headers', '{}')
+  // see: https://pptr.dev/api/puppeteer.page.emulatemediafeatures
+  .option('--media <str>', 'The media feature, see Page.emulateMediaFeatures', '[]');
+
+program.parse();
+
+const options = program.opts();
+
+(async () => {
+  const browser = await puppeteer.launch({
+    headless: 'new',
+    args: ['--no-sandbox', '--disable-web-security'],
+  });
+  const page = await browser.newPage();
+  page.setDefaultNavigationTimeout(60000);
+  await page.setExtraHTTPHeaders(JSON.parse(options.headers));
+  await page.emulateMediaFeatures(JSON.parse(options.media));
+
+  page.on('console', async (msg) => {
+    const msgArgs = msg.args();
+    for (let i = 0; i < msgArgs.length; ++i) {
+      console.log(await msgArgs[i].jsonValue());
+    }
+  });
+  page.on('error', (err) => {
+    console.log('error', err);
+  });
+  page.on('pageerror', (err) => {
+    console.log('pageerror', err);
+  });
+  page.on('requestfailed', (request) => {
+    console.log('requestfailed on URL:', request.url());
+    console.log(request.failure());
+    const response = request.response();
+    if (response !== null) {
+      console.log(response);
+      console.log(response.status());
+      console.log(response.statusText());
+      console.log(response.text());
+    }
+  });
+
+  await page.goto(options.url, { timeout: 60000 });
+
+  await page.setViewport({
+    width: parseInt(options.width),
+    height: parseInt(options.height),
+  });
+  await page.screenshot({
+    path: options.output,
+    clip: { x: 0, y: 0, width: parseInt(options.width), height: parseInt(options.height) },
+  });
+  await browser.close();
+})();

c2cwsgiutils/acceptance/utils.py

@@ -1,33 +1,22 @@
 import logging
-import os
 import time
-from typing import Any, Callable, List, Tuple
+from typing import Any, Callable
 
-import boltons.iterutils
-import netifaces
 import pytest
 import requests
 
-LOG = logging.getLogger(__name__)
+_LOG = logging.getLogger(__name__)
+_DEFAULT_TIMEOUT = 60
 
 
-def in_docker() -> bool:
-    """Is in Docker mode."""
-    return os.environ.get("DOCKER_RUN") != "0"
-
-
-DOCKER_GATEWAY = netifaces.gateways()[netifaces.AF_INET][0][0] if in_docker() else "localhost"
-DEFAULT_TIMEOUT = 60
-
-
-def wait_url(url: str, timeout: float = DEFAULT_TIMEOUT) -> None:
+def wait_url(url: str, timeout: float = _DEFAULT_TIMEOUT) -> None:
     """Wait the the URL is available without any error."""
 
     def what() -> bool:
-        LOG.info("Trying to connect to %s... ", url)
+        _LOG.info("Trying to connect to %s... ", url)
         r = requests.get(url, timeout=timeout)
         if r.status_code == 200:
-            LOG.info("%s service started", url)
+            _LOG.info("%s service started", url)
             return True
         else:
             return False
@@ -35,7 +24,7 @@ def wait_url(url: str, timeout: float = DEFAULT_TIMEOUT) -> None:
     retry_timeout(what, timeout=timeout)
 
 
-def retry_timeout(what: Callable[[], Any], timeout: float = DEFAULT_TIMEOUT, interval: float = 0.5) -> Any:
+def retry_timeout(what: Callable[[], Any], timeout: float = _DEFAULT_TIMEOUT, interval: float = 0.5) -> Any:
     """
     Retry the function until the timeout.
 
@@ -45,7 +34,8 @@ def retry_timeout(what: Callable[[], Any], timeout: float = DEFAULT_TIMEOUT, int
         timeout: the timeout to get a success
         interval: the interval between try
     """
-    timeout = time.monotonic() + timeout
+
+    timeout = time.perf_counter() + timeout
     while True:
         error = ""
         try:
@@ -56,8 +46,8 @@ def retry_timeout(what: Callable[[], Any], timeout: float = DEFAULT_TIMEOUT, int
             raise
         except Exception as e:  # pylint: disable=broad-except
             error = str(e)
-            LOG.info("  Failed: %s", e)
-        if time.monotonic() > timeout:
+            _LOG.info("  Failed: %s", e)
+        if time.perf_counter() > timeout:
             assert False, "Timeout: " + error
         time.sleep(interval)
 
@@ -68,10 +58,12 @@ def approx(struct: Any, **kwargs: Any) -> Any:
 
     See pytest.approx
     """
+    import boltons.iterutils
+
     if isinstance(struct, float):
         return pytest.approx(struct, **kwargs)
 
-    def visit(_path: List[str], key: Any, value: Any) -> Tuple[Any, Any]:
+    def visit(_path: list[str], key: Any, value: Any) -> tuple[Any, Any]:
         if isinstance(value, float):
             value = pytest.approx(value, **kwargs)
         return key, value

c2cwsgiutils/auth.py

@@ -1,7 +1,8 @@
 import hashlib
 import logging
+from collections.abc import Mapping
 from enum import Enum
-from typing import Any, Mapping, Optional, Tuple, TypedDict, cast
+from typing import Any, Optional, TypedDict, cast
 
 import jwt
 import pyramid.request
@@ -98,8 +99,7 @@ def _is_auth_secret(request: pyramid.request.Request) -> bool:
     return False
 
 
-def _is_auth_user_github(request: pyramid.request.Request) -> Tuple[bool, UserDetails]:
-
+def _is_auth_user_github(request: pyramid.request.Request) -> tuple[bool, UserDetails]:
     settings = request.registry.settings
     cookie = request.cookies.get(
         env_or_settings(
@@ -129,7 +129,7 @@ def _is_auth_user_github(request: pyramid.request.Request) -> Tuple[bool, UserDe
     return False, {}
 
 
-def is_auth_user(request: pyramid.request.Request) -> Tuple[bool, UserDetails]:
+def is_auth_user(request: pyramid.request.Request) -> tuple[bool, UserDetails]:
     """
     Check if the client is authenticated.
 

c2cwsgiutils/broadcast/__init__.py

@@ -2,7 +2,7 @@
 import functools
 import logging
 import warnings
-from typing import Any, Callable, Dict, List, Optional, TypeVar
+from typing import Any, Callable, Optional, TypeVar
 
 import pyramid.config
 
@@ -36,11 +36,12 @@ def includeme(config: Optional[pyramid.config.Configurator] = None) -> None:
     if _broadcaster is None:
         if master is not None and slave is not None:
             _broadcaster = redis.RedisBroadcaster(broadcast_prefix, master, slave)
+            LOG.info("Broadcast service setup using Redis implementation")
         else:
             _broadcaster = local.LocalBroadcaster()
             LOG.info("Broadcast service setup using local implementation")
     elif isinstance(_broadcaster, local.LocalBroadcaster) and master is not None and slave is not None:
-        LOG.info("Switching from a local broadcaster to a redis broadcaster")
+        LOG.info("Switching from a local broadcaster to a Redis broadcaster")
         prev_broadcaster = _broadcaster
         _broadcaster = redis.RedisBroadcaster(broadcast_prefix, master, slave)
         _broadcaster.copy_local_subscriptions(prev_broadcaster)
@@ -55,6 +56,13 @@ def _get(need_init: bool = False) -> interface.BaseBroadcaster:
     return _broadcaster
 
 
+def cleanup() -> None:
+    """Cleanup the broadcaster to force to reinitialize it."""
+
+    global _broadcaster
+    _broadcaster = None
+
+
 def subscribe(channel: str, callback: Callable[..., Any]) -> None:
     """
     Subscribe to a broadcast channel with the given callback.
@@ -73,8 +81,8 @@ def unsubscribe(channel: str) -> None:
 
 
 def broadcast(
-    channel: str, params: Optional[Dict[str, Any]] = None, expect_answers: bool = False, timeout: float = 10
-) -> Optional[List[Any]]:
+    channel: str, params: Optional[dict[str, Any]] = None, expect_answers: bool = False, timeout: float = 10
+) -> Optional[list[Any]]:
     """
     Broadcast a message to the given channel.
 
@@ -92,16 +100,16 @@ _DECORATOR_RETURN = TypeVar("_DECORATOR_RETURN")
 
 def decorator(
     channel: Optional[str] = None, expect_answers: bool = False, timeout: float = 10
-) -> Callable[[Callable[..., _DECORATOR_RETURN]], Callable[..., Optional[List[_DECORATOR_RETURN]]]]:
+) -> Callable[[Callable[..., _DECORATOR_RETURN]], Callable[..., Optional[list[_DECORATOR_RETURN]]]]:
     """
     Decorate function will be called through the broadcast functionality.
 
     If expect_answers is set to True, the returned value will be a list of all the answers.
     """
 
-    def impl(func: Callable[..., _DECORATOR_RETURN]) -> Callable[..., Optional[List[_DECORATOR_RETURN]]]:
+    def impl(func: Callable[..., _DECORATOR_RETURN]) -> Callable[..., Optional[list[_DECORATOR_RETURN]]]:
         @functools.wraps(func)
-        def wrapper(**kwargs: Any) -> Optional[List[_DECORATOR_RETURN]]:
+        def wrapper(**kwargs: Any) -> Optional[list[_DECORATOR_RETURN]]:
             return broadcast(_channel, params=kwargs, expect_answers=expect_answers, timeout=timeout)
 
         if channel is None:

c2cwsgiutils/broadcast/interface.py

@@ -1,5 +1,6 @@
 from abc import abstractmethod
-from typing import Any, Callable, List, Mapping, Optional
+from collections.abc import Mapping
+from typing import Any, Callable, Optional
 
 
 class BaseBroadcaster:
@@ -16,5 +17,5 @@ class BaseBroadcaster:
     @abstractmethod
     def broadcast(
         self, channel: str, params: Mapping[str, Any], expect_answers: bool, timeout: float
-    ) -> Optional[List[Any]]:
+    ) -> Optional[list[Any]]:
         pass  # pragma: no cover

c2cwsgiutils/broadcast/local.py

@@ -1,4 +1,5 @@
-from typing import Any, Callable, List, Mapping, MutableMapping, Optional
+from collections.abc import Mapping, MutableMapping
+from typing import Any, Callable, Optional
 
 # noinspection PyProtectedMember
 from c2cwsgiutils.broadcast import interface, utils
@@ -18,7 +19,7 @@ class LocalBroadcaster(interface.BaseBroadcaster):
 
     def broadcast(
         self, channel: str, params: Mapping[str, Any], expect_answers: bool, timeout: float
-    ) -> Optional[List[Any]]:
+    ) -> Optional[list[Any]]:
         subscriber = self._subscribers.get(channel, None)
         answers = [utils.add_host_info(subscriber(**params))] if subscriber is not None else []
         return answers if expect_answers else None

c2cwsgiutils/broadcast/redis.py

@@ -4,9 +4,10 @@ import random
 import string
 import threading
 import time
-from typing import Any, Callable, List, Mapping, Optional
+from collections.abc import Mapping
+from typing import Any, Callable, Optional
 
-import redis  # pylint: disable=unused-import
+import redis
 
 from c2cwsgiutils.broadcast import interface, local, utils
 
@@ -46,7 +47,7 @@ class RedisBroadcaster(interface.BaseBroadcaster):
                 response = callback(**data["params"])
             except Exception as e:  # pragma: no cover  # pylint: disable=broad-except
                 LOG.error("Failed handling a broadcast message", exc_info=True)
-                response = dict(status=500, message=str(e))
+                response = {"status": 500, "message": str(e)}
             answer_channel = data.get("answer_channel")
             if answer_channel is not None:
                 LOG.debug("Sending broadcast answer on %s", answer_channel)
@@ -63,7 +64,7 @@ class RedisBroadcaster(interface.BaseBroadcaster):
 
     def broadcast(
         self, channel: str, params: Mapping[str, Any], expect_answers: bool, timeout: float
-    ) -> Optional[List[Any]]:
+    ) -> Optional[list[Any]]:
         if expect_answers:
             return self._broadcast_with_answer(channel, params, timeout)
         else:
@@ -72,7 +73,7 @@ class RedisBroadcaster(interface.BaseBroadcaster):
 
     def _broadcast_with_answer(
         self, channel: str, params: Optional[Mapping[str, Any]], timeout: float
-    ) -> List[Any]:
+    ) -> list[Any]:
         cond = threading.Condition()
         answers = []
         assert self._thread.is_alive()
@@ -93,10 +94,10 @@ class RedisBroadcaster(interface.BaseBroadcaster):
         try:
             nb_received = self._broadcast(channel, message)
 
-            timeout_time = time.monotonic() + timeout
+            timeout_time = time.perf_counter() + timeout
             with cond:
                 while len(answers) < nb_received:
-                    to_wait = timeout_time - time.monotonic()
+                    to_wait = timeout_time - time.perf_counter()
                     if to_wait <= 0.0:  # pragma: no cover
                         LOG.warning(
                             "timeout waiting for %d/%d answers on %s",

c2cwsgiutils/client_info.py

@@ -1,5 +1,5 @@
 import re
-from typing import Any, Callable, Dict
+from typing import Any, Callable
 
 SEP_RE = re.compile(r", *")
 
@@ -12,10 +12,10 @@ class Filter:
     Concerned headers: Forwarded and the X_Forwarded_* Headers.
     """
 
-    def __init__(self, application: Callable[[Dict[str, str], Any], Any]):
+    def __init__(self, application: Callable[[dict[str, str], Any], Any]):
         self._application = application
 
-    def __call__(self, environ: Dict[str, str], start_response: Any) -> Any:
+    def __call__(self, environ: dict[str, str], start_response: Any) -> Any:
         # https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Forwarded
         if "HTTP_FORWARDED" in environ:
             _handle_forwarded(environ)
@@ -25,7 +25,7 @@ class Filter:
         return self._application(environ, start_response)
 
 
-def _handle_others(environ: Dict[str, str]) -> None:
+def _handle_others(environ: dict[str, str]) -> None:
     # The rest is taken from paste.deploy.config.PrefixMiddleware
     if "HTTP_X_FORWARDED_SERVER" in environ:
         environ["HTTP_ORIGINAL_X_FORWARDED_SERVER"] = environ["HTTP_X_FORWARDED_SERVER"]
@@ -45,7 +45,7 @@ def _handle_others(environ: Dict[str, str]) -> None:
         environ["wsgi.url_scheme"] = environ.pop("HTTP_X_FORWARDED_PROTO")
 
 
-def _handle_forwarded(environ: Dict[str, str]) -> None:
+def _handle_forwarded(environ: dict[str, str]) -> None:
     environ["HTTP_ORIGINAL_FORWARDED"] = environ["HTTP_FORWARDED"]
     for header in (
         "X_FORWARDED_SERVER",

c2cwsgiutils/config_utils.py

@@ -1,6 +1,7 @@
 """Private utilities."""
 import os
-from typing import Any, Callable, Mapping, Optional, cast
+from collections.abc import Mapping
+from typing import Any, Callable, Optional, cast
 
 import pyramid.config
 

c2cwsgiutils/coverage_setup.py

@@ -9,13 +9,13 @@ LOG = logging.getLogger(__name__)
 
 
 def init() -> None:
-    """Initialise the code coverage, for backward compatibility."""
+    """Initialize the code coverage, for backward compatibility."""
     warnings.warn("init function is deprecated; use includeme instead")
     includeme()
 
 
 def includeme(config: Optional[pyramid.config.Configurator] = None) -> None:
-    """Initialise the code coverage."""
+    """Initialize the code coverage."""
     if os.environ.get("COVERAGE", "0") != "1":
         return
     import coverage