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

c2cwsgiutils/broadcast/__init__.py

@@ -3,7 +3,8 @@
 import functools
 import logging
 import warnings
-from typing import Any, Callable, Optional, TypeVar
+from collections.abc import Callable
+from typing import Any, TypeVar
 
 import pyramid.config
 
@@ -14,16 +15,16 @@ _LOG = logging.getLogger(__name__)
 _BROADCAST_ENV_KEY = "C2C_BROADCAST_PREFIX"
 _BROADCAST_CONFIG_KEY = "c2c.broadcast_prefix"
 
-_broadcaster: Optional[interface.BaseBroadcaster] = None
+_broadcaster: interface.BaseBroadcaster | None = None
 
 
-def init(config: Optional[pyramid.config.Configurator] = None) -> None:
+def init(config: pyramid.config.Configurator | None = None) -> None:
     """Initialize the broadcaster with Redis, if configured, for backward compatibility."""
     warnings.warn("init function is deprecated; use includeme instead", stacklevel=2)
     includeme(config)
 
 
-def includeme(config: Optional[pyramid.config.Configurator] = None) -> None:
+def includeme(config: pyramid.config.Configurator | None = None) -> None:
     """
     Initialize the broadcaster with Redis, if configured.
 
@@ -31,7 +32,10 @@ def includeme(config: Optional[pyramid.config.Configurator] = None) -> None:
     """
     global _broadcaster  # pylint: disable=global-statement
     broadcast_prefix = config_utils.env_or_config(
-        config, _BROADCAST_ENV_KEY, _BROADCAST_CONFIG_KEY, "broadcast_api_"
+        config,
+        _BROADCAST_ENV_KEY,
+        _BROADCAST_CONFIG_KEY,
+        "broadcast_api_",
     )
     master, slave, _ = redis_utils.get(config.get_settings() if config else None)
     if _broadcaster is None:
@@ -81,15 +85,21 @@ 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: dict[str, Any] | None = None,
+    expect_answers: bool = False,
+    timeout: float = 10,
+) -> list[Any] | None:
     """
     Broadcast a message to the given channel.
 
     If answers are expected, it will wait up to "timeout" seconds to get all the answers.
     """
     return _get(need_init=True).broadcast(
-        channel, params if params is not None else {}, expect_answers, timeout
+        channel,
+        params if params is not None else {},
+        expect_answers,
+        timeout,
     )
 
 
@@ -99,23 +109,22 @@ _DecoratorReturn = TypeVar("_DecoratorReturn")
 
 
 def decorator(
-    channel: Optional[str] = None, expect_answers: bool = False, timeout: float = 10
-) -> Callable[[Callable[..., _DecoratorReturn]], Callable[..., Optional[list[_DecoratorReturn]]]]:
+    channel: str | None = None,
+    expect_answers: bool = False,
+    timeout: float = 10,
+) -> Callable[[Callable[..., _DecoratorReturn]], Callable[..., list[_DecoratorReturn] | None]]:
     """
     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[..., _DecoratorReturn]) -> Callable[..., Optional[list[_DecoratorReturn]]]:
+    def impl(func: Callable[..., _DecoratorReturn]) -> Callable[..., list[_DecoratorReturn] | None]:
         @functools.wraps(func)
-        def wrapper(**kwargs: Any) -> Optional[list[_DecoratorReturn]]:
+        def wrapper(**kwargs: Any) -> list[_DecoratorReturn] | None:
             return broadcast(_channel, params=kwargs, expect_answers=expect_answers, timeout=timeout)
 
-        if channel is None:
-            _channel = f"c2c_decorated_{func.__module__}.{func.__name__}"
-        else:
-            _channel = channel
+        _channel = f"c2c_decorated_{func.__module__}.{func.__name__}" if channel is None else channel
         subscribe(_channel, func)
 
         return wrapper

c2cwsgiutils/broadcast/interface.py

@@ -1,6 +1,6 @@
 from abc import abstractmethod
-from collections.abc import Mapping
-from typing import Any, Callable, Optional
+from collections.abc import Callable, Mapping
+from typing import Any
 
 
 class BaseBroadcaster:
@@ -16,6 +16,10 @@ class BaseBroadcaster:
 
     @abstractmethod
     def broadcast(
-        self, channel: str, params: Mapping[str, Any], expect_answers: bool, timeout: float
-    ) -> Optional[list[Any]]:
+        self,
+        channel: str,
+        params: Mapping[str, Any],
+        expect_answers: bool,
+        timeout: float,
+    ) -> list[Any] | None:
         """Broadcast a message to a channel."""

c2cwsgiutils/broadcast/local.py

@@ -1,5 +1,5 @@
-from collections.abc import Mapping, MutableMapping
-from typing import Any, Callable, Optional
+from collections.abc import Callable, Mapping, MutableMapping
+from typing import Any
 
 # noinspection PyProtectedMember
 from c2cwsgiutils.broadcast import interface, utils
@@ -21,9 +21,14 @@ class LocalBroadcaster(interface.BaseBroadcaster):
         del self._subscribers[channel]
 
     def broadcast(
-        self, channel: str, params: Mapping[str, Any], expect_answers: bool, timeout: float
-    ) -> Optional[list[Any]]:
+        self,
+        channel: str,
+        params: Mapping[str, Any],
+        expect_answers: bool,
+        timeout: float,
+    ) -> list[Any] | None:
         """Broadcast a message to all the listeners."""
+        del timeout  # Not used
         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,13 +4,14 @@ import random
 import string
 import threading
 import time
-from collections.abc import Mapping
-from typing import Any, Callable, Optional
-
-import redis
+from collections.abc import Callable, Mapping
+from typing import TYPE_CHECKING, Any
 
 from c2cwsgiutils.broadcast import interface, local, utils
 
+if TYPE_CHECKING:
+    import redis
+
 _LOG = logging.getLogger(__name__)
 
 
@@ -33,7 +34,7 @@ class RedisBroadcaster(interface.BaseBroadcaster):
         self._pub_sub = self._master.pubsub(ignore_subscribe_messages=True)
 
         # Need to be subscribed to something for the thread to stay alive
-        self._pub_sub.subscribe(**{self._get_channel("c2c_dummy"): lambda message: None})
+        self._pub_sub.subscribe(**{self._get_channel("c2c_dummy"): lambda _: None})
         self._thread = redis_utils.PubSubWorkerThread(self._pub_sub, name="c2c_broadcast_listener")
         self._thread.start()
 
@@ -48,7 +49,7 @@ class RedisBroadcaster(interface.BaseBroadcaster):
             data = json.loads(message["data"])
             try:
                 response = callback(**data["params"])
-            except Exception as e:  # pragma: no cover  # pylint: disable=broad-except
+            except Exception as e:  # pragma: no cover  # pylint: disable=broad-exception-caught
                 _LOG.error("Failed handling a broadcast message", exc_info=True)
                 response = {"status": 500, "message": str(e)}
             answer_channel = data.get("answer_channel")
@@ -67,17 +68,23 @@ class RedisBroadcaster(interface.BaseBroadcaster):
         self._pub_sub.unsubscribe(actual_channel)
 
     def broadcast(
-        self, channel: str, params: Mapping[str, Any], expect_answers: bool, timeout: float
-    ) -> Optional[list[Any]]:
+        self,
+        channel: str,
+        params: Mapping[str, Any],
+        expect_answers: bool,
+        timeout: float,
+    ) -> list[Any] | None:
         """Broadcast a message to all the listeners."""
         if expect_answers:
             return self._broadcast_with_answer(channel, params, timeout)
-        else:
-            self._broadcast(channel, {"params": params})
-            return None
+        self._broadcast(channel, {"params": params})
+        return None
 
     def _broadcast_with_answer(
-        self, channel: str, params: Optional[Mapping[str, Any]], timeout: float
+        self,
+        channel: str,
+        params: Mapping[str, Any] | None,
+        timeout: float,
     ) -> list[Any]:
         cond = threading.Condition()
         answers = []

c2cwsgiutils/client_info.py

@@ -1,7 +1,8 @@
 import logging
 import os
 import re
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 _LOG = logging.getLogger(__name__)
 SEP_RE = re.compile(r", *")
@@ -15,7 +16,7 @@ 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]) -> None:
         """Initialize the filter."""
         self._application = application
 

c2cwsgiutils/config_utils.py

@@ -1,8 +1,8 @@
 """Private utilities."""
 
 import os
-from collections.abc import Mapping
-from typing import Any, Callable, Optional, cast
+from collections.abc import Callable, Mapping
+from typing import Any, cast
 
 import pyramid.config
 
@@ -13,22 +13,26 @@ def get_base_path(config: pyramid.config.Configurator) -> str:
 
 
 def env_or_config(
-    config: Optional[pyramid.config.Configurator],
-    env_name: Optional[str] = None,
-    config_name: Optional[str] = None,
+    config: pyramid.config.Configurator | None,
+    env_name: str | None = None,
+    config_name: str | None = None,
     default: Any = None,
     type_: Callable[[str], Any] = str,
 ) -> Any:
     """Get the setting from the environment or from the config file."""
     return env_or_settings(
-        config.get_settings() if config is not None else {}, env_name, config_name, default, type_
+        config.get_settings() if config is not None else {},
+        env_name,
+        config_name,
+        default,
+        type_,
     )
 
 
 def env_or_settings(
-    settings: Optional[Mapping[str, Any]],
-    env_name: Optional[str] = None,
-    settings_name: Optional[str] = None,
+    settings: Mapping[str, Any] | None,
+    env_name: str | None = None,
+    settings_name: str | None = None,
     default: Any = None,
     type_: Callable[[str], Any] = str,
 ) -> Any:
@@ -40,7 +44,7 @@ def env_or_settings(
     return default
 
 
-def config_bool(value: Optional[str]) -> bool:
+def config_bool(value: str | None) -> bool:
     """Get boolean from the value."""
     if value is None:
         return False

c2cwsgiutils/coverage_setup.py

@@ -1,7 +1,7 @@
 import logging
 import os
 import warnings
-from typing import Optional
+from pathlib import Path
 
 import pyramid.config
 
@@ -14,7 +14,7 @@ def init() -> None:
     includeme()
 
 
-def includeme(config: Optional[pyramid.config.Configurator] = None) -> None:
+def includeme(config: pyramid.config.Configurator | None = None) -> None:
     """Initialize the code coverage."""
     del config  # unused
     if os.environ.get("COVERAGE", "0") != "1":
@@ -22,10 +22,10 @@ def includeme(config: Optional[pyramid.config.Configurator] = None) -> None:
     import coverage  # pylint: disable=import-outside-toplevel
 
     _LOG.warning("Setting up code coverage")
-    report_dir = "/tmp/coverage/api"  # noqa: S108 # nosec
-    os.makedirs(report_dir, exist_ok=True)
+    report_dir = Path("/tmp/coverage/api")  # noqa: S108 # nosec
+    report_dir.mkdir(parents=True, exist_ok=True)
     cov = coverage.Coverage(
-        data_file=os.path.join(report_dir, "coverage"),
+        data_file=str(report_dir / "coverage"),
         data_suffix=True,
         auto_data=True,
         branch=True,

c2cwsgiutils/db.py

@@ -3,9 +3,9 @@
 import logging
 import re
 import warnings
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from re import Pattern
-from typing import Any, Callable, Optional, Union, cast
+from typing import Any, cast
 
 import pyramid.config
 import pyramid.config.settings
@@ -37,11 +37,11 @@ tweens = Tweens()
 def setup_session(
     config: pyramid.config.Configurator,
     master_prefix: str,
-    slave_prefix: Optional[str] = None,
-    force_master: Optional[Iterable[str]] = None,
-    force_slave: Optional[Iterable[str]] = None,
+    slave_prefix: str | None = None,
+    force_master: Iterable[str] | None = None,
+    force_slave: Iterable[str] | None = None,
 ) -> tuple[
-    Union[sqlalchemy.orm.Session, _scoped_session],
+    sqlalchemy.orm.Session | _scoped_session,
     sqlalchemy.engine.Engine,
     sqlalchemy.engine.Engine,
 ]:
@@ -69,13 +69,14 @@ def setup_session(
 
     """
     warnings.warn(
-        "setup_session function is deprecated; use init and request.dbsession instead", stacklevel=2
+        "setup_session function is deprecated; use init and request.dbsession instead",
+        stacklevel=2,
     )
     if slave_prefix is None:
         slave_prefix = master_prefix
     settings = config.registry.settings
     rw_engine = sqlalchemy.engine_from_config(settings, master_prefix + ".")
-    rw_engine.c2c_name = master_prefix  # type: ignore
+    rw_engine.c2c_name = master_prefix  # type: ignore[attr-defined]
     factory = sqlalchemy.orm.sessionmaker(bind=rw_engine)
     register(factory)
     db_session = sqlalchemy.orm.scoped_session(factory)
@@ -84,26 +85,26 @@ def setup_session(
     if settings[master_prefix + ".url"] != settings.get(slave_prefix + ".url"):
         _LOG.info("Using a slave DB for reading %s", master_prefix)
         ro_engine = sqlalchemy.engine_from_config(config.get_settings(), slave_prefix + ".")
-        ro_engine.c2c_name = slave_prefix  # type: ignore
+        ro_engine.c2c_name = slave_prefix  # type: ignore[attr-defined]
         tween_name = master_prefix.replace(".", "_")
         _add_tween(config, tween_name, db_session, force_master, force_slave)
     else:
         ro_engine = rw_engine
 
-    db_session.c2c_rw_bind = rw_engine  # type: ignore
-    db_session.c2c_ro_bind = ro_engine  # type: ignore
+    db_session.c2c_rw_bind = rw_engine  # type: ignore[attr-defined]
+    db_session.c2c_ro_bind = ro_engine  # type: ignore[attr-defined]
     return db_session, rw_engine, ro_engine
 
 
 def create_session(
-    config: Optional[pyramid.config.Configurator],
+    config: pyramid.config.Configurator | None,
     name: str,
     url: str,
-    slave_url: Optional[str] = None,
-    force_master: Optional[Iterable[str]] = None,
-    force_slave: Optional[Iterable[str]] = None,
+    slave_url: str | None = None,
+    force_master: Iterable[str] | None = None,
+    force_slave: Iterable[str] | None = None,
     **engine_config: Any,
-) -> Union[sqlalchemy.orm.Session, _scoped_session]:
+) -> sqlalchemy.orm.Session | _scoped_session:
     """
     Create a SQLAlchemy session.
 
@@ -128,7 +129,8 @@ def create_session(
 
     """
     warnings.warn(
-        "create_session function is deprecated; use init and request.dbsession instead", stacklevel=2
+        "create_session function is deprecated; use init and request.dbsession instead",
+        stacklevel=2,
     )
     if slave_url is None:
         slave_url = url
@@ -143,14 +145,14 @@ def create_session(
         _LOG.info("Using a slave DB for reading %s", name)
         ro_engine = sqlalchemy.create_engine(slave_url, **engine_config)
         _add_tween(config, name, db_session, force_master, force_slave)
-        rw_engine.c2c_name = name + "_master"  # type: ignore
-        ro_engine.c2c_name = name + "_slave"  # type: ignore
+        rw_engine.c2c_name = name + "_master"  # type: ignore[attr-defined]
+        ro_engine.c2c_name = name + "_slave"  # type: ignore[attr-defined]
     else:
-        rw_engine.c2c_name = name  # type: ignore
+        rw_engine.c2c_name = name  # type: ignore[attr-defined]
         ro_engine = rw_engine
 
-    db_session.c2c_rw_bind = rw_engine  # type: ignore
-    db_session.c2c_ro_bind = ro_engine  # type: ignore
+    db_session.c2c_rw_bind = rw_engine  # type: ignore[attr-defined]
+    db_session.c2c_ro_bind = ro_engine  # type: ignore[attr-defined]
     return db_session
 
 
@@ -158,8 +160,8 @@ def _add_tween(
     config: pyramid.config.Configurator,
     name: str,
     db_session: _scoped_session,
-    force_master: Optional[Iterable[str]],
-    force_slave: Optional[Iterable[str]],
+    force_master: Iterable[str] | None,
+    force_slave: Iterable[str] | None,
 ) -> None:
     master_paths: Iterable[Pattern[str]] = (
         list(map(_RE_COMPILE, force_master)) if force_master is not None else []
@@ -169,7 +171,8 @@ def _add_tween(
     )
 
     def db_chooser_tween_factory(
-        handler: Callable[[pyramid.request.Request], Any], _registry: Any
+        handler: Callable[[pyramid.request.Request], Any],
+        _registry: Any,
     ) -> Callable[[pyramid.request.Request], Any]:
         """
         Tween factory to route to a slave DB for read-only queries.
@@ -188,17 +191,17 @@ def _add_tween(
             ):
                 _LOG.debug(
                     "Using %s database for: %s",
-                    db_session.c2c_ro_bind.c2c_name,  # type: ignore
+                    db_session.c2c_ro_bind.c2c_name,  # type: ignore[attr-defined]
                     method_path,
                 )
-                session.bind = db_session.c2c_ro_bind  # type: ignore
+                session.bind = db_session.c2c_ro_bind  # type: ignore[attr-defined]
             else:
                 _LOG.debug(
                     "Using %s database for: %s",
-                    db_session.c2c_rw_bind.c2c_name,  # type: ignore
+                    db_session.c2c_rw_bind.c2c_name,  # type: ignore[attr-defined]
                     method_path,
                 )
-                session.bind = db_session.c2c_rw_bind  # type: ignore
+                session.bind = db_session.c2c_rw_bind  # type: ignore[attr-defined]
 
             try:
                 return handler(request)
@@ -216,11 +219,11 @@ class SessionFactory(_sessionmaker):
 
     def __init__(
         self,
-        force_master: Optional[Iterable[str]],
-        force_slave: Optional[Iterable[str]],
+        force_master: Iterable[str] | None,
+        force_slave: Iterable[str] | None,
         ro_engine: sqlalchemy.engine.Engine,
         rw_engine: sqlalchemy.engine.Engine,
-    ):
+    ) -> None:
         """Initialize the session factory."""
         super().__init__()
         self.master_paths: Iterable[Pattern[str]] = (
@@ -233,19 +236,22 @@ class SessionFactory(_sessionmaker):
     def engine_name(self, readwrite: bool) -> str:
         """Get the engine name."""
         if readwrite:
-            return cast(str, self.rw_engine.c2c_name)  # type: ignore
-        return cast(str, self.ro_engine.c2c_name)  # type: ignore
+            return cast(str, self.rw_engine.c2c_name)  # type: ignore[attr-defined]
+        return cast(str, self.ro_engine.c2c_name)  # type: ignore[attr-defined]
 
-    def __call__(  # type: ignore
-        self, request: Optional[pyramid.request.Request], readwrite: Optional[bool] = None, **local_kw: Any
+    def __call__(  # type: ignore[override]
+        self,
+        request: pyramid.request.Request | None,
+        readwrite: bool | None = None,
+        **local_kw: Any,
     ) -> _scoped_session:
         """Set the engine based on the request."""
         if readwrite is not None:
             if readwrite and not FORCE_READONLY:
-                _LOG.debug("Using %s database", self.rw_engine.c2c_name)  # type: ignore
+                _LOG.debug("Using %s database", self.rw_engine.c2c_name)  # type: ignore[attr-defined]
                 self.configure(bind=self.rw_engine)
             else:
-                _LOG.debug("Using %s database", self.ro_engine.c2c_name)  # type: ignore
+                _LOG.debug("Using %s database", self.ro_engine.c2c_name)  # type: ignore[attr-defined]
                 self.configure(bind=self.ro_engine)
         else:
             assert request is not None
@@ -258,16 +264,17 @@ class SessionFactory(_sessionmaker):
                     or any(r.match(method_path) for r in self.slave_paths)
                 )
             ):
-                _LOG.debug("Using %s database for: %s", self.ro_engine.c2c_name, method_path)  # type: ignore
+                _LOG.debug("Using %s database for: %s", self.ro_engine.c2c_name, method_path)  # type: ignore[attr-defined]
                 self.configure(bind=self.ro_engine)
             else:
-                _LOG.debug("Using %s database for: %s", self.rw_engine.c2c_name, method_path)  # type: ignore
+                _LOG.debug("Using %s database for: %s", self.rw_engine.c2c_name, method_path)  # type: ignore[attr-defined]
                 self.configure(bind=self.rw_engine)
-        return super().__call__(**local_kw)  # type: ignore
+        return super().__call__(**local_kw)  # type: ignore[return-value]
 
 
 def get_engine(
-    settings: pyramid.config.settings.Settings, prefix: str = "sqlalchemy."
+    settings: pyramid.config.settings.Settings,
+    prefix: str = "sqlalchemy.",
 ) -> sqlalchemy.engine.Engine:
     """Get the engine from the settings."""
     return engine_from_config(settings, prefix)
@@ -365,9 +372,9 @@ def get_tm_session_pyramid(
 def init(
     config: pyramid.config.Configurator,
     master_prefix: str,
-    slave_prefix: Optional[str] = None,
-    force_master: Optional[Iterable[str]] = None,
-    force_slave: Optional[Iterable[str]] = None,
+    slave_prefix: str | None = None,
+    force_master: Iterable[str] | None = None,
+    force_slave: Iterable[str] | None = None,
 ) -> SessionFactory:
     """
     Initialize the database for a Pyramid app.
@@ -391,13 +398,13 @@ def init(
     dbengine = settings.get("dbengine")
     if not dbengine:
         rw_engine = get_engine(settings, master_prefix + ".")
-        rw_engine.c2c_name = master_prefix  # type: ignore
+        rw_engine.c2c_name = master_prefix  # type: ignore[attr-defined]
 
         # Setup a slave DB connection and add a tween to use it.
         if slave_prefix and settings[master_prefix + ".url"] != settings.get(slave_prefix + ".url"):
             _LOG.info("Using a slave DB for reading %s", master_prefix)
             ro_engine = get_engine(config.get_settings(), slave_prefix + ".")
-            ro_engine.c2c_name = slave_prefix  # type: ignore
+            ro_engine.c2c_name = slave_prefix  # type: ignore[attr-defined]
         else:
             ro_engine = rw_engine
     else:

c2cwsgiutils/db_maintenance_view.py

@@ -1,7 +1,7 @@
 import logging
 import warnings
 from collections.abc import Mapping
-from typing import Any, Optional, cast
+from typing import Any, cast
 
 import pyramid.request
 
@@ -42,11 +42,10 @@ def _db_maintenance(request: pyramid.request.Request) -> Mapping[str, Any]:
         _set_readonly(value=readonly)
         _store(request.registry.settings, readonly)
         return {"status": 200, "readonly": readonly}
-    else:
-        readonly = _get_redis_value(request.registry.settings)
-        if readonly is not None:
-            readonly = readonly == "true"
-        return {"status": 200, "current_readonly": readonly}
+    readonly = _get_redis_value(request.registry.settings)
+    if readonly is not None:
+        readonly = readonly == "true"
+    return {"status": 200, "current_readonly": readonly}
 
 
 @broadcast.decorator(expect_answers=True)
@@ -63,7 +62,7 @@ def _restore(config: pyramid.config.Configurator) -> None:
             db.FORCE_READONLY = readonly == "true"
     except ImportError:
         pass  # don't have redis
-    except Exception:  # pylint: disable=broad-except
+    except Exception:  # pylint: disable=broad-exception-caught
         # survive an error since crashing now can have bad consequences for the service. :/
         _LOG.error("Cannot restore readonly DB status.", exc_info=True)
 
@@ -74,7 +73,7 @@ def _store(settings: Mapping[str, Any], readonly: bool) -> None:
         master.set(_REDIS_PREFIX + "force_readonly", "true" if readonly else "false")
 
 
-def _get_redis_value(settings: Mapping[str, Any]) -> Optional[str]:
+def _get_redis_value(settings: Mapping[str, Any]) -> str | None:
     _, slave, _ = redis_utils.get(settings)
     if slave is not None:
         value = slave.get(_REDIS_PREFIX + "force_readonly")

c2cwsgiutils/debug/__init__.py

@@ -1,5 +1,4 @@
 import warnings
-from typing import Optional
 
 import pyramid.config
 
@@ -29,7 +28,7 @@ def includeme(config: pyramid.config.Configurator) -> None:
         _views.init(config)
 
 
-def init_daemon(config: Optional[pyramid.config.Configurator] = None) -> None:
+def init_daemon(config: pyramid.config.Configurator | None = None) -> None:
     """
     Initialize the debug broadcast listeners.
 

c2cwsgiutils/debug/_listeners.py

@@ -4,7 +4,7 @@ import threading
 import time
 import traceback
 from collections.abc import Mapping
-from typing import Any, Optional, cast
+from typing import Any, cast
 
 import objgraph
 
@@ -17,7 +17,7 @@ FILES_FIELDS = {"__name__", "__doc__", "__package__", "__loader__", "__spec__",
 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
+    for thread_id, stack in sys._current_frames().items():  # pylint: disable=protected-access
         frames = []
         for filename, lineno, name, line in traceback.extract_stack(stack):
             cur = {"file": filename, "line": lineno, "function": name}
@@ -31,7 +31,7 @@ def _dump_stacks_impl() -> dict[str, Any]:
 # pylint: disable=too-many-branches
 def _dump_memory_impl(
     limit: int,
-    analyze_type: Optional[str],
+    analyze_type: str | None,
     python_internals_map: bool = False,
 ) -> Mapping[str, Any]:
     nb_collected = [gc.collect(generation) for generation in range(3)]
@@ -39,7 +39,9 @@ def _dump_memory_impl(
         "nb_collected": nb_collected,
         "most_common_types": objgraph.most_common_types(limit=limit, shortnames=False),
         "leaking_objects": objgraph.most_common_types(
-            limit=limit, shortnames=False, objects=objgraph.get_leaking_objects()
+            limit=limit,
+            shortnames=False,
+            objects=objgraph.get_leaking_objects(),
         ),
     }