uvicorn 0.24.0.post1__tar.gz → 0.25.0__tar.gz

{uvicorn-0.24.0.post1 → uvicorn-0.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: uvicorn
-Version: 0.24.0.post1
+Version: 0.25.0
 Summary: The lightning-fast ASGI server.
 Project-URL: Changelog, https://github.com/encode/uvicorn/blob/master/CHANGELOG.md
 Project-URL: Funding, https://github.com/sponsors/encode
@@ -28,11 +28,11 @@ Requires-Dist: click>=7.0
 Requires-Dist: h11>=0.8
 Requires-Dist: typing-extensions>=4.0; python_version < '3.11'
 Provides-Extra: standard
-Requires-Dist: colorama>=0.4; sys_platform == 'win32' and extra == 'standard'
+Requires-Dist: colorama>=0.4; (sys_platform == 'win32') and extra == 'standard'
 Requires-Dist: httptools>=0.5.0; extra == 'standard'
 Requires-Dist: python-dotenv>=0.13; extra == 'standard'
 Requires-Dist: pyyaml>=5.1; extra == 'standard'
-Requires-Dist: uvloop!=0.15.0,!=0.15.1,>=0.14.0; sys_platform != 'win32' and (sys_platform != 'cygwin' and platform_python_implementation != 'PyPy') and extra == 'standard'
+Requires-Dist: uvloop!=0.15.0,!=0.15.1,>=0.14.0; (sys_platform != 'win32' and (sys_platform != 'cygwin' and platform_python_implementation != 'PyPy')) and extra == 'standard'
 Requires-Dist: watchfiles>=0.13; extra == 'standard'
 Requires-Dist: websockets>=10.4; extra == 'standard'
 Description-Content-Type: text/markdown

{uvicorn-0.24.0.post1 → uvicorn-0.25.0}/pyproject.toml

@@ -64,7 +64,7 @@ include = ["/uvicorn"]
 select = ["E", "F", "I"]
 ignore = ["B904", "B028"]
 
-[tool.ruff.isort]
+[tool.ruff.lint.isort]
 combine-as-imports = true
 
 [tool.mypy]

{uvicorn-0.24.0.post1 → uvicorn-0.25.0}/uvicorn/__init__.py

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

{uvicorn-0.24.0.post1 → uvicorn-0.25.0}/uvicorn/_types.py

@@ -124,14 +124,14 @@ class HTTPResponseDebugEvent(TypedDict):
 class HTTPResponseStartEvent(TypedDict):
     type: Literal["http.response.start"]
     status: int
-    headers: Iterable[Tuple[bytes, bytes]]
+    headers: NotRequired[Iterable[Tuple[bytes, bytes]]]
     trailers: NotRequired[bool]
 
 
 class HTTPResponseBodyEvent(TypedDict):
     type: Literal["http.response.body"]
     body: bytes
-    more_body: bool
+    more_body: NotRequired[bool]
 
 
 class HTTPResponseTrailersEvent(TypedDict):
@@ -156,20 +156,38 @@ class WebSocketConnectEvent(TypedDict):
 
 class WebSocketAcceptEvent(TypedDict):
     type: Literal["websocket.accept"]
-    subprotocol: Optional[str]
-    headers: Iterable[Tuple[bytes, bytes]]
+    subprotocol: NotRequired[Optional[str]]
+    headers: NotRequired[Iterable[Tuple[bytes, bytes]]]
+
+
+class _WebSocketReceiveEventBytes(TypedDict):
+    type: Literal["websocket.receive"]
+    bytes: bytes
+    text: NotRequired[None]
 
 
-class WebSocketReceiveEvent(TypedDict):
+class _WebSocketReceiveEventText(TypedDict):
     type: Literal["websocket.receive"]
-    bytes: Optional[bytes]
-    text: Optional[str]
+    bytes: NotRequired[None]
+    text: str
+
+
+WebSocketReceiveEvent = Union[_WebSocketReceiveEventBytes, _WebSocketReceiveEventText]
 
 
-class WebSocketSendEvent(TypedDict):
+class _WebSocketSendEventBytes(TypedDict):
     type: Literal["websocket.send"]
-    bytes: Optional[bytes]
-    text: Optional[str]
+    bytes: bytes
+    text: NotRequired[None]
+
+
+class _WebSocketSendEventText(TypedDict):
+    type: Literal["websocket.send"]
+    bytes: NotRequired[None]
+    text: str
+
+
+WebSocketSendEvent = Union[_WebSocketSendEventBytes, _WebSocketSendEventText]
 
 
 class WebSocketResponseStartEvent(TypedDict):
@@ -181,7 +199,7 @@ class WebSocketResponseStartEvent(TypedDict):
 class WebSocketResponseBodyEvent(TypedDict):
     type: Literal["websocket.http.response.body"]
     body: bytes
-    more_body: bool
+    more_body: NotRequired[bool]
 
 
 class WebSocketDisconnectEvent(TypedDict):
@@ -191,8 +209,8 @@ class WebSocketDisconnectEvent(TypedDict):
 
 class WebSocketCloseEvent(TypedDict):
     type: Literal["websocket.close"]
-    code: int
-    reason: Optional[str]
+    code: NotRequired[int]
+    reason: NotRequired[Optional[str]]
 
 
 class LifespanStartupEvent(TypedDict):

{uvicorn-0.24.0.post1 → uvicorn-0.25.0}/uvicorn/config.py

@@ -187,7 +187,7 @@ def _normalize_dirs(dirs: Union[List[str], str, None]) -> List[str]:
 class Config:
     def __init__(
         self,
-        app: Union["ASGIApplication", Callable, str],
+        app: Union["ASGIApplication", Callable[..., Any], str],
         host: str = "127.0.0.1",
         port: int = 8000,
         uds: Optional[str] = None,
@@ -201,7 +201,7 @@ class Config:
         ws_ping_timeout: Optional[float] = 20.0,
         ws_per_message_deflate: bool = True,
         lifespan: LifespanType = "auto",
-        env_file: Optional[Union[str, os.PathLike]] = None,
+        env_file: "str | os.PathLike[str] | None" = None,
         log_config: Optional[Union[Dict[str, Any], str]] = LOGGING_CONFIG,
         log_level: Optional[Union[str, int]] = None,
         access_log: bool = True,
@@ -226,7 +226,7 @@ class Config:
         timeout_graceful_shutdown: Optional[int] = None,
         callback_notify: Optional[Callable[..., Awaitable[None]]] = None,
         ssl_keyfile: Optional[str] = None,
-        ssl_certfile: Optional[Union[str, os.PathLike]] = None,
+        ssl_certfile: "str | os.PathLike[str] | None" = None,
         ssl_keyfile_password: Optional[str] = None,
         ssl_version: int = SSL_PROTOCOL_VERSION,
         ssl_cert_reqs: int = ssl.CERT_NONE,

{uvicorn-0.24.0.post1 → uvicorn-0.25.0}/uvicorn/main.py

@@ -156,14 +156,14 @@ def print_version(ctx: click.Context, param: click.Parameter, value: bool) -> No
     "--ws-ping-interval",
     type=float,
     default=20.0,
-    help="WebSocket ping interval",
+    help="WebSocket ping interval in seconds.",
     show_default=True,
 )
 @click.option(
     "--ws-ping-timeout",
     type=float,
     default=20.0,
-    help="WebSocket ping timeout",
+    help="WebSocket ping timeout in seconds.",
     show_default=True,
 )
 @click.option(
@@ -465,7 +465,7 @@ def main(
 
 
 def run(
-    app: typing.Union["ASGIApplication", typing.Callable, str],
+    app: typing.Union["ASGIApplication", typing.Callable[..., typing.Any], str],
     *,
     host: str = "127.0.0.1",
     port: int = 8000,
@@ -487,7 +487,7 @@ def run(
     reload_excludes: typing.Optional[typing.Union[typing.List[str], str]] = None,
     reload_delay: float = 0.25,
     workers: typing.Optional[int] = None,
-    env_file: typing.Optional[typing.Union[str, os.PathLike]] = None,
+    env_file: "str | os.PathLike[str] | None" = None,
     log_config: typing.Optional[
         typing.Union[typing.Dict[str, typing.Any], str]
     ] = LOGGING_CONFIG,
@@ -504,7 +504,7 @@ def run(
     timeout_keep_alive: int = 5,
     timeout_graceful_shutdown: typing.Optional[int] = None,
     ssl_keyfile: typing.Optional[str] = None,
-    ssl_certfile: typing.Optional[typing.Union[str, os.PathLike]] = None,
+    ssl_certfile: "str | os.PathLike[str] | None" = None,
     ssl_keyfile_password: typing.Optional[str] = None,
     ssl_version: int = SSL_PROTOCOL_VERSION,
     ssl_cert_reqs: int = ssl.CERT_NONE,

{uvicorn-0.24.0.post1 → uvicorn-0.25.0}/uvicorn/protocols/websockets/websockets_impl.py

@@ -29,6 +29,8 @@ from uvicorn._types import (
     WebSocketConnectEvent,
     WebSocketDisconnectEvent,
     WebSocketReceiveEvent,
+    WebSocketResponseBodyEvent,
+    WebSocketResponseStartEvent,
     WebSocketScope,
     WebSocketSendEvent,
 )
@@ -196,6 +198,7 @@ class WebSocketProtocol(WebSocketServerProtocol):
             "headers": asgi_headers,
             "subprotocols": subprotocols,
             "state": self.app_state.copy(),
+            "extensions": {"websocket.http.response": {}},
         }
         task = self.loop.create_task(self.run_asgi())
         task.add_done_callback(self.on_task_complete)
@@ -302,14 +305,31 @@ class WebSocketProtocol(WebSocketServerProtocol):
                 self.handshake_started_event.set()
                 self.closed_event.set()
 
+            elif message_type == "websocket.http.response.start":
+                message = cast("WebSocketResponseStartEvent", message)
+                self.logger.info(
+                    '%s - "WebSocket %s" %d',
+                    self.scope["client"],
+                    get_path_with_query_string(self.scope),
+                    message["status"],
+                )
+                # 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", [])
+                ]
+                self.initial_response = (status, headers, b"")
+                self.handshake_started_event.set()
+
             else:
                 msg = (
-                    "Expected ASGI message 'websocket.accept' or 'websocket.close', "
-                    "but got '%s'."
+                    "Expected ASGI message 'websocket.accept', 'websocket.close', "
+                    "or 'websocket.http.response.start' but got '%s'."
                 )
                 raise RuntimeError(msg % message_type)
 
-        elif not self.closed_event.is_set():
+        elif not self.closed_event.is_set() and self.initial_response is None:
             await self.handshake_completed_event.wait()
 
             if message_type == "websocket.send":
@@ -333,8 +353,25 @@ class WebSocketProtocol(WebSocketServerProtocol):
                 )
                 raise RuntimeError(msg % message_type)
 
+        elif self.initial_response is not None:
+            if message_type == "websocket.http.response.body":
+                message = cast("WebSocketResponseBodyEvent", message)
+                body = self.initial_response[2] + message["body"]
+                self.initial_response = self.initial_response[:2] + (body,)
+                if not message.get("more_body", False):
+                    self.closed_event.set()
+            else:
+                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'."
+            msg = (
+                "Unexpected ASGI message '%s', after sending 'websocket.close' "
+                "or response already completed."
+            )
             raise RuntimeError(msg % message_type)
 
     async def asgi_receive(
@@ -364,13 +401,6 @@ class WebSocketProtocol(WebSocketServerProtocol):
                 return {"type": "websocket.disconnect", "code": 1012}
             return {"type": "websocket.disconnect", "code": exc.code}
 
-        msg: WebSocketReceiveEvent = {  # type: ignore[typeddict-item]
-            "type": "websocket.receive"
-        }
-
         if isinstance(data, str):
-            msg["text"] = data
-        else:
-            msg["bytes"] = data
-
-        return msg
+            return {"type": "websocket.receive", "text": data}
+        return {"type": "websocket.receive", "bytes": data}

{uvicorn-0.24.0.post1 → uvicorn-0.25.0}/uvicorn/protocols/websockets/wsproto_impl.py

@@ -15,7 +15,8 @@ from uvicorn._types import (
     WebSocketAcceptEvent,
     WebSocketCloseEvent,
     WebSocketEvent,
-    WebSocketReceiveEvent,
+    WebSocketResponseBodyEvent,
+    WebSocketResponseStartEvent,
     WebSocketScope,
     WebSocketSendEvent,
 )
@@ -64,6 +65,9 @@ class WSProtocol(asyncio.Protocol):
         self.handshake_complete = False
         self.close_sent = False
 
+        # Rejection state
+        self.response_started = False
+
         self.conn = wsproto.WSConnection(connection_type=ConnectionType.SERVER)
 
         self.read_paused = False
@@ -172,6 +176,7 @@ class WSProtocol(asyncio.Protocol):
             "headers": headers,
             "subprotocols": event.subprotocols,
             "state": self.app_state.copy(),
+            "extensions": {"websocket.http.response": {}},
         }
         self.queue.put_nowait({"type": "websocket.connect"})
         task = self.loop.create_task(self.run_asgi())
@@ -181,11 +186,7 @@ class WSProtocol(asyncio.Protocol):
     def handle_text(self, event: events.TextMessage) -> None:
         self.text += event.data
         if event.message_finished:
-            msg: "WebSocketReceiveEvent" = {  # type: ignore[typeddict-item]
-                "type": "websocket.receive",
-                "text": self.text,
-            }
-            self.queue.put_nowait(msg)
+            self.queue.put_nowait({"type": "websocket.receive", "text": self.text})
             self.text = ""
             if not self.read_paused:
                 self.read_paused = True
@@ -195,11 +196,7 @@ class WSProtocol(asyncio.Protocol):
         self.bytes += event.data
         # todo: we may want to guard the size of self.bytes and self.text
         if event.message_finished:
-            msg: "WebSocketReceiveEvent" = {  # type: ignore[typeddict-item]
-                "type": "websocket.receive",
-                "bytes": self.bytes,
-            }
-            self.queue.put_nowait(msg)
+            self.queue.put_nowait({"type": "websocket.receive", "bytes": self.bytes})
             self.bytes = b""
             if not self.read_paused:
                 self.read_paused = True
@@ -215,6 +212,8 @@ class WSProtocol(asyncio.Protocol):
         self.transport.write(self.conn.send(event.response()))
 
     def send_500_response(self) -> None:
+        if self.response_started or self.handshake_complete:
+            return  # we cannot send responses anymore
         headers = [
             (b"content-type", b"text/plain; charset=utf-8"),
             (b"connection", b"close"),
@@ -234,8 +233,7 @@ class WSProtocol(asyncio.Protocol):
             result = await self.app(self.scope, self.receive, self.send)
         except BaseException:
             self.logger.exception("Exception in ASGI application\n")
-            if not self.handshake_complete:
-                self.send_500_response()
+            self.send_500_response()
             self.transport.close()
         else:
             if not self.handshake_complete:
@@ -291,14 +289,37 @@ class WSProtocol(asyncio.Protocol):
                 self.transport.write(output)
                 self.transport.close()
 
+            elif message_type == "websocket.http.response.start":
+                message = typing.cast("WebSocketResponseStartEvent", message)
+                # ensure status code is in the valid range
+                if not (100 <= message["status"] < 600):
+                    msg = "Invalid HTTP status code '%d' in response."
+                    raise RuntimeError(msg % message["status"])
+                self.logger.info(
+                    '%s - "WebSocket %s" %d',
+                    self.scope["client"],
+                    get_path_with_query_string(self.scope),
+                    message["status"],
+                )
+                self.handshake_complete = True
+                event = events.RejectConnection(
+                    status_code=message["status"],
+                    headers=list(message["headers"]),
+                    has_body=True,
+                )
+                output = self.conn.send(event)
+                self.transport.write(output)
+                self.response_started = True
+
             else:
                 msg = (
-                    "Expected ASGI message 'websocket.accept' or 'websocket.close', "
+                    "Expected ASGI message 'websocket.accept', 'websocket.close' "
+                    "or 'websocket.http.response.start' "
                     "but got '%s'."
                 )
                 raise RuntimeError(msg % message_type)
 
-        elif not self.close_sent:
+        elif not self.close_sent and not self.response_started:
             if message_type == "websocket.send":
                 message = typing.cast("WebSocketSendEvent", message)
                 bytes_data = message.get("bytes")
@@ -329,6 +350,29 @@ class WSProtocol(asyncio.Protocol):
                     " but got '%s'."
                 )
                 raise RuntimeError(msg % message_type)
+        elif self.response_started:
+            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
+                )
+                output = self.conn.send(reject_data)
+                self.transport.write(output)
+
+                if body_finished:
+                    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'."
+                )
+                raise RuntimeError(msg % message_type)
 
         else:
             msg = "Unexpected ASGI message '%s', after sending 'websocket.close'."

{uvicorn-0.24.0.post1 → uvicorn-0.25.0}/uvicorn/supervisors/watchfilesreload.py

@@ -43,6 +43,9 @@ class FileFilter:
     def __call__(self, path: Path) -> bool:
         for include_pattern in self.includes:
             if path.match(include_pattern):
+                if str(path).endswith(include_pattern):
+                    return True
+
                 for exclude_dir in self.exclude_dirs:
                     if exclude_dir in path.parents:
                         return False

{uvicorn-0.24.0.post1 → uvicorn-0.25.0}/uvicorn/supervisors/watchgodreload.py

@@ -56,6 +56,9 @@ class CustomWatcher(DefaultWatcher):
             self.watched_files[entry.path] = False
             return False
         for include_pattern in self.includes:
+            if str(entry_path).endswith(include_pattern):
+                self.watched_files[entry.path] = True
+                return True
             if entry_path.match(include_pattern):
                 for exclude_pattern in self.excludes:
                     if entry_path.match(exclude_pattern):