Generic ExceptionHandler type

starlette/_exception_handler.py

@@ -18,13 +18,13 @@
 )
 from starlette.websockets import WebSocket
 
-ExceptionHandlers = typing.Dict[typing.Any, ExceptionHandler]
-StatusHandlers = typing.Dict[int, ExceptionHandler]
+ExceptionHandlers = typing.Dict[typing.Any, ExceptionHandler[Exception]]
+StatusHandlers = typing.Dict[int, ExceptionHandler[Exception]]
 
 
 def _lookup_exception_handler(
     exc_handlers: ExceptionHandlers, exc: Exception
-) -> ExceptionHandler | None:
+) -> ExceptionHandler[Exception] | None:
     for cls in type(exc).__mro__:
         if cls in exc_handlers:
             return exc_handlers[cls]
@@ -69,15 +69,15 @@ async def sender(message: Message) -> None:
 
             if scope["type"] == "http":
                 nonlocal conn
-                handler = typing.cast(HTTPExceptionHandler, handler)
+                handler = typing.cast(HTTPExceptionHandler[Exception], handler)
                 conn = typing.cast(Request, conn)
                 if is_async_callable(handler):
                     response = await handler(conn, exc)
                 else:
                     response = await run_in_threadpool(handler, conn, exc)
                 await response(scope, receive, sender)
             elif scope["type"] == "websocket":
-                handler = typing.cast(WebSocketExceptionHandler, handler)
+                handler = typing.cast(WebSocketExceptionHandler[Exception], handler)
                 conn = typing.cast(WebSocket, conn)
                 if is_async_callable(handler):
                     await handler(conn, exc)

starlette/applications.py

@@ -17,7 +17,15 @@
 from starlette.requests import Request
 from starlette.responses import Response
 from starlette.routing import BaseRoute, Router
-from starlette.types import ASGIApp, ExceptionHandler, Lifespan, Receive, Scope, Send
+from starlette.types import (
+    ASGIApp,
+    ExceptionHandler,
+    ExceptionType,
+    Lifespan,
+    Receive,
+    Scope,
+    Send,
+)
 from starlette.websockets import WebSocket
 
 AppType = typing.TypeVar("AppType", bound="Starlette")
@@ -59,7 +67,8 @@ def __init__(
         debug: bool = False,
         routes: typing.Sequence[BaseRoute] | None = None,
         middleware: typing.Sequence[Middleware] | None = None,
-        exception_handlers: typing.Mapping[typing.Any, ExceptionHandler] | None = None,
+        exception_handlers: typing.Mapping[typing.Any, ExceptionHandler[ExceptionType]]
+        | None = None,
         on_startup: typing.Sequence[typing.Callable[[], typing.Any]] | None = None,
         on_shutdown: typing.Sequence[typing.Callable[[], typing.Any]] | None = None,
         lifespan: Lifespan[AppType] | None = None,
@@ -143,8 +152,8 @@ def add_middleware(
 
     def add_exception_handler(
         self,
-        exc_class_or_status_code: int | type[Exception],
-        handler: ExceptionHandler,
+        exc_class_or_status_code: int | type[ExceptionType],
+        handler: ExceptionHandler[ExceptionType],
     ) -> None:  # pragma: no cover
         self.exception_handlers[exc_class_or_status_code] = handler
 

starlette/types.py

@@ -21,10 +21,14 @@
 ]
 Lifespan = typing.Union[StatelessLifespan[AppType], StatefulLifespan[AppType]]
 
+ExceptionType = typing.TypeVar("ExceptionType", bound=Exception)
+
 HTTPExceptionHandler = typing.Callable[
-    ["Request", Exception], "Response | typing.Awaitable[Response]"
+    ["Request", ExceptionType], "Response | typing.Awaitable[Response]"
 ]
 WebSocketExceptionHandler = typing.Callable[
-    ["WebSocket", Exception], typing.Awaitable[None]
+    ["WebSocket", ExceptionType], typing.Awaitable[None]
+]
+ExceptionHandler = typing.Union[
+    HTTPExceptionHandler[ExceptionType], WebSocketExceptionHandler[ExceptionType]
 ]
-ExceptionHandler = typing.Union[HTTPExceptionHandler, WebSocketExceptionHandler]