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

c2cwsgiutils/request_tracking/__init__.py

@@ -10,7 +10,6 @@ import urllib.parse
 import uuid
 import warnings
 from collections.abc import Mapping
-from typing import Optional, Union
 
 import prometheus_client
 import pyramid.request
@@ -23,7 +22,7 @@ from c2cwsgiutils import config_utils, prometheus
 _ID_HEADERS: list[str] = []
 _HTTPAdapter_send = requests.adapters.HTTPAdapter.send
 _LOG = logging.getLogger(__name__)
-_DEFAULT_TIMEOUT: Optional[float] = None
+_DEFAULT_TIMEOUT: float | None = None
 _PROMETHEUS_REQUESTS_SUMMARY = prometheus_client.Summary(
     prometheus.build_metric_name("requests"),
     "Requests requests",
@@ -35,7 +34,7 @@ _PROMETHEUS_REQUESTS_SUMMARY = prometheus_client.Summary(
 def _gen_request_id(request: pyramid.request.Request) -> str:
     for id_header in _ID_HEADERS:
         if id_header in request.headers:
-            return request.headers[id_header]  # type: ignore
+            return request.headers[id_header]  # type: ignore[no-any-return]
     return str(uuid.uuid4())
 
 
@@ -44,10 +43,10 @@ def _patch_requests() -> None:
         self: requests.adapters.HTTPAdapter,
         request: requests.models.PreparedRequest,
         stream: bool = False,
-        timeout: Union[None, float, tuple[float, float], tuple[float, None]] = None,
-        verify: Union[bool, str] = True,
-        cert: Union[None, bytes, str, tuple[Union[bytes, str], Union[bytes, str]]] = None,
-        proxies: Optional[Mapping[str, str]] = None,
+        timeout: None | float | tuple[float, float] | tuple[float, None] = None,
+        verify: bool | str = True,
+        cert: None | bytes | str | tuple[bytes | str, bytes | str] = None,
+        proxies: Mapping[str, str] | None = None,
     ) -> requests.Response:
         pyramid_request = get_current_request()
         header = _ID_HEADERS[0]
@@ -65,7 +64,13 @@ def _patch_requests() -> None:
         port = parsed.port or (80 if parsed.scheme == "http" else 443)
         start = time.perf_counter()
         response = _HTTPAdapter_send(
-            self, request, timeout=timeout, stream=stream, verify=verify, cert=cert, proxies=proxies
+            self,
+            request,
+            timeout=timeout,
+            stream=stream,
+            verify=verify,
+            cert=cert,
+            proxies=proxies,
         )
 
         _PROMETHEUS_REQUESTS_SUMMARY.labels(
@@ -81,13 +86,13 @@ def _patch_requests() -> None:
     requests.adapters.HTTPAdapter.send = send_wrapper  # type: ignore[method-assign]
 
 
-def init(config: Optional[pyramid.config.Configurator] = None) -> None:
+def init(config: pyramid.config.Configurator | None = None) -> None:
     """Initialize the request tracking, 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 request tracking.
 
@@ -103,11 +108,14 @@ def includeme(config: Optional[pyramid.config.Configurator] = None) -> None:
         config.add_request_method(_gen_request_id, "c2c_request_id", reify=True)
 
     _DEFAULT_TIMEOUT = config_utils.env_or_config(
-        config, "C2C_REQUESTS_DEFAULT_TIMEOUT", "c2c.requests_default_timeout", type_=float
+        config,
+        "C2C_REQUESTS_DEFAULT_TIMEOUT",
+        "c2c.requests_default_timeout",
+        type_=float,
     )
     _patch_requests()
 
-    if config_utils.env_or_config(config, "C2C_SQL_REQUEST_ID", "c2c.sql_request_id", False):
+    if config_utils.env_or_config(config, "C2C_SQL_REQUEST_ID", "c2c.sql_request_id", default=False):
         from . import _sql  # pylint: disable=import-outside-toplevel
 
         _sql.init()

c2cwsgiutils/request_tracking/_sql.py

@@ -9,7 +9,8 @@ def _add_session_id(session: Session, _transaction: Any) -> None:
     request = get_current_request()
     if request is not None:
         session.execute(
-            sqlalchemy.text("set application_name=:session_id"), params={"session_id": request.c2c_request_id}
+            sqlalchemy.text("set application_name=:session_id"),
+            params={"session_id": request.c2c_request_id},
         )
 
 

c2cwsgiutils/scripts/genversion.py

@@ -6,14 +6,15 @@ import re
 import subprocess  # nosec
 import sys
 import warnings
-from typing import Optional, cast
+from pathlib import Path
+from typing import cast
 
 _SRC_VERSION_RE = re.compile(r"^.*\(([^=]*)===?([^=]*)\)$")
 _VERSION_RE = re.compile(r"^([^=]*)==([^=]*)$")
 _LOG = logging.getLogger(__name__)
 
 
-def _get_package_version(comp: str) -> tuple[Optional[str], Optional[str]]:
+def _get_package_version(comp: str) -> tuple[str | None, str | None]:
     """
     Parse plain and editable versions.
 
@@ -23,15 +24,14 @@ def _get_package_version(comp: str) -> tuple[Optional[str], Optional[str]]:
     matcher = src_matcher or _VERSION_RE.match(comp)
     if matcher:
         return cast(tuple[str, str], matcher.groups())
-    else:
-        if len(comp) > 0 and comp[:3] != "-e ":
-            print("Cannot parse package version: " + comp)
-        return None, None
+    if len(comp) > 0 and comp[:3] != "-e ":
+        print("Cannot parse package version: " + comp)
+    return None, None
 
 
 def _get_packages_version() -> dict[str, str]:
     result = {}
-    with open(os.devnull, "w", encoding="utf-8") as devnull:
+    with open(os.devnull, "w", encoding="utf-8") as devnull:  # noqa: PTH123
         for comp in (
             subprocess.check_output(["python3", "-m", "pip", "freeze"], stderr=devnull)  # nosec
             .decode()
@@ -47,7 +47,8 @@ def _get_packages_version() -> dict[str, str]:
 def deprecated() -> None:
     """Run the command and print a deprecated notice."""
     warnings.warn(
-        "c2cwsgiutils_genversion.py is deprecated; use c2cwsgiutils-genversion instead", stacklevel=2
+        "c2cwsgiutils_genversion.py is deprecated; use c2cwsgiutils-genversion instead",
+        stacklevel=2,
     )
     return main()
 
@@ -63,7 +64,7 @@ def main() -> None:
     report = {"main": {"git_hash": git_hash}, "packages": _get_packages_version()}
     if git_tag is not None:
         report["main"]["git_tag"] = git_tag
-    with open("versions.json", "w", encoding="utf-8") as file:
+    with Path("versions.json").open("w", encoding="utf-8") as file:
         json.dump(report, file, indent=2)
 
 

c2cwsgiutils/scripts/stats_db.py

@@ -6,7 +6,6 @@ import logging
 import os
 import sys
 import time
-from typing import Optional
 from wsgiref.simple_server import make_server
 
 import sqlalchemy
@@ -30,7 +29,12 @@ def _parse_args() -> argparse.Namespace:
     c2cwsgiutils.setup_process.fill_arguments(parser)
     parser.add_argument("--db", type=str, required=True, help="DB connection string")
     parser.add_argument(
-        "--schema", type=str, action="append", required=True, default=["public"], help="schema to dump"
+        "--schema",
+        type=str,
+        action="append",
+        required=True,
+        default=["public"],
+        help="schema to dump",
     )
     parser.add_argument(
         "--extra",
@@ -46,7 +50,10 @@ def _parse_args() -> argparse.Namespace:
         help="A SQL query that returns a metric name and a value, with gauge name and help",
     )
     parser.add_argument(
-        "--prometheus-url", "--prometheus_url", type=str, help="Base URL for the Prometheus Pushgateway"
+        "--prometheus-url",
+        "--prometheus_url",
+        type=str,
+        help="Base URL for the Prometheus Pushgateway",
     )
     parser.add_argument(
         "--prometheus-instance",
@@ -63,7 +70,7 @@ class Reporter:
 
     def __init__(self, args: argparse.Namespace) -> None:
         """Initialize the reporter."""
-        self._error: Optional[Exception] = None
+        self._error: Exception | None = None
         self.registry = CollectorRegistry()
         self.prometheus_push = args.prometheus_url is not None
         self.args = args
@@ -81,7 +88,12 @@ class Reporter:
         return self.gauges[kind]
 
     def do_report(
-        self, metric: list[str], value: int, kind: str, kind_help: str, tags: dict[str, str]
+        self,
+        metric: list[str],
+        value: int,
+        kind: str,
+        kind_help: str,
+        tags: dict[str, str],
     ) -> None:
         """Report a metric."""
         _LOG.debug("%s.%s -> %d", kind, ".".join(metric), value)
@@ -150,7 +162,7 @@ def _do_indexes(
          ) AS foo
          ON t.tablename = foo.ctablename AND t.schemaname=foo.schemaname
     WHERE t.schemaname=:schema AND t.tablename=:table
-    """
+    """,
         ),
         params={"schema": schema, "table": table},
     ):
@@ -185,7 +197,7 @@ def _do_table_size(
     FROM pg_class c
     LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
     WHERE relkind = 'r' AND nspname=:schema AND relname=:table
-    """
+    """,
         ),
         params={"schema": schema, "table": table},
     ).fetchone()
@@ -212,7 +224,7 @@ def _do_table_count(
     result = session.execute(
         sqlalchemy.text(
             "SELECT reltuples FROM pg_class where "
-            "oid=(quote_ident(:schema) || '.' || quote_ident(:table))::regclass;"
+            "oid=(quote_ident(:schema) || '.' || quote_ident(:table))::regclass;",
         ),
         params={"schema": schema, "table": table},
     ).fetchone()
@@ -231,7 +243,11 @@ def do_extra(session: scoped_session, sql: str, kind: str, gauge_help: str, repo
     """Do an extra report."""
     for metric, count in session.execute(sqlalchemy.text(sql)):
         reporter.do_report(
-            str(metric).split("."), count, kind=kind, kind_help=gauge_help, tags={"metric": metric}
+            str(metric).split("."),
+            count,
+            kind=kind,
+            kind_help=gauge_help,
+            tags={"metric": metric},
         )
 
 
@@ -251,7 +267,7 @@ def _do_dtats_db(args: argparse.Namespace) -> None:
             """
     SELECT table_schema, table_name FROM information_schema.tables
     WHERE table_type='BASE TABLE' AND table_schema IN :schemas
-    """
+    """,
         ),
         params={"schemas": tuple(args.schema)},
     ).fetchall()
@@ -259,7 +275,7 @@ def _do_dtats_db(args: argparse.Namespace) -> None:
         _LOG.info("Process table %s.%s.", schema, table)
         try:
             do_table(session, schema, table, reporter)
-        except Exception as e:  # pylint: disable=broad-except
+        except Exception as e:  # pylint: disable=broad-exception-caught
             _LOG.exception("Process table %s.%s error.", schema, table)
             reporter.error([schema, table], e)
 
@@ -268,7 +284,7 @@ def _do_dtats_db(args: argparse.Namespace) -> None:
             _LOG.info("Process extra %s.", extra)
             try:
                 do_extra(session, extra, "extra", "Extra metric", reporter)
-            except Exception as e:  # pylint: disable=broad-except
+            except Exception as e:  # pylint: disable=broad-exception-caught
                 _LOG.exception("Process extra %s error.", extra)
                 reporter.error(["extra", str(pos + 1)], e)
     if args.extra_gauge:
@@ -277,7 +293,7 @@ def _do_dtats_db(args: argparse.Namespace) -> None:
             _LOG.info("Process extra %s.", extra)
             try:
                 do_extra(session, sql, gauge, gauge_help, reporter)
-            except Exception as e:  # pylint: disable=broad-except
+            except Exception as e:  # pylint: disable=broad-exception-caught
                 _LOG.exception("Process extra %s error.", extra)
                 reporter.error(["extra", str(len(args.extra) + pos + 1)], e)
 

c2cwsgiutils/sentry.py

@@ -2,8 +2,8 @@ import contextlib
 import logging
 import os
 import warnings
-from collections.abc import Generator, MutableMapping
-from typing import Any, Callable, Optional
+from collections.abc import Callable, Generator, MutableMapping
+from typing import Any
 
 import pyramid.config
 import sentry_sdk.integrations
@@ -31,13 +31,13 @@ def _create_before_send_filter(tags: MutableMapping[str, str]) -> Callable[[Any,
     return do_filter
 
 
-def init(config: Optional[pyramid.config.Configurator] = None) -> None:
+def init(config: pyramid.config.Configurator | None = None) -> None:
     """Initialize the Sentry integration, 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 Sentry integration."""
     global _CLIENT_SETUP  # pylint: disable=global-statement
     sentry_url = config_utils.env_or_config(config, "SENTRY_URL", "c2c.sentry.url")
@@ -76,45 +76,66 @@ def includeme(config: Optional[pyramid.config.Configurator] = None) -> None:
 
         traces_sample_rate = float(
             config_utils.env_or_config(
-                config, "SENTRY_TRACES_SAMPLE_RATE", "c2c.sentry_traces_sample_rate", "0.0"
-            )
+                config,
+                "SENTRY_TRACES_SAMPLE_RATE",
+                "c2c.sentry_traces_sample_rate",
+                "0.0",
+            ),
         )
         integrations: list[sentry_sdk.integrations.Integration] = []
         if config_utils.config_bool(
             config_utils.env_or_config(
-                config, "SENTRY_INTEGRATION_LOGGING", "c2c.sentry_integration_logging", "true"
-            )
+                config,
+                "SENTRY_INTEGRATION_LOGGING",
+                "c2c.sentry_integration_logging",
+                "true",
+            ),
         ):
             integrations.append(
                 LoggingIntegration(
                     level=logging.DEBUG,
                     event_level=config_utils.env_or_config(
-                        config, "SENTRY_LEVEL", "c2c.sentry_level", "ERROR"
+                        config,
+                        "SENTRY_LEVEL",
+                        "c2c.sentry_level",
+                        "ERROR",
                     ).upper(),
-                )
+                ),
             )
         if config_utils.config_bool(
             config_utils.env_or_config(
-                config, "SENTRY_INTEGRATION_PYRAMID", "c2c.sentry_integration_pyramid", "true"
-            )
+                config,
+                "SENTRY_INTEGRATION_PYRAMID",
+                "c2c.sentry_integration_pyramid",
+                "true",
+            ),
         ):
             integrations.append(PyramidIntegration())
         if config_utils.config_bool(
             config_utils.env_or_config(
-                config, "SENTRY_INTEGRATION_SQLALCHEMY", "c2c.sentry_integration_sqlalchemy", "true"
-            )
+                config,
+                "SENTRY_INTEGRATION_SQLALCHEMY",
+                "c2c.sentry_integration_sqlalchemy",
+                "true",
+            ),
         ):
             integrations.append(SqlalchemyIntegration())
         if config_utils.config_bool(
             config_utils.env_or_config(
-                config, "SENTRY_INTEGRATION_REDIS", "c2c.sentry_integration_redis", "true"
-            )
+                config,
+                "SENTRY_INTEGRATION_REDIS",
+                "c2c.sentry_integration_redis",
+                "true",
+            ),
         ):
             integrations.append(RedisIntegration())
         if config_utils.config_bool(
             config_utils.env_or_config(
-                config, "SENTRY_INTEGRATION_ASYNCIO", "c2c.sentry_integration_asyncio", "true"
-            )
+                config,
+                "SENTRY_INTEGRATION_ASYNCIO",
+                "c2c.sentry_integration_asyncio",
+                "true",
+            ),
         ):
             integrations.append(AsyncioIntegration())
 
@@ -128,7 +149,10 @@ def includeme(config: Optional[pyramid.config.Configurator] = None) -> None:
         _CLIENT_SETUP = True
 
         excludes = config_utils.env_or_config(
-            config, "SENTRY_EXCLUDES", "c2c.sentry.excludes", "sentry_sdk"
+            config,
+            "SENTRY_EXCLUDES",
+            "c2c.sentry.excludes",
+            "sentry_sdk",
         ).split(",")
         for exclude in excludes:
             ignore_logger(exclude)
@@ -160,7 +184,7 @@ def filter_wsgi_app(application: Callable[..., Any]) -> Callable[..., Any]:
         try:
             _LOG.info("Enable WSGI filter for Sentry")
             return SentryWsgiMiddleware(application)
-        except Exception:  # pylint: disable=broad-except
+        except Exception:  # pylint: disable=broad-exception-caught
             _LOG.error("Failed enabling sentry. Continuing without it.", exc_info=True)
             return application
     else:

c2cwsgiutils/setup_process.py

@@ -7,7 +7,8 @@ Must be imported at the very beginning of the process's life, before any other m
 import argparse
 import logging
 import warnings
-from typing import Any, Callable, Optional, TypedDict, cast
+from collections.abc import Callable
+from typing import Any, TypedDict, cast
 
 import pyramid.config
 import pyramid.registry
@@ -57,7 +58,8 @@ def init(config_file: str = "c2c:///app/production.ini") -> None:
 def init_logging(config_file: str = "c2c:///app/production.ini") -> None:
     """Initialize the non-WSGI application."""
     warnings.warn(
-        "init_logging function is deprecated; use init instead so that all features are enabled", stacklevel=2
+        "init_logging function is deprecated; use init instead so that all features are enabled",
+        stacklevel=2,
     )
     loader = get_config_loader(config_file)
     loader.setup_logging(None)
@@ -82,13 +84,14 @@ def bootstrap_application_from_options(options: argparse.Namespace) -> PyramidEn
     https://docs.pylonsproject.org/projects/pyramid/en/latest/api/paster.html?highlight=bootstrap#pyramid.paster.bootstrap
     """
     return bootstrap_application(
-        options.config_uri, parse_vars(options.config_vars) if options.config_vars else None
+        options.config_uri,
+        parse_vars(options.config_vars) if options.config_vars else None,
     )
 
 
 def bootstrap_application(
     config_uri: str = "c2c:///app/production.ini",
-    options: Optional[dict[str, Any]] = None,
+    options: dict[str, Any] | None = None,
 ) -> PyramidEnv:
     """
     Initialize all the application.

c2cwsgiutils/sql_profiler/_impl.py

@@ -51,12 +51,13 @@ class _Repository:
                             [
                                 row[0]
                                 for row in c.execute(
-                                    sqlalchemy.text(f"EXPLAIN ANALYZE {statement}"), parameters
+                                    sqlalchemy.text(f"EXPLAIN ANALYZE {statement}"),
+                                    parameters,
                                 )
-                            ]
+                            ],
                         )
                     _LOG.info(output)
-                except Exception:  # pylint: disable=broad-except # noqa: S110
+                except Exception:  # pylint: disable=broad-exception-caught
                     pass
 
 
@@ -75,11 +76,10 @@ def _setup_profiler(enable: str) -> None:
             _LOG.info("Enabling the SQL profiler")
             _REPOSITORY = _Repository()
             sqlalchemy.event.listen(sqlalchemy.engine.Engine, "before_cursor_execute", _REPOSITORY.profile)
-    else:
-        if _REPOSITORY is not None:
-            _LOG.info("Disabling the SQL profiler")
-            sqlalchemy.event.remove(sqlalchemy.engine.Engine, "before_cursor_execute", _REPOSITORY.profile)
-            _REPOSITORY = None
+    elif _REPOSITORY is not None:
+        _LOG.info("Disabling the SQL profiler")
+        sqlalchemy.event.remove(sqlalchemy.engine.Engine, "before_cursor_execute", _REPOSITORY.profile)
+        _REPOSITORY = None
 
 
 def _beautify_sql(statement: str) -> str:
@@ -87,8 +87,7 @@ def _beautify_sql(statement: str) -> str:
     statement = re.sub(r" ((?:LEFT )?(?:OUTER )?JOIN )", r"\n\1", statement)
     statement = re.sub(r" ON ", r"\n  ON ", statement)
     statement = re.sub(r" GROUP BY ", r"\nGROUP BY ", statement)
-    statement = re.sub(r" ORDER BY ", r"\nORDER BY ", statement)
-    return statement
+    return re.sub(r" ORDER BY ", r"\nORDER BY ", statement)
 
 
 def _indent(statement: str, indent: str = "  ") -> str:
@@ -100,7 +99,9 @@ def init(config: pyramid.config.Configurator) -> None:
     broadcast.subscribe("c2c_sql_profiler", _setup_profiler)
 
     config.add_route(
-        "c2c_sql_profiler", config_utils.get_base_path(config) + r"/sql_profiler", request_method="GET"
+        "c2c_sql_profiler",
+        config_utils.get_base_path(config) + r"/sql_profiler",
+        request_method="GET",
     )
     config.add_view(_sql_profiler_view, route_name="c2c_sql_profiler", renderer="fast_json", http_cache=0)
     _LOG.info("Enabled the /sql_profiler API")

c2cwsgiutils/sqlalchemylogger/_models.py

@@ -1,4 +1,4 @@
-from typing import Any, Union
+from typing import Any
 
 from sqlalchemy import Column
 from sqlalchemy.orm import declarative_base
@@ -8,10 +8,10 @@ from sqlalchemy.types import DateTime, Integer, String
 Base = declarative_base()
 
 
-def create_log_class(tablename: str = "logs", tableargs: Union[str, dict[str, str]] = "") -> Any:
+def create_log_class(tablename: str = "logs", tableargs: str | dict[str, str] = "") -> Any:
     """Get the sqlalchemy lgo class."""
 
-    class Log(Base):  # type: ignore
+    class Log(Base):  # type: ignore[valid-type,misc]
         """The SQLAlchemy class that represent the log table."""
 
         __table_args__ = tableargs

c2cwsgiutils/sqlalchemylogger/handlers.py

@@ -38,10 +38,10 @@ class SQLAlchemyHandler(logging.Handler):
         self.engine = create_engine(sqlalchemy_url["url"])
         self.Log = create_log_class(  # pylint: disable=invalid-name
             tablename=sqlalchemy_url.get("tablename", "logs"),
-            tableargs=sqlalchemy_url.get("tableargs"),  # type: ignore
+            tableargs=sqlalchemy_url.get("tableargs"),  # type: ignore[arg-type]
         )
         Base.metadata.bind = self.engine
-        self.session = sessionmaker(bind=self.engine)()  # noqa
+        self.session = sessionmaker(bind=self.engine)()
         # Initialize log queue
         self.log_queue: Any = queue.Queue()
         # Initialize a thread to process the logs Asynchronously
@@ -68,10 +68,8 @@ class SQLAlchemyHandler(logging.Handler):
                 # try to reduce the number of INSERT requests to the DB
                 # by writing chunks of self.MAX_NB_LOGS size,
                 # but also do not wait forever before writing stuff (self.MAX_TIMOUT)
-                if (
-                    logs
-                    and (len(logs) >= self.MAX_NB_LOGS)
-                    or (time.perf_counter() >= (time_since_last + self.MAX_TIMEOUT))
+                if (logs and (len(logs) >= self.MAX_NB_LOGS)) or (
+                    time.perf_counter() >= (time_since_last + self.MAX_TIMEOUT)
                 ):
                     self._write_logs(logs)
                     break
@@ -87,7 +85,7 @@ class SQLAlchemyHandler(logging.Handler):
                 self.session.rollback()
                 self.session.bulk_save_objects(logs)
                 self.session.commit()
-            except Exception as e:  # pylint: disable=broad-except
+            except Exception as e:  # pylint: disable=broad-exception-caught #
                 # if we really cannot commit the log to DB, do not lock the
                 # thread and do not crash the application
                 _LOG.critical(e)
@@ -101,8 +99,9 @@ class SQLAlchemyHandler(logging.Handler):
             create_database(self.engine.url)
         # FIXME: we should not access directly the private __table_args__ # pylint: disable=fixme
         # variable, but add an accessor method in models.Log class
-        if not isinstance(self.Log.__table_args__, type(None)) and self.Log.__table_args__.get(
-            "schema", None
+        if self.Log.__table_args__ is not None and self.Log.__table_args__.get(
+            "schema",
+            None,
         ):
             with self.engine.begin() as connection:
                 if not self.engine.dialect.has_schema(connection, self.Log.__table_args__["schema"]):

c2cwsgiutils/stats_pyramid/_db_spy.py

@@ -1,7 +1,8 @@
 import logging
 import re
 import time
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 import prometheus_client
 import sqlalchemy.event
@@ -77,10 +78,18 @@ def _create_sqlalchemy_timer_cb(what: str) -> Callable[..., Any]:
 
 
 def _before_cursor_execute(
-    conn: Connection, _cursor: Any, statement: str, _parameters: Any, _context: Any, _executemany: Any
+    conn: Connection,
+    _cursor: Any,
+    statement: str,
+    _parameters: Any,
+    _context: Any,
+    _executemany: Any,
 ) -> None:
     sqlalchemy.event.listen(
-        conn, "after_cursor_execute", _create_sqlalchemy_timer_cb(_simplify_sql(statement)), once=True
+        conn,
+        "after_cursor_execute",
+        _create_sqlalchemy_timer_cb(_simplify_sql(statement)),
+        once=True,
     )
 
 

c2cwsgiutils/stats_pyramid/_pyramid_spy.py

@@ -1,6 +1,6 @@
 import logging
 import time
-from typing import Callable, Optional
+from collections.abc import Callable
 
 import prometheus_client
 import pyramid.config
@@ -29,8 +29,8 @@ _PROMETHEUS_PYRAMID_VIEWS_SUMMARY = prometheus_client.Summary(
 def _add_server_metric(
     request: pyramid.request.Request,
     name: str,
-    duration: Optional[float] = None,
-    description: Optional[str] = None,
+    duration: float | None = None,
+    description: str | None = None,
 ) -> None:
     # format: <name>;due=<duration>;desc=<description>
     metric = name
@@ -46,16 +46,14 @@ def _add_server_metric(
 
 
 def _create_finished_cb(
-    kind: str, measure: prometheus_client.Summary
+    kind: str,
+    measure: prometheus_client.Summary,
 ) -> Callable[[pyramid.request.Request], None]:  # pragma: nocover
     start = time.process_time()
 
     def finished_cb(request: pyramid.request.Request) -> None:
         if request.exception is not None:
-            if isinstance(request.exception, HTTPException):
-                status = request.exception.code
-            else:
-                status = 599
+            status = request.exception.code if isinstance(request.exception, HTTPException) else 599
         else:
             status = request.response.status_code
         if request.matched_route is None:
@@ -74,7 +72,10 @@ def _create_finished_cb(
                 status,
             )
         measure.labels(
-            method=request.method, route=name, status=status, group=str(status // 100 * 100)
+            method=request.method,
+            route=name,
+            status=status,
+            group=str(status // 100 * 100),
         ).observe(time.process_time() - start)
         _add_server_metric(request, kind, duration=time.process_time() - start)