sentry-sdk 3.0.0a1__py2.py3-none-any.whl → 3.0.0a3__py2.py3-none-any.whl

sentry_sdk/integrations/django/__init__.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import functools
 import inspect
 import sys
@@ -107,18 +108,17 @@ class DjangoIntegration(Integration):
     middleware_spans = None
     signals_spans = None
     cache_spans = None
-    signals_denylist = []  # type: list[signals.Signal]
+    signals_denylist: list[signals.Signal] = []
 
     def __init__(
         self,
-        transaction_style="url",  # type: str
-        middleware_spans=True,  # type: bool
-        signals_spans=True,  # type: bool
-        cache_spans=True,  # type: bool
-        signals_denylist=None,  # type: Optional[list[signals.Signal]]
-        http_methods_to_capture=DEFAULT_HTTP_METHODS_TO_CAPTURE,  # type: tuple[str, ...]
-    ):
-        # type: (...) -> None
+        transaction_style: str = "url",
+        middleware_spans: bool = True,
+        signals_spans: bool = True,
+        cache_spans: bool = True,
+        signals_denylist: Optional[list[signals.Signal]] = None,
+        http_methods_to_capture: tuple[str, ...] = DEFAULT_HTTP_METHODS_TO_CAPTURE,
+    ) -> None:
         if transaction_style not in TRANSACTION_STYLE_VALUES:
             raise ValueError(
                 "Invalid value for transaction_style: %s (must be in %s)"
@@ -135,8 +135,7 @@ class DjangoIntegration(Integration):
         self.http_methods_to_capture = tuple(map(str.upper, http_methods_to_capture))
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         _check_minimum_version(DjangoIntegration, DJANGO_VERSION)
 
         install_sql_hook()
@@ -151,8 +150,9 @@ class DjangoIntegration(Integration):
         old_app = WSGIHandler.__call__
 
         @ensure_integration_enabled(DjangoIntegration, old_app)
-        def sentry_patched_wsgi_handler(self, environ, start_response):
-            # type: (Any, Dict[str, str], Callable[..., Any]) -> _ScopedResponse
+        def sentry_patched_wsgi_handler(
+            self: Any, environ: Dict[str, str], start_response: Callable[..., Any]
+        ) -> _ScopedResponse:
             bound_old_app = old_app.__get__(self, WSGIHandler)
 
             from django.conf import settings
@@ -182,8 +182,9 @@ class DjangoIntegration(Integration):
         signals.got_request_exception.connect(_got_request_exception)
 
         @add_global_event_processor
-        def process_django_templates(event, hint):
-            # type: (Event, Optional[Hint]) -> Optional[Event]
+        def process_django_templates(
+            event: Event, hint: Optional[Hint]
+        ) -> Optional[Event]:
             if hint is None:
                 return event
 
@@ -225,8 +226,9 @@ class DjangoIntegration(Integration):
             return event
 
         @add_global_repr_processor
-        def _django_queryset_repr(value, hint):
-            # type: (Any, Dict[str, Any]) -> Union[NotImplementedType, str]
+        def _django_queryset_repr(
+            value: Any, hint: Dict[str, Any]
+        ) -> Union[NotImplementedType, str]:
             try:
                 # Django 1.6 can fail to import `QuerySet` when Django settings
                 # have not yet been initialized.
@@ -261,8 +263,7 @@ _DRF_PATCHED = False
 _DRF_PATCH_LOCK = threading.Lock()
 
 
-def _patch_drf():
-    # type: () -> None
+def _patch_drf() -> None:
     """
     Patch Django Rest Framework for more/better request data. DRF's request
     type is a wrapper around Django's request type. The attribute we're
@@ -305,8 +306,9 @@ def _patch_drf():
                 old_drf_initial = APIView.initial
 
                 @functools.wraps(old_drf_initial)
-                def sentry_patched_drf_initial(self, request, *args, **kwargs):
-                    # type: (APIView, Any, *Any, **Any) -> Any
+                def sentry_patched_drf_initial(
+                    self: APIView, request: Any, *args: Any, **kwargs: Any
+                ) -> Any:
                     with capture_internal_exceptions():
                         request._request._sentry_drf_request_backref = weakref.ref(
                             request
@@ -317,8 +319,7 @@ def _patch_drf():
                 APIView.initial = sentry_patched_drf_initial
 
 
-def _patch_channels():
-    # type: () -> None
+def _patch_channels() -> None:
     try:
         from channels.http import AsgiHandler  # type: ignore
     except ImportError:
@@ -342,8 +343,7 @@ def _patch_channels():
     patch_channels_asgi_handler_impl(AsgiHandler)
 
 
-def _patch_django_asgi_handler():
-    # type: () -> None
+def _patch_django_asgi_handler() -> None:
     try:
         from django.core.handlers.asgi import ASGIHandler
     except ImportError:
@@ -364,8 +364,9 @@ def _patch_django_asgi_handler():
     patch_django_asgi_handler_impl(ASGIHandler)
 
 
-def _set_transaction_name_and_source(scope, transaction_style, request):
-    # type: (sentry_sdk.Scope, str, WSGIRequest) -> None
+def _set_transaction_name_and_source(
+    scope: sentry_sdk.Scope, transaction_style: str, request: WSGIRequest
+) -> None:
     try:
         transaction_name = None
         if transaction_style == "function_name":
@@ -408,8 +409,7 @@ def _set_transaction_name_and_source(scope, transaction_style, request):
         pass
 
 
-def _before_get_response(request):
-    # type: (WSGIRequest) -> None
+def _before_get_response(request: WSGIRequest) -> None:
     integration = sentry_sdk.get_client().get_integration(DjangoIntegration)
     if integration is None:
         return
@@ -425,8 +425,9 @@ def _before_get_response(request):
     )
 
 
-def _attempt_resolve_again(request, scope, transaction_style):
-    # type: (WSGIRequest, sentry_sdk.Scope, str) -> None
+def _attempt_resolve_again(
+    request: WSGIRequest, scope: sentry_sdk.Scope, transaction_style: str
+) -> None:
     """
     Some django middlewares overwrite request.urlconf
     so we need to respect that contract,
@@ -438,8 +439,7 @@ def _attempt_resolve_again(request, scope, transaction_style):
     _set_transaction_name_and_source(scope, transaction_style, request)
 
 
-def _after_get_response(request):
-    # type: (WSGIRequest) -> None
+def _after_get_response(request: WSGIRequest) -> None:
     integration = sentry_sdk.get_client().get_integration(DjangoIntegration)
     if integration is None or integration.transaction_style != "url":
         return
@@ -448,8 +448,7 @@ def _after_get_response(request):
     _attempt_resolve_again(request, scope, integration.transaction_style)
 
 
-def _patch_get_response():
-    # type: () -> None
+def _patch_get_response() -> None:
     """
     patch get_response, because at that point we have the Django request object
     """
@@ -458,8 +457,9 @@ def _patch_get_response():
     old_get_response = BaseHandler.get_response
 
     @functools.wraps(old_get_response)
-    def sentry_patched_get_response(self, request):
-        # type: (Any, WSGIRequest) -> Union[HttpResponse, BaseException]
+    def sentry_patched_get_response(
+        self: Any, request: WSGIRequest
+    ) -> Union[HttpResponse, BaseException]:
         _before_get_response(request)
         rv = old_get_response(self, request)
         _after_get_response(request)
@@ -473,10 +473,10 @@ def _patch_get_response():
         patch_get_response_async(BaseHandler, _before_get_response)
 
 
-def _make_wsgi_request_event_processor(weak_request, integration):
-    # type: (Callable[[], WSGIRequest], DjangoIntegration) -> EventProcessor
-    def wsgi_request_event_processor(event, hint):
-        # type: (Event, dict[str, Any]) -> Event
+def _make_wsgi_request_event_processor(
+    weak_request: Callable[[], WSGIRequest], integration: DjangoIntegration
+) -> EventProcessor:
+    def wsgi_request_event_processor(event: Event, hint: dict[str, Any]) -> Event:
         # if the request is gone we are fine not logging the data from
         # it.  This might happen if the processor is pushed away to
         # another thread.
@@ -501,8 +501,7 @@ def _make_wsgi_request_event_processor(weak_request, integration):
     return wsgi_request_event_processor
 
 
-def _got_request_exception(request=None, **kwargs):
-    # type: (WSGIRequest, **Any) -> None
+def _got_request_exception(request: WSGIRequest = None, **kwargs: Any) -> None:
     client = sentry_sdk.get_client()
     integration = client.get_integration(DjangoIntegration)
     if integration is None:
@@ -521,8 +520,7 @@ def _got_request_exception(request=None, **kwargs):
 
 
 class DjangoRequestExtractor(RequestExtractor):
-    def __init__(self, request):
-        # type: (Union[WSGIRequest, ASGIRequest]) -> None
+    def __init__(self, request: Union[WSGIRequest, ASGIRequest]) -> None:
         try:
             drf_request = request._sentry_drf_request_backref()
             if drf_request is not None:
@@ -531,18 +529,16 @@ class DjangoRequestExtractor(RequestExtractor):
             pass
         self.request = request
 
-    def env(self):
-        # type: () -> Dict[str, str]
+    def env(self) -> Dict[str, str]:
         return self.request.META
 
-    def cookies(self):
-        # type: () -> Dict[str, Union[str, AnnotatedValue]]
+    def cookies(self) -> Dict[str, Union[str, AnnotatedValue]]:
         privacy_cookies = [
             django_settings.CSRF_COOKIE_NAME,
             django_settings.SESSION_COOKIE_NAME,
         ]
 
-        clean_cookies = {}  # type: Dict[str, Union[str, AnnotatedValue]]
+        clean_cookies: Dict[str, Union[str, AnnotatedValue]] = {}
         for key, val in self.request.COOKIES.items():
             if key in privacy_cookies:
                 clean_cookies[key] = SENSITIVE_DATA_SUBSTITUTE
@@ -551,32 +547,26 @@ class DjangoRequestExtractor(RequestExtractor):
 
         return clean_cookies
 
-    def raw_data(self):
-        # type: () -> bytes
+    def raw_data(self) -> bytes:
         return self.request.body
 
-    def form(self):
-        # type: () -> QueryDict
+    def form(self) -> QueryDict:
         return self.request.POST
 
-    def files(self):
-        # type: () -> MultiValueDict
+    def files(self) -> MultiValueDict:
         return self.request.FILES
 
-    def size_of_file(self, file):
-        # type: (Any) -> int
+    def size_of_file(self, file: Any) -> int:
         return file.size
 
-    def parsed_body(self):
-        # type: () -> Optional[Dict[str, Any]]
+    def parsed_body(self) -> Optional[Dict[str, Any]]:
         try:
             return self.request.data
         except Exception:
             return RequestExtractor.parsed_body(self)
 
 
-def _set_user_info(request, event):
-    # type: (WSGIRequest, Event) -> None
+def _set_user_info(request: WSGIRequest, event: Event) -> None:
     user_info = event.setdefault("user", {})
 
     user = getattr(request, "user", None)
@@ -600,8 +590,7 @@ def _set_user_info(request, event):
         pass
 
 
-def install_sql_hook():
-    # type: () -> None
+def install_sql_hook() -> None:
     """If installed this causes Django's queries to be captured."""
     try:
         from django.db.backends.utils import CursorWrapper
@@ -615,8 +604,7 @@ def install_sql_hook():
     real_connect = BaseDatabaseWrapper.connect
 
     @ensure_integration_enabled(DjangoIntegration, real_execute)
-    def execute(self, sql, params=None):
-        # type: (CursorWrapper, Any, Optional[Any]) -> Any
+    def execute(self: CursorWrapper, sql: Any, params: Optional[Any] = None) -> Any:
         with record_sql_queries(
             cursor=self.cursor,
             query=sql,
@@ -634,8 +622,7 @@ def install_sql_hook():
         return result
 
     @ensure_integration_enabled(DjangoIntegration, real_executemany)
-    def executemany(self, sql, param_list):
-        # type: (CursorWrapper, Any, List[Any]) -> Any
+    def executemany(self: CursorWrapper, sql: Any, param_list: List[Any]) -> Any:
         with record_sql_queries(
             cursor=self.cursor,
             query=sql,
@@ -654,8 +641,7 @@ def install_sql_hook():
         return result
 
     @ensure_integration_enabled(DjangoIntegration, real_connect)
-    def connect(self):
-        # type: (BaseDatabaseWrapper) -> None
+    def connect(self: BaseDatabaseWrapper) -> None:
         with capture_internal_exceptions():
             sentry_sdk.add_breadcrumb(message="connect", category="query")
 
@@ -674,8 +660,7 @@ def install_sql_hook():
     ignore_logger("django.db.backends")
 
 
-def _set_db_data(span, cursor_or_db):
-    # type: (Span, Any) -> None
+def _set_db_data(span: Span, cursor_or_db: Any) -> None:
     db = cursor_or_db.db if hasattr(cursor_or_db, "db") else cursor_or_db
     vendor = db.vendor
     span.set_attribute(SPANDATA.DB_SYSTEM, vendor)

sentry_sdk/integrations/django/asgi.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 """
 Instrumentation for Django 3.0
 
@@ -51,10 +53,8 @@ else:
         return func
 
 
-def _make_asgi_request_event_processor(request):
-    # type: (ASGIRequest) -> EventProcessor
-    def asgi_request_event_processor(event, hint):
-        # type: (Event, dict[str, Any]) -> Event
+def _make_asgi_request_event_processor(request: ASGIRequest) -> EventProcessor:
+    def asgi_request_event_processor(event: Event, hint: dict[str, Any]) -> Event:
         # if the request is gone we are fine not logging the data from
         # it.  This might happen if the processor is pushed away to
         # another thread.
@@ -81,16 +81,16 @@ def _make_asgi_request_event_processor(request):
     return asgi_request_event_processor
 
 
-def patch_django_asgi_handler_impl(cls):
-    # type: (Any) -> None
+def patch_django_asgi_handler_impl(cls: Any) -> None:
 
     from sentry_sdk.integrations.django import DjangoIntegration
 
     old_app = cls.__call__
 
     @functools.wraps(old_app)
-    async def sentry_patched_asgi_handler(self, scope, receive, send):
-        # type: (Any, Any, Any, Any) -> Any
+    async def sentry_patched_asgi_handler(
+        self: Any, scope: Any, receive: Any, send: Any
+    ) -> Any:
         integration = sentry_sdk.get_client().get_integration(DjangoIntegration)
         if integration is None:
             return await old_app(self, scope, receive, send)
@@ -111,8 +111,7 @@ def patch_django_asgi_handler_impl(cls):
         old_create_request = cls.create_request
 
         @ensure_integration_enabled(DjangoIntegration, old_create_request)
-        def sentry_patched_create_request(self, *args, **kwargs):
-            # type: (Any, *Any, **Any) -> Any
+        def sentry_patched_create_request(self: Any, *args: Any, **kwargs: Any) -> Any:
             request, error_response = old_create_request(self, *args, **kwargs)
             scope = sentry_sdk.get_isolation_scope()
             scope.add_event_processor(_make_asgi_request_event_processor(request))
@@ -122,21 +121,20 @@ def patch_django_asgi_handler_impl(cls):
         cls.create_request = sentry_patched_create_request
 
 
-def patch_get_response_async(cls, _before_get_response):
-    # type: (Any, Any) -> None
+def patch_get_response_async(cls: Any, _before_get_response: Any) -> None:
     old_get_response_async = cls.get_response_async
 
     @functools.wraps(old_get_response_async)
-    async def sentry_patched_get_response_async(self, request):
-        # type: (Any, Any) -> Union[HttpResponse, BaseException]
+    async def sentry_patched_get_response_async(
+        self: Any, request: Any
+    ) -> Union[HttpResponse, BaseException]:
         _before_get_response(request)
         return await old_get_response_async(self, request)
 
     cls.get_response_async = sentry_patched_get_response_async
 
 
-def patch_channels_asgi_handler_impl(cls):
-    # type: (Any) -> None
+def patch_channels_asgi_handler_impl(cls: Any) -> None:
     import channels  # type: ignore
 
     from sentry_sdk.integrations.django import DjangoIntegration
@@ -145,8 +143,9 @@ def patch_channels_asgi_handler_impl(cls):
         old_app = cls.__call__
 
         @functools.wraps(old_app)
-        async def sentry_patched_asgi_handler(self, receive, send):
-            # type: (Any, Any, Any) -> Any
+        async def sentry_patched_asgi_handler(
+            self: Any, receive: Any, send: Any
+        ) -> Any:
             integration = sentry_sdk.get_client().get_integration(DjangoIntegration)
             if integration is None:
                 return await old_app(self, receive, send)
@@ -168,13 +167,11 @@ def patch_channels_asgi_handler_impl(cls):
         patch_django_asgi_handler_impl(cls)
 
 
-def wrap_async_view(callback):
-    # type: (Any) -> Any
+def wrap_async_view(callback: Any) -> Any:
     from sentry_sdk.integrations.django import DjangoIntegration
 
     @functools.wraps(callback)
-    async def sentry_wrapped_callback(request, *args, **kwargs):
-        # type: (Any, *Any, **Any) -> Any
+    async def sentry_wrapped_callback(request: Any, *args: Any, **kwargs: Any) -> Any:
         current_scope = sentry_sdk.get_current_scope()
         if current_scope.root_span is not None:
             current_scope.root_span.update_active_thread()
@@ -194,8 +191,7 @@ def wrap_async_view(callback):
     return sentry_wrapped_callback
 
 
-def _asgi_middleware_mixin_factory(_check_middleware_span):
-    # type: (Callable[..., Any]) -> Any
+def _asgi_middleware_mixin_factory(_check_middleware_span: Callable[..., Any]) -> Any:
     """
     Mixin class factory that generates a middleware mixin for handling requests
     in async mode.
@@ -205,14 +201,12 @@ def _asgi_middleware_mixin_factory(_check_middleware_span):
         if TYPE_CHECKING:
             _inner = None
 
-        def __init__(self, get_response):
-            # type: (Callable[..., Any]) -> None
+        def __init__(self, get_response: Callable[..., Any]) -> None:
             self.get_response = get_response
             self._acall_method = None
             self._async_check()
 
-        def _async_check(self):
-            # type: () -> None
+        def _async_check(self) -> None:
             """
             If get_response is a coroutine function, turns us into async mode so
             a thread is not consumed during a whole request.
@@ -221,16 +215,14 @@ def _asgi_middleware_mixin_factory(_check_middleware_span):
             if iscoroutinefunction(self.get_response):
                 markcoroutinefunction(self)
 
-        def async_route_check(self):
-            # type: () -> bool
+        def async_route_check(self) -> bool:
             """
             Function that checks if we are in async mode,
             and if we are forwards the handling of requests to __acall__
             """
             return iscoroutinefunction(self.get_response)
 
-        async def __acall__(self, *args, **kwargs):
-            # type: (*Any, **Any) -> Any
+        async def __acall__(self, *args: Any, **kwargs: Any) -> Any:
             f = self._acall_method
             if f is None:
                 if hasattr(self._inner, "__acall__"):
@@ -241,9 +233,9 @@ def _asgi_middleware_mixin_factory(_check_middleware_span):
             middleware_span = _check_middleware_span(old_method=f)
 
             if middleware_span is None:
-                return await f(*args, **kwargs)
+                return await f(*args, **kwargs)  # type: ignore
 
             with middleware_span:
-                return await f(*args, **kwargs)
+                return await f(*args, **kwargs)  # type: ignore
 
     return SentryASGIMixin

sentry_sdk/integrations/django/caching.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import functools
 from typing import TYPE_CHECKING
 from sentry_sdk.integrations.redis.utils import _get_safe_key, _key_as_string
@@ -28,22 +29,29 @@ METHODS_TO_INSTRUMENT = [
 ]
 
 
-def _get_span_description(method_name, args, kwargs):
-    # type: (str, tuple[Any], dict[str, Any]) -> str
+def _get_span_description(
+    method_name: str, args: tuple[Any], kwargs: dict[str, Any]
+) -> str:
     return _key_as_string(_get_safe_key(method_name, args, kwargs))
 
 
-def _patch_cache_method(cache, method_name, address, port):
-    # type: (CacheHandler, str, Optional[str], Optional[int]) -> None
+def _patch_cache_method(
+    cache: CacheHandler, method_name: str, address: Optional[str], port: Optional[int]
+) -> None:
     from sentry_sdk.integrations.django import DjangoIntegration
 
     original_method = getattr(cache, method_name)
 
     @ensure_integration_enabled(DjangoIntegration, original_method)
     def _instrument_call(
-        cache, method_name, original_method, args, kwargs, address, port
-    ):
-        # type: (CacheHandler, str, Callable[..., Any], tuple[Any, ...], dict[str, Any], Optional[str], Optional[int]) -> Any
+        cache: CacheHandler,
+        method_name: str,
+        original_method: Callable[..., Any],
+        args: tuple[Any, ...],
+        kwargs: dict[str, Any],
+        address: Optional[str],
+        port: Optional[int],
+    ) -> Any:
         is_set_operation = method_name.startswith("set")
         is_get_operation = not is_set_operation
 
@@ -91,8 +99,7 @@ def _patch_cache_method(cache, method_name, address, port):
             return value
 
     @functools.wraps(original_method)
-    def sentry_method(*args, **kwargs):
-        # type: (*Any, **Any) -> Any
+    def sentry_method(*args: Any, **kwargs: Any) -> Any:
         return _instrument_call(
             cache, method_name, original_method, args, kwargs, address, port
         )
@@ -100,16 +107,16 @@ def _patch_cache_method(cache, method_name, address, port):
     setattr(cache, method_name, sentry_method)
 
 
-def _patch_cache(cache, address=None, port=None):
-    # type: (CacheHandler, Optional[str], Optional[int]) -> None
+def _patch_cache(
+    cache: CacheHandler, address: Optional[str] = None, port: Optional[int] = None
+) -> None:
     if not hasattr(cache, "_sentry_patched"):
         for method_name in METHODS_TO_INSTRUMENT:
             _patch_cache_method(cache, method_name, address, port)
         cache._sentry_patched = True
 
 
-def _get_address_port(settings):
-    # type: (dict[str, Any]) -> tuple[Optional[str], Optional[int]]
+def _get_address_port(settings: dict[str, Any]) -> tuple[Optional[str], Optional[int]]:
     location = settings.get("LOCATION")
 
     # TODO: location can also be an array of locations
@@ -134,8 +141,7 @@ def _get_address_port(settings):
     return address, int(port) if port is not None else None
 
 
-def patch_caching():
-    # type: () -> None
+def patch_caching() -> None:
     from sentry_sdk.integrations.django import DjangoIntegration
 
     if not hasattr(CacheHandler, "_sentry_patched"):
@@ -143,8 +149,7 @@ def patch_caching():
             original_get_item = CacheHandler.__getitem__
 
             @functools.wraps(original_get_item)
-            def sentry_get_item(self, alias):
-                # type: (CacheHandler, str) -> Any
+            def sentry_get_item(self: CacheHandler, alias: str) -> Any:
                 cache = original_get_item(self, alias)
 
                 integration = sentry_sdk.get_client().get_integration(DjangoIntegration)
@@ -166,8 +171,7 @@ def patch_caching():
             original_create_connection = CacheHandler.create_connection
 
             @functools.wraps(original_create_connection)
-            def sentry_create_connection(self, alias):
-                # type: (CacheHandler, str) -> Any
+            def sentry_create_connection(self: CacheHandler, alias: str) -> Any:
                 cache = original_create_connection(self, alias)
 
                 integration = sentry_sdk.get_client().get_integration(DjangoIntegration)

sentry_sdk/integrations/django/middleware.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 """
 Create spans from Django middleware invocations
 """
@@ -38,14 +40,12 @@ else:
     from .asgi import _asgi_middleware_mixin_factory
 
 
-def patch_django_middlewares():
-    # type: () -> None
+def patch_django_middlewares() -> None:
     from django.core.handlers import base
 
     old_import_string = base.import_string
 
-    def sentry_patched_import_string(dotted_path):
-        # type: (str) -> Any
+    def sentry_patched_import_string(dotted_path: str) -> Any:
         rv = old_import_string(dotted_path)
 
         if _import_string_should_wrap_middleware.get(None):
@@ -57,8 +57,7 @@ def patch_django_middlewares():
 
     old_load_middleware = base.BaseHandler.load_middleware
 
-    def sentry_patched_load_middleware(*args, **kwargs):
-        # type: (Any, Any) -> Any
+    def sentry_patched_load_middleware(*args: Any, **kwargs: Any) -> Any:
         _import_string_should_wrap_middleware.set(True)
         try:
             return old_load_middleware(*args, **kwargs)
@@ -68,12 +67,10 @@ def patch_django_middlewares():
     base.BaseHandler.load_middleware = sentry_patched_load_middleware
 
 
-def _wrap_middleware(middleware, middleware_name):
-    # type: (Any, str) -> Any
+def _wrap_middleware(middleware: Any, middleware_name: str) -> Any:
     from sentry_sdk.integrations.django import DjangoIntegration
 
-    def _check_middleware_span(old_method):
-        # type: (Callable[..., Any]) -> Optional[Span]
+    def _check_middleware_span(old_method: Callable[..., Any]) -> Optional[Span]:
         integration = sentry_sdk.get_client().get_integration(DjangoIntegration)
         if integration is None or not integration.middleware_spans:
             return None
@@ -96,12 +93,10 @@ def _wrap_middleware(middleware, middleware_name):
 
         return middleware_span
 
-    def _get_wrapped_method(old_method):
-        # type: (F) -> F
+    def _get_wrapped_method(old_method: F) -> F:
         with capture_internal_exceptions():
 
-            def sentry_wrapped_method(*args, **kwargs):
-                # type: (*Any, **Any) -> Any
+            def sentry_wrapped_method(*args: Any, **kwargs: Any) -> Any:
                 middleware_span = _check_middleware_span(old_method)
 
                 if middleware_span is None:
@@ -131,8 +126,12 @@ def _wrap_middleware(middleware, middleware_name):
             middleware, "async_capable", False
         )
 
-        def __init__(self, get_response=None, *args, **kwargs):
-            # type: (Optional[Callable[..., Any]], *Any, **Any) -> None
+        def __init__(
+            self,
+            get_response: Optional[Callable[..., Any]] = None,
+            *args: Any,
+            **kwargs: Any,
+        ) -> None:
             if get_response:
                 self._inner = middleware(get_response, *args, **kwargs)
             else:
@@ -144,8 +143,7 @@ def _wrap_middleware(middleware, middleware_name):
 
         # We need correct behavior for `hasattr()`, which we can only determine
         # when we have an instance of the middleware we're wrapping.
-        def __getattr__(self, method_name):
-            # type: (str) -> Any
+        def __getattr__(self, method_name: str) -> Any:
             if method_name not in (
                 "process_request",
                 "process_view",
@@ -160,8 +158,7 @@ def _wrap_middleware(middleware, middleware_name):
             self.__dict__[method_name] = rv
             return rv
 
-        def __call__(self, *args, **kwargs):
-            # type: (*Any, **Any) -> Any
+        def __call__(self, *args: Any, **kwargs: Any) -> Any:
             if hasattr(self, "async_route_check") and self.async_route_check():
                 return self.__acall__(*args, **kwargs)