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

c2cwsgiutils/debug/_views.py

@@ -1,12 +1,12 @@
+import datetime
 import gc
 import logging
 import os
 import re
 import time
-from collections.abc import Mapping
-from datetime import datetime
+from collections.abc import Callable, Mapping
 from io import StringIO
-from typing import Any, Callable, cast
+from typing import Any, cast
 
 import objgraph
 import psutil
@@ -79,7 +79,7 @@ def _dump_memory_diff(request: pyramid.request.Request) -> list[Any]:
     try:
         if request.params.get("no_warmup", "0").lower() in ("1", "true", "on"):
             request.invoke_subrequest(sub_request)
-    except Exception:  # pylint: disable=broad-except
+    except Exception:  # pylint: disable=broad-exception-caught
         pass
 
     _LOG.debug("checking memory growth for %s", path)
@@ -119,7 +119,7 @@ def _dump_memory_diff(request: pyramid.request.Request) -> list[Any]:
             "dirty_kb": (mem_after.dirty - mem_before.dirty) / 1024,
         },
         "elapsed_time": elapsed_time,
-        "objgraph.growth": objgraph.growth(limit=limit, peak_stats=peak_stats, shortnames=False),  # type: ignore
+        "objgraph.growth": objgraph.growth(limit=limit, peak_stats=peak_stats, shortnames=False),  # type: ignore[return-value]
     }
 
 
@@ -162,18 +162,23 @@ def _error(request: pyramid.request.Request) -> Any:
 def _time(request: pyramid.request.Request) -> Any:
     del request  # unused
     return {
-        "local_time": str(datetime.now()),
-        "gmt_time": str(datetime.utcnow()),
+        "local_time": str(datetime.datetime.now()),  # noqa: DTZ005
+        "gmt_time": str(datetime.datetime.now(datetime.timezone.utc)),
         "epoch": time.time(),
-        "timezone": datetime.now().astimezone().tzname(),
+        "timezone": datetime.datetime.now().astimezone().tzname(),
     }
 
 
 def _add_view(
-    config: pyramid.config.Configurator, name: str, path: str, view: Callable[[pyramid.request.Request], Any]
+    config: pyramid.config.Configurator,
+    name: str,
+    path: str,
+    view: Callable[[pyramid.request.Request], Any],
 ) -> None:
     config.add_route(
-        "c2c_debug_" + name, config_utils.get_base_path(config) + r"/debug/" + path, request_method="GET"
+        "c2c_debug_" + name,
+        config_utils.get_base_path(config) + r"/debug/" + path,
+        request_method="GET",
     )
     config.add_view(view, route_name="c2c_debug_" + name, renderer="fast_json", http_cache=0)
 

c2cwsgiutils/debug/utils.py

@@ -1,9 +1,9 @@
 import gc
 import logging
-import os
 import re
 import sys
 from collections import defaultdict
+from pathlib import Path
 from types import FunctionType, ModuleType
 from typing import Any
 
@@ -37,14 +37,14 @@ def get_size(obj: Any) -> int:
 
 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):
+    filename = Path("/proc") / pid / "smaps"
+    if not filename.exists():
         return []
-    with open(filename, encoding="utf-8") as input_:
+    with filename.open(encoding="utf-8") as input_:
         cur_dict: dict[str, int] = defaultdict(int)
         sizes: dict[str, Any] = {}
         for line in input_:
-            line = line.rstrip("\n")
+            line = line.rstrip("\n")  # noqa: PLW2901
             matcher = _SMAPS_LOCATION_RE.match(line)
             if matcher:
                 cur_dict = sizes.setdefault(matcher.group(1), defaultdict(int))

c2cwsgiutils/errors.py

@@ -4,7 +4,8 @@ import logging
 import os
 import traceback
 import warnings
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 import pyramid.request
 import sqlalchemy.exc
@@ -34,7 +35,7 @@ def _crude_add_cors(request: pyramid.request.Request, response: pyramid.response
         response = request.response
     response.headers["Access-Control-Allow-Origin"] = "*"
     response.headers["Access-Control-Allow-Methods"] = ",".join(
-        {request.headers.get("Access-Control-Request-Method", request.method)} | {"OPTIONS", "HEAD"}
+        {request.headers.get("Access-Control-Request-Method", request.method)} | {"OPTIONS", "HEAD"},
     )
     response.headers["Access-Control-Allow-Headers"] = "session-id"
     response.headers["Access-Control-Max-Age"] = "86400"
@@ -57,7 +58,7 @@ def _do_error(
     status: int,
     exception: Exception,
     logger: Callable[..., None] = _LOG.error,
-    reduce_info_sent: Callable[[Exception], None] = lambda e: None,
+    reduce_info_sent: Callable[[Exception], None] = lambda e: None,  # noqa: ARG005
 ) -> pyramid.response.Response:
     logger(
         "%s %s returned status code %s",
@@ -98,10 +99,9 @@ def _http_error(exception: HTTPException, request: pyramid.request.Request) -> A
         _add_cors(request)
         request.response.status_code = exception.status_code
         return {"message": str(exception), "status": exception.status_code}
-    else:
-        _crude_add_cors(request)
-        request.response.status_code = 200
-        return request.response
+    _crude_add_cors(request)
+    request.response.status_code = 200
+    return request.response
 
 
 def _include_dev_details(request: pyramid.request.Request) -> bool:
@@ -109,7 +109,8 @@ def _include_dev_details(request: pyramid.request.Request) -> bool:
 
 
 def _integrity_error(
-    exception: sqlalchemy.exc.StatementError, request: pyramid.request.Request
+    exception: sqlalchemy.exc.StatementError,
+    request: pyramid.request.Request,
 ) -> pyramid.response.Response:
     def reduce_info_sent(e: Exception) -> None:
         if isinstance(e, sqlalchemy.exc.StatementError):
@@ -121,7 +122,8 @@ def _integrity_error(
 
 
 def _client_interrupted_error(
-    exception: Exception, request: pyramid.request.Request
+    exception: Exception,
+    request: pyramid.request.Request,
 ) -> pyramid.response.Response:
     # No need to cry wolf if it's just the client that interrupted the connection
     return _do_error(request, 500, exception, logger=_LOG.info)
@@ -165,7 +167,10 @@ def includeme(config: pyramid.config.Configurator) -> None:
     """Initialize the error views."""
     if (
         config_utils.env_or_config(
-            config, "C2C_ENABLE_EXCEPTION_HANDLING", "c2c.enable_exception_handling", "0"
+            config,
+            "C2C_ENABLE_EXCEPTION_HANDLING",
+            "c2c.enable_exception_handling",
+            "0",
         )
         != "0"
     ):

c2cwsgiutils/health_check.py

@@ -13,10 +13,11 @@ import re
 import subprocess  # nosec
 import time
 import traceback
-from collections.abc import Mapping
+from collections.abc import Callable, Mapping
 from enum import Enum
+from pathlib import Path
 from types import TracebackType
-from typing import Any, Callable, Literal, Optional, Union, cast
+from typing import Any, Literal, cast
 
 import prometheus_client
 import pyramid.config
@@ -63,10 +64,10 @@ class EngineType(Enum):
     READ_AND_WRITE = 3
 
 
-class JsonCheckException(Exception):
+class JsonCheckException(Exception):  # noqa: N818
     """Checker exception used to add some structured content to a failure."""
 
-    def __init__(self, message: str, json: Any):
+    def __init__(self, message: str, json: Any) -> None:
         """Initialize the exception."""
         super().__init__()
         self.message = message
@@ -83,22 +84,22 @@ class JsonCheckException(Exception):
 class _Binding:
     def name(self) -> str:
         """Return the name of the binding."""
-        raise NotImplementedError()
+        raise NotImplementedError
 
     def __enter__(self) -> _scoped_session:
-        raise NotImplementedError()
+        raise NotImplementedError
 
     def __exit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_value: Optional[BaseException],
-        exc_traceback: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        exc_traceback: TracebackType | None,
     ) -> Literal[False]:
         return False
 
 
 class _NewBinding(_Binding):
-    def __init__(self, session: c2cwsgiutils.db.SessionFactory, readwrite: bool):
+    def __init__(self, session: c2cwsgiutils.db.SessionFactory, readwrite: bool) -> None:
         self.session = session
         self.readwrite = readwrite
 
@@ -110,84 +111,85 @@ class _NewBinding(_Binding):
 
 
 class _OldBinding(_Binding):
-    def __init__(self, session: _scoped_session, engine: sqlalchemy.engine.Engine):
+    def __init__(self, session: _scoped_session, engine: sqlalchemy.engine.Engine) -> None:
         self.session = session
         self.engine = engine
         self.prev_bind = None
 
     def name(self) -> str:
-        return cast(str, self.engine.c2c_name)  # type: ignore
+        return cast(str, self.engine.c2c_name)  # type: ignore[attr-defined]
 
     def __enter__(self) -> _scoped_session:
-        self.prev_bind = self.session.bind  # type: ignore
+        self.prev_bind = self.session.bind  # type: ignore[assignment]
         self.session.bind = self.engine
         return self.session
 
     def __exit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_value: Optional[BaseException],
-        exc_traceback: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        exc_traceback: TracebackType | None,
     ) -> Literal[False]:
         self.session.bind = self.prev_bind
         return False
 
 
 def _get_binding_class(
-    session: Union[_scoped_session, c2cwsgiutils.db.SessionFactory],
+    session: _scoped_session | c2cwsgiutils.db.SessionFactory,
     ro_engin: sqlalchemy.engine.Engine,
     rw_engin: sqlalchemy.engine.Engine,
     readwrite: bool,
 ) -> _Binding:
     if isinstance(session, c2cwsgiutils.db.SessionFactory):
         return _NewBinding(session, readwrite)
-    else:
-        return _OldBinding(session, ro_engin if readwrite else rw_engin)
+    return _OldBinding(session, ro_engin if readwrite else rw_engin)
 
 
 def _get_bindings(
-    session: Union[_scoped_session, c2cwsgiutils.db.SessionFactory],
+    session: _scoped_session | c2cwsgiutils.db.SessionFactory,
     engine_type: EngineType,
 ) -> list[_Binding]:
     if isinstance(session, c2cwsgiutils.db.SessionFactory):
         ro_engin = session.ro_engine
         rw_engin = session.rw_engine
     else:
-        ro_engin = session.c2c_ro_bind  # type: ignore
-        rw_engin = session.c2c_rw_bind  # type: ignore
+        ro_engin = session.c2c_ro_bind  # type: ignore[attr-defined]
+        rw_engin = session.c2c_rw_bind  # type: ignore[attr-defined]
 
     if rw_engin == ro_engin:
         engine_type = EngineType.WRITE_ONLY
 
     if engine_type == EngineType.READ_AND_WRITE:
         return [
-            _get_binding_class(session, ro_engin, rw_engin, False),
-            _get_binding_class(session, ro_engin, rw_engin, True),
+            _get_binding_class(session, ro_engin, rw_engin, readwrite=False),
+            _get_binding_class(session, ro_engin, rw_engin, readwrite=True),
         ]
     if engine_type == EngineType.READ_ONLY:
-        return [_get_binding_class(session, ro_engin, ro_engin, False)]
+        return [_get_binding_class(session, ro_engin, ro_engin, readwrite=False)]
     if engine_type == EngineType.WRITE_ONLY:
-        return [_get_binding_class(session, rw_engin, rw_engin, True)]
+        return [_get_binding_class(session, rw_engin, rw_engin, readwrite=True)]
 
     raise NotImplementedError(f"Unhandled engine type {engine_type}")
 
 
-def _get_alembic_version(alembic_ini_path: str, name: str) -> str:
+def _get_alembic_version(alembic_ini_path: Path, name: str) -> str:
     # Go to the directory holding the config file and add '.' to the PYTHONPATH variable to support Alembic
     # migration scripts using common modules
     env = dict(os.environ)
     pythonpath = os.environ.get("PYTHONPATH", "")
     pythonpath = (pythonpath + ":" if pythonpath else "") + "."
     env["PYTHONPATH"] = pythonpath
-    dirname = os.path.abspath(os.path.dirname(alembic_ini_path))
+    dirname = alembic_ini_path.parent.resolve()
 
     out = subprocess.check_output(  # nosec
-        ["alembic", "--config", alembic_ini_path, "--name", name, "heads"], cwd=dirname, env=env
+        ["alembic", "--config", alembic_ini_path, "--name", name, "heads"],
+        cwd=dirname,
+        env=env,
     ).decode("utf-8")
     out_match = _ALEMBIC_HEAD_RE.match(out)
     if not out_match:
         raise Exception(  # pylint: disable=broad-exception-raised
-            "Cannot get the alembic HEAD version from: " + out
+            "Cannot get the alembic HEAD version from: " + out,
         )
     return out_match.group(1)
 
@@ -202,7 +204,9 @@ class HealthCheck:
     def __init__(self, config: pyramid.config.Configurator) -> None:
         """Initialize the health check view."""
         config.add_route(
-            "c2c_health_check", config_utils.get_base_path(config) + r"/health_check", request_method="GET"
+            "c2c_health_check",
+            config_utils.get_base_path(config) + r"/health_check",
+            request_method="GET",
         )
         config.add_view(self._view, route_name="c2c_health_check", renderer="fast_json", http_cache=0)
         self._checks: list[tuple[str, Callable[[pyramid.request.Request], Any], int]] = []
@@ -220,9 +224,9 @@ class HealthCheck:
 
     def add_db_session_check(
         self,
-        session: Union[_scoped_session, c2cwsgiutils.db.SessionFactory],
-        query_cb: Optional[Callable[[_scoped_session], Any]] = None,
-        at_least_one_model: Optional[object] = None,
+        session: _scoped_session | c2cwsgiutils.db.SessionFactory,
+        query_cb: Callable[[_scoped_session], Any] | None = None,
+        at_least_one_model: object | None = None,
         level: int = 1,
         engine_type: EngineType = EngineType.READ_AND_WRITE,
     ) -> None:
@@ -249,11 +253,11 @@ class HealthCheck:
     def add_alembic_check(
         self,
         session: _scoped_session,
-        alembic_ini_path: str,
+        alembic_ini_path: Path | str,
         level: int = 2,
         name: str = "alembic",
-        version_schema: Optional[str] = None,
-        version_table: Optional[str] = None,
+        version_schema: str | None = None,
+        version_table: str | None = None,
     ) -> None:
         """
         Check the DB version against the HEAD version of Alembic.
@@ -270,6 +274,8 @@ class HealthCheck:
             ro_engin: the RO engine to use (if None, use the session one)
 
         """
+        if isinstance(alembic_ini_path, str):
+            alembic_ini_path = Path(alembic_ini_path)
         version_ = _get_alembic_version(alembic_ini_path, name)
 
         config = configparser.ConfigParser()
@@ -288,47 +294,55 @@ class HealthCheck:
                 self.session = session
 
             def __call__(self, request: pyramid.request.Request) -> str:
+                del request  # Unused
                 assert version_schema
                 assert version_table
                 for binding in _get_bindings(self.session, EngineType.READ_AND_WRITE):
                     with (
                         binding as binded_session,
                         _PROMETHEUS_DB_SUMMARY.labels(
-                            configuration=alembic_ini_path, connection=binding.name(), check="alembic"
+                            configuration=alembic_ini_path,
+                            connection=binding.name(),
+                            check="alembic",
                         ).time(),
                     ):
                         result = binded_session.execute(
                             sqlalchemy.text(
                                 "SELECT version_num FROM "  # noqa: S608 # nosec
-                                f"{sqlalchemy.sql.quoted_name(version_schema, True)}."
-                                f"{sqlalchemy.sql.quoted_name(version_table, True)}"
-                            )
+                                f"{sqlalchemy.sql.quoted_name(version_schema, quote=True)}."
+                                f"{sqlalchemy.sql.quoted_name(version_table, quote=True)}",
+                            ),
                         ).fetchone()
                         assert result is not None
                         (actual_version,) = result
                         _PROMETHEUS_ALEMBIC_VERSION.labels(
-                            version=actual_version, name=name, configuration=alembic_ini_path
+                            version=actual_version,
+                            name=name,
+                            configuration=alembic_ini_path,
                         ).set(1)
                         if actual_version != version_:
-                            raise Exception(  # pylint: disable=broad-exception-raised
+                            error_message = (
                                 f"Invalid alembic version (db: {actual_version}, code: {version_})"
                             )
+                            raise Exception(error_message)  # pylint: disable=broad-exception-raised
                 return version_
 
         self._checks.append(
-            ("alembic_" + alembic_ini_path.replace("/", "_").strip("_") + "_" + name, _Check(session), level)
+            (
+                "alembic_" + str(alembic_ini_path).replace("/", "_").strip("_") + "_" + name,
+                _Check(session),
+                level,
+            ),
         )
 
     def add_url_check(
         self,
-        url: Union[str, Callable[[pyramid.request.Request], str]],
-        params: Union[Mapping[str, str], Callable[[pyramid.request.Request], Mapping[str, str]], None] = None,
-        headers: Union[
-            Mapping[str, str], Callable[[pyramid.request.Request], Mapping[str, str]], None
-        ] = None,
-        name: Optional[str] = None,
-        check_cb: Callable[[pyramid.request.Request, requests.Response], Any] = lambda request,
-        response: None,
+        url: str | Callable[[pyramid.request.Request], str],
+        params: Mapping[str, str] | Callable[[pyramid.request.Request], Mapping[str, str]] | None = None,
+        headers: Mapping[str, str] | Callable[[pyramid.request.Request], Mapping[str, str]] | None = None,
+        name: str | None = None,
+        check_cb: Callable[[pyramid.request.Request, requests.Response], Any] = lambda request,  # noqa: ARG005
+        response: None,  # noqa: ARG005
         timeout: float = 3,
         level: int = 1,
     ) -> None:
@@ -344,7 +358,6 @@ class HealthCheck:
                          response as parameters)
             timeout: the timeout
             level: the level of the health check
-
         """
 
         def check(request: pyramid.request.Request) -> Any:
@@ -362,7 +375,7 @@ class HealthCheck:
         assert name
         self._checks.append((name, check, level))
 
-    def add_redis_check(self, name: Optional[str] = None, level: int = 1) -> None:
+    def add_redis_check(self, name: str | None = None, level: int = 1) -> None:
         """
         Check that the given redis server is reachable.
 
@@ -382,7 +395,7 @@ class HealthCheck:
             def add(name: str, func: Callable[..., Any], *args: Any) -> None:
                 try:
                     result[name] = func(*args)
-                except Exception as e:  # pylint: disable=broad-except
+                except Exception as e:  # pylint: disable=broad-exception-caught
                     result[name] = {"error": str(e)}
 
             if master is not None:
@@ -409,7 +422,8 @@ class HealthCheck:
             name = self.name
 
             if name is None:
-                raise RuntimeError("Redis should be configured")
+                exception_message = "Redis should be configured"
+                raise RuntimeError(exception_message)
 
         self._checks.append((name, check, level))
 
@@ -437,7 +451,10 @@ class HealthCheck:
         self._checks.append((name, check, level))
 
     def add_custom_check(
-        self, name: str, check_cb: Callable[[pyramid.request.Request], Any], level: int = 1
+        self,
+        name: str,
+        check_cb: Callable[[pyramid.request.Request], Any],
+        level: int = 1,
     ) -> None:
         """
         Add a custom check.
@@ -489,7 +506,7 @@ class HealthCheck:
             if result is not None:
                 results["successes"][name]["result"] = result
             _set_success(check_name=name)
-        except Exception as e:  # pylint: disable=broad-except
+        except Exception as e:  # pylint: disable=broad-exception-caught
             _PROMETHEUS_HEALTH_CHECKS_FAILURE.labels(name=name).set(1)
             _LOG.warning("Health check %s failed", name, exc_info=True)
             failure = {"message": str(e), "timing": time.perf_counter() - start, "level": level}
@@ -509,7 +526,9 @@ class HealthCheck:
             with (
                 binding as session,
                 _PROMETHEUS_DB_SUMMARY.labels(
-                    connection=binding.name(), check="database", configuration="<default>"
+                    connection=binding.name(),
+                    check="database",
+                    configuration="<default>",
                 ).time(),
             ):
                 return query_cb(session)
@@ -537,5 +556,5 @@ def _set_success(check_name: str) -> None:
 
 
 @broadcast.decorator(expect_answers=True)
-def _get_all_versions() -> Optional[str]:
+def _get_all_versions() -> str | None:
     return version.get_version()