sentry-sdk 3.0.0a2__py2.py3-none-any.whl → 3.0.0a4__py2.py3-none-any.whl

sentry_sdk/integrations/_asgi_common.py

@@ -1,26 +1,25 @@
+from __future__ import annotations
 import urllib
 
 from sentry_sdk.scope import should_send_default_pii
 from sentry_sdk.integrations._wsgi_common import _filter_headers
 
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from typing import Any
     from typing import Dict
     from typing import Optional
     from typing import Union
-    from typing_extensions import Literal
 
     from sentry_sdk.utils import AnnotatedValue
 
 
-def _get_headers(asgi_scope):
-    # type: (Any) -> Dict[str, str]
+def _get_headers(asgi_scope: Any) -> Dict[str, str]:
     """
     Extract headers from the ASGI scope, in the format that the Sentry protocol expects.
     """
-    headers = {}  # type: Dict[str, str]
+    headers: Dict[str, str] = {}
     for raw_key, raw_value in asgi_scope.get("headers", {}):
         key = raw_key.decode("latin-1")
         value = raw_value.decode("latin-1")
@@ -32,12 +31,16 @@ def _get_headers(asgi_scope):
     return headers
 
 
-def _get_url(asgi_scope, default_scheme=None, host=None):
-    # type: (Dict[str, Any], Optional[Literal["ws", "http"]], Optional[Union[AnnotatedValue, str]]) -> str
+def _get_url(
+    asgi_scope: Dict[str, Any],
+    host: Optional[Union[AnnotatedValue, str]] = None,
+) -> str:
     """
     Extract URL from the ASGI scope, without also including the querystring.
     """
-    scheme = cast(str, asgi_scope.get("scheme", default_scheme))
+    scheme = asgi_scope.get(
+        "scheme", "http" if asgi_scope.get("type") == "http" else "ws"
+    )
     server = asgi_scope.get("server", None)
     path = asgi_scope.get("root_path", "") + asgi_scope.get("path", "")
 
@@ -53,8 +56,7 @@ def _get_url(asgi_scope, default_scheme=None, host=None):
     return path
 
 
-def _get_query(asgi_scope):
-    # type: (Any) -> Any
+def _get_query(asgi_scope: Any) -> Any:
     """
     Extract querystring from the ASGI scope, in the format that the Sentry protocol expects.
     """
@@ -64,8 +66,7 @@ def _get_query(asgi_scope):
     return urllib.parse.unquote(qs.decode("latin-1"))
 
 
-def _get_ip(asgi_scope):
-    # type: (Any) -> str
+def _get_ip(asgi_scope: Any) -> str:
     """
     Extract IP Address from the ASGI scope based on request headers with fallback to scope client.
     """
@@ -83,12 +84,11 @@ def _get_ip(asgi_scope):
     return asgi_scope.get("client")[0]
 
 
-def _get_request_data(asgi_scope):
-    # type: (Any) -> Dict[str, Any]
+def _get_request_data(asgi_scope: Any) -> Dict[str, Any]:
     """
     Returns data related to the HTTP request from the ASGI scope.
     """
-    request_data = {}  # type: Dict[str, Any]
+    request_data: Dict[str, Any] = {}
     ty = asgi_scope["type"]
     if ty in ("http", "websocket"):
         request_data["method"] = asgi_scope.get("method")
@@ -96,9 +96,7 @@ def _get_request_data(asgi_scope):
         request_data["headers"] = headers = _filter_headers(_get_headers(asgi_scope))
         request_data["query_string"] = _get_query(asgi_scope)
 
-        request_data["url"] = _get_url(
-            asgi_scope, "http" if ty == "http" else "ws", headers.get("host")
-        )
+        request_data["url"] = _get_url(asgi_scope, headers.get("host"))
 
     client = asgi_scope.get("client")
     if client and should_send_default_pii():

sentry_sdk/integrations/_wsgi_common.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import json
 from copy import deepcopy
 
@@ -50,8 +51,9 @@ DEFAULT_HTTP_METHODS_TO_CAPTURE = (
 )
 
 
-def request_body_within_bounds(client, content_length):
-    # type: (Optional[sentry_sdk.client.BaseClient], int) -> bool
+def request_body_within_bounds(
+    client: Optional[sentry_sdk.client.BaseClient], content_length: int
+) -> bool:
     if client is None:
         return False
 
@@ -73,17 +75,15 @@ class RequestExtractor:
     # it. Only some child classes implement all methods that raise
     # NotImplementedError in this class.
 
-    def __init__(self, request):
-        # type: (Any) -> None
+    def __init__(self, request: Any) -> None:
         self.request = request
 
-    def extract_into_event(self, event):
-        # type: (Event) -> None
+    def extract_into_event(self, event: Event) -> None:
         client = sentry_sdk.get_client()
         if not client.is_active():
             return
 
-        data = None  # type: Optional[Union[AnnotatedValue, Dict[str, Any]]]
+        data: Optional[Union[AnnotatedValue, Dict[str, Any]]] = None
 
         content_length = self.content_length()
         request_info = event.get("request", {})
@@ -119,27 +119,22 @@ class RequestExtractor:
 
         event["request"] = deepcopy(request_info)
 
-    def content_length(self):
-        # type: () -> int
+    def content_length(self) -> int:
         try:
             return int(self.env().get("CONTENT_LENGTH", 0))
         except ValueError:
             return 0
 
-    def cookies(self):
-        # type: () -> MutableMapping[str, Any]
+    def cookies(self) -> MutableMapping[str, Any]:
         raise NotImplementedError()
 
-    def raw_data(self):
-        # type: () -> Optional[Union[str, bytes]]
+    def raw_data(self) -> Optional[Union[str, bytes]]:
         raise NotImplementedError()
 
-    def form(self):
-        # type: () -> Optional[Dict[str, Any]]
+    def form(self) -> Optional[Dict[str, Any]]:
         raise NotImplementedError()
 
-    def parsed_body(self):
-        # type: () -> Optional[Dict[str, Any]]
+    def parsed_body(self) -> Optional[Dict[str, Any]]:
         try:
             form = self.form()
         except Exception:
@@ -161,12 +156,10 @@ class RequestExtractor:
 
         return self.json()
 
-    def is_json(self):
-        # type: () -> bool
+    def is_json(self) -> bool:
         return _is_json_content_type(self.env().get("CONTENT_TYPE"))
 
-    def json(self):
-        # type: () -> Optional[Any]
+    def json(self) -> Optional[Any]:
         try:
             if not self.is_json():
                 return None
@@ -190,21 +183,17 @@ class RequestExtractor:
 
         return None
 
-    def files(self):
-        # type: () -> Optional[Dict[str, Any]]
+    def files(self) -> Optional[Dict[str, Any]]:
         raise NotImplementedError()
 
-    def size_of_file(self, file):
-        # type: (Any) -> int
+    def size_of_file(self, file: Any) -> int:
         raise NotImplementedError()
 
-    def env(self):
-        # type: () -> Dict[str, Any]
+    def env(self) -> Dict[str, Any]:
         raise NotImplementedError()
 
 
-def _is_json_content_type(ct):
-    # type: (Optional[str]) -> bool
+def _is_json_content_type(ct: Optional[str]) -> bool:
     mt = (ct or "").split(";", 1)[0]
     return (
         mt == "application/json"
@@ -213,8 +202,9 @@ def _is_json_content_type(ct):
     )
 
 
-def _filter_headers(headers):
-    # type: (Mapping[str, str]) -> Mapping[str, Union[AnnotatedValue, str]]
+def _filter_headers(
+    headers: Mapping[str, str],
+) -> Mapping[str, Union[AnnotatedValue, str]]:
     if should_send_default_pii():
         return headers
 
@@ -228,8 +218,7 @@ def _filter_headers(headers):
     }
 
 
-def _request_headers_to_span_attributes(headers):
-    # type: (dict[str, str]) -> dict[str, str]
+def _request_headers_to_span_attributes(headers: dict[str, str]) -> dict[str, str]:
     attributes = {}
 
     headers = _filter_headers(headers)

sentry_sdk/integrations/aiohttp.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sys
 import weakref
 from functools import wraps
@@ -85,11 +86,10 @@ class AioHttpIntegration(Integration):
 
     def __init__(
         self,
-        transaction_style="handler_name",  # type: str
+        transaction_style: str = "handler_name",
         *,
-        failed_request_status_codes=_DEFAULT_FAILED_REQUEST_STATUS_CODES,  # type: Set[int]
-    ):
-        # type: (...) -> None
+        failed_request_status_codes: Set[int] = _DEFAULT_FAILED_REQUEST_STATUS_CODES,
+    ) -> None:
         if transaction_style not in TRANSACTION_STYLE_VALUES:
             raise ValueError(
                 "Invalid value for transaction_style: %s (must be in %s)"
@@ -99,8 +99,7 @@ class AioHttpIntegration(Integration):
         self._failed_request_status_codes = failed_request_status_codes
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
 
         version = parse_version(AIOHTTP_VERSION)
         _check_minimum_version(AioHttpIntegration, version)
@@ -117,8 +116,9 @@ class AioHttpIntegration(Integration):
 
         old_handle = Application._handle
 
-        async def sentry_app_handle(self, request, *args, **kwargs):
-            # type: (Any, Request, *Any, **Any) -> Any
+        async def sentry_app_handle(
+            self: Any, request: Request, *args: Any, **kwargs: Any
+        ) -> Any:
             integration = sentry_sdk.get_client().get_integration(AioHttpIntegration)
             if integration is None:
                 return await old_handle(self, request, *args, **kwargs)
@@ -172,8 +172,9 @@ class AioHttpIntegration(Integration):
         old_urldispatcher_resolve = UrlDispatcher.resolve
 
         @wraps(old_urldispatcher_resolve)
-        async def sentry_urldispatcher_resolve(self, request):
-            # type: (UrlDispatcher, Request) -> UrlMappingMatchInfo
+        async def sentry_urldispatcher_resolve(
+            self: UrlDispatcher, request: Request
+        ) -> UrlMappingMatchInfo:
             rv = await old_urldispatcher_resolve(self, request)
 
             integration = sentry_sdk.get_client().get_integration(AioHttpIntegration)
@@ -205,8 +206,7 @@ class AioHttpIntegration(Integration):
         old_client_session_init = ClientSession.__init__
 
         @ensure_integration_enabled(AioHttpIntegration, old_client_session_init)
-        def init(*args, **kwargs):
-            # type: (Any, Any) -> None
+        def init(*args: Any, **kwargs: Any) -> None:
             client_trace_configs = list(kwargs.get("trace_configs") or ())
             trace_config = create_trace_config()
             client_trace_configs.append(trace_config)
@@ -217,11 +217,13 @@ class AioHttpIntegration(Integration):
         ClientSession.__init__ = init
 
 
-def create_trace_config():
-    # type: () -> TraceConfig
+def create_trace_config() -> TraceConfig:
 
-    async def on_request_start(session, trace_config_ctx, params):
-        # type: (ClientSession, SimpleNamespace, TraceRequestStartParams) -> None
+    async def on_request_start(
+        session: ClientSession,
+        trace_config_ctx: SimpleNamespace,
+        params: TraceRequestStartParams,
+    ) -> None:
         if sentry_sdk.get_client().get_integration(AioHttpIntegration) is None:
             return
 
@@ -236,7 +238,7 @@ def create_trace_config():
             name="%s %s"
             % (method, parsed_url.url if parsed_url else SENSITIVE_DATA_SUBSTITUTE),
             origin=AioHttpIntegration.origin,
-            only_if_parent=True,
+            only_as_child_span=True,
         )
 
         data = {
@@ -277,8 +279,11 @@ def create_trace_config():
         trace_config_ctx.span = span
         trace_config_ctx.span_data = data
 
-    async def on_request_end(session, trace_config_ctx, params):
-        # type: (ClientSession, SimpleNamespace, TraceRequestEndParams) -> None
+    async def on_request_end(
+        session: ClientSession,
+        trace_config_ctx: SimpleNamespace,
+        params: TraceRequestEndParams,
+    ) -> None:
         if trace_config_ctx.span is None:
             return
 
@@ -307,13 +312,13 @@ def create_trace_config():
     return trace_config
 
 
-def _make_request_processor(weak_request):
-    # type: (weakref.ReferenceType[Request]) -> EventProcessor
+def _make_request_processor(
+    weak_request: weakref.ReferenceType[Request],
+) -> EventProcessor:
     def aiohttp_processor(
-        event,  # type: Event
-        hint,  # type: dict[str, Tuple[type, BaseException, Any]]
-    ):
-        # type: (...) -> Event
+        event: Event,
+        hint: dict[str, Tuple[type, BaseException, Any]],
+    ) -> Event:
         request = weak_request()
         if request is None:
             return event
@@ -342,8 +347,7 @@ def _make_request_processor(weak_request):
     return aiohttp_processor
 
 
-def _capture_exception():
-    # type: () -> ExcInfo
+def _capture_exception() -> ExcInfo:
     exc_info = sys.exc_info()
     event, hint = event_from_exception(
         exc_info,
@@ -357,8 +361,7 @@ def _capture_exception():
 BODY_NOT_READ_MESSAGE = "[Can't show request body due to implementation details.]"
 
 
-def get_aiohttp_request_data(request):
-    # type: (Request) -> Union[Optional[str], AnnotatedValue]
+def get_aiohttp_request_data(request: Request) -> Union[Optional[str], AnnotatedValue]:
     bytes_body = request._read_bytes
 
     if bytes_body is not None:
@@ -377,8 +380,7 @@ def get_aiohttp_request_data(request):
     return None
 
 
-def _prepopulate_attributes(request):
-    # type: (Request) -> dict[str, Any]
+def _prepopulate_attributes(request: Request) -> dict[str, Any]:
     """Construct initial span attributes that can be used in traces sampler."""
     attributes = {}
 

sentry_sdk/integrations/anthropic.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from functools import wraps
 from typing import TYPE_CHECKING
 
@@ -29,13 +30,11 @@ class AnthropicIntegration(Integration):
     identifier = "anthropic"
     origin = f"auto.ai.{identifier}"
 
-    def __init__(self, include_prompts=True):
-        # type: (AnthropicIntegration, bool) -> None
+    def __init__(self: AnthropicIntegration, include_prompts: bool = True) -> None:
         self.include_prompts = include_prompts
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         version = package_version("anthropic")
         _check_minimum_version(AnthropicIntegration, version)
 
@@ -43,8 +42,7 @@ class AnthropicIntegration(Integration):
         AsyncMessages.create = _wrap_message_create_async(AsyncMessages.create)
 
 
-def _capture_exception(exc):
-    # type: (Any) -> None
+def _capture_exception(exc: Any) -> None:
     event, hint = event_from_exception(
         exc,
         client_options=sentry_sdk.get_client().options,
@@ -53,8 +51,7 @@ def _capture_exception(exc):
     sentry_sdk.capture_event(event, hint=hint)
 
 
-def _calculate_token_usage(result, span):
-    # type: (Messages, Span) -> None
+def _calculate_token_usage(result: Messages, span: Span) -> None:
     input_tokens = 0
     output_tokens = 0
     if hasattr(result, "usage"):
@@ -65,11 +62,16 @@ def _calculate_token_usage(result, span):
             output_tokens = usage.output_tokens
 
     total_tokens = input_tokens + output_tokens
-    record_token_usage(span, input_tokens, output_tokens, total_tokens)
+
+    record_token_usage(
+        span,
+        input_tokens=input_tokens,
+        output_tokens=output_tokens,
+        total_tokens=total_tokens,
+    )
 
 
-def _get_responses(content):
-    # type: (list[Any]) -> list[dict[str, Any]]
+def _get_responses(content: list[Any]) -> list[dict[str, Any]]:
     """
     Get JSON of a Anthropic responses.
     """
@@ -85,8 +87,12 @@ def _get_responses(content):
     return responses
 
 
-def _collect_ai_data(event, input_tokens, output_tokens, content_blocks):
-    # type: (MessageStreamEvent, int, int, list[str]) -> tuple[int, int, list[str]]
+def _collect_ai_data(
+    event: MessageStreamEvent,
+    input_tokens: int,
+    output_tokens: int,
+    content_blocks: list[str],
+) -> tuple[int, int, list[str]]:
     """
     Count token usage and collect content blocks from the AI streaming response.
     """
@@ -112,9 +118,12 @@ def _collect_ai_data(event, input_tokens, output_tokens, content_blocks):
 
 
 def _add_ai_data_to_span(
-    span, integration, input_tokens, output_tokens, content_blocks
-):
-    # type: (Span, AnthropicIntegration, int, int, list[str]) -> None
+    span: Span,
+    integration: AnthropicIntegration,
+    input_tokens: int,
+    output_tokens: int,
+    content_blocks: list[str],
+) -> None:
     """
     Add token usage and content blocks from the AI streaming response to the span.
     """
@@ -126,12 +135,16 @@ def _add_ai_data_to_span(
                 [{"type": "text", "text": complete_message}],
             )
         total_tokens = input_tokens + output_tokens
-        record_token_usage(span, input_tokens, output_tokens, total_tokens)
+        record_token_usage(
+            span,
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            total_tokens=total_tokens,
+        )
         span.set_attribute(SPANDATA.AI_STREAMING, True)
 
 
-def _sentry_patched_create_common(f, *args, **kwargs):
-    # type: (Any, *Any, **Any) -> Any
+def _sentry_patched_create_common(f: Any, *args: Any, **kwargs: Any) -> Any:
     integration = kwargs.pop("integration")
     if integration is None:
         return f(*args, **kwargs)
@@ -148,7 +161,7 @@ def _sentry_patched_create_common(f, *args, **kwargs):
         op=OP.ANTHROPIC_MESSAGES_CREATE,
         description="Anthropic messages create",
         origin=AnthropicIntegration.origin,
-        only_if_parent=True,
+        only_as_child_span=True,
     )
     span.__enter__()
 
@@ -177,11 +190,10 @@ def _sentry_patched_create_common(f, *args, **kwargs):
         elif hasattr(result, "_iterator"):
             old_iterator = result._iterator
 
-            def new_iterator():
-                # type: () -> Iterator[MessageStreamEvent]
+            def new_iterator() -> Iterator[MessageStreamEvent]:
                 input_tokens = 0
                 output_tokens = 0
-                content_blocks = []  # type: list[str]
+                content_blocks: list[str] = []
 
                 for event in old_iterator:
                     input_tokens, output_tokens, content_blocks = _collect_ai_data(
@@ -194,11 +206,10 @@ def _sentry_patched_create_common(f, *args, **kwargs):
                 )
                 span.__exit__(None, None, None)
 
-            async def new_iterator_async():
-                # type: () -> AsyncIterator[MessageStreamEvent]
+            async def new_iterator_async() -> AsyncIterator[MessageStreamEvent]:
                 input_tokens = 0
                 output_tokens = 0
-                content_blocks = []  # type: list[str]
+                content_blocks: list[str] = []
 
                 async for event in old_iterator:
                     input_tokens, output_tokens, content_blocks = _collect_ai_data(
@@ -223,10 +234,8 @@ def _sentry_patched_create_common(f, *args, **kwargs):
     return result
 
 
-def _wrap_message_create(f):
-    # type: (Any) -> Any
-    def _execute_sync(f, *args, **kwargs):
-        # type: (Any, *Any, **Any) -> Any
+def _wrap_message_create(f: Any) -> Any:
+    def _execute_sync(f: Any, *args: Any, **kwargs: Any) -> Any:
         gen = _sentry_patched_create_common(f, *args, **kwargs)
 
         try:
@@ -246,8 +255,7 @@ def _wrap_message_create(f):
             return e.value
 
     @wraps(f)
-    def _sentry_patched_create_sync(*args, **kwargs):
-        # type: (*Any, **Any) -> Any
+    def _sentry_patched_create_sync(*args: Any, **kwargs: Any) -> Any:
         integration = sentry_sdk.get_client().get_integration(AnthropicIntegration)
         kwargs["integration"] = integration
 
@@ -256,10 +264,8 @@ def _wrap_message_create(f):
     return _sentry_patched_create_sync
 
 
-def _wrap_message_create_async(f):
-    # type: (Any) -> Any
-    async def _execute_async(f, *args, **kwargs):
-        # type: (Any, *Any, **Any) -> Any
+def _wrap_message_create_async(f: Any) -> Any:
+    async def _execute_async(f: Any, *args: Any, **kwargs: Any) -> Any:
         gen = _sentry_patched_create_common(f, *args, **kwargs)
 
         try:
@@ -279,8 +285,7 @@ def _wrap_message_create_async(f):
             return e.value
 
     @wraps(f)
-    async def _sentry_patched_create_async(*args, **kwargs):
-        # type: (*Any, **Any) -> Any
+    async def _sentry_patched_create_async(*args: Any, **kwargs: Any) -> Any:
         integration = sentry_sdk.get_client().get_integration(AnthropicIntegration)
         kwargs["integration"] = integration
 

sentry_sdk/integrations/argv.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sys
 
 import sentry_sdk
@@ -16,11 +17,9 @@ class ArgvIntegration(Integration):
     identifier = "argv"
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         @add_global_event_processor
-        def processor(event, hint):
-            # type: (Event, Optional[Hint]) -> Optional[Event]
+        def processor(event: Event, hint: Optional[Hint]) -> Optional[Event]:
             if sentry_sdk.get_client().get_integration(ArgvIntegration) is not None:
                 extra = event.setdefault("extra", {})
                 # If some event processor decided to set extra to e.g. an

sentry_sdk/integrations/ariadne.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from importlib import import_module
 
 import sentry_sdk
@@ -33,8 +34,7 @@ class AriadneIntegration(Integration):
     identifier = "ariadne"
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         version = package_version("ariadne")
         _check_minimum_version(AriadneIntegration, version)
 
@@ -43,15 +43,15 @@ class AriadneIntegration(Integration):
         _patch_graphql()
 
 
-def _patch_graphql():
-    # type: () -> None
+def _patch_graphql() -> None:
     old_parse_query = ariadne_graphql.parse_query
     old_handle_errors = ariadne_graphql.handle_graphql_errors
     old_handle_query_result = ariadne_graphql.handle_query_result
 
     @ensure_integration_enabled(AriadneIntegration, old_parse_query)
-    def _sentry_patched_parse_query(context_value, query_parser, data):
-        # type: (Optional[Any], Optional[QueryParser], Any) -> DocumentNode
+    def _sentry_patched_parse_query(
+        context_value: Optional[Any], query_parser: Optional[QueryParser], data: Any
+    ) -> DocumentNode:
         event_processor = _make_request_event_processor(data)
         sentry_sdk.get_isolation_scope().add_event_processor(event_processor)
 
@@ -59,8 +59,9 @@ def _patch_graphql():
         return result
 
     @ensure_integration_enabled(AriadneIntegration, old_handle_errors)
-    def _sentry_patched_handle_graphql_errors(errors, *args, **kwargs):
-        # type: (List[GraphQLError], Any, Any) -> GraphQLResult
+    def _sentry_patched_handle_graphql_errors(
+        errors: List[GraphQLError], *args: Any, **kwargs: Any
+    ) -> GraphQLResult:
         result = old_handle_errors(errors, *args, **kwargs)
 
         event_processor = _make_response_event_processor(result[1])
@@ -83,8 +84,9 @@ def _patch_graphql():
         return result
 
     @ensure_integration_enabled(AriadneIntegration, old_handle_query_result)
-    def _sentry_patched_handle_query_result(result, *args, **kwargs):
-        # type: (Any, Any, Any) -> GraphQLResult
+    def _sentry_patched_handle_query_result(
+        result: Any, *args: Any, **kwargs: Any
+    ) -> GraphQLResult:
         query_result = old_handle_query_result(result, *args, **kwargs)
 
         event_processor = _make_response_event_processor(query_result[1])
@@ -111,12 +113,10 @@ def _patch_graphql():
     ariadne_graphql.handle_query_result = _sentry_patched_handle_query_result  # type: ignore
 
 
-def _make_request_event_processor(data):
-    # type: (GraphQLSchema) -> EventProcessor
+def _make_request_event_processor(data: GraphQLSchema) -> EventProcessor:
     """Add request data and api_target to events."""
 
-    def inner(event, hint):
-        # type: (Event, dict[str, Any]) -> Event
+    def inner(event: Event, hint: dict[str, Any]) -> Event:
         if not isinstance(data, dict):
             return event
 
@@ -143,12 +143,10 @@ def _make_request_event_processor(data):
     return inner
 
 
-def _make_response_event_processor(response):
-    # type: (Dict[str, Any]) -> EventProcessor
+def _make_response_event_processor(response: Dict[str, Any]) -> EventProcessor:
     """Add response data to the event's response context."""
 
-    def inner(event, hint):
-        # type: (Event, dict[str, Any]) -> Event
+    def inner(event: Event, hint: dict[str, Any]) -> Event:
         with capture_internal_exceptions():
             if should_send_default_pii() and response.get("errors"):
                 contexts = event.setdefault("contexts", {})