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

sentry_sdk/integrations/stdlib.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import os
 import subprocess
 import sys
@@ -34,25 +35,23 @@ if TYPE_CHECKING:
     from sentry_sdk._types import Event, Hint
 
 
-_RUNTIME_CONTEXT = {
+_RUNTIME_CONTEXT: dict[str, object] = {
     "name": platform.python_implementation(),
     "version": "%s.%s.%s" % (sys.version_info[:3]),
     "build": sys.version,
-}  # type: dict[str, object]
+}
 
 
 class StdlibIntegration(Integration):
     identifier = "stdlib"
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         _install_httplib()
         _install_subprocess()
 
         @add_global_event_processor
-        def add_python_runtime_context(event, hint):
-            # type: (Event, Hint) -> Optional[Event]
+        def add_python_runtime_context(event: Event, hint: Hint) -> Optional[Event]:
             if sentry_sdk.get_client().get_integration(StdlibIntegration) is not None:
                 contexts = event.setdefault("contexts", {})
                 if isinstance(contexts, dict) and "runtime" not in contexts:
@@ -61,13 +60,13 @@ class StdlibIntegration(Integration):
             return event
 
 
-def _install_httplib():
-    # type: () -> None
+def _install_httplib() -> None:
     real_putrequest = HTTPConnection.putrequest
     real_getresponse = HTTPConnection.getresponse
 
-    def putrequest(self, method, url, *args, **kwargs):
-        # type: (HTTPConnection, str, str, *Any, **Any) -> Any
+    def putrequest(
+        self: HTTPConnection, method: str, url: str, *args: Any, **kwargs: Any
+    ) -> Any:
         host = self.host
         port = self.port
         default_port = self.default_port
@@ -134,8 +133,7 @@ def _install_httplib():
 
         return rv
 
-    def getresponse(self, *args, **kwargs):
-        # type: (HTTPConnection, *Any, **Any) -> Any
+    def getresponse(self: HTTPConnection, *args: Any, **kwargs: Any) -> Any:
         span = getattr(self, "_sentrysdk_span", None)
 
         if span is None:
@@ -167,8 +165,13 @@ def _install_httplib():
     HTTPConnection.getresponse = getresponse  # type: ignore[method-assign]
 
 
-def _init_argument(args, kwargs, name, position, setdefault_callback=None):
-    # type: (List[Any], Dict[Any, Any], str, int, Optional[Callable[[Any], Any]]) -> Any
+def _init_argument(
+    args: List[Any],
+    kwargs: Dict[Any, Any],
+    name: str,
+    position: int,
+    setdefault_callback: Optional[Callable[[Any], Any]] = None,
+) -> Any:
     """
     given (*args, **kwargs) of a function call, retrieve (and optionally set a
     default for) an argument by either name or position.
@@ -198,13 +201,13 @@ def _init_argument(args, kwargs, name, position, setdefault_callback=None):
     return rv
 
 
-def _install_subprocess():
-    # type: () -> None
+def _install_subprocess() -> None:
     old_popen_init = subprocess.Popen.__init__
 
     @ensure_integration_enabled(StdlibIntegration, old_popen_init)
-    def sentry_patched_popen_init(self, *a, **kw):
-        # type: (subprocess.Popen[Any], *Any, **Any) -> None
+    def sentry_patched_popen_init(
+        self: subprocess.Popen[Any], *a: Any, **kw: Any
+    ) -> None:
         # Convert from tuple to list to be able to set values.
         a = list(a)
 
@@ -279,8 +282,9 @@ def _install_subprocess():
     old_popen_wait = subprocess.Popen.wait
 
     @ensure_integration_enabled(StdlibIntegration, old_popen_wait)
-    def sentry_patched_popen_wait(self, *a, **kw):
-        # type: (subprocess.Popen[Any], *Any, **Any) -> Any
+    def sentry_patched_popen_wait(
+        self: subprocess.Popen[Any], *a: Any, **kw: Any
+    ) -> Any:
         with sentry_sdk.start_span(
             op=OP.SUBPROCESS_WAIT,
             origin="auto.subprocess.stdlib.subprocess",
@@ -294,8 +298,9 @@ def _install_subprocess():
     old_popen_communicate = subprocess.Popen.communicate
 
     @ensure_integration_enabled(StdlibIntegration, old_popen_communicate)
-    def sentry_patched_popen_communicate(self, *a, **kw):
-        # type: (subprocess.Popen[Any], *Any, **Any) -> Any
+    def sentry_patched_popen_communicate(
+        self: subprocess.Popen[Any], *a: Any, **kw: Any
+    ) -> Any:
         with sentry_sdk.start_span(
             op=OP.SUBPROCESS_COMMUNICATE,
             origin="auto.subprocess.stdlib.subprocess",
@@ -307,6 +312,5 @@ def _install_subprocess():
     subprocess.Popen.communicate = sentry_patched_popen_communicate  # type: ignore
 
 
-def get_subprocess_traceparent_headers():
-    # type: () -> EnvironHeaders
+def get_subprocess_traceparent_headers() -> EnvironHeaders:
     return EnvironHeaders(os.environ, prefix="SUBPROCESS_")

sentry_sdk/integrations/strawberry.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import functools
 import hashlib
 from inspect import isawaitable
@@ -62,8 +63,7 @@ class StrawberryIntegration(Integration):
     identifier = "strawberry"
     origin = f"auto.graphql.{identifier}"
 
-    def __init__(self, async_execution=None):
-        # type: (Optional[bool]) -> None
+    def __init__(self, async_execution: Optional[bool] = None) -> None:
         if async_execution not in (None, False, True):
             raise ValueError(
                 'Invalid value for async_execution: "{}" (must be bool)'.format(
@@ -73,8 +73,7 @@ class StrawberryIntegration(Integration):
         self.async_execution = async_execution
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         version = package_version("strawberry-graphql")
         _check_minimum_version(StrawberryIntegration, version, "strawberry-graphql")
 
@@ -82,13 +81,11 @@ class StrawberryIntegration(Integration):
         _patch_views()
 
 
-def _patch_schema_init():
-    # type: () -> None
+def _patch_schema_init() -> None:
     old_schema_init = Schema.__init__
 
     @functools.wraps(old_schema_init)
-    def _sentry_patched_schema_init(self, *args, **kwargs):
-        # type: (Schema, Any, Any) -> None
+    def _sentry_patched_schema_init(self: Schema, *args: Any, **kwargs: Any) -> None:
         integration = sentry_sdk.get_client().get_integration(StrawberryIntegration)
         if integration is None:
             return old_schema_init(self, *args, **kwargs)
@@ -121,17 +118,15 @@ def _patch_schema_init():
 
 class SentryAsyncExtension(SchemaExtension):
     def __init__(
-        self,
+        self: Any,
         *,
-        execution_context=None,
-    ):
-        # type: (Any, Optional[ExecutionContext]) -> None
+        execution_context: Optional[ExecutionContext] = None,
+    ) -> None:
         if execution_context:
             self.execution_context = execution_context
 
     @cached_property
-    def _resource_name(self):
-        # type: () -> str
+    def _resource_name(self) -> str:
         query_hash = self.hash_query(self.execution_context.query)  # type: ignore
 
         if self.execution_context.operation_name:
@@ -139,12 +134,10 @@ class SentryAsyncExtension(SchemaExtension):
 
         return query_hash
 
-    def hash_query(self, query):
-        # type: (str) -> str
+    def hash_query(self, query: str) -> str:
         return hashlib.md5(query.encode("utf-8")).hexdigest()
 
-    def on_operation(self):
-        # type: () -> Generator[None, None, None]
+    def on_operation(self) -> Generator[None, None, None]:
         self._operation_name = self.execution_context.operation_name
 
         operation_type = "query"
@@ -205,8 +198,7 @@ class SentryAsyncExtension(SchemaExtension):
             if root_span:
                 root_span.op = op
 
-    def on_validate(self):
-        # type: () -> Generator[None, None, None]
+    def on_validate(self) -> Generator[None, None, None]:
         with sentry_sdk.start_span(
             op=OP.GRAPHQL_VALIDATE,
             name="validation",
@@ -214,8 +206,7 @@ class SentryAsyncExtension(SchemaExtension):
         ):
             yield
 
-    def on_parse(self):
-        # type: () -> Generator[None, None, None]
+    def on_parse(self) -> Generator[None, None, None]:
         with sentry_sdk.start_span(
             op=OP.GRAPHQL_PARSE,
             name="parsing",
@@ -223,12 +214,21 @@ class SentryAsyncExtension(SchemaExtension):
         ):
             yield
 
-    def should_skip_tracing(self, _next, info):
-        # type: (Callable[[Any, GraphQLResolveInfo, Any, Any], Any], GraphQLResolveInfo) -> bool
+    def should_skip_tracing(
+        self,
+        _next: Callable[[Any, GraphQLResolveInfo, Any, Any], Any],
+        info: GraphQLResolveInfo,
+    ) -> bool:
         return strawberry_should_skip_tracing(_next, info)
 
-    async def _resolve(self, _next, root, info, *args, **kwargs):
-        # type: (Callable[[Any, GraphQLResolveInfo, Any, Any], Any], Any, GraphQLResolveInfo, str, Any) -> Any
+    async def _resolve(
+        self,
+        _next: Callable[[Any, GraphQLResolveInfo, Any, Any], Any],
+        root: Any,
+        info: GraphQLResolveInfo,
+        *args: str,
+        **kwargs: Any,
+    ) -> Any:
         result = _next(root, info, *args, **kwargs)
 
         if isawaitable(result):
@@ -236,8 +236,14 @@ class SentryAsyncExtension(SchemaExtension):
 
         return result
 
-    async def resolve(self, _next, root, info, *args, **kwargs):
-        # type: (Callable[[Any, GraphQLResolveInfo, Any, Any], Any], Any, GraphQLResolveInfo, str, Any) -> Any
+    async def resolve(
+        self,
+        _next: Callable[[Any, GraphQLResolveInfo, Any, Any], Any],
+        root: Any,
+        info: GraphQLResolveInfo,
+        *args: str,
+        **kwargs: Any,
+    ) -> Any:
         if self.should_skip_tracing(_next, info):
             return await self._resolve(_next, root, info, *args, **kwargs)
 
@@ -257,8 +263,14 @@ class SentryAsyncExtension(SchemaExtension):
 
 
 class SentrySyncExtension(SentryAsyncExtension):
-    def resolve(self, _next, root, info, *args, **kwargs):
-        # type: (Callable[[Any, Any, Any, Any], Any], Any, GraphQLResolveInfo, str, Any) -> Any
+    def resolve(
+        self,
+        _next: Callable[[Any, Any, Any, Any], Any],
+        root: Any,
+        info: GraphQLResolveInfo,
+        *args: str,
+        **kwargs: Any,
+    ) -> Any:
         if self.should_skip_tracing(_next, info):
             return _next(root, info, *args, **kwargs)
 
@@ -277,24 +289,26 @@ class SentrySyncExtension(SentryAsyncExtension):
             return _next(root, info, *args, **kwargs)
 
 
-def _patch_views():
-    # type: () -> None
+def _patch_views() -> None:
     old_async_view_handle_errors = async_base_view.AsyncBaseHTTPView._handle_errors
     old_sync_view_handle_errors = sync_base_view.SyncBaseHTTPView._handle_errors
 
-    def _sentry_patched_async_view_handle_errors(self, errors, response_data):
-        # type: (Any, List[GraphQLError], GraphQLHTTPResponse) -> None
+    def _sentry_patched_async_view_handle_errors(
+        self: Any, errors: List[GraphQLError], response_data: GraphQLHTTPResponse
+    ) -> None:
         old_async_view_handle_errors(self, errors, response_data)
         _sentry_patched_handle_errors(self, errors, response_data)
 
-    def _sentry_patched_sync_view_handle_errors(self, errors, response_data):
-        # type: (Any, List[GraphQLError], GraphQLHTTPResponse) -> None
+    def _sentry_patched_sync_view_handle_errors(
+        self: Any, errors: List[GraphQLError], response_data: GraphQLHTTPResponse
+    ) -> None:
         old_sync_view_handle_errors(self, errors, response_data)
         _sentry_patched_handle_errors(self, errors, response_data)
 
     @ensure_integration_enabled(StrawberryIntegration)
-    def _sentry_patched_handle_errors(self, errors, response_data):
-        # type: (Any, List[GraphQLError], GraphQLHTTPResponse) -> None
+    def _sentry_patched_handle_errors(
+        self: Any, errors: List[GraphQLError], response_data: GraphQLHTTPResponse
+    ) -> None:
         if not errors:
             return
 
@@ -322,18 +336,18 @@ def _patch_views():
     )
 
 
-def _make_request_event_processor(execution_context):
-    # type: (ExecutionContext) -> EventProcessor
+def _make_request_event_processor(
+    execution_context: ExecutionContext,
+) -> EventProcessor:
 
-    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():
                 request_data = event.setdefault("request", {})
                 request_data["api_target"] = "graphql"
 
                 if not request_data.get("data"):
-                    data = {"query": execution_context.query}  # type: dict[str, Any]
+                    data: dict[str, Any] = {"query": execution_context.query}
                     if execution_context.variables:
                         data["variables"] = execution_context.variables
                     if execution_context.operation_name:
@@ -352,11 +366,11 @@ def _make_request_event_processor(execution_context):
     return inner
 
 
-def _make_response_event_processor(response_data):
-    # type: (GraphQLHTTPResponse) -> EventProcessor
+def _make_response_event_processor(
+    response_data: GraphQLHTTPResponse,
+) -> EventProcessor:
 
-    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():
                 contexts = event.setdefault("contexts", {})
@@ -367,8 +381,7 @@ def _make_response_event_processor(response_data):
     return inner
 
 
-def _guess_if_using_async(extensions):
-    # type: (List[SchemaExtension]) -> bool
+def _guess_if_using_async(extensions: List[SchemaExtension]) -> bool:
     return bool(
         {"starlette", "starlite", "litestar", "fastapi"} & set(_get_installed_modules())
     )

sentry_sdk/integrations/sys_exit.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import functools
 import sys
 
@@ -24,23 +25,19 @@ class SysExitIntegration(Integration):
 
     identifier = "sys_exit"
 
-    def __init__(self, *, capture_successful_exits=False):
-        # type: (bool) -> None
+    def __init__(self, *, capture_successful_exits: bool = False) -> None:
         self._capture_successful_exits = capture_successful_exits
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         SysExitIntegration._patch_sys_exit()
 
     @staticmethod
-    def _patch_sys_exit():
-        # type: () -> None
-        old_exit = sys.exit  # type: Callable[[Union[str, int, None]], NoReturn]
+    def _patch_sys_exit() -> None:
+        old_exit: Callable[[Union[str, int, None]], NoReturn] = sys.exit
 
         @functools.wraps(old_exit)
-        def sentry_patched_exit(__status=0):
-            # type: (Union[str, int, None]) -> NoReturn
+        def sentry_patched_exit(__status: Union[str, int, None] = 0) -> NoReturn:
             # @ensure_integration_enabled ensures that this is non-None
             integration = sentry_sdk.get_client().get_integration(SysExitIntegration)
             if integration is None:
@@ -60,8 +57,7 @@ class SysExitIntegration(Integration):
         sys.exit = sentry_patched_exit
 
 
-def _capture_exception(exc):
-    # type: (SystemExit) -> None
+def _capture_exception(exc: SystemExit) -> None:
     event, hint = event_from_exception(
         exc,
         client_options=sentry_sdk.get_client().options,

sentry_sdk/integrations/threading.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sys
 import warnings
 from functools import wraps
@@ -28,13 +29,11 @@ if TYPE_CHECKING:
 class ThreadingIntegration(Integration):
     identifier = "threading"
 
-    def __init__(self, propagate_scope=True):
-        # type: (bool) -> None
+    def __init__(self, propagate_scope: bool = True) -> None:
         self.propagate_scope = propagate_scope
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         old_start = Thread.start
 
         try:
@@ -47,8 +46,7 @@ class ThreadingIntegration(Integration):
             channels_version = None
 
         @wraps(old_start)
-        def sentry_start(self, *a, **kw):
-            # type: (Thread, *Any, **Any) -> Any
+        def sentry_start(self: Thread, *a: Any, **kw: Any) -> Any:
             integration = sentry_sdk.get_client().get_integration(ThreadingIntegration)
             if integration is None:
                 return old_start(self, *a, **kw)
@@ -98,13 +96,14 @@ class ThreadingIntegration(Integration):
         Thread.start = sentry_start  # type: ignore
 
 
-def _wrap_run(isolation_scope_to_use, current_scope_to_use, old_run_func):
-    # type: (sentry_sdk.Scope, sentry_sdk.Scope, F) -> F
+def _wrap_run(
+    isolation_scope_to_use: sentry_sdk.Scope,
+    current_scope_to_use: sentry_sdk.Scope,
+    old_run_func: F,
+) -> F:
     @wraps(old_run_func)
-    def run(*a, **kw):
-        # type: (*Any, **Any) -> Any
-        def _run_old_run_func():
-            # type: () -> Any
+    def run(*a: Any, **kw: Any) -> Any:
+        def _run_old_run_func() -> Any:
             try:
                 self = current_thread()
                 return old_run_func(self, *a, **kw)
@@ -118,8 +117,7 @@ def _wrap_run(isolation_scope_to_use, current_scope_to_use, old_run_func):
     return run  # type: ignore
 
 
-def _capture_exception():
-    # type: () -> ExcInfo
+def _capture_exception() -> ExcInfo:
     exc_info = sys.exc_info()
 
     client = sentry_sdk.get_client()

sentry_sdk/integrations/tornado.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import weakref
 import contextlib
 from inspect import iscoroutinefunction
@@ -56,8 +57,7 @@ class TornadoIntegration(Integration):
     origin = f"auto.http.{identifier}"
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         _check_minimum_version(TornadoIntegration, TORNADO_VERSION)
 
         if not HAS_REAL_CONTEXTVARS:
@@ -77,16 +77,18 @@ class TornadoIntegration(Integration):
         if awaitable:
             # Starting Tornado 6 RequestHandler._execute method is a standard Python coroutine (async/await)
             # In that case our method should be a coroutine function too
-            async def sentry_execute_request_handler(self, *args, **kwargs):
-                # type: (RequestHandler, *Any, **Any) -> Any
+            async def sentry_execute_request_handler(
+                self: RequestHandler, *args: Any, **kwargs: Any
+            ) -> Any:
                 with _handle_request_impl(self):
                     return await old_execute(self, *args, **kwargs)
 
         else:
 
             @coroutine  # type: ignore
-            def sentry_execute_request_handler(self, *args, **kwargs):  # type: ignore
-                # type: (RequestHandler, *Any, **Any) -> Any
+            def sentry_execute_request_handler(
+                self: RequestHandler, *args: Any, **kwargs: Any
+            ) -> Any:
                 with _handle_request_impl(self):
                     result = yield from old_execute(self, *args, **kwargs)
                     return result
@@ -95,8 +97,14 @@ class TornadoIntegration(Integration):
 
         old_log_exception = RequestHandler.log_exception
 
-        def sentry_log_exception(self, ty, value, tb, *args, **kwargs):
-            # type: (Any, type, BaseException, Any, *Any, **Any) -> Optional[Any]
+        def sentry_log_exception(
+            self: Any,
+            ty: type,
+            value: BaseException,
+            tb: Any,
+            *args: Any,
+            **kwargs: Any,
+        ) -> Optional[Any]:
             _capture_exception(ty, value, tb)
             return old_log_exception(self, ty, value, tb, *args, **kwargs)
 
@@ -104,8 +112,7 @@ class TornadoIntegration(Integration):
 
 
 @contextlib.contextmanager
-def _handle_request_impl(self):
-    # type: (RequestHandler) -> Generator[None, None, None]
+def _handle_request_impl(self: RequestHandler) -> Generator[None, None, None]:
     integration = sentry_sdk.get_client().get_integration(TornadoIntegration)
 
     if integration is None:
@@ -136,8 +143,7 @@ def _handle_request_impl(self):
 
 
 @ensure_integration_enabled(TornadoIntegration)
-def _capture_exception(ty, value, tb):
-    # type: (type, BaseException, Any) -> None
+def _capture_exception(ty: type, value: BaseException, tb: Any) -> None:
     if isinstance(value, HTTPError):
         return
 
@@ -150,10 +156,8 @@ def _capture_exception(ty, value, tb):
     sentry_sdk.capture_event(event, hint=hint)
 
 
-def _make_event_processor(weak_handler):
-    # type: (Callable[[], RequestHandler]) -> EventProcessor
-    def tornado_processor(event, hint):
-        # type: (Event, dict[str, Any]) -> Event
+def _make_event_processor(weak_handler: Callable[[], RequestHandler]) -> EventProcessor:
+    def tornado_processor(event: Event, hint: dict[str, Any]) -> Event:
         handler = weak_handler()
         if handler is None:
             return event
@@ -192,42 +196,34 @@ def _make_event_processor(weak_handler):
 
 
 class TornadoRequestExtractor(RequestExtractor):
-    def content_length(self):
-        # type: () -> int
+    def content_length(self) -> int:
         if self.request.body is None:
             return 0
         return len(self.request.body)
 
-    def cookies(self):
-        # type: () -> Dict[str, str]
+    def cookies(self) -> Dict[str, str]:
         return {k: v.value for k, v in self.request.cookies.items()}
 
-    def raw_data(self):
-        # type: () -> bytes
+    def raw_data(self) -> bytes:
         return self.request.body
 
-    def form(self):
-        # type: () -> Dict[str, Any]
+    def form(self) -> Dict[str, Any]:
         return {
             k: [v.decode("latin1", "replace") for v in vs]
             for k, vs in self.request.body_arguments.items()
         }
 
-    def is_json(self):
-        # type: () -> bool
+    def is_json(self) -> bool:
         return _is_json_content_type(self.request.headers.get("content-type"))
 
-    def files(self):
-        # type: () -> Dict[str, Any]
+    def files(self) -> Dict[str, Any]:
         return {k: v[0] for k, v in self.request.files.items() if v}
 
-    def size_of_file(self, file):
-        # type: (Any) -> int
+    def size_of_file(self, file: Any) -> int:
         return len(file.body or ())
 
 
-def _prepopulate_attributes(request):
-    # type: (HTTPServerRequest) -> dict[str, Any]
+def _prepopulate_attributes(request: HTTPServerRequest) -> dict[str, Any]:
     # https://www.tornadoweb.org/en/stable/httputil.html#tornado.httputil.HTTPServerRequest
     attributes = {}
 

sentry_sdk/integrations/trytond.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sentry_sdk
 from sentry_sdk.integrations import _check_minimum_version, Integration
 from sentry_sdk.integrations.wsgi import SentryWsgiMiddleware
@@ -15,11 +16,11 @@ class TrytondWSGIIntegration(Integration):
     identifier = "trytond_wsgi"
     origin = f"auto.http.{identifier}"
 
-    def __init__(self):  # type: () -> None
+    def __init__(self) -> None:
         pass
 
     @staticmethod
-    def setup_once():  # type: () -> None
+    def setup_once() -> None:
         _check_minimum_version(TrytondWSGIIntegration, trytond_version)
 
         app.wsgi_app = SentryWsgiMiddleware(
@@ -28,7 +29,7 @@ class TrytondWSGIIntegration(Integration):
         )
 
         @ensure_integration_enabled(TrytondWSGIIntegration)
-        def error_handler(e):  # type: (Exception) -> None
+        def error_handler(e: Exception) -> None:
             if isinstance(e, TrytonException):
                 return
             else:

sentry_sdk/integrations/typer.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sentry_sdk
 from sentry_sdk.utils import (
     capture_internal_exceptions,
@@ -30,15 +31,16 @@ class TyperIntegration(Integration):
     identifier = "typer"
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         typer.main.except_hook = _make_excepthook(typer.main.except_hook)  # type: ignore
 
 
-def _make_excepthook(old_excepthook):
-    # type: (Excepthook) -> Excepthook
-    def sentry_sdk_excepthook(type_, value, traceback):
-        # type: (Type[BaseException], BaseException, Optional[TracebackType]) -> None
+def _make_excepthook(old_excepthook: Excepthook) -> Excepthook:
+    def sentry_sdk_excepthook(
+        type_: Type[BaseException],
+        value: BaseException,
+        traceback: Optional[TracebackType],
+    ) -> None:
         integration = sentry_sdk.get_client().get_integration(TyperIntegration)
 
         # Note: If we replace this with ensure_integration_enabled then