uvicorn 0.27.1__py3-none-any.whl → 0.28.1__py3-none-any.whl

uvicorn/__init__.py

@@ -1,5 +1,5 @@
 from uvicorn.config import Config
 from uvicorn.main import Server, main, run
 
-__version__ = "0.27.1"
+__version__ = "0.28.1"
 __all__ = ["main", "run", "Config", "Server"]

uvicorn/_subprocess.py

@@ -9,7 +9,7 @@ import os
 import sys
 from multiprocessing.context import SpawnProcess
 from socket import socket
-from typing import Callable, Optional
+from typing import Callable
 
 from uvicorn.config import Config
 
@@ -34,10 +34,10 @@ def get_subprocess(
     """
     # We pass across the stdin fileno, and reopen it in the child process.
     # This is required for some debugging environments.
-    stdin_fileno: Optional[int]
     try:
         stdin_fileno = sys.stdin.fileno()
-    except OSError:
+    # The `sys.stdin` can be `None`, see https://docs.python.org/3/library/sys.html#sys.__stdin__.
+    except (AttributeError, OSError):
         stdin_fileno = None
 
     kwargs = {

uvicorn/_types.py

@@ -36,18 +36,16 @@ from typing import (
     Awaitable,
     Callable,
     Iterable,
+    Literal,
     MutableMapping,
     Optional,
+    Protocol,
     Tuple,
     Type,
+    TypedDict,
     Union,
 )
 
-if sys.version_info >= (3, 8):  # pragma: py-lt-38
-    from typing import Literal, Protocol, TypedDict
-else:  # pragma: py-gte-38
-    from typing_extensions import Literal, Protocol, TypedDict
-
 if sys.version_info >= (3, 11):  # pragma: py-lt-311
     from typing import NotRequired
 else:  # pragma: py-gte-311
@@ -239,9 +237,7 @@ class LifespanShutdownFailedEvent(TypedDict):
     message: str
 
 
-WebSocketEvent = Union[
-    WebSocketReceiveEvent, WebSocketDisconnectEvent, WebSocketConnectEvent
-]
+WebSocketEvent = Union[WebSocketReceiveEvent, WebSocketDisconnectEvent, WebSocketConnectEvent]
 
 
 ASGIReceiveEvent = Union[
@@ -281,9 +277,7 @@ class ASGI2Protocol(Protocol):
     def __init__(self, scope: Scope) -> None:
         ...  # pragma: no cover
 
-    async def __call__(
-        self, receive: ASGIReceiveCallable, send: ASGISendCallable
-    ) -> None:
+    async def __call__(self, receive: ASGIReceiveCallable, send: ASGISendCallable) -> None:
         ...  # pragma: no cover
 
 

uvicorn/config.py

@@ -127,9 +127,7 @@ def is_dir(path: Path) -> bool:
         return False
 
 
-def resolve_reload_patterns(
-    patterns_list: list[str], directories_list: list[str]
-) -> tuple[list[str], list[Path]]:
+def resolve_reload_patterns(patterns_list: list[str], directories_list: list[str]) -> tuple[list[str], list[Path]]:
     directories: list[Path] = list(set(map(Path, directories_list.copy())))
     patterns: list[str] = patterns_list.copy()
 
@@ -150,9 +148,7 @@ def resolve_reload_patterns(
     directories = list(set(directories))
     directories = list(map(Path, directories))
     directories = list(map(lambda x: x.resolve(), directories))
-    directories = list(
-        {reload_path for reload_path in directories if is_dir(reload_path)}
-    )
+    directories = list({reload_path for reload_path in directories if is_dir(reload_path)})
 
     children = []
     for j in range(len(directories)):
@@ -280,12 +276,9 @@ class Config:
         self.reload_includes: list[str] = []
         self.reload_excludes: list[str] = []
 
-        if (
-            reload_dirs or reload_includes or reload_excludes
-        ) and not self.should_reload:
+        if (reload_dirs or reload_includes or reload_excludes) and not self.should_reload:
             logger.warning(
-                "Current configuration will not reload as not all conditions are met, "
-                "please refer to documentation."
+                "Current configuration will not reload as not all conditions are met, " "please refer to documentation."
             )
 
         if self.should_reload:
@@ -293,22 +286,15 @@ class Config:
             reload_includes = _normalize_dirs(reload_includes)
             reload_excludes = _normalize_dirs(reload_excludes)
 
-            self.reload_includes, self.reload_dirs = resolve_reload_patterns(
-                reload_includes, reload_dirs
-            )
+            self.reload_includes, self.reload_dirs = resolve_reload_patterns(reload_includes, reload_dirs)
 
-            self.reload_excludes, self.reload_dirs_excludes = resolve_reload_patterns(
-                reload_excludes, []
-            )
+            self.reload_excludes, self.reload_dirs_excludes = resolve_reload_patterns(reload_excludes, [])
 
             reload_dirs_tmp = self.reload_dirs.copy()
 
             for directory in self.reload_dirs_excludes:
                 for reload_directory in reload_dirs_tmp:
-                    if (
-                        directory == reload_directory
-                        or directory in reload_directory.parents
-                    ):
+                    if directory == reload_directory or directory in reload_directory.parents:
                         try:
                             self.reload_dirs.remove(reload_directory)
                         except ValueError:
@@ -343,9 +329,7 @@ class Config:
 
         self.forwarded_allow_ips: list[str] | str
         if forwarded_allow_ips is None:
-            self.forwarded_allow_ips = os.environ.get(
-                "FORWARDED_ALLOW_IPS", "127.0.0.1"
-            )
+            self.forwarded_allow_ips = os.environ.get("FORWARDED_ALLOW_IPS", "127.0.0.1")
         else:
             self.forwarded_allow_ips = forwarded_allow_ips
 
@@ -375,12 +359,8 @@ class Config:
         if self.log_config is not None:
             if isinstance(self.log_config, dict):
                 if self.use_colors in (True, False):
-                    self.log_config["formatters"]["default"][
-                        "use_colors"
-                    ] = self.use_colors
-                    self.log_config["formatters"]["access"][
-                        "use_colors"
-                    ] = self.use_colors
+                    self.log_config["formatters"]["default"]["use_colors"] = self.use_colors
+                    self.log_config["formatters"]["access"]["use_colors"] = self.use_colors
                 logging.config.dictConfig(self.log_config)
             elif self.log_config.endswith(".json"):
                 with open(self.log_config) as file:
@@ -397,9 +377,7 @@ class Config:
             else:
                 # See the note about fileConfig() here:
                 # https://docs.python.org/3/library/logging.config.html#configuration-file-format
-                logging.config.fileConfig(
-                    self.log_config, disable_existing_loggers=False
-                )
+                logging.config.fileConfig(self.log_config, disable_existing_loggers=False)
 
         if self.log_level is not None:
             if isinstance(self.log_level, str):
@@ -430,10 +408,7 @@ class Config:
         else:
             self.ssl = None
 
-        encoded_headers = [
-            (key.lower().encode("latin1"), value.encode("latin1"))
-            for key, value in self.headers
-        ]
+        encoded_headers = [(key.lower().encode("latin1"), value.encode("latin1")) for key, value in self.headers]
         self.encoded_headers = (
             [(b"server", b"uvicorn")] + encoded_headers
             if b"server" not in dict(encoded_headers) and self.server_header
@@ -469,8 +444,7 @@ class Config:
         else:
             if not self.factory:
                 logger.warning(
-                    "ASGI app factory detected. Using it, "
-                    "but please consider setting the --factory flag explicitly."
+                    "ASGI app factory detected. Using it, " "but please consider setting the --factory flag explicitly."
                 )
 
         if self.interface == "auto":
@@ -492,9 +466,7 @@ class Config:
         if logger.getEffectiveLevel() <= TRACE_LOG_LEVEL:
             self.loaded_app = MessageLoggerMiddleware(self.loaded_app)
         if self.proxy_headers:
-            self.loaded_app = ProxyHeadersMiddleware(
-                self.loaded_app, trusted_hosts=self.forwarded_allow_ips
-            )
+            self.loaded_app = ProxyHeadersMiddleware(self.loaded_app, trusted_hosts=self.forwarded_allow_ips)
 
         self.loaded = True
 
@@ -518,21 +490,13 @@ class Config:
 
             message = "Uvicorn running on unix socket %s (Press CTRL+C to quit)"
             sock_name_format = "%s"
-            color_message = (
-                "Uvicorn running on "
-                + click.style(sock_name_format, bold=True)
-                + " (Press CTRL+C to quit)"
-            )
+            color_message = "Uvicorn running on " + click.style(sock_name_format, bold=True) + " (Press CTRL+C to quit)"
             logger_args = [self.uds]
         elif self.fd:  # pragma: py-win32
             sock = socket.fromfd(self.fd, socket.AF_UNIX, socket.SOCK_STREAM)
             message = "Uvicorn running on socket %s (Press CTRL+C to quit)"
             fd_name_format = "%s"
-            color_message = (
-                "Uvicorn running on "
-                + click.style(fd_name_format, bold=True)
-                + " (Press CTRL+C to quit)"
-            )
+            color_message = "Uvicorn running on " + click.style(fd_name_format, bold=True) + " (Press CTRL+C to quit)"
             logger_args = [sock.getsockname()]
         else:
             family = socket.AF_INET
@@ -552,11 +516,7 @@ class Config:
                 sys.exit(1)
 
             message = f"Uvicorn running on {addr_format} (Press CTRL+C to quit)"
-            color_message = (
-                "Uvicorn running on "
-                + click.style(addr_format, bold=True)
-                + " (Press CTRL+C to quit)"
-            )
+            color_message = "Uvicorn running on " + click.style(addr_format, bold=True) + " (Press CTRL+C to quit)"
             protocol_name = "https" if self.is_ssl else "http"
             logger_args = [protocol_name, self.host, sock.getsockname()[1]]
         logger.info(message, *logger_args, extra={"color_message": color_message})

uvicorn/importer.py

@@ -12,9 +12,7 @@ def import_from_string(import_str: Any) -> Any:
 
     module_str, _, attrs_str = import_str.partition(":")
     if not module_str or not attrs_str:
-        message = (
-            'Import string "{import_str}" must be in format "<module>:<attribute>".'
-        )
+        message = 'Import string "{import_str}" must be in format "<module>:<attribute>".'
         raise ImportFromStringError(message.format(import_str=import_str))
 
     try:
@@ -31,8 +29,6 @@ def import_from_string(import_str: Any) -> Any:
             instance = getattr(instance, attr_str)
     except AttributeError:
         message = 'Attribute "{attrs_str}" not found in module "{module_str}".'
-        raise ImportFromStringError(
-            message.format(attrs_str=attrs_str, module_str=module_str)
-        )
+        raise ImportFromStringError(message.format(attrs_str=attrs_str, module_str=module_str))
 
     return instance

uvicorn/lifespan/off.py

@@ -1,4 +1,6 @@
-from typing import Any, Dict
+from __future__ import annotations
+
+from typing import Any
 
 from uvicorn import Config
 
@@ -6,7 +8,7 @@ from uvicorn import Config
 class LifespanOff:
     def __init__(self, config: Config) -> None:
         self.should_exit = False
-        self.state: Dict[str, Any] = {}
+        self.state: dict[str, Any] = {}
 
     async def startup(self) -> None:
         pass

uvicorn/lifespan/on.py

@@ -1,7 +1,9 @@
+from __future__ import annotations
+
 import asyncio
 import logging
 from asyncio import Queue
-from typing import Any, Dict, Union
+from typing import Any, Union
 
 from uvicorn import Config
 from uvicorn._types import (
@@ -35,12 +37,12 @@ class LifespanOn:
         self.logger = logging.getLogger("uvicorn.error")
         self.startup_event = asyncio.Event()
         self.shutdown_event = asyncio.Event()
-        self.receive_queue: "Queue[LifespanReceiveMessage]" = asyncio.Queue()
+        self.receive_queue: Queue[LifespanReceiveMessage] = asyncio.Queue()
         self.error_occured = False
         self.startup_failed = False
         self.shutdown_failed = False
         self.should_exit = False
-        self.state: Dict[str, Any] = {}
+        self.state: dict[str, Any] = {}
 
     async def startup(self) -> None:
         self.logger.info("Waiting for application startup.")
@@ -67,9 +69,7 @@ class LifespanOn:
         await self.receive_queue.put(shutdown_event)
         await self.shutdown_event.wait()
 
-        if self.shutdown_failed or (
-            self.error_occured and self.config.lifespan == "on"
-        ):
+        if self.shutdown_failed or (self.error_occured and self.config.lifespan == "on"):
             self.logger.error("Application shutdown failed. Exiting.")
             self.should_exit = True
         else:
@@ -99,7 +99,7 @@ class LifespanOn:
             self.startup_event.set()
             self.shutdown_event.set()
 
-    async def send(self, message: "LifespanSendMessage") -> None:
+    async def send(self, message: LifespanSendMessage) -> None:
         assert message["type"] in (
             "lifespan.startup.complete",
             "lifespan.startup.failed",
@@ -133,5 +133,5 @@ class LifespanOn:
             if message.get("message"):
                 self.logger.error(message["message"])
 
-    async def receive(self) -> "LifespanReceiveMessage":
+    async def receive(self) -> LifespanReceiveMessage:
         return await self.receive_queue.get()

uvicorn/logging.py

@@ -26,9 +26,7 @@ class ColourizedFormatter(logging.Formatter):
         logging.INFO: lambda level_name: click.style(str(level_name), fg="green"),
         logging.WARNING: lambda level_name: click.style(str(level_name), fg="yellow"),
         logging.ERROR: lambda level_name: click.style(str(level_name), fg="red"),
-        logging.CRITICAL: lambda level_name: click.style(
-            str(level_name), fg="bright_red"
-        ),
+        logging.CRITICAL: lambda level_name: click.style(str(level_name), fg="bright_red"),
     }
 
     def __init__(
@@ -86,7 +84,7 @@ class AccessFormatter(ColourizedFormatter):
             status_phrase = http.HTTPStatus(status_code).phrase
         except ValueError:
             status_phrase = ""
-        status_and_phrase = "%s %s" % (status_code, status_phrase)
+        status_and_phrase = f"{status_code} {status_phrase}"
         if self.use_colors:
 
             def default(code: int) -> str:
@@ -106,7 +104,7 @@ class AccessFormatter(ColourizedFormatter):
             status_code,
         ) = recordcopy.args  # type: ignore[misc]
         status_code = self.get_status_code(int(status_code))  # type: ignore[arg-type]
-        request_line = "%s %s HTTP/%s" % (method, full_path, http_version)
+        request_line = f"{method} {full_path} HTTP/{http_version}"
         if self.use_colors:
             request_line = click.style(request_line, bold=True)
         recordcopy.__dict__.update(

uvicorn/main.py

@@ -47,12 +47,11 @@ def print_version(ctx: click.Context, param: click.Parameter, value: bool) -> No
     if not value or ctx.resilient_parsing:
         return
     click.echo(
-        "Running uvicorn %s with %s %s on %s"
-        % (
-            uvicorn.__version__,
-            platform.python_implementation(),
-            platform.python_version(),
-            platform.system(),
+        "Running uvicorn {version} with {py_implementation} {py_version} on {system}".format(
+            version=uvicorn.__version__,
+            py_implementation=platform.python_implementation(),
+            py_version=platform.python_version(),
+            system=platform.system(),
         )
     )
     ctx.exit()
@@ -75,16 +74,13 @@ def print_version(ctx: click.Context, param: click.Parameter, value: bool) -> No
     show_default=True,
 )
 @click.option("--uds", type=str, default=None, help="Bind to a UNIX domain socket.")
-@click.option(
-    "--fd", type=int, default=None, help="Bind to socket from this file descriptor."
-)
+@click.option("--fd", type=int, default=None, help="Bind to socket from this file descriptor.")
 @click.option("--reload", is_flag=True, default=False, help="Enable auto-reload.")
 @click.option(
     "--reload-dir",
     "reload_dirs",
     multiple=True,
-    help="Set reload directories explicitly, instead of using the current working"
-    " directory.",
+    help="Set reload directories explicitly, instead of using the current working" " directory.",
     type=click.Path(exists=True),
 )
 @click.option(
@@ -109,8 +105,7 @@ def print_version(ctx: click.Context, param: click.Parameter, value: bool) -> No
     type=float,
     default=0.25,
     show_default=True,
-    help="Delay between previous and next check if application needs to be."
-    " Defaults to 0.25s.",
+    help="Delay between previous and next check if application needs to be." " Defaults to 0.25s.",
 )
 @click.option(
     "--workers",
@@ -226,8 +221,7 @@ def print_version(ctx: click.Context, param: click.Parameter, value: bool) -> No
     "--proxy-headers/--no-proxy-headers",
     is_flag=True,
     default=True,
-    help="Enable/Disable X-Forwarded-Proto, X-Forwarded-For, X-Forwarded-Port to "
-    "populate remote address info.",
+    help="Enable/Disable X-Forwarded-Proto, X-Forwarded-For, X-Forwarded-Port to " "populate remote address info.",
 )
 @click.option(
     "--server-header/--no-server-header",
@@ -258,8 +252,7 @@ def print_version(ctx: click.Context, param: click.Parameter, value: bool) -> No
     "--limit-concurrency",
     type=int,
     default=None,
-    help="Maximum number of concurrent connections or tasks to allow, before issuing"
-    " HTTP 503 responses.",
+    help="Maximum number of concurrent connections or tasks to allow, before issuing" " HTTP 503 responses.",
 )
 @click.option(
     "--backlog",
@@ -286,9 +279,7 @@ def print_version(ctx: click.Context, param: click.Parameter, value: bool) -> No
     default=None,
     help="Maximum number of seconds to wait for graceful shutdown.",
 )
-@click.option(
-    "--ssl-keyfile", type=str, default=None, help="SSL key file", show_default=True
-)
+@click.option("--ssl-keyfile", type=str, default=None, help="SSL key file", show_default=True)
 @click.option(
     "--ssl-certfile",
     type=str,
@@ -571,10 +562,7 @@ def run(
 
     if (config.reload or config.workers > 1) and not isinstance(app, str):
         logger = logging.getLogger("uvicorn.error")
-        logger.warning(
-            "You must pass the application as an import string to enable 'reload' or "
-            "'workers'."
-        )
+        logger.warning("You must pass the application as an import string to enable 'reload' or " "'workers'.")
         sys.exit(1)
 
     if config.should_reload:

uvicorn/middleware/asgi2.py

@@ -10,8 +10,6 @@ class ASGI2Middleware:
     def __init__(self, app: "ASGI2Application"):
         self.app = app
 
-    async def __call__(
-        self, scope: "Scope", receive: "ASGIReceiveCallable", send: "ASGISendCallable"
-    ) -> None:
+    async def __call__(self, scope: "Scope", receive: "ASGIReceiveCallable", send: "ASGISendCallable") -> None:
         instance = self.app(scope)
         await instance(receive, send)

uvicorn/middleware/proxy_headers.py

@@ -8,23 +8,18 @@ the connecting client, rather that the connecting proxy.
 
 https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers#Proxies
 """
-from typing import List, Optional, Tuple, Union, cast
+from __future__ import annotations
 
-from uvicorn._types import (
-    ASGI3Application,
-    ASGIReceiveCallable,
-    ASGISendCallable,
-    HTTPScope,
-    Scope,
-    WebSocketScope,
-)
+from typing import Union, cast
+
+from uvicorn._types import ASGI3Application, ASGIReceiveCallable, ASGISendCallable, HTTPScope, Scope, WebSocketScope
 
 
 class ProxyHeadersMiddleware:
     def __init__(
         self,
-        app: "ASGI3Application",
-        trusted_hosts: Union[List[str], str] = "127.0.0.1",
+        app: ASGI3Application,
+        trusted_hosts: list[str] | str = "127.0.0.1",
     ) -> None:
         self.app = app
         if isinstance(trusted_hosts, str):
@@ -33,9 +28,7 @@ class ProxyHeadersMiddleware:
             self.trusted_hosts = set(trusted_hosts)
         self.always_trust = "*" in self.trusted_hosts
 
-    def get_trusted_client_host(
-        self, x_forwarded_for_hosts: List[str]
-    ) -> Optional[str]:
+    def get_trusted_client_host(self, x_forwarded_for_hosts: list[str]) -> str | None:
         if self.always_trust:
             return x_forwarded_for_hosts[0]
 
@@ -45,12 +38,10 @@ class ProxyHeadersMiddleware:
 
         return None
 
-    async def __call__(
-        self, scope: "Scope", receive: "ASGIReceiveCallable", send: "ASGISendCallable"
-    ) -> None:
+    async def __call__(self, scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable) -> None:
         if scope["type"] in ("http", "websocket"):
             scope = cast(Union["HTTPScope", "WebSocketScope"], scope)
-            client_addr: Optional[Tuple[str, int]] = scope.get("client")
+            client_addr: tuple[str, int] | None = scope.get("client")
             client_host = client_addr[0] if client_addr else None
 
             if self.always_trust or client_host in self.trusted_hosts:
@@ -59,13 +50,9 @@ class ProxyHeadersMiddleware:
                 if b"x-forwarded-proto" in headers:
                     # Determine if the incoming request was http or https based on
                     # the X-Forwarded-Proto header.
-                    x_forwarded_proto = (
-                        headers[b"x-forwarded-proto"].decode("latin1").strip()
-                    )
+                    x_forwarded_proto = headers[b"x-forwarded-proto"].decode("latin1").strip()
                     if scope["type"] == "websocket":
-                        scope["scheme"] = (
-                            "wss" if x_forwarded_proto == "https" else "ws"
-                        )
+                        scope["scheme"] = x_forwarded_proto.replace("http", "ws")
                     else:
                         scope["scheme"] = x_forwarded_proto
 
@@ -74,9 +61,7 @@ class ProxyHeadersMiddleware:
                     # X-Forwarded-For header. We've lost the connecting client's port
                     # information by now, so only include the host.
                     x_forwarded_for = headers[b"x-forwarded-for"].decode("latin1")
-                    x_forwarded_for_hosts = [
-                        item.strip() for item in x_forwarded_for.split(",")
-                    ]
+                    x_forwarded_for_hosts = [item.strip() for item in x_forwarded_for.split(",")]
                     host = self.get_trusted_client_host(x_forwarded_for_hosts)
                     port = 0
                     scope["client"] = (host, port)  # type: ignore[arg-type]

uvicorn/middleware/wsgi.py

@@ -1,10 +1,12 @@
+from __future__ import annotations
+
 import asyncio
 import concurrent.futures
 import io
 import sys
 import warnings
 from collections import deque
-from typing import Deque, Iterable, Optional, Tuple
+from typing import Iterable
 
 from uvicorn._types import (
     ASGIReceiveCallable,
@@ -22,9 +24,7 @@ from uvicorn._types import (
 )
 
 
-def build_environ(
-    scope: "HTTPScope", message: "ASGIReceiveEvent", body: io.BytesIO
-) -> Environ:
+def build_environ(scope: HTTPScope, message: ASGIReceiveEvent, body: io.BytesIO) -> Environ:
     """
     Builds a scope and request message into a WSGI environ object.
     """
@@ -91,9 +91,9 @@ class _WSGIMiddleware:
 
     async def __call__(
         self,
-        scope: "HTTPScope",
-        receive: "ASGIReceiveCallable",
-        send: "ASGISendCallable",
+        scope: HTTPScope,
+        receive: ASGIReceiveCallable,
+        send: ASGISendCallable,
     ) -> None:
         assert scope["type"] == "http"
         instance = WSGIResponder(self.app, self.executor, scope)
@@ -105,7 +105,7 @@ class WSGIResponder:
         self,
         app: WSGIApp,
         executor: concurrent.futures.ThreadPoolExecutor,
-        scope: "HTTPScope",
+        scope: HTTPScope,
     ):
         self.app = app
         self.executor = executor
@@ -113,21 +113,19 @@ class WSGIResponder:
         self.status = None
         self.response_headers = None
         self.send_event = asyncio.Event()
-        self.send_queue: Deque[Optional["ASGISendEvent"]] = deque()
+        self.send_queue: deque[ASGISendEvent | None] = deque()
         self.loop: asyncio.AbstractEventLoop = asyncio.get_event_loop()
         self.response_started = False
-        self.exc_info: Optional[ExcInfo] = None
+        self.exc_info: ExcInfo | None = None
 
-    async def __call__(
-        self, receive: "ASGIReceiveCallable", send: "ASGISendCallable"
-    ) -> None:
+    async def __call__(self, receive: ASGIReceiveCallable, send: ASGISendCallable) -> None:
         message: HTTPRequestEvent = await receive()  # type: ignore[assignment]
         body = io.BytesIO(message.get("body", b""))
         more_body = message.get("more_body", False)
         if more_body:
             body.seek(0, io.SEEK_END)
             while more_body:
-                body_message: "HTTPRequestEvent" = (
+                body_message: HTTPRequestEvent = (
                     await receive()  # type: ignore[assignment]
                 )
                 body.write(body_message.get("body", b""))
@@ -135,9 +133,7 @@ class WSGIResponder:
             body.seek(0)
         environ = build_environ(self.scope, message, body)
         self.loop = asyncio.get_event_loop()
-        wsgi = self.loop.run_in_executor(
-            self.executor, self.wsgi, environ, self.start_response
-        )
+        wsgi = self.loop.run_in_executor(self.executor, self.wsgi, environ, self.start_response)
         sender = self.loop.create_task(self.sender(send))
         try:
             await asyncio.wait_for(wsgi, None)
@@ -148,7 +144,7 @@ class WSGIResponder:
         if self.exc_info is not None:
             raise self.exc_info[0].with_traceback(self.exc_info[1], self.exc_info[2])
 
-    async def sender(self, send: "ASGISendCallable") -> None:
+    async def sender(self, send: ASGISendCallable) -> None:
         while True:
             if self.send_queue:
                 message = self.send_queue.popleft()
@@ -162,18 +158,15 @@ class WSGIResponder:
     def start_response(
         self,
         status: str,
-        response_headers: Iterable[Tuple[str, str]],
-        exc_info: Optional[ExcInfo] = None,
+        response_headers: Iterable[tuple[str, str]],
+        exc_info: ExcInfo | None = None,
     ) -> None:
         self.exc_info = exc_info
         if not self.response_started:
             self.response_started = True
             status_code_str, _ = status.split(" ", 1)
             status_code = int(status_code_str)
-            headers = [
-                (name.encode("ascii"), value.encode("ascii"))
-                for name, value in response_headers
-            ]
+            headers = [(name.encode("ascii"), value.encode("ascii")) for name, value in response_headers]
             http_response_start_event: HTTPResponseStartEvent = {
                 "type": "http.response.start",
                 "status": status_code,

uvicorn/protocols/http/flow_control.py

@@ -45,9 +45,7 @@ class FlowControl:
             self._is_writable_event.set()
 
 
-async def service_unavailable(
-    scope: "Scope", receive: "ASGIReceiveCallable", send: "ASGISendCallable"
-) -> None:
+async def service_unavailable(scope: "Scope", receive: "ASGIReceiveCallable", send: "ASGISendCallable") -> None:
     response_start: "HTTPResponseStartEvent" = {
         "type": "http.response.start",
         "status": 503,