c2cwsgiutils 5.2.1__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
 
@@ -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,7 +4,8 @@ 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
 
@@ -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/db.py

@@ -2,7 +2,9 @@
 import logging
 import re
 import warnings
-from typing import Any, Callable, Iterable, Optional, Pattern, Tuple, Union, cast
+from collections.abc import Iterable
+from re import Pattern
+from typing import TYPE_CHECKING, Any, Callable, Optional, Union, cast
 
 import pyramid.config
 import pyramid.config.settings
@@ -12,9 +14,16 @@ import sqlalchemy.orm
 import transaction
 import zope.sqlalchemy
 from sqlalchemy import engine_from_config
-from sqlalchemy.orm import sessionmaker
 from zope.sqlalchemy import register
 
+if TYPE_CHECKING:
+    scoped_session = sqlalchemy.orm.scoped_session[sqlalchemy.orm.Session]
+    sessionmaker = sqlalchemy.orm.sessionmaker[sqlalchemy.orm.Session]
+else:
+    scoped_session = sqlalchemy.orm.scoped_session
+    sessionmaker = sqlalchemy.orm.sessionmaker
+
+
 LOG = logging.getLogger(__name__)
 RE_COMPILE: Callable[[str], Pattern[str]] = re.compile
 
@@ -34,8 +43,8 @@ def setup_session(
     slave_prefix: Optional[str] = None,
     force_master: Optional[Iterable[str]] = None,
     force_slave: Optional[Iterable[str]] = None,
-) -> Tuple[
-    Union[sqlalchemy.orm.Session, sqlalchemy.orm.scoped_session[sqlalchemy.orm.Session]],
+) -> tuple[
+    Union[sqlalchemy.orm.Session, scoped_session],
     sqlalchemy.engine.Engine,
     sqlalchemy.engine.Engine,
 ]:
@@ -95,7 +104,7 @@ def create_session(
     force_master: Optional[Iterable[str]] = None,
     force_slave: Optional[Iterable[str]] = None,
     **engine_config: Any,
-) -> Union[sqlalchemy.orm.Session, sqlalchemy.orm.scoped_session[sqlalchemy.orm.Session]]:
+) -> Union[sqlalchemy.orm.Session, scoped_session]:
     """
     Create a SQLAlchemy session.
 
@@ -147,7 +156,7 @@ def create_session(
 def _add_tween(
     config: pyramid.config.Configurator,
     name: str,
-    db_session: sqlalchemy.orm.scoped_session[sqlalchemy.orm.Session],
+    db_session: scoped_session,
     force_master: Optional[Iterable[str]],
     force_slave: Optional[Iterable[str]],
 ) -> None:
@@ -201,7 +210,7 @@ def _add_tween(
     config.add_tween("c2cwsgiutils.db.tweens." + name, over="pyramid_tm.tm_tween_factory")
 
 
-class SessionFactory(sessionmaker[sqlalchemy.orm.Session]):  # pylint: disable=unsubscriptable-object
+class SessionFactory(sessionmaker):
     """The custom session factory that manage the read only and read write sessions."""
 
     def __init__(
@@ -226,7 +235,7 @@ class SessionFactory(sessionmaker[sqlalchemy.orm.Session]):  # pylint: disable=u
 
     def __call__(  # type: ignore
         self, request: Optional[pyramid.request.Request], readwrite: Optional[bool] = None, **local_kw: Any
-    ) -> sqlalchemy.orm.scoped_session[sqlalchemy.orm.Session]:
+    ) -> scoped_session:
         if readwrite is not None:
             if readwrite and not force_readonly:
                 LOG.debug("Using %s database", self.rw_engine.c2c_name)  # type: ignore
@@ -262,7 +271,7 @@ def get_engine(
 
 def get_session_factory(
     engine: sqlalchemy.engine.Engine,
-) -> sessionmaker[sqlalchemy.orm.Session]:  # pylint: disable=unsubscriptable-object
+) -> sessionmaker:
     """Get the session factory from the engine."""
     factory = sessionmaker()
     factory.configure(bind=engine)
@@ -270,7 +279,7 @@ def get_session_factory(
 
 
 def get_tm_session(
-    session_factory: sessionmaker[sqlalchemy.orm.Session],  # pylint: disable=unsubscriptable-object
+    session_factory: sessionmaker,
     transaction_manager: transaction.TransactionManager,
 ) -> sqlalchemy.orm.Session:
     """
@@ -338,7 +347,7 @@ def get_tm_session_pyramid(
     session_factory: SessionFactory,
     transaction_manager: transaction.TransactionManager,
     request: pyramid.request.Request,
-) -> sqlalchemy.orm.scoped_session[sqlalchemy.orm.Session]:
+) -> scoped_session:
     """
     Get a ``sqlalchemy.orm.Session`` instance backed by a transaction.
 

c2cwsgiutils/db_maintenance_view.py

@@ -1,6 +1,7 @@
 import logging
 import warnings
-from typing import Any, Mapping, Optional, cast
+from collections.abc import Mapping
+from typing import Any, Optional, cast
 
 import pyramid.request
 

c2cwsgiutils/debug/_listeners.py

@@ -3,7 +3,8 @@ import sys
 import threading
 import time
 import traceback
-from typing import Any, Dict, List, Mapping, Optional, Tuple, cast
+from collections.abc import Mapping
+from typing import Any, Optional, cast
 
 import objgraph
 
@@ -13,7 +14,7 @@ from c2cwsgiutils.debug.utils import get_size
 FILES_FIELDS = {"__name__", "__doc__", "__package__", "__loader__", "__spec__", "__file__"}
 
 
-def _dump_stacks_impl() -> Dict[str, Any]:
+def _dump_stacks_impl() -> dict[str, Any]:
     id2name = {th.ident: th.name for th in threading.enumerate()}
     threads = {}
     for thread_id, stack in sys._current_frames().items():  # pylint: disable=W0212
@@ -47,10 +48,10 @@ def _dump_memory_impl(
 
     if analyze_type:
         # timeout after one minute, must be set to a bit less that the timeout of the broadcast in _views.py
-        timeout = time.monotonic() + 60
+        timeout = time.perf_counter() + 60
 
-        mod_counts: Dict[str, int] = {}
-        biggest_objects: List[Tuple[float, Any]] = []
+        mod_counts: dict[str, int] = {}
+        biggest_objects: list[tuple[float, Any]] = []
         result[analyze_type] = {}
         for obj in objgraph.by_type(analyze_type):
             if analyze_type == "builtins.function":
@@ -80,7 +81,7 @@ def _dump_memory_impl(
                     biggest_objects.sort(key=lambda x: x[0])
                     if len(biggest_objects) > limit:
                         biggest_objects = biggest_objects[-limit:]
-            if time.monotonic() > timeout:
+            if time.perf_counter() > timeout:
                 result[analyze_type]["timeout"] = True
                 break
         if analyze_type == "builtins.function":

c2cwsgiutils/debug/_views.py

@@ -2,9 +2,10 @@ import gc
 import logging
 import re
 import time
+from collections.abc import Mapping
 from datetime import datetime
 from io import StringIO
-from typing import Any, Callable, Dict, List, Mapping, cast
+from typing import Any, Callable, cast
 
 import objgraph
 import pyramid.config
@@ -19,9 +20,9 @@ LOG = logging.getLogger(__name__)
 SPACE_RE = re.compile(r" +")
 
 
-def _beautify_stacks(source: List[Mapping[str, Any]]) -> List[Mapping[str, Any]]:
+def _beautify_stacks(source: list[Mapping[str, Any]]) -> list[Mapping[str, Any]]:
     """Group the identical stacks together along with a list of threads sporting them."""
-    results: List[Mapping[str, Any]] = []
+    results: list[Mapping[str, Any]] = []
     for host_stacks in source:
         host_id = f"{host_stacks['hostname']}/{host_stacks['pid']:d}"
         for thread, frames in host_stacks["threads"].items():
@@ -35,14 +36,14 @@ def _beautify_stacks(source: List[Mapping[str, Any]]) -> List[Mapping[str, Any]]
     return results
 
 
-def _dump_stacks(request: pyramid.request.Request) -> List[Mapping[str, Any]]:
+def _dump_stacks(request: pyramid.request.Request) -> list[Mapping[str, Any]]:
     auth.auth_view(request)
     result = broadcast.broadcast("c2c_dump_stacks", expect_answers=True)
     assert result is not None
     return _beautify_stacks(result)
 
 
-def _dump_memory(request: pyramid.request.Request) -> List[Mapping[str, Any]]:
+def _dump_memory(request: pyramid.request.Request) -> list[Mapping[str, Any]]:
     auth.auth_view(request)
     limit = int(request.params.get("limit", "30"))
     analyze_type = request.params.get("analyze_type")
@@ -57,7 +58,7 @@ def _dump_memory(request: pyramid.request.Request) -> List[Mapping[str, Any]]:
     return result
 
 
-def _dump_memory_diff(request: pyramid.request.Request) -> List[Any]:
+def _dump_memory_diff(request: pyramid.request.Request) -> list[Any]:
     auth.auth_view(request)
     limit = int(request.params.get("limit", "30"))
     if "path" in request.matchdict:
@@ -81,7 +82,7 @@ def _dump_memory_diff(request: pyramid.request.Request) -> List[Any]:
 
     LOG.debug("checking memory growth for %s", path)
 
-    peak_stats: Dict[Any, Any] = {}
+    peak_stats: dict[Any, Any] = {}
     for i in range(3):
         gc.collect(i)
 
@@ -158,7 +159,7 @@ def _add_view(
     config.add_view(view, route_name="c2c_debug_" + name, renderer="fast_json", http_cache=0)
 
 
-def _dump_memory_maps(request: pyramid.request.Request) -> List[Dict[str, Any]]:
+def _dump_memory_maps(request: pyramid.request.Request) -> list[dict[str, Any]]:
     auth.auth_view(request)
     return sorted(dump_memory_maps(), key=lambda i: cast(int, -i.get("pss_kb", 0)))
 
@@ -168,13 +169,13 @@ def _show_refs(request: pyramid.request.Request) -> pyramid.response.Response:
     for generation in range(3):
         gc.collect(generation)
 
-    objs: List[Any] = []
+    objs: list[Any] = []
     if "analyze_type" in request.params:
         objs = objgraph.by_type(request.params["analyze_type"])
     elif "analyze_id" in request.params:
         objs = [objgraph.by(int(request.params["analyze_id"]))]
 
-    args: Dict[str, Any] = {
+    args: dict[str, Any] = {
         "refcounts": True,
     }
     if request.params.get("max_depth", "") != "":

c2cwsgiutils/debug/utils.py

@@ -5,7 +5,7 @@ import re
 import sys
 from collections import defaultdict
 from types import FunctionType, ModuleType
-from typing import Any, Dict, List, Set
+from typing import Any
 
 # 7ff7d33bd000-7ff7d33be000 r--p 00000000 00:65 49                         /usr/lib/toto.so
 SMAPS_LOCATION_RE = re.compile(r"^[0-9a-f]+-[0-9a-f]+ +.... +[0-9a-f]+ +[^ ]+ +\d+ +(.*)$")
@@ -21,7 +21,7 @@ def get_size(obj: Any) -> int:
     """Get the sum size of object & members."""
     if isinstance(obj, BLACKLIST):
         return 0
-    seen_ids: Set[int] = set()
+    seen_ids: set[int] = set()
     size = 0
     objects = [obj]
     while objects:
@@ -35,14 +35,14 @@ def get_size(obj: Any) -> int:
     return size
 
 
-def dump_memory_maps(pid: str = "self") -> List[Dict[str, Any]]:
+def dump_memory_maps(pid: str = "self") -> list[dict[str, Any]]:
     """Get the Linux memory maps."""
     filename = os.path.join("/proc", pid, "smaps")
     if not os.path.exists(filename):
         return []
     with open(filename, encoding="utf-8") as input_:
-        cur_dict: Dict[str, int] = defaultdict(int)
-        sizes: Dict[str, Any] = {}
+        cur_dict: dict[str, int] = defaultdict(int)
+        sizes: dict[str, Any] = {}
         for line in input_:
             line = line.rstrip("\n")
             matcher = SMAPS_LOCATION_RE.match(line)