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

uvicorn/protocols/http/h11_impl.py

@@ -43,9 +43,7 @@ def _get_status_phrase(status_code: int) -> bytes:
         return b""
 
 
-STATUS_PHRASES = {
-    status_code: _get_status_phrase(status_code) for status_code in range(100, 600)
-}
+STATUS_PHRASES = {status_code: _get_status_phrase(status_code) for status_code in range(100, 600)}
 
 
 class H11Protocol(asyncio.Protocol):
@@ -205,7 +203,7 @@ class H11Protocol(asyncio.Protocol):
                     "type": "http",
                     "asgi": {
                         "version": self.config.asgi_version,
-                        "spec_version": "2.3",
+                        "spec_version": "2.4",
                     },
                     "http_version": event.http_version.decode("ascii"),
                     "server": self.server,
@@ -227,8 +225,7 @@ class H11Protocol(asyncio.Protocol):
 
                 # Handle 503 responses when 'limit_concurrency' is exceeded.
                 if self.limit_concurrency is not None and (
-                    len(self.connections) >= self.limit_concurrency
-                    or len(self.tasks) >= self.limit_concurrency
+                    len(self.connections) >= self.limit_concurrency or len(self.tasks) >= self.limit_concurrency
                 ):
                     app = service_unavailable
                     message = "Exceeded concurrency limit."
@@ -322,9 +319,7 @@ class H11Protocol(asyncio.Protocol):
         # Set a short Keep-Alive timeout.
         self._unset_keepalive_if_required()
 
-        self.timeout_keep_alive_task = self.loop.call_later(
-            self.timeout_keep_alive, self.timeout_keep_alive_handler
-        )
+        self.timeout_keep_alive_task = self.loop.call_later(self.timeout_keep_alive, self.timeout_keep_alive_handler)
 
         # Unpause data reads if needed.
         self.flow.resume_reading()
@@ -371,7 +366,7 @@ class H11Protocol(asyncio.Protocol):
 class RequestResponseCycle:
     def __init__(
         self,
-        scope: "HTTPScope",
+        scope: HTTPScope,
         conn: h11.Connection,
         transport: asyncio.Transport,
         flow: FlowControl,
@@ -407,7 +402,7 @@ class RequestResponseCycle:
         self.response_complete = False
 
     # ASGI exception wrapper
-    async def run_asgi(self, app: "ASGI3Application") -> None:
+    async def run_asgi(self, app: ASGI3Application) -> None:
         try:
             result = await app(  # type: ignore[func-returns-value]
                 self.scope, self.receive, self.send
@@ -436,7 +431,7 @@ class RequestResponseCycle:
             self.on_response = lambda: None
 
     async def send_500_response(self) -> None:
-        response_start_event: "HTTPResponseStartEvent" = {
+        response_start_event: HTTPResponseStartEvent = {
             "type": "http.response.start",
             "status": 500,
             "headers": [
@@ -445,7 +440,7 @@ class RequestResponseCycle:
             ],
         }
         await self.send(response_start_event)
-        response_body_event: "HTTPResponseBodyEvent" = {
+        response_body_event: HTTPResponseBodyEvent = {
             "type": "http.response.body",
             "body": b"Internal Server Error",
             "more_body": False,
@@ -453,7 +448,7 @@ class RequestResponseCycle:
         await self.send(response_body_event)
 
     # ASGI interface
-    async def send(self, message: "ASGISendEvent") -> None:
+    async def send(self, message: ASGISendEvent) -> None:
         message_type = message["type"]
 
         if self.flow.write_paused and not self.disconnected:
@@ -527,12 +522,10 @@ class RequestResponseCycle:
                 self.transport.close()
             self.on_response()
 
-    async def receive(self) -> "ASGIReceiveEvent":
+    async def receive(self) -> ASGIReceiveEvent:
         if self.waiting_for_100_continue and not self.transport.is_closing():
             headers: list[tuple[str, str]] = []
-            event = h11.InformationalResponse(
-                status_code=100, headers=headers, reason="Continue"
-            )
+            event = h11.InformationalResponse(status_code=100, headers=headers, reason="Continue")
             output = self.conn.send(event=event)
             self.transport.write(output)
             self.waiting_for_100_continue = False
@@ -545,7 +538,7 @@ class RequestResponseCycle:
         if self.disconnected or self.response_complete:
             return {"type": "http.disconnect"}
 
-        message: "HTTPRequestEvent" = {
+        message: HTTPRequestEvent = {
             "type": "http.request",
             "body": self.body,
             "more_body": self.more_body,

uvicorn/protocols/http/httptools_impl.py

@@ -7,7 +7,7 @@ import re
 import urllib
 from asyncio.events import TimerHandle
 from collections import deque
-from typing import Any, Callable, Deque, Literal, cast
+from typing import Any, Callable, Literal, cast
 
 import httptools
 
@@ -15,7 +15,6 @@ from uvicorn._types import (
     ASGI3Application,
     ASGIReceiveEvent,
     ASGISendEvent,
-    HTTPDisconnectEvent,
     HTTPRequestEvent,
     HTTPResponseBodyEvent,
     HTTPResponseStartEvent,
@@ -50,9 +49,7 @@ def _get_status_line(status_code: int) -> bytes:
     return b"".join([b"HTTP/1.1 ", str(status_code).encode(), b" ", phrase, b"\r\n"])
 
 
-STATUS_LINE = {
-    status_code: _get_status_line(status_code) for status_code in range(100, 600)
-}
+STATUS_LINE = {status_code: _get_status_line(status_code) for status_code in range(100, 600)}
 
 
 class HttpToolsProtocol(asyncio.Protocol):
@@ -93,7 +90,7 @@ class HttpToolsProtocol(asyncio.Protocol):
         self.server: tuple[str, int] | None = None
         self.client: tuple[str, int] | None = None
         self.scheme: Literal["http", "https"] | None = None
-        self.pipeline: Deque[tuple[RequestResponseCycle, ASGI3Application]] = deque()
+        self.pipeline: deque[tuple[RequestResponseCycle, ASGI3Application]] = deque()
 
         # Per-request state
         self.scope: HTTPScope = None  # type: ignore[assignment]
@@ -227,7 +224,7 @@ class HttpToolsProtocol(asyncio.Protocol):
         self.headers = []
         self.scope = {  # type: ignore[typeddict-item]
             "type": "http",
-            "asgi": {"version": self.config.asgi_version, "spec_version": "2.3"},
+            "asgi": {"version": self.config.asgi_version, "spec_version": "2.4"},
             "http_version": "1.1",
             "server": self.server,
             "client": self.client,
@@ -268,8 +265,7 @@ class HttpToolsProtocol(asyncio.Protocol):
 
         # Handle 503 responses when 'limit_concurrency' is exceeded.
         if self.limit_concurrency is not None and (
-            len(self.connections) >= self.limit_concurrency
-            or len(self.tasks) >= self.limit_concurrency
+            len(self.connections) >= self.limit_concurrency or len(self.tasks) >= self.limit_concurrency
         ):
             app = service_unavailable
             message = "Exceeded concurrency limit."
@@ -302,9 +298,7 @@ class HttpToolsProtocol(asyncio.Protocol):
             self.pipeline.appendleft((self.cycle, app))
 
     def on_body(self, body: bytes) -> None:
-        if (
-            self.parser.should_upgrade() and self._should_upgrade()
-        ) or self.cycle.response_complete:
+        if (self.parser.should_upgrade() and self._should_upgrade()) or self.cycle.response_complete:
             return
         self.cycle.body += body
         if len(self.cycle.body) > HIGH_WATER_LIMIT:
@@ -312,9 +306,7 @@ class HttpToolsProtocol(asyncio.Protocol):
         self.cycle.message_event.set()
 
     def on_message_complete(self) -> None:
-        if (
-            self.parser.should_upgrade() and self._should_upgrade()
-        ) or self.cycle.response_complete:
+        if (self.parser.should_upgrade() and self._should_upgrade()) or self.cycle.response_complete:
             return
         self.cycle.more_body = False
         self.cycle.message_event.set()
@@ -376,7 +368,7 @@ class HttpToolsProtocol(asyncio.Protocol):
 class RequestResponseCycle:
     def __init__(
         self,
-        scope: "HTTPScope",
+        scope: HTTPScope,
         transport: asyncio.Transport,
         flow: FlowControl,
         logger: logging.Logger,
@@ -414,7 +406,7 @@ class RequestResponseCycle:
         self.expected_content_length = 0
 
     # ASGI exception wrapper
-    async def run_asgi(self, app: "ASGI3Application") -> None:
+    async def run_asgi(self, app: ASGI3Application) -> None:
         try:
             result = await app(  # type: ignore[func-returns-value]
                 self.scope, self.receive, self.send
@@ -443,7 +435,7 @@ class RequestResponseCycle:
             self.on_response = lambda: None
 
     async def send_500_response(self) -> None:
-        response_start_event: "HTTPResponseStartEvent" = {
+        response_start_event: HTTPResponseStartEvent = {
             "type": "http.response.start",
             "status": 500,
             "headers": [
@@ -452,7 +444,7 @@ class RequestResponseCycle:
             ],
         }
         await self.send(response_start_event)
-        response_body_event: "HTTPResponseBodyEvent" = {
+        response_body_event: HTTPResponseBodyEvent = {
             "type": "http.response.body",
             "body": b"Internal Server Error",
             "more_body": False,
@@ -460,7 +452,7 @@ class RequestResponseCycle:
         await self.send(response_body_event)
 
     # ASGI interface
-    async def send(self, message: "ASGISendEvent") -> None:
+    async def send(self, message: ASGISendEvent) -> None:
         message_type = message["type"]
 
         if self.flow.write_paused and not self.disconnected:
@@ -515,11 +507,7 @@ class RequestResponseCycle:
                     self.keep_alive = False
                 content.extend([name, b": ", value, b"\r\n"])
 
-            if (
-                self.chunked_encoding is None
-                and self.scope["method"] != "HEAD"
-                and status_code not in (204, 304)
-            ):
+            if self.chunked_encoding is None and self.scope["method"] != "HEAD" and status_code not in (204, 304):
                 # Neither content-length nor transfer-encoding specified
                 self.chunked_encoding = True
                 content.append(b"transfer-encoding: chunked\r\n")
@@ -570,7 +558,7 @@ class RequestResponseCycle:
             msg = "Unexpected ASGI message '%s' sent, after response already completed."
             raise RuntimeError(msg % message_type)
 
-    async def receive(self) -> "ASGIReceiveEvent":
+    async def receive(self) -> ASGIReceiveEvent:
         if self.waiting_for_100_continue and not self.transport.is_closing():
             self.transport.write(b"HTTP/1.1 100 Continue\r\n\r\n")
             self.waiting_for_100_continue = False
@@ -580,15 +568,8 @@ class RequestResponseCycle:
             await self.message_event.wait()
             self.message_event.clear()
 
-        message: HTTPDisconnectEvent | HTTPRequestEvent
         if self.disconnected or self.response_complete:
-            message = {"type": "http.disconnect"}
-        else:
-            message = {
-                "type": "http.request",
-                "body": self.body,
-                "more_body": self.more_body,
-            }
-            self.body = b""
-
+            return {"type": "http.disconnect"}
+        message: HTTPRequestEvent = {"type": "http.request", "body": self.body, "more_body": self.more_body}
+        self.body = b""
         return message

uvicorn/protocols/utils.py

@@ -53,7 +53,5 @@ def get_client_addr(scope: WWWScope) -> str:
 def get_path_with_query_string(scope: WWWScope) -> str:
     path_with_query_string = urllib.parse.quote(scope["path"])
     if scope["query_string"]:
-        path_with_query_string = "{}?{}".format(
-            path_with_query_string, scope["query_string"].decode("ascii")
-        )
+        path_with_query_string = "{}?{}".format(path_with_query_string, scope["query_string"].decode("ascii"))
     return path_with_query_string

uvicorn/protocols/websockets/auto.py

@@ -1,7 +1,9 @@
+from __future__ import annotations
+
 import asyncio
 import typing
 
-AutoWebSocketsProtocol: typing.Optional[typing.Callable[..., asyncio.Protocol]]
+AutoWebSocketsProtocol: typing.Callable[..., asyncio.Protocol] | None
 try:
     import websockets  # noqa
 except ImportError:  # pragma: no cover

uvicorn/protocols/websockets/websockets_impl.py

@@ -3,16 +3,7 @@ from __future__ import annotations
 import asyncio
 import http
 import logging
-from typing import (
-    Any,
-    List,
-    Literal,
-    Optional,
-    Sequence,
-    Tuple,
-    Union,
-    cast,
-)
+from typing import Any, Literal, Optional, Sequence, cast
 from urllib.parse import unquote
 
 import websockets
@@ -61,7 +52,7 @@ class Server:
 
 
 class WebSocketProtocol(WebSocketServerProtocol):
-    extra_headers: List[Tuple[str, str]]
+    extra_headers: list[tuple[str, str]]
 
     def __init__(
         self,
@@ -117,8 +108,7 @@ class WebSocketProtocol(WebSocketServerProtocol):
         )
         self.server_header = None
         self.extra_headers = [
-            (name.decode("latin-1"), value.decode("latin-1"))
-            for name, value in server_state.default_headers
+            (name.decode("latin-1"), value.decode("latin-1")) for name, value in server_state.default_headers
         ]
 
     def connection_made(  # type: ignore[override]
@@ -136,16 +126,14 @@ class WebSocketProtocol(WebSocketServerProtocol):
 
         super().connection_made(transport)
 
-    def connection_lost(self, exc: Optional[Exception]) -> None:
+    def connection_lost(self, exc: Exception | None) -> None:
         self.connections.remove(self)
 
         if self.logger.isEnabledFor(TRACE_LOG_LEVEL):
             prefix = "%s:%d - " % self.client if self.client else ""
             self.logger.log(TRACE_LOG_LEVEL, "%sWebSocket connection lost", prefix)
 
-        self.lost_connection_before_handshake = (
-            not self.handshake_completed_event.is_set()
-        )
+        self.lost_connection_before_handshake = not self.handshake_completed_event.is_set()
         self.handshake_completed_event.set()
         super().connection_lost(exc)
         if exc is None:
@@ -162,9 +150,7 @@ class WebSocketProtocol(WebSocketServerProtocol):
     def on_task_complete(self, task: asyncio.Task) -> None:
         self.tasks.discard(task)
 
-    async def process_request(
-        self, path: str, headers: Headers
-    ) -> Optional[HTTPResponse]:
+    async def process_request(self, path: str, headers: Headers) -> HTTPResponse | None:
         """
         This hook is called to determine if the websocket should return
         an HTTP response and close.
@@ -212,8 +198,8 @@ class WebSocketProtocol(WebSocketServerProtocol):
         return self.initial_response
 
     def process_subprotocol(
-        self, headers: Headers, available_subprotocols: Optional[Sequence[Subprotocol]]
-    ) -> Optional[Subprotocol]:
+        self, headers: Headers, available_subprotocols: Sequence[Subprotocol] | None
+    ) -> Subprotocol | None:
         """
         We override the standard 'process_subprotocol' behavior here so that
         we return whatever subprotocol is sent in the 'accept' message.
@@ -223,8 +209,7 @@ class WebSocketProtocol(WebSocketServerProtocol):
     def send_500_response(self) -> None:
         msg = b"Internal Server Error"
         content = [
-            b"HTTP/1.1 500 Internal Server Error\r\n"
-            b"content-type: text/plain; charset=utf-8\r\n",
+            b"HTTP/1.1 500 Internal Server Error\r\n" b"content-type: text/plain; charset=utf-8\r\n",
             b"content-length: " + str(len(msg)).encode("ascii") + b"\r\n",
             b"connection: close\r\n",
             b"\r\n",
@@ -278,7 +263,7 @@ class WebSocketProtocol(WebSocketServerProtocol):
                 await self.handshake_completed_event.wait()
                 self.transport.close()
 
-    async def asgi_send(self, message: "ASGISendEvent") -> None:
+    async def asgi_send(self, message: ASGISendEvent) -> None:
         message_type = message["type"]
 
         if not self.handshake_started_event.is_set():
@@ -290,9 +275,7 @@ class WebSocketProtocol(WebSocketServerProtocol):
                     get_path_with_query_string(self.scope),
                 )
                 self.initial_response = None
-                self.accepted_subprotocol = cast(
-                    Optional[Subprotocol], message.get("subprotocol")
-                )
+                self.accepted_subprotocol = cast(Optional[Subprotocol], message.get("subprotocol"))
                 if "headers" in message:
                     self.extra_headers.extend(
                         # ASGI spec requires bytes
@@ -324,8 +307,7 @@ class WebSocketProtocol(WebSocketServerProtocol):
                 # websockets requires the status to be an enum. look it up.
                 status = http.HTTPStatus(message["status"])
                 headers = [
-                    (name.decode("latin-1"), value.decode("latin-1"))
-                    for name, value in message.get("headers", [])
+                    (name.decode("latin-1"), value.decode("latin-1")) for name, value in message.get("headers", [])
                 ]
                 self.initial_response = (status, headers, b"")
                 self.handshake_started_event.set()
@@ -356,10 +338,7 @@ class WebSocketProtocol(WebSocketServerProtocol):
                     self.closed_event.set()
 
                 else:
-                    msg = (
-                        "Expected ASGI message 'websocket.send' or 'websocket.close',"
-                        " but got '%s'."
-                    )
+                    msg = "Expected ASGI message 'websocket.send' or 'websocket.close'," " but got '%s'."
                     raise RuntimeError(msg % message_type)
             except ConnectionClosed as exc:
                 raise ClientDisconnected from exc
@@ -372,24 +351,16 @@ class WebSocketProtocol(WebSocketServerProtocol):
                 if not message.get("more_body", False):
                     self.closed_event.set()
             else:
-                msg = (
-                    "Expected ASGI message 'websocket.http.response.body' "
-                    "but got '%s'."
-                )
+                msg = "Expected ASGI message 'websocket.http.response.body' " "but got '%s'."
                 raise RuntimeError(msg % message_type)
 
         else:
-            msg = (
-                "Unexpected ASGI message '%s', after sending 'websocket.close' "
-                "or response already completed."
-            )
+            msg = "Unexpected ASGI message '%s', after sending 'websocket.close' " "or response already completed."
             raise RuntimeError(msg % message_type)
 
     async def asgi_receive(
         self,
-    ) -> Union[
-        "WebSocketDisconnectEvent", "WebSocketConnectEvent", "WebSocketReceiveEvent"
-    ]:
+    ) -> WebSocketDisconnectEvent | WebSocketConnectEvent | WebSocketReceiveEvent:
         if not self.connect_sent:
             self.connect_sent = True
             return {"type": "websocket.connect"}

uvicorn/protocols/websockets/wsproto_impl.py

@@ -168,7 +168,7 @@ class WSProtocol(asyncio.Protocol):
         path = unquote(raw_path)
         full_path = self.root_path + path
         full_raw_path = self.root_path.encode("ascii") + raw_path.encode("ascii")
-        self.scope: "WebSocketScope" = {
+        self.scope: WebSocketScope = {
             "type": "websocket",
             "asgi": {"version": self.config.asgi_version, "spec_version": "2.4"},
             "http_version": "1.1",
@@ -224,14 +224,8 @@ class WSProtocol(asyncio.Protocol):
             (b"content-type", b"text/plain; charset=utf-8"),
             (b"connection", b"close"),
         ]
-        output = self.conn.send(
-            wsproto.events.RejectConnection(
-                status_code=500, headers=headers, has_body=True
-            )
-        )
-        output += self.conn.send(
-            wsproto.events.RejectData(data=b"Internal Server Error")
-        )
+        output = self.conn.send(wsproto.events.RejectConnection(status_code=500, headers=headers, has_body=True))
+        output += self.conn.send(wsproto.events.RejectData(data=b"Internal Server Error"))
         self.transport.write(output)
 
     async def run_asgi(self) -> None:
@@ -269,7 +263,7 @@ class WSProtocol(asyncio.Protocol):
                 )
                 subprotocol = message.get("subprotocol")
                 extra_headers = self.default_headers + list(message.get("headers", []))
-                extensions: typing.List[Extension] = []
+                extensions: list[Extension] = []
                 if self.config.ws_per_message_deflate:
                     extensions.append(PerMessageDeflate())
                 if not self.transport.is_closing():
@@ -343,21 +337,14 @@ class WSProtocol(asyncio.Protocol):
                     self.close_sent = True
                     code = message.get("code", 1000)
                     reason = message.get("reason", "") or ""
-                    self.queue.put_nowait(
-                        {"type": "websocket.disconnect", "code": code}
-                    )
-                    output = self.conn.send(
-                        wsproto.events.CloseConnection(code=code, reason=reason)
-                    )
+                    self.queue.put_nowait({"type": "websocket.disconnect", "code": code})
+                    output = self.conn.send(wsproto.events.CloseConnection(code=code, reason=reason))
                     if not self.transport.is_closing():
                         self.transport.write(output)
                         self.transport.close()
 
                 else:
-                    msg = (
-                        "Expected ASGI message 'websocket.send' or 'websocket.close',"
-                        " but got '%s'."
-                    )
+                    msg = "Expected ASGI message 'websocket.send' or 'websocket.close'," " but got '%s'."
                     raise RuntimeError(msg % message_type)
             except LocalProtocolError as exc:
                 raise ClientDisconnected from exc
@@ -365,24 +352,17 @@ class WSProtocol(asyncio.Protocol):
             if message_type == "websocket.http.response.body":
                 message = typing.cast("WebSocketResponseBodyEvent", message)
                 body_finished = not message.get("more_body", False)
-                reject_data = events.RejectData(
-                    data=message["body"], body_finished=body_finished
-                )
+                reject_data = events.RejectData(data=message["body"], body_finished=body_finished)
                 output = self.conn.send(reject_data)
                 self.transport.write(output)
 
                 if body_finished:
-                    self.queue.put_nowait(
-                        {"type": "websocket.disconnect", "code": 1006}
-                    )
+                    self.queue.put_nowait({"type": "websocket.disconnect", "code": 1006})
                     self.close_sent = True
                     self.transport.close()
 
             else:
-                msg = (
-                    "Expected ASGI message 'websocket.http.response.body' "
-                    "but got '%s'."
-                )
+                msg = "Expected ASGI message 'websocket.http.response.body' " "but got '%s'."
                 raise RuntimeError(msg % message_type)
 
         else:

uvicorn/server.py

@@ -126,18 +126,14 @@ class Server:
                 is_windows = platform.system() == "Windows"
                 if config.workers > 1 and is_windows:  # pragma: py-not-win32
                     sock = _share_socket(sock)  # type: ignore[assignment]
-                server = await loop.create_server(
-                    create_protocol, sock=sock, ssl=config.ssl, backlog=config.backlog
-                )
+                server = await loop.create_server(create_protocol, sock=sock, ssl=config.ssl, backlog=config.backlog)
                 self.servers.append(server)
             listeners = sockets
 
         elif config.fd is not None:  # pragma: py-win32
             # Use an existing socket, from a file descriptor.
             sock = socket.fromfd(config.fd, socket.AF_UNIX, socket.SOCK_STREAM)
-            server = await loop.create_server(
-                create_protocol, sock=sock, ssl=config.ssl, backlog=config.backlog
-            )
+            server = await loop.create_server(create_protocol, sock=sock, ssl=config.ssl, backlog=config.backlog)
             assert server.sockets is not None  # mypy
             listeners = server.sockets
             self.servers = [server]
@@ -194,9 +190,7 @@ class Server:
             )
 
         elif config.uds is not None:  # pragma: py-win32
-            logger.info(
-                "Uvicorn running on unix socket %s (Press CTRL+C to quit)", config.uds
-            )
+            logger.info("Uvicorn running on unix socket %s (Press CTRL+C to quit)", config.uds)
 
         else:
             addr_format = "%s://%s:%d"
@@ -211,11 +205,7 @@ class Server:
 
             protocol_name = "https" if config.ssl else "http"
             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)"
             logger.info(
                 message,
                 protocol_name,
@@ -244,9 +234,7 @@ class Server:
             else:
                 date_header = []
 
-            self.server_state.default_headers = (
-                date_header + self.config.encoded_headers
-            )
+            self.server_state.default_headers = date_header + self.config.encoded_headers
 
             # Callback to `callback_notify` once every `timeout_notify` seconds.
             if self.config.callback_notify is not None:

uvicorn/supervisors/__init__.py

@@ -1,10 +1,12 @@
-from typing import TYPE_CHECKING, Type
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 
 from uvicorn.supervisors.basereload import BaseReload
 from uvicorn.supervisors.multiprocess import Multiprocess
 
 if TYPE_CHECKING:
-    ChangeReload: Type[BaseReload]
+    ChangeReload: type[BaseReload]
 else:
     try:
         from uvicorn.supervisors.watchfilesreload import (

uvicorn/supervisors/basereload.py

@@ -81,9 +81,7 @@ class BaseReload:
         for sig in HANDLED_SIGNALS:
             signal.signal(sig, self.signal_handler)
 
-        self.process = get_subprocess(
-            config=self.config, target=self.target, sockets=self.sockets
-        )
+        self.process = get_subprocess(config=self.config, target=self.target, sockets=self.sockets)
         self.process.start()
 
     def restart(self) -> None:
@@ -95,9 +93,7 @@ class BaseReload:
             self.process.terminate()
         self.process.join()
 
-        self.process = get_subprocess(
-            config=self.config, target=self.target, sockets=self.sockets
-        )
+        self.process = get_subprocess(config=self.config, target=self.target, sockets=self.sockets)
         self.process.start()
 
     def shutdown(self) -> None:
@@ -110,10 +106,8 @@ class BaseReload:
         for sock in self.sockets:
             sock.close()
 
-        message = "Stopping reloader process [{}]".format(str(self.pid))
-        color_message = "Stopping reloader process [{}]".format(
-            click.style(str(self.pid), fg="cyan", bold=True)
-        )
+        message = f"Stopping reloader process [{str(self.pid)}]"
+        color_message = "Stopping reloader process [{}]".format(click.style(str(self.pid), fg="cyan", bold=True))
         logger.info(message, extra={"color_message": color_message})
 
     def should_restart(self) -> list[Path] | None:

uvicorn/supervisors/multiprocess.py

@@ -48,19 +48,15 @@ class Multiprocess:
         self.shutdown()
 
     def startup(self) -> None:
-        message = "Started parent process [{}]".format(str(self.pid))
-        color_message = "Started parent process [{}]".format(
-            click.style(str(self.pid), fg="cyan", bold=True)
-        )
+        message = f"Started parent process [{str(self.pid)}]"
+        color_message = "Started parent process [{}]".format(click.style(str(self.pid), fg="cyan", bold=True))
         logger.info(message, extra={"color_message": color_message})
 
         for sig in HANDLED_SIGNALS:
             signal.signal(sig, self.signal_handler)
 
         for _idx in range(self.config.workers):
-            process = get_subprocess(
-                config=self.config, target=self.target, sockets=self.sockets
-            )
+            process = get_subprocess(config=self.config, target=self.target, sockets=self.sockets)
             process.start()
             self.processes.append(process)
 
@@ -69,8 +65,6 @@ class Multiprocess:
             process.terminate()
             process.join()
 
-        message = "Stopping parent process [{}]".format(str(self.pid))
-        color_message = "Stopping parent process [{}]".format(
-            click.style(str(self.pid), fg="cyan", bold=True)
-        )
+        message = f"Stopping parent process [{str(self.pid)}]"
+        color_message = "Stopping parent process [{}]".format(click.style(str(self.pid), fg="cyan", bold=True))
         logger.info(message, extra={"color_message": color_message})