diff options
Diffstat (limited to 'venv/lib/python3.11/site-packages/uvicorn')
79 files changed, 0 insertions, 5189 deletions
diff --git a/venv/lib/python3.11/site-packages/uvicorn/__init__.py b/venv/lib/python3.11/site-packages/uvicorn/__init__.py deleted file mode 100644 index 4df960e..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -from uvicorn.config import Config -from uvicorn.main import Server, main, run - -__version__ = "0.29.0" -__all__ = ["main", "run", "Config", "Server"] diff --git a/venv/lib/python3.11/site-packages/uvicorn/__main__.py b/venv/lib/python3.11/site-packages/uvicorn/__main__.py deleted file mode 100644 index 8a1dc97..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/__main__.py +++ /dev/null @@ -1,4 +0,0 @@ -import uvicorn - -if __name__ == "__main__": - uvicorn.main() diff --git a/venv/lib/python3.11/site-packages/uvicorn/__pycache__/__init__.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/__pycache__/__init__.cpython-311.pyc Binary files differdeleted file mode 100644 index ca2251a..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/__pycache__/__init__.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/__pycache__/__main__.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/__pycache__/__main__.cpython-311.pyc Binary files differdeleted file mode 100644 index b9b0e05..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/__pycache__/__main__.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/__pycache__/_subprocess.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/__pycache__/_subprocess.cpython-311.pyc Binary files differdeleted file mode 100644 index 315201a..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/__pycache__/_subprocess.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/__pycache__/_types.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/__pycache__/_types.cpython-311.pyc Binary files differdeleted file mode 100644 index 9273f99..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/__pycache__/_types.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/__pycache__/config.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/__pycache__/config.cpython-311.pyc Binary files differdeleted file mode 100644 index 95e5ab1..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/__pycache__/config.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/__pycache__/importer.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/__pycache__/importer.cpython-311.pyc Binary files differdeleted file mode 100644 index 3faca2d..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/__pycache__/importer.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/__pycache__/logging.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/__pycache__/logging.cpython-311.pyc Binary files differdeleted file mode 100644 index dd70008..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/__pycache__/logging.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/__pycache__/main.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/__pycache__/main.cpython-311.pyc Binary files differdeleted file mode 100644 index 89edd30..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/__pycache__/main.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/__pycache__/server.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/__pycache__/server.cpython-311.pyc Binary files differdeleted file mode 100644 index 6244d66..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/__pycache__/server.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/__pycache__/workers.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/__pycache__/workers.cpython-311.pyc Binary files differdeleted file mode 100644 index d0ff7eb..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/__pycache__/workers.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/_subprocess.py b/venv/lib/python3.11/site-packages/uvicorn/_subprocess.py deleted file mode 100644 index 5eb8353..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/_subprocess.py +++ /dev/null @@ -1,78 +0,0 @@ -""" -Some light wrappers around Python's multiprocessing, to deal with cleanly -starting child processes. -""" -from __future__ import annotations - -import multiprocessing -import os -import sys -from multiprocessing.context import SpawnProcess -from socket import socket -from typing import Callable - -from uvicorn.config import Config - -multiprocessing.allow_connection_pickling() -spawn = multiprocessing.get_context("spawn") - - -def get_subprocess( - config: Config, - target: Callable[..., None], - sockets: list[socket], -) -> SpawnProcess: - """ - Called in the parent process, to instantiate a new child process instance. - The child is not yet started at this point. - - * config - The Uvicorn configuration instance. - * target - A callable that accepts a list of sockets. In practice this will - be the `Server.run()` method. - * sockets - A list of sockets to pass to the server. Sockets are bound once - by the parent process, and then passed to the child processes. - """ - # We pass across the stdin fileno, and reopen it in the child process. - # This is required for some debugging environments. - try: - stdin_fileno = sys.stdin.fileno() - # The `sys.stdin` can be `None`, see https://docs.python.org/3/library/sys.html#sys.__stdin__. - except (AttributeError, OSError): - stdin_fileno = None - - kwargs = { - "config": config, - "target": target, - "sockets": sockets, - "stdin_fileno": stdin_fileno, - } - - return spawn.Process(target=subprocess_started, kwargs=kwargs) - - -def subprocess_started( - config: Config, - target: Callable[..., None], - sockets: list[socket], - stdin_fileno: int | None, -) -> None: - """ - Called when the child process starts. - - * config - The Uvicorn configuration instance. - * target - A callable that accepts a list of sockets. In practice this will - be the `Server.run()` method. - * sockets - A list of sockets to pass to the server. Sockets are bound once - by the parent process, and then passed to the child processes. - * stdin_fileno - The file number of sys.stdin, so that it can be reattached - to the child process. - """ - # Re-open stdin. - if stdin_fileno is not None: - sys.stdin = os.fdopen(stdin_fileno) - - # Logging needs to be setup again for each child. - config.configure_logging() - - # Now we can call into `Server.run(sockets=sockets)` - target(sockets=sockets) diff --git a/venv/lib/python3.11/site-packages/uvicorn/_types.py b/venv/lib/python3.11/site-packages/uvicorn/_types.py deleted file mode 100644 index 7546262..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/_types.py +++ /dev/null @@ -1,293 +0,0 @@ -""" -Copyright (c) Django Software Foundation and individual contributors. -All rights reserved. - -Redistribution and use in source and binary forms, with or without modification, -are permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in the - documentation and/or other materials provided with the distribution. - - 3. Neither the name of Django nor the names of its contributors may be used - to endorse or promote products derived from this software without - specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON -ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -""" -from __future__ import annotations - -import sys -import types -from typing import ( - Any, - Awaitable, - Callable, - Iterable, - Literal, - MutableMapping, - Optional, - Protocol, - Tuple, - Type, - TypedDict, - Union, -) - -if sys.version_info >= (3, 11): # pragma: py-lt-311 - from typing import NotRequired -else: # pragma: py-gte-311 - from typing_extensions import NotRequired - -# WSGI -Environ = MutableMapping[str, Any] -ExcInfo = Tuple[Type[BaseException], BaseException, Optional[types.TracebackType]] -StartResponse = Callable[[str, Iterable[Tuple[str, str]], Optional[ExcInfo]], None] -WSGIApp = Callable[[Environ, StartResponse], Union[Iterable[bytes], BaseException]] - - -# ASGI -class ASGIVersions(TypedDict): - spec_version: str - version: Literal["2.0"] | Literal["3.0"] - - -class HTTPScope(TypedDict): - type: Literal["http"] - asgi: ASGIVersions - http_version: str - method: str - scheme: str - path: str - raw_path: bytes - query_string: bytes - root_path: str - headers: Iterable[tuple[bytes, bytes]] - client: tuple[str, int] | None - server: tuple[str, int | None] | None - state: NotRequired[dict[str, Any]] - extensions: NotRequired[dict[str, dict[object, object]]] - - -class WebSocketScope(TypedDict): - type: Literal["websocket"] - asgi: ASGIVersions - http_version: str - scheme: str - path: str - raw_path: bytes - query_string: bytes - root_path: str - headers: Iterable[tuple[bytes, bytes]] - client: tuple[str, int] | None - server: tuple[str, int | None] | None - subprotocols: Iterable[str] - state: NotRequired[dict[str, Any]] - extensions: NotRequired[dict[str, dict[object, object]]] - - -class LifespanScope(TypedDict): - type: Literal["lifespan"] - asgi: ASGIVersions - state: NotRequired[dict[str, Any]] - - -WWWScope = Union[HTTPScope, WebSocketScope] -Scope = Union[HTTPScope, WebSocketScope, LifespanScope] - - -class HTTPRequestEvent(TypedDict): - type: Literal["http.request"] - body: bytes - more_body: bool - - -class HTTPResponseDebugEvent(TypedDict): - type: Literal["http.response.debug"] - info: dict[str, object] - - -class HTTPResponseStartEvent(TypedDict): - type: Literal["http.response.start"] - status: int - headers: NotRequired[Iterable[tuple[bytes, bytes]]] - trailers: NotRequired[bool] - - -class HTTPResponseBodyEvent(TypedDict): - type: Literal["http.response.body"] - body: bytes - more_body: NotRequired[bool] - - -class HTTPResponseTrailersEvent(TypedDict): - type: Literal["http.response.trailers"] - headers: Iterable[tuple[bytes, bytes]] - more_trailers: bool - - -class HTTPServerPushEvent(TypedDict): - type: Literal["http.response.push"] - path: str - headers: Iterable[tuple[bytes, bytes]] - - -class HTTPDisconnectEvent(TypedDict): - type: Literal["http.disconnect"] - - -class WebSocketConnectEvent(TypedDict): - type: Literal["websocket.connect"] - - -class WebSocketAcceptEvent(TypedDict): - type: Literal["websocket.accept"] - subprotocol: NotRequired[str | None] - headers: NotRequired[Iterable[tuple[bytes, bytes]]] - - -class _WebSocketReceiveEventBytes(TypedDict): - type: Literal["websocket.receive"] - bytes: bytes - text: NotRequired[None] - - -class _WebSocketReceiveEventText(TypedDict): - type: Literal["websocket.receive"] - bytes: NotRequired[None] - text: str - - -WebSocketReceiveEvent = Union[_WebSocketReceiveEventBytes, _WebSocketReceiveEventText] - - -class _WebSocketSendEventBytes(TypedDict): - type: Literal["websocket.send"] - bytes: bytes - text: NotRequired[None] - - -class _WebSocketSendEventText(TypedDict): - type: Literal["websocket.send"] - bytes: NotRequired[None] - text: str - - -WebSocketSendEvent = Union[_WebSocketSendEventBytes, _WebSocketSendEventText] - - -class WebSocketResponseStartEvent(TypedDict): - type: Literal["websocket.http.response.start"] - status: int - headers: Iterable[tuple[bytes, bytes]] - - -class WebSocketResponseBodyEvent(TypedDict): - type: Literal["websocket.http.response.body"] - body: bytes - more_body: NotRequired[bool] - - -class WebSocketDisconnectEvent(TypedDict): - type: Literal["websocket.disconnect"] - code: int - - -class WebSocketCloseEvent(TypedDict): - type: Literal["websocket.close"] - code: NotRequired[int] - reason: NotRequired[str | None] - - -class LifespanStartupEvent(TypedDict): - type: Literal["lifespan.startup"] - - -class LifespanShutdownEvent(TypedDict): - type: Literal["lifespan.shutdown"] - - -class LifespanStartupCompleteEvent(TypedDict): - type: Literal["lifespan.startup.complete"] - - -class LifespanStartupFailedEvent(TypedDict): - type: Literal["lifespan.startup.failed"] - message: str - - -class LifespanShutdownCompleteEvent(TypedDict): - type: Literal["lifespan.shutdown.complete"] - - -class LifespanShutdownFailedEvent(TypedDict): - type: Literal["lifespan.shutdown.failed"] - message: str - - -WebSocketEvent = Union[WebSocketReceiveEvent, WebSocketDisconnectEvent, WebSocketConnectEvent] - - -ASGIReceiveEvent = Union[ - HTTPRequestEvent, - HTTPDisconnectEvent, - WebSocketConnectEvent, - WebSocketReceiveEvent, - WebSocketDisconnectEvent, - LifespanStartupEvent, - LifespanShutdownEvent, -] - - -ASGISendEvent = Union[ - HTTPResponseStartEvent, - HTTPResponseBodyEvent, - HTTPResponseTrailersEvent, - HTTPServerPushEvent, - HTTPDisconnectEvent, - WebSocketAcceptEvent, - WebSocketSendEvent, - WebSocketResponseStartEvent, - WebSocketResponseBodyEvent, - WebSocketCloseEvent, - LifespanStartupCompleteEvent, - LifespanStartupFailedEvent, - LifespanShutdownCompleteEvent, - LifespanShutdownFailedEvent, -] - - -ASGIReceiveCallable = Callable[[], Awaitable[ASGIReceiveEvent]] -ASGISendCallable = Callable[[ASGISendEvent], Awaitable[None]] - - -class ASGI2Protocol(Protocol): - def __init__(self, scope: Scope) -> None: - ... # pragma: no cover - - async def __call__(self, receive: ASGIReceiveCallable, send: ASGISendCallable) -> None: - ... # pragma: no cover - - -ASGI2Application = Type[ASGI2Protocol] -ASGI3Application = Callable[ - [ - Scope, - ASGIReceiveCallable, - ASGISendCallable, - ], - Awaitable[None], -] -ASGIApplication = Union[ASGI2Application, ASGI3Application] diff --git a/venv/lib/python3.11/site-packages/uvicorn/config.py b/venv/lib/python3.11/site-packages/uvicorn/config.py deleted file mode 100644 index 3cad1d9..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/config.py +++ /dev/null @@ -1,528 +0,0 @@ -from __future__ import annotations - -import asyncio -import inspect -import json -import logging -import logging.config -import os -import socket -import ssl -import sys -from pathlib import Path -from typing import Any, Awaitable, Callable, Literal - -import click - -from uvicorn._types import ASGIApplication -from uvicorn.importer import ImportFromStringError, import_from_string -from uvicorn.logging import TRACE_LOG_LEVEL -from uvicorn.middleware.asgi2 import ASGI2Middleware -from uvicorn.middleware.message_logger import MessageLoggerMiddleware -from uvicorn.middleware.proxy_headers import ProxyHeadersMiddleware -from uvicorn.middleware.wsgi import WSGIMiddleware - -HTTPProtocolType = Literal["auto", "h11", "httptools"] -WSProtocolType = Literal["auto", "none", "websockets", "wsproto"] -LifespanType = Literal["auto", "on", "off"] -LoopSetupType = Literal["none", "auto", "asyncio", "uvloop"] -InterfaceType = Literal["auto", "asgi3", "asgi2", "wsgi"] - -LOG_LEVELS: dict[str, int] = { - "critical": logging.CRITICAL, - "error": logging.ERROR, - "warning": logging.WARNING, - "info": logging.INFO, - "debug": logging.DEBUG, - "trace": TRACE_LOG_LEVEL, -} -HTTP_PROTOCOLS: dict[HTTPProtocolType, str] = { - "auto": "uvicorn.protocols.http.auto:AutoHTTPProtocol", - "h11": "uvicorn.protocols.http.h11_impl:H11Protocol", - "httptools": "uvicorn.protocols.http.httptools_impl:HttpToolsProtocol", -} -WS_PROTOCOLS: dict[WSProtocolType, str | None] = { - "auto": "uvicorn.protocols.websockets.auto:AutoWebSocketsProtocol", - "none": None, - "websockets": "uvicorn.protocols.websockets.websockets_impl:WebSocketProtocol", - "wsproto": "uvicorn.protocols.websockets.wsproto_impl:WSProtocol", -} -LIFESPAN: dict[LifespanType, str] = { - "auto": "uvicorn.lifespan.on:LifespanOn", - "on": "uvicorn.lifespan.on:LifespanOn", - "off": "uvicorn.lifespan.off:LifespanOff", -} -LOOP_SETUPS: dict[LoopSetupType, str | None] = { - "none": None, - "auto": "uvicorn.loops.auto:auto_loop_setup", - "asyncio": "uvicorn.loops.asyncio:asyncio_setup", - "uvloop": "uvicorn.loops.uvloop:uvloop_setup", -} -INTERFACES: list[InterfaceType] = ["auto", "asgi3", "asgi2", "wsgi"] - -SSL_PROTOCOL_VERSION: int = ssl.PROTOCOL_TLS_SERVER - -LOGGING_CONFIG: dict[str, Any] = { - "version": 1, - "disable_existing_loggers": False, - "formatters": { - "default": { - "()": "uvicorn.logging.DefaultFormatter", - "fmt": "%(levelprefix)s %(message)s", - "use_colors": None, - }, - "access": { - "()": "uvicorn.logging.AccessFormatter", - "fmt": '%(levelprefix)s %(client_addr)s - "%(request_line)s" %(status_code)s', # noqa: E501 - }, - }, - "handlers": { - "default": { - "formatter": "default", - "class": "logging.StreamHandler", - "stream": "ext://sys.stderr", - }, - "access": { - "formatter": "access", - "class": "logging.StreamHandler", - "stream": "ext://sys.stdout", - }, - }, - "loggers": { - "uvicorn": {"handlers": ["default"], "level": "INFO", "propagate": False}, - "uvicorn.error": {"level": "INFO"}, - "uvicorn.access": {"handlers": ["access"], "level": "INFO", "propagate": False}, - }, -} - -logger = logging.getLogger("uvicorn.error") - - -def create_ssl_context( - certfile: str | os.PathLike[str], - keyfile: str | os.PathLike[str] | None, - password: str | None, - ssl_version: int, - cert_reqs: int, - ca_certs: str | os.PathLike[str] | None, - ciphers: str | None, -) -> ssl.SSLContext: - ctx = ssl.SSLContext(ssl_version) - get_password = (lambda: password) if password else None - ctx.load_cert_chain(certfile, keyfile, get_password) - ctx.verify_mode = ssl.VerifyMode(cert_reqs) - if ca_certs: - ctx.load_verify_locations(ca_certs) - if ciphers: - ctx.set_ciphers(ciphers) - return ctx - - -def is_dir(path: Path) -> bool: - try: - if not path.is_absolute(): - path = path.resolve() - return path.is_dir() - except OSError: - return False - - -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() - - current_working_directory = Path.cwd() - for pattern in patterns_list: - # Special case for the .* pattern, otherwise this would only match - # hidden directories which is probably undesired - if pattern == ".*": - continue - patterns.append(pattern) - if is_dir(Path(pattern)): - directories.append(Path(pattern)) - else: - for match in current_working_directory.glob(pattern): - if is_dir(match): - directories.append(match) - - 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)}) - - children = [] - for j in range(len(directories)): - for k in range(j + 1, len(directories)): - if directories[j] in directories[k].parents: - children.append(directories[k]) # pragma: py-darwin - elif directories[k] in directories[j].parents: - children.append(directories[j]) - - directories = list(set(directories).difference(set(children))) - - return list(set(patterns)), directories - - -def _normalize_dirs(dirs: list[str] | str | None) -> list[str]: - if dirs is None: - return [] - if isinstance(dirs, str): - return [dirs] - return list(set(dirs)) - - -class Config: - def __init__( - self, - app: ASGIApplication | Callable[..., Any] | str, - host: str = "127.0.0.1", - port: int = 8000, - uds: str | None = None, - fd: int | None = None, - loop: LoopSetupType = "auto", - http: type[asyncio.Protocol] | HTTPProtocolType = "auto", - ws: type[asyncio.Protocol] | WSProtocolType = "auto", - ws_max_size: int = 16 * 1024 * 1024, - ws_max_queue: int = 32, - ws_ping_interval: float | None = 20.0, - ws_ping_timeout: float | None = 20.0, - ws_per_message_deflate: bool = True, - lifespan: LifespanType = "auto", - env_file: str | os.PathLike[str] | None = None, - log_config: dict[str, Any] | str | None = LOGGING_CONFIG, - log_level: str | int | None = None, - access_log: bool = True, - use_colors: bool | None = None, - interface: InterfaceType = "auto", - reload: bool = False, - reload_dirs: list[str] | str | None = None, - reload_delay: float = 0.25, - reload_includes: list[str] | str | None = None, - reload_excludes: list[str] | str | None = None, - workers: int | None = None, - proxy_headers: bool = True, - server_header: bool = True, - date_header: bool = True, - forwarded_allow_ips: list[str] | str | None = None, - root_path: str = "", - limit_concurrency: int | None = None, - limit_max_requests: int | None = None, - backlog: int = 2048, - timeout_keep_alive: int = 5, - timeout_notify: int = 30, - timeout_graceful_shutdown: int | None = None, - callback_notify: Callable[..., Awaitable[None]] | None = None, - ssl_keyfile: str | None = None, - ssl_certfile: str | os.PathLike[str] | None = None, - ssl_keyfile_password: str | None = None, - ssl_version: int = SSL_PROTOCOL_VERSION, - ssl_cert_reqs: int = ssl.CERT_NONE, - ssl_ca_certs: str | None = None, - ssl_ciphers: str = "TLSv1", - headers: list[tuple[str, str]] | None = None, - factory: bool = False, - h11_max_incomplete_event_size: int | None = None, - ): - self.app = app - self.host = host - self.port = port - self.uds = uds - self.fd = fd - self.loop = loop - self.http = http - self.ws = ws - self.ws_max_size = ws_max_size - self.ws_max_queue = ws_max_queue - self.ws_ping_interval = ws_ping_interval - self.ws_ping_timeout = ws_ping_timeout - self.ws_per_message_deflate = ws_per_message_deflate - self.lifespan = lifespan - self.log_config = log_config - self.log_level = log_level - self.access_log = access_log - self.use_colors = use_colors - self.interface = interface - self.reload = reload - self.reload_delay = reload_delay - self.workers = workers or 1 - self.proxy_headers = proxy_headers - self.server_header = server_header - self.date_header = date_header - self.root_path = root_path - self.limit_concurrency = limit_concurrency - self.limit_max_requests = limit_max_requests - self.backlog = backlog - self.timeout_keep_alive = timeout_keep_alive - self.timeout_notify = timeout_notify - self.timeout_graceful_shutdown = timeout_graceful_shutdown - self.callback_notify = callback_notify - self.ssl_keyfile = ssl_keyfile - self.ssl_certfile = ssl_certfile - self.ssl_keyfile_password = ssl_keyfile_password - self.ssl_version = ssl_version - self.ssl_cert_reqs = ssl_cert_reqs - self.ssl_ca_certs = ssl_ca_certs - self.ssl_ciphers = ssl_ciphers - self.headers: list[tuple[str, str]] = headers or [] - self.encoded_headers: list[tuple[bytes, bytes]] = [] - self.factory = factory - self.h11_max_incomplete_event_size = h11_max_incomplete_event_size - - self.loaded = False - self.configure_logging() - - self.reload_dirs: list[Path] = [] - self.reload_dirs_excludes: list[Path] = [] - self.reload_includes: list[str] = [] - self.reload_excludes: list[str] = [] - - 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." - ) - - if self.should_reload: - reload_dirs = _normalize_dirs(reload_dirs) - 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_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: - try: - self.reload_dirs.remove(reload_directory) - except ValueError: - pass - - for pattern in self.reload_excludes: - if pattern in self.reload_includes: - self.reload_includes.remove(pattern) - - if not self.reload_dirs: - if reload_dirs: - logger.warning( - "Provided reload directories %s did not contain valid " - + "directories, watching current working directory.", - reload_dirs, - ) - self.reload_dirs = [Path(os.getcwd())] - - logger.info( - "Will watch for changes in these directories: %s", - sorted(list(map(str, self.reload_dirs))), - ) - - if env_file is not None: - from dotenv import load_dotenv - - logger.info("Loading environment from '%s'", env_file) - load_dotenv(dotenv_path=env_file) - - if workers is None and "WEB_CONCURRENCY" in os.environ: - self.workers = int(os.environ["WEB_CONCURRENCY"]) - - 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") - else: - self.forwarded_allow_ips = forwarded_allow_ips - - if self.reload and self.workers > 1: - logger.warning('"workers" flag is ignored when reloading is enabled.') - - @property - def asgi_version(self) -> Literal["2.0", "3.0"]: - mapping: dict[str, Literal["2.0", "3.0"]] = { - "asgi2": "2.0", - "asgi3": "3.0", - "wsgi": "3.0", - } - return mapping[self.interface] - - @property - def is_ssl(self) -> bool: - return bool(self.ssl_keyfile or self.ssl_certfile) - - @property - def use_subprocess(self) -> bool: - return bool(self.reload or self.workers > 1) - - def configure_logging(self) -> None: - logging.addLevelName(TRACE_LOG_LEVEL, "TRACE") - - 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 - logging.config.dictConfig(self.log_config) - elif self.log_config.endswith(".json"): - with open(self.log_config) as file: - loaded_config = json.load(file) - logging.config.dictConfig(loaded_config) - elif self.log_config.endswith((".yaml", ".yml")): - # Install the PyYAML package or the uvicorn[standard] optional - # dependencies to enable this functionality. - import yaml - - with open(self.log_config) as file: - loaded_config = yaml.safe_load(file) - logging.config.dictConfig(loaded_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) - - if self.log_level is not None: - if isinstance(self.log_level, str): - log_level = LOG_LEVELS[self.log_level] - else: - log_level = self.log_level - logging.getLogger("uvicorn.error").setLevel(log_level) - logging.getLogger("uvicorn.access").setLevel(log_level) - logging.getLogger("uvicorn.asgi").setLevel(log_level) - if self.access_log is False: - logging.getLogger("uvicorn.access").handlers = [] - logging.getLogger("uvicorn.access").propagate = False - - def load(self) -> None: - assert not self.loaded - - if self.is_ssl: - assert self.ssl_certfile - self.ssl: ssl.SSLContext | None = create_ssl_context( - keyfile=self.ssl_keyfile, - certfile=self.ssl_certfile, - password=self.ssl_keyfile_password, - ssl_version=self.ssl_version, - cert_reqs=self.ssl_cert_reqs, - ca_certs=self.ssl_ca_certs, - ciphers=self.ssl_ciphers, - ) - else: - self.ssl = None - - 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 - else encoded_headers - ) - - if isinstance(self.http, str): - http_protocol_class = import_from_string(HTTP_PROTOCOLS[self.http]) - self.http_protocol_class: type[asyncio.Protocol] = http_protocol_class - else: - self.http_protocol_class = self.http - - if isinstance(self.ws, str): - ws_protocol_class = import_from_string(WS_PROTOCOLS[self.ws]) - self.ws_protocol_class: type[asyncio.Protocol] | None = ws_protocol_class - else: - self.ws_protocol_class = self.ws - - self.lifespan_class = import_from_string(LIFESPAN[self.lifespan]) - - try: - self.loaded_app = import_from_string(self.app) - except ImportFromStringError as exc: - logger.error("Error loading ASGI app. %s" % exc) - sys.exit(1) - - try: - self.loaded_app = self.loaded_app() - except TypeError as exc: - if self.factory: - logger.error("Error loading ASGI app factory: %s", exc) - sys.exit(1) - else: - if not self.factory: - logger.warning( - "ASGI app factory detected. Using it, " "but please consider setting the --factory flag explicitly." - ) - - if self.interface == "auto": - if inspect.isclass(self.loaded_app): - use_asgi_3 = hasattr(self.loaded_app, "__await__") - elif inspect.isfunction(self.loaded_app): - use_asgi_3 = asyncio.iscoroutinefunction(self.loaded_app) - else: - call = getattr(self.loaded_app, "__call__", None) - use_asgi_3 = asyncio.iscoroutinefunction(call) - self.interface = "asgi3" if use_asgi_3 else "asgi2" - - if self.interface == "wsgi": - self.loaded_app = WSGIMiddleware(self.loaded_app) - self.ws_protocol_class = None - elif self.interface == "asgi2": - self.loaded_app = ASGI2Middleware(self.loaded_app) - - 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 = True - - def setup_event_loop(self) -> None: - loop_setup: Callable | None = import_from_string(LOOP_SETUPS[self.loop]) - if loop_setup is not None: - loop_setup(use_subprocess=self.use_subprocess) - - def bind_socket(self) -> socket.socket: - logger_args: list[str | int] - if self.uds: # pragma: py-win32 - path = self.uds - sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) - try: - sock.bind(path) - uds_perms = 0o666 - os.chmod(self.uds, uds_perms) - except OSError as exc: - logger.error(exc) - sys.exit(1) - - 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)" - 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)" - logger_args = [sock.getsockname()] - else: - family = socket.AF_INET - addr_format = "%s://%s:%d" - - if self.host and ":" in self.host: # pragma: py-win32 - # It's an IPv6 address. - family = socket.AF_INET6 - addr_format = "%s://[%s]:%d" - - sock = socket.socket(family=family) - sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) - try: - sock.bind((self.host, self.port)) - except OSError as exc: - logger.error(exc) - 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)" - 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}) - sock.set_inheritable(True) - return sock - - @property - def should_reload(self) -> bool: - return isinstance(self.app, str) and self.reload diff --git a/venv/lib/python3.11/site-packages/uvicorn/importer.py b/venv/lib/python3.11/site-packages/uvicorn/importer.py deleted file mode 100644 index f77520e..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/importer.py +++ /dev/null @@ -1,34 +0,0 @@ -import importlib -from typing import Any - - -class ImportFromStringError(Exception): - pass - - -def import_from_string(import_str: Any) -> Any: - if not isinstance(import_str, str): - return import_str - - 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>".' - raise ImportFromStringError(message.format(import_str=import_str)) - - try: - module = importlib.import_module(module_str) - except ModuleNotFoundError as exc: - if exc.name != module_str: - raise exc from None - message = 'Could not import module "{module_str}".' - raise ImportFromStringError(message.format(module_str=module_str)) - - instance = module - try: - for attr_str in attrs_str.split("."): - 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)) - - return instance diff --git a/venv/lib/python3.11/site-packages/uvicorn/lifespan/__init__.py b/venv/lib/python3.11/site-packages/uvicorn/lifespan/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/lifespan/__init__.py +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/lifespan/__pycache__/__init__.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/lifespan/__pycache__/__init__.cpython-311.pyc Binary files differdeleted file mode 100644 index 4efab48..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/lifespan/__pycache__/__init__.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/lifespan/__pycache__/off.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/lifespan/__pycache__/off.cpython-311.pyc Binary files differdeleted file mode 100644 index ca66309..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/lifespan/__pycache__/off.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/lifespan/__pycache__/on.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/lifespan/__pycache__/on.cpython-311.pyc Binary files differdeleted file mode 100644 index 52c3ab4..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/lifespan/__pycache__/on.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/lifespan/off.py b/venv/lib/python3.11/site-packages/uvicorn/lifespan/off.py deleted file mode 100644 index 74554b1..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/lifespan/off.py +++ /dev/null @@ -1,17 +0,0 @@ -from __future__ import annotations - -from typing import Any - -from uvicorn import Config - - -class LifespanOff: - def __init__(self, config: Config) -> None: - self.should_exit = False - self.state: dict[str, Any] = {} - - async def startup(self) -> None: - pass - - async def shutdown(self) -> None: - pass diff --git a/venv/lib/python3.11/site-packages/uvicorn/lifespan/on.py b/venv/lib/python3.11/site-packages/uvicorn/lifespan/on.py deleted file mode 100644 index 09df984..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/lifespan/on.py +++ /dev/null @@ -1,137 +0,0 @@ -from __future__ import annotations - -import asyncio -import logging -from asyncio import Queue -from typing import Any, Union - -from uvicorn import Config -from uvicorn._types import ( - LifespanScope, - LifespanShutdownCompleteEvent, - LifespanShutdownEvent, - LifespanShutdownFailedEvent, - LifespanStartupCompleteEvent, - LifespanStartupEvent, - LifespanStartupFailedEvent, -) - -LifespanReceiveMessage = Union[LifespanStartupEvent, LifespanShutdownEvent] -LifespanSendMessage = Union[ - LifespanStartupFailedEvent, - LifespanShutdownFailedEvent, - LifespanStartupCompleteEvent, - LifespanShutdownCompleteEvent, -] - - -STATE_TRANSITION_ERROR = "Got invalid state transition on lifespan protocol." - - -class LifespanOn: - def __init__(self, config: Config) -> None: - if not config.loaded: - config.load() - - self.config = config - self.logger = logging.getLogger("uvicorn.error") - self.startup_event = asyncio.Event() - self.shutdown_event = asyncio.Event() - 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] = {} - - async def startup(self) -> None: - self.logger.info("Waiting for application startup.") - - loop = asyncio.get_event_loop() - main_lifespan_task = loop.create_task(self.main()) # noqa: F841 - # Keep a hard reference to prevent garbage collection - # See https://github.com/encode/uvicorn/pull/972 - startup_event: LifespanStartupEvent = {"type": "lifespan.startup"} - await self.receive_queue.put(startup_event) - await self.startup_event.wait() - - if self.startup_failed or (self.error_occured and self.config.lifespan == "on"): - self.logger.error("Application startup failed. Exiting.") - self.should_exit = True - else: - self.logger.info("Application startup complete.") - - async def shutdown(self) -> None: - if self.error_occured: - return - self.logger.info("Waiting for application shutdown.") - shutdown_event: LifespanShutdownEvent = {"type": "lifespan.shutdown"} - 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"): - self.logger.error("Application shutdown failed. Exiting.") - self.should_exit = True - else: - self.logger.info("Application shutdown complete.") - - async def main(self) -> None: - try: - app = self.config.loaded_app - scope: LifespanScope = { - "type": "lifespan", - "asgi": {"version": self.config.asgi_version, "spec_version": "2.0"}, - "state": self.state, - } - await app(scope, self.receive, self.send) - except BaseException as exc: - self.asgi = None - self.error_occured = True - if self.startup_failed or self.shutdown_failed: - return - if self.config.lifespan == "auto": - msg = "ASGI 'lifespan' protocol appears unsupported." - self.logger.info(msg) - else: - msg = "Exception in 'lifespan' protocol\n" - self.logger.error(msg, exc_info=exc) - finally: - self.startup_event.set() - self.shutdown_event.set() - - async def send(self, message: LifespanSendMessage) -> None: - assert message["type"] in ( - "lifespan.startup.complete", - "lifespan.startup.failed", - "lifespan.shutdown.complete", - "lifespan.shutdown.failed", - ) - - if message["type"] == "lifespan.startup.complete": - assert not self.startup_event.is_set(), STATE_TRANSITION_ERROR - assert not self.shutdown_event.is_set(), STATE_TRANSITION_ERROR - self.startup_event.set() - - elif message["type"] == "lifespan.startup.failed": - assert not self.startup_event.is_set(), STATE_TRANSITION_ERROR - assert not self.shutdown_event.is_set(), STATE_TRANSITION_ERROR - self.startup_event.set() - self.startup_failed = True - if message.get("message"): - self.logger.error(message["message"]) - - elif message["type"] == "lifespan.shutdown.complete": - assert self.startup_event.is_set(), STATE_TRANSITION_ERROR - assert not self.shutdown_event.is_set(), STATE_TRANSITION_ERROR - self.shutdown_event.set() - - elif message["type"] == "lifespan.shutdown.failed": - assert self.startup_event.is_set(), STATE_TRANSITION_ERROR - assert not self.shutdown_event.is_set(), STATE_TRANSITION_ERROR - self.shutdown_event.set() - self.shutdown_failed = True - if message.get("message"): - self.logger.error(message["message"]) - - async def receive(self) -> LifespanReceiveMessage: - return await self.receive_queue.get() diff --git a/venv/lib/python3.11/site-packages/uvicorn/logging.py b/venv/lib/python3.11/site-packages/uvicorn/logging.py deleted file mode 100644 index ab6261d..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/logging.py +++ /dev/null @@ -1,117 +0,0 @@ -from __future__ import annotations - -import http -import logging -import sys -from copy import copy -from typing import Literal - -import click - -TRACE_LOG_LEVEL = 5 - - -class ColourizedFormatter(logging.Formatter): - """ - A custom log formatter class that: - - * Outputs the LOG_LEVEL with an appropriate color. - * If a log call includes an `extras={"color_message": ...}` it will be used - for formatting the output, instead of the plain text message. - """ - - level_name_colors = { - TRACE_LOG_LEVEL: lambda level_name: click.style(str(level_name), fg="blue"), - logging.DEBUG: lambda level_name: click.style(str(level_name), fg="cyan"), - 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"), - } - - def __init__( - self, - fmt: str | None = None, - datefmt: str | None = None, - style: Literal["%", "{", "$"] = "%", - use_colors: bool | None = None, - ): - if use_colors in (True, False): - self.use_colors = use_colors - else: - self.use_colors = sys.stdout.isatty() - super().__init__(fmt=fmt, datefmt=datefmt, style=style) - - def color_level_name(self, level_name: str, level_no: int) -> str: - def default(level_name: str) -> str: - return str(level_name) # pragma: no cover - - func = self.level_name_colors.get(level_no, default) - return func(level_name) - - def should_use_colors(self) -> bool: - return True # pragma: no cover - - def formatMessage(self, record: logging.LogRecord) -> str: - recordcopy = copy(record) - levelname = recordcopy.levelname - seperator = " " * (8 - len(recordcopy.levelname)) - if self.use_colors: - levelname = self.color_level_name(levelname, recordcopy.levelno) - if "color_message" in recordcopy.__dict__: - recordcopy.msg = recordcopy.__dict__["color_message"] - recordcopy.__dict__["message"] = recordcopy.getMessage() - recordcopy.__dict__["levelprefix"] = levelname + ":" + seperator - return super().formatMessage(recordcopy) - - -class DefaultFormatter(ColourizedFormatter): - def should_use_colors(self) -> bool: - return sys.stderr.isatty() # pragma: no cover - - -class AccessFormatter(ColourizedFormatter): - status_code_colours = { - 1: lambda code: click.style(str(code), fg="bright_white"), - 2: lambda code: click.style(str(code), fg="green"), - 3: lambda code: click.style(str(code), fg="yellow"), - 4: lambda code: click.style(str(code), fg="red"), - 5: lambda code: click.style(str(code), fg="bright_red"), - } - - def get_status_code(self, status_code: int) -> str: - try: - status_phrase = http.HTTPStatus(status_code).phrase - except ValueError: - status_phrase = "" - status_and_phrase = f"{status_code} {status_phrase}" - if self.use_colors: - - def default(code: int) -> str: - return status_and_phrase # pragma: no cover - - func = self.status_code_colours.get(status_code // 100, default) - return func(status_and_phrase) - return status_and_phrase - - def formatMessage(self, record: logging.LogRecord) -> str: - recordcopy = copy(record) - ( - client_addr, - method, - full_path, - http_version, - status_code, - ) = recordcopy.args # type: ignore[misc] - status_code = self.get_status_code(int(status_code)) # type: ignore[arg-type] - request_line = f"{method} {full_path} HTTP/{http_version}" - if self.use_colors: - request_line = click.style(request_line, bold=True) - recordcopy.__dict__.update( - { - "client_addr": client_addr, - "request_line": request_line, - "status_code": status_code, - } - ) - return super().formatMessage(recordcopy) diff --git a/venv/lib/python3.11/site-packages/uvicorn/loops/__init__.py b/venv/lib/python3.11/site-packages/uvicorn/loops/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/loops/__init__.py +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/loops/__pycache__/__init__.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/loops/__pycache__/__init__.cpython-311.pyc Binary files differdeleted file mode 100644 index 7bf402c..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/loops/__pycache__/__init__.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/loops/__pycache__/asyncio.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/loops/__pycache__/asyncio.cpython-311.pyc Binary files differdeleted file mode 100644 index d1bdfe7..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/loops/__pycache__/asyncio.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/loops/__pycache__/auto.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/loops/__pycache__/auto.cpython-311.pyc Binary files differdeleted file mode 100644 index 74bbf27..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/loops/__pycache__/auto.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/loops/__pycache__/uvloop.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/loops/__pycache__/uvloop.cpython-311.pyc Binary files differdeleted file mode 100644 index 62ad95c..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/loops/__pycache__/uvloop.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/loops/asyncio.py b/venv/lib/python3.11/site-packages/uvicorn/loops/asyncio.py deleted file mode 100644 index b24f4fe..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/loops/asyncio.py +++ /dev/null @@ -1,10 +0,0 @@ -import asyncio -import logging -import sys - -logger = logging.getLogger("uvicorn.error") - - -def asyncio_setup(use_subprocess: bool = False) -> None: - if sys.platform == "win32" and use_subprocess: - asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy()) diff --git a/venv/lib/python3.11/site-packages/uvicorn/loops/auto.py b/venv/lib/python3.11/site-packages/uvicorn/loops/auto.py deleted file mode 100644 index 2285457..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/loops/auto.py +++ /dev/null @@ -1,11 +0,0 @@ -def auto_loop_setup(use_subprocess: bool = False) -> None: - try: - import uvloop # noqa - except ImportError: # pragma: no cover - from uvicorn.loops.asyncio import asyncio_setup as loop_setup - - loop_setup(use_subprocess=use_subprocess) - else: # pragma: no cover - from uvicorn.loops.uvloop import uvloop_setup - - uvloop_setup(use_subprocess=use_subprocess) diff --git a/venv/lib/python3.11/site-packages/uvicorn/loops/uvloop.py b/venv/lib/python3.11/site-packages/uvicorn/loops/uvloop.py deleted file mode 100644 index 0e2fd1e..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/loops/uvloop.py +++ /dev/null @@ -1,7 +0,0 @@ -import asyncio - -import uvloop - - -def uvloop_setup(use_subprocess: bool = False) -> None: - asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) diff --git a/venv/lib/python3.11/site-packages/uvicorn/main.py b/venv/lib/python3.11/site-packages/uvicorn/main.py deleted file mode 100644 index ace2b70..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/main.py +++ /dev/null @@ -1,584 +0,0 @@ -from __future__ import annotations - -import asyncio -import logging -import os -import platform -import ssl -import sys -from typing import Any, Callable - -import click - -import uvicorn -from uvicorn._types import ASGIApplication -from uvicorn.config import ( - HTTP_PROTOCOLS, - INTERFACES, - LIFESPAN, - LOG_LEVELS, - LOGGING_CONFIG, - LOOP_SETUPS, - SSL_PROTOCOL_VERSION, - WS_PROTOCOLS, - Config, - HTTPProtocolType, - InterfaceType, - LifespanType, - LoopSetupType, - WSProtocolType, -) -from uvicorn.server import Server, ServerState # noqa: F401 # Used to be defined here. -from uvicorn.supervisors import ChangeReload, Multiprocess - -LEVEL_CHOICES = click.Choice(list(LOG_LEVELS.keys())) -HTTP_CHOICES = click.Choice(list(HTTP_PROTOCOLS.keys())) -WS_CHOICES = click.Choice(list(WS_PROTOCOLS.keys())) -LIFESPAN_CHOICES = click.Choice(list(LIFESPAN.keys())) -LOOP_CHOICES = click.Choice([key for key in LOOP_SETUPS.keys() if key != "none"]) -INTERFACE_CHOICES = click.Choice(INTERFACES) - -STARTUP_FAILURE = 3 - -logger = logging.getLogger("uvicorn.error") - - -def print_version(ctx: click.Context, param: click.Parameter, value: bool) -> None: - if not value or ctx.resilient_parsing: - return - click.echo( - "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() - - -@click.command(context_settings={"auto_envvar_prefix": "UVICORN"}) -@click.argument("app", envvar="UVICORN_APP") -@click.option( - "--host", - type=str, - default="127.0.0.1", - help="Bind socket to this host.", - show_default=True, -) -@click.option( - "--port", - type=int, - default=8000, - help="Bind socket to this port. If 0, an available port will be picked.", - 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("--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.", - type=click.Path(exists=True), -) -@click.option( - "--reload-include", - "reload_includes", - multiple=True, - help="Set glob patterns to include while watching for files. Includes '*.py' " - "by default; these defaults can be overridden with `--reload-exclude`. " - "This option has no effect unless watchfiles is installed.", -) -@click.option( - "--reload-exclude", - "reload_excludes", - multiple=True, - help="Set glob patterns to exclude while watching for files. Includes " - "'.*, .py[cod], .sw.*, ~*' by default; these defaults can be overridden " - "with `--reload-include`. This option has no effect unless watchfiles is " - "installed.", -) -@click.option( - "--reload-delay", - type=float, - default=0.25, - show_default=True, - help="Delay between previous and next check if application needs to be." " Defaults to 0.25s.", -) -@click.option( - "--workers", - default=None, - type=int, - help="Number of worker processes. Defaults to the $WEB_CONCURRENCY environment" - " variable if available, or 1. Not valid with --reload.", -) -@click.option( - "--loop", - type=LOOP_CHOICES, - default="auto", - help="Event loop implementation.", - show_default=True, -) -@click.option( - "--http", - type=HTTP_CHOICES, - default="auto", - help="HTTP protocol implementation.", - show_default=True, -) -@click.option( - "--ws", - type=WS_CHOICES, - default="auto", - help="WebSocket protocol implementation.", - show_default=True, -) -@click.option( - "--ws-max-size", - type=int, - default=16777216, - help="WebSocket max size message in bytes", - show_default=True, -) -@click.option( - "--ws-max-queue", - type=int, - default=32, - help="The maximum length of the WebSocket message queue.", - show_default=True, -) -@click.option( - "--ws-ping-interval", - type=float, - default=20.0, - help="WebSocket ping interval in seconds.", - show_default=True, -) -@click.option( - "--ws-ping-timeout", - type=float, - default=20.0, - help="WebSocket ping timeout in seconds.", - show_default=True, -) -@click.option( - "--ws-per-message-deflate", - type=bool, - default=True, - help="WebSocket per-message-deflate compression", - show_default=True, -) -@click.option( - "--lifespan", - type=LIFESPAN_CHOICES, - default="auto", - help="Lifespan implementation.", - show_default=True, -) -@click.option( - "--interface", - type=INTERFACE_CHOICES, - default="auto", - help="Select ASGI3, ASGI2, or WSGI as the application interface.", - show_default=True, -) -@click.option( - "--env-file", - type=click.Path(exists=True), - default=None, - help="Environment configuration file.", - show_default=True, -) -@click.option( - "--log-config", - type=click.Path(exists=True), - default=None, - help="Logging configuration file. Supported formats: .ini, .json, .yaml.", - show_default=True, -) -@click.option( - "--log-level", - type=LEVEL_CHOICES, - default=None, - help="Log level. [default: info]", - show_default=True, -) -@click.option( - "--access-log/--no-access-log", - is_flag=True, - default=True, - help="Enable/Disable access log.", -) -@click.option( - "--use-colors/--no-use-colors", - is_flag=True, - default=None, - help="Enable/Disable colorized logging.", -) -@click.option( - "--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.", -) -@click.option( - "--server-header/--no-server-header", - is_flag=True, - default=True, - help="Enable/Disable default Server header.", -) -@click.option( - "--date-header/--no-date-header", - is_flag=True, - default=True, - help="Enable/Disable default Date header.", -) -@click.option( - "--forwarded-allow-ips", - type=str, - default=None, - help="Comma separated list of IPs to trust with proxy headers. Defaults to" - " the $FORWARDED_ALLOW_IPS environment variable if available, or '127.0.0.1'.", -) -@click.option( - "--root-path", - type=str, - default="", - help="Set the ASGI 'root_path' for applications submounted below a given URL path.", -) -@click.option( - "--limit-concurrency", - type=int, - default=None, - help="Maximum number of concurrent connections or tasks to allow, before issuing" " HTTP 503 responses.", -) -@click.option( - "--backlog", - type=int, - default=2048, - help="Maximum number of connections to hold in backlog", -) -@click.option( - "--limit-max-requests", - type=int, - default=None, - help="Maximum number of requests to service before terminating the process.", -) -@click.option( - "--timeout-keep-alive", - type=int, - default=5, - help="Close Keep-Alive connections if no new data is received within this timeout.", - show_default=True, -) -@click.option( - "--timeout-graceful-shutdown", - type=int, - 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-certfile", - type=str, - default=None, - help="SSL certificate file", - show_default=True, -) -@click.option( - "--ssl-keyfile-password", - type=str, - default=None, - help="SSL keyfile password", - show_default=True, -) -@click.option( - "--ssl-version", - type=int, - default=int(SSL_PROTOCOL_VERSION), - help="SSL version to use (see stdlib ssl module's)", - show_default=True, -) -@click.option( - "--ssl-cert-reqs", - type=int, - default=int(ssl.CERT_NONE), - help="Whether client certificate is required (see stdlib ssl module's)", - show_default=True, -) -@click.option( - "--ssl-ca-certs", - type=str, - default=None, - help="CA certificates file", - show_default=True, -) -@click.option( - "--ssl-ciphers", - type=str, - default="TLSv1", - help="Ciphers to use (see stdlib ssl module's)", - show_default=True, -) -@click.option( - "--header", - "headers", - multiple=True, - help="Specify custom default HTTP response headers as a Name:Value pair", -) -@click.option( - "--version", - is_flag=True, - callback=print_version, - expose_value=False, - is_eager=True, - help="Display the uvicorn version and exit.", -) -@click.option( - "--app-dir", - default="", - show_default=True, - help="Look for APP in the specified directory, by adding this to the PYTHONPATH." - " Defaults to the current working directory.", -) -@click.option( - "--h11-max-incomplete-event-size", - "h11_max_incomplete_event_size", - type=int, - default=None, - help="For h11, the maximum number of bytes to buffer of an incomplete event.", -) -@click.option( - "--factory", - is_flag=True, - default=False, - help="Treat APP as an application factory, i.e. a () -> <ASGI app> callable.", - show_default=True, -) -def main( - app: str, - host: str, - port: int, - uds: str, - fd: int, - loop: LoopSetupType, - http: HTTPProtocolType, - ws: WSProtocolType, - ws_max_size: int, - ws_max_queue: int, - ws_ping_interval: float, - ws_ping_timeout: float, - ws_per_message_deflate: bool, - lifespan: LifespanType, - interface: InterfaceType, - reload: bool, - reload_dirs: list[str], - reload_includes: list[str], - reload_excludes: list[str], - reload_delay: float, - workers: int, - env_file: str, - log_config: str, - log_level: str, - access_log: bool, - proxy_headers: bool, - server_header: bool, - date_header: bool, - forwarded_allow_ips: str, - root_path: str, - limit_concurrency: int, - backlog: int, - limit_max_requests: int, - timeout_keep_alive: int, - timeout_graceful_shutdown: int | None, - ssl_keyfile: str, - ssl_certfile: str, - ssl_keyfile_password: str, - ssl_version: int, - ssl_cert_reqs: int, - ssl_ca_certs: str, - ssl_ciphers: str, - headers: list[str], - use_colors: bool, - app_dir: str, - h11_max_incomplete_event_size: int | None, - factory: bool, -) -> None: - run( - app, - host=host, - port=port, - uds=uds, - fd=fd, - loop=loop, - http=http, - ws=ws, - ws_max_size=ws_max_size, - ws_max_queue=ws_max_queue, - ws_ping_interval=ws_ping_interval, - ws_ping_timeout=ws_ping_timeout, - ws_per_message_deflate=ws_per_message_deflate, - lifespan=lifespan, - env_file=env_file, - log_config=LOGGING_CONFIG if log_config is None else log_config, - log_level=log_level, - access_log=access_log, - interface=interface, - reload=reload, - reload_dirs=reload_dirs or None, - reload_includes=reload_includes or None, - reload_excludes=reload_excludes or None, - reload_delay=reload_delay, - workers=workers, - proxy_headers=proxy_headers, - server_header=server_header, - date_header=date_header, - forwarded_allow_ips=forwarded_allow_ips, - root_path=root_path, - limit_concurrency=limit_concurrency, - backlog=backlog, - limit_max_requests=limit_max_requests, - timeout_keep_alive=timeout_keep_alive, - timeout_graceful_shutdown=timeout_graceful_shutdown, - ssl_keyfile=ssl_keyfile, - ssl_certfile=ssl_certfile, - ssl_keyfile_password=ssl_keyfile_password, - ssl_version=ssl_version, - ssl_cert_reqs=ssl_cert_reqs, - ssl_ca_certs=ssl_ca_certs, - ssl_ciphers=ssl_ciphers, - headers=[header.split(":", 1) for header in headers], # type: ignore[misc] - use_colors=use_colors, - factory=factory, - app_dir=app_dir, - h11_max_incomplete_event_size=h11_max_incomplete_event_size, - ) - - -def run( - app: ASGIApplication | Callable[..., Any] | str, - *, - host: str = "127.0.0.1", - port: int = 8000, - uds: str | None = None, - fd: int | None = None, - loop: LoopSetupType = "auto", - http: type[asyncio.Protocol] | HTTPProtocolType = "auto", - ws: type[asyncio.Protocol] | WSProtocolType = "auto", - ws_max_size: int = 16777216, - ws_max_queue: int = 32, - ws_ping_interval: float | None = 20.0, - ws_ping_timeout: float | None = 20.0, - ws_per_message_deflate: bool = True, - lifespan: LifespanType = "auto", - interface: InterfaceType = "auto", - reload: bool = False, - reload_dirs: list[str] | str | None = None, - reload_includes: list[str] | str | None = None, - reload_excludes: list[str] | str | None = None, - reload_delay: float = 0.25, - workers: int | None = None, - env_file: str | os.PathLike[str] | None = None, - log_config: dict[str, Any] | str | None = LOGGING_CONFIG, - log_level: str | int | None = None, - access_log: bool = True, - proxy_headers: bool = True, - server_header: bool = True, - date_header: bool = True, - forwarded_allow_ips: list[str] | str | None = None, - root_path: str = "", - limit_concurrency: int | None = None, - backlog: int = 2048, - limit_max_requests: int | None = None, - timeout_keep_alive: int = 5, - timeout_graceful_shutdown: int | None = None, - ssl_keyfile: str | None = None, - ssl_certfile: str | os.PathLike[str] | None = None, - ssl_keyfile_password: str | None = None, - ssl_version: int = SSL_PROTOCOL_VERSION, - ssl_cert_reqs: int = ssl.CERT_NONE, - ssl_ca_certs: str | None = None, - ssl_ciphers: str = "TLSv1", - headers: list[tuple[str, str]] | None = None, - use_colors: bool | None = None, - app_dir: str | None = None, - factory: bool = False, - h11_max_incomplete_event_size: int | None = None, -) -> None: - if app_dir is not None: - sys.path.insert(0, app_dir) - - config = Config( - app, - host=host, - port=port, - uds=uds, - fd=fd, - loop=loop, - http=http, - ws=ws, - ws_max_size=ws_max_size, - ws_max_queue=ws_max_queue, - ws_ping_interval=ws_ping_interval, - ws_ping_timeout=ws_ping_timeout, - ws_per_message_deflate=ws_per_message_deflate, - lifespan=lifespan, - interface=interface, - reload=reload, - reload_dirs=reload_dirs, - reload_includes=reload_includes, - reload_excludes=reload_excludes, - reload_delay=reload_delay, - workers=workers, - env_file=env_file, - log_config=log_config, - log_level=log_level, - access_log=access_log, - proxy_headers=proxy_headers, - server_header=server_header, - date_header=date_header, - forwarded_allow_ips=forwarded_allow_ips, - root_path=root_path, - limit_concurrency=limit_concurrency, - backlog=backlog, - limit_max_requests=limit_max_requests, - timeout_keep_alive=timeout_keep_alive, - timeout_graceful_shutdown=timeout_graceful_shutdown, - ssl_keyfile=ssl_keyfile, - ssl_certfile=ssl_certfile, - ssl_keyfile_password=ssl_keyfile_password, - ssl_version=ssl_version, - ssl_cert_reqs=ssl_cert_reqs, - ssl_ca_certs=ssl_ca_certs, - ssl_ciphers=ssl_ciphers, - headers=headers, - use_colors=use_colors, - factory=factory, - h11_max_incomplete_event_size=h11_max_incomplete_event_size, - ) - server = Server(config=config) - - 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'.") - sys.exit(1) - - if config.should_reload: - sock = config.bind_socket() - ChangeReload(config, target=server.run, sockets=[sock]).run() - elif config.workers > 1: - sock = config.bind_socket() - Multiprocess(config, target=server.run, sockets=[sock]).run() - else: - server.run() - if config.uds and os.path.exists(config.uds): - os.remove(config.uds) # pragma: py-win32 - - if not server.started and not config.should_reload and config.workers == 1: - sys.exit(STARTUP_FAILURE) - - -if __name__ == "__main__": - main() # pragma: no cover diff --git a/venv/lib/python3.11/site-packages/uvicorn/middleware/__init__.py b/venv/lib/python3.11/site-packages/uvicorn/middleware/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/middleware/__init__.py +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/middleware/__pycache__/__init__.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/middleware/__pycache__/__init__.cpython-311.pyc Binary files differdeleted file mode 100644 index 5f70c5b..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/middleware/__pycache__/__init__.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/middleware/__pycache__/asgi2.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/middleware/__pycache__/asgi2.cpython-311.pyc Binary files differdeleted file mode 100644 index 905a366..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/middleware/__pycache__/asgi2.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/middleware/__pycache__/message_logger.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/middleware/__pycache__/message_logger.cpython-311.pyc Binary files differdeleted file mode 100644 index 87303e2..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/middleware/__pycache__/message_logger.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/middleware/__pycache__/proxy_headers.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/middleware/__pycache__/proxy_headers.cpython-311.pyc Binary files differdeleted file mode 100644 index 5f8e2c9..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/middleware/__pycache__/proxy_headers.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/middleware/__pycache__/wsgi.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/middleware/__pycache__/wsgi.cpython-311.pyc Binary files differdeleted file mode 100644 index 2dfa1f9..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/middleware/__pycache__/wsgi.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/middleware/asgi2.py b/venv/lib/python3.11/site-packages/uvicorn/middleware/asgi2.py deleted file mode 100644 index 4e15d15..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/middleware/asgi2.py +++ /dev/null @@ -1,15 +0,0 @@ -from uvicorn._types import ( - ASGI2Application, - ASGIReceiveCallable, - ASGISendCallable, - Scope, -) - - -class ASGI2Middleware: - def __init__(self, app: "ASGI2Application"): - self.app = app - - async def __call__(self, scope: "Scope", receive: "ASGIReceiveCallable", send: "ASGISendCallable") -> None: - instance = self.app(scope) - await instance(receive, send) diff --git a/venv/lib/python3.11/site-packages/uvicorn/middleware/message_logger.py b/venv/lib/python3.11/site-packages/uvicorn/middleware/message_logger.py deleted file mode 100644 index 0174bcc..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/middleware/message_logger.py +++ /dev/null @@ -1,87 +0,0 @@ -import logging -from typing import Any - -from uvicorn._types import ( - ASGI3Application, - ASGIReceiveCallable, - ASGIReceiveEvent, - ASGISendCallable, - ASGISendEvent, - WWWScope, -) -from uvicorn.logging import TRACE_LOG_LEVEL - -PLACEHOLDER_FORMAT = { - "body": "<{length} bytes>", - "bytes": "<{length} bytes>", - "text": "<{length} chars>", - "headers": "<...>", -} - - -def message_with_placeholders(message: Any) -> Any: - """ - Return an ASGI message, with any body-type content omitted and replaced - with a placeholder. - """ - new_message = message.copy() - for attr in PLACEHOLDER_FORMAT.keys(): - if message.get(attr) is not None: - content = message[attr] - placeholder = PLACEHOLDER_FORMAT[attr].format(length=len(content)) - new_message[attr] = placeholder - return new_message - - -class MessageLoggerMiddleware: - def __init__(self, app: "ASGI3Application"): - self.task_counter = 0 - self.app = app - self.logger = logging.getLogger("uvicorn.asgi") - - def trace(message: Any, *args: Any, **kwargs: Any) -> None: - self.logger.log(TRACE_LOG_LEVEL, message, *args, **kwargs) - - self.logger.trace = trace # type: ignore - - async def __call__( - self, - scope: "WWWScope", - receive: "ASGIReceiveCallable", - send: "ASGISendCallable", - ) -> None: - self.task_counter += 1 - - task_counter = self.task_counter - client = scope.get("client") - prefix = "%s:%d - ASGI" % (client[0], client[1]) if client else "ASGI" - - async def inner_receive() -> "ASGIReceiveEvent": - message = await receive() - logged_message = message_with_placeholders(message) - log_text = "%s [%d] Receive %s" - self.logger.trace( # type: ignore - log_text, prefix, task_counter, logged_message - ) - return message - - async def inner_send(message: "ASGISendEvent") -> None: - logged_message = message_with_placeholders(message) - log_text = "%s [%d] Send %s" - self.logger.trace( # type: ignore - log_text, prefix, task_counter, logged_message - ) - await send(message) - - logged_scope = message_with_placeholders(scope) - log_text = "%s [%d] Started scope=%s" - self.logger.trace(log_text, prefix, task_counter, logged_scope) # type: ignore - try: - await self.app(scope, inner_receive, inner_send) - except BaseException as exc: - log_text = "%s [%d] Raised exception" - self.logger.trace(log_text, prefix, task_counter) # type: ignore - raise exc from None - else: - log_text = "%s [%d] Completed" - self.logger.trace(log_text, prefix, task_counter) # type: ignore diff --git a/venv/lib/python3.11/site-packages/uvicorn/middleware/proxy_headers.py b/venv/lib/python3.11/site-packages/uvicorn/middleware/proxy_headers.py deleted file mode 100644 index 8f987ab..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/middleware/proxy_headers.py +++ /dev/null @@ -1,69 +0,0 @@ -""" -This middleware can be used when a known proxy is fronting the application, -and is trusted to be properly setting the `X-Forwarded-Proto` and -`X-Forwarded-For` headers with the connecting client information. - -Modifies the `client` and `scheme` information so that they reference -the connecting client, rather that the connecting proxy. - -https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers#Proxies -""" -from __future__ import annotations - -from typing import Union, cast - -from uvicorn._types import ASGI3Application, ASGIReceiveCallable, ASGISendCallable, HTTPScope, Scope, WebSocketScope - - -class ProxyHeadersMiddleware: - def __init__( - self, - app: ASGI3Application, - trusted_hosts: list[str] | str = "127.0.0.1", - ) -> None: - self.app = app - if isinstance(trusted_hosts, str): - self.trusted_hosts = {item.strip() for item in trusted_hosts.split(",")} - else: - 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]) -> str | None: - if self.always_trust: - return x_forwarded_for_hosts[0] - - for host in reversed(x_forwarded_for_hosts): - if host not in self.trusted_hosts: - return host - - return 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: 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: - headers = dict(scope["headers"]) - - 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() - if scope["type"] == "websocket": - scope["scheme"] = x_forwarded_proto.replace("http", "ws") - else: - scope["scheme"] = x_forwarded_proto - - if b"x-forwarded-for" in headers: - # Determine the client address from the last trusted IP in the - # 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(",")] - host = self.get_trusted_client_host(x_forwarded_for_hosts) - port = 0 - scope["client"] = (host, port) # type: ignore[arg-type] - - return await self.app(scope, receive, send) diff --git a/venv/lib/python3.11/site-packages/uvicorn/middleware/wsgi.py b/venv/lib/python3.11/site-packages/uvicorn/middleware/wsgi.py deleted file mode 100644 index 078de1a..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/middleware/wsgi.py +++ /dev/null @@ -1,200 +0,0 @@ -from __future__ import annotations - -import asyncio -import concurrent.futures -import io -import sys -import warnings -from collections import deque -from typing import Iterable - -from uvicorn._types import ( - ASGIReceiveCallable, - ASGIReceiveEvent, - ASGISendCallable, - ASGISendEvent, - Environ, - ExcInfo, - HTTPRequestEvent, - HTTPResponseBodyEvent, - HTTPResponseStartEvent, - HTTPScope, - StartResponse, - WSGIApp, -) - - -def build_environ(scope: HTTPScope, message: ASGIReceiveEvent, body: io.BytesIO) -> Environ: - """ - Builds a scope and request message into a WSGI environ object. - """ - script_name = scope.get("root_path", "").encode("utf8").decode("latin1") - path_info = scope["path"].encode("utf8").decode("latin1") - if path_info.startswith(script_name): - path_info = path_info[len(script_name) :] - environ = { - "REQUEST_METHOD": scope["method"], - "SCRIPT_NAME": script_name, - "PATH_INFO": path_info, - "QUERY_STRING": scope["query_string"].decode("ascii"), - "SERVER_PROTOCOL": "HTTP/%s" % scope["http_version"], - "wsgi.version": (1, 0), - "wsgi.url_scheme": scope.get("scheme", "http"), - "wsgi.input": body, - "wsgi.errors": sys.stdout, - "wsgi.multithread": True, - "wsgi.multiprocess": True, - "wsgi.run_once": False, - } - - # Get server name and port - required in WSGI, not in ASGI - server = scope.get("server") - if server is None: - server = ("localhost", 80) - environ["SERVER_NAME"] = server[0] - environ["SERVER_PORT"] = server[1] - - # Get client IP address - client = scope.get("client") - if client is not None: - environ["REMOTE_ADDR"] = client[0] - - # Go through headers and make them into environ entries - for name, value in scope.get("headers", []): - name_str: str = name.decode("latin1") - if name_str == "content-length": - corrected_name = "CONTENT_LENGTH" - elif name_str == "content-type": - corrected_name = "CONTENT_TYPE" - else: - corrected_name = "HTTP_%s" % name_str.upper().replace("-", "_") - # HTTPbis say only ASCII chars are allowed in headers, but we latin1 - # just in case - value_str: str = value.decode("latin1") - if corrected_name in environ: - corrected_name_environ = environ[corrected_name] - assert isinstance(corrected_name_environ, str) - value_str = corrected_name_environ + "," + value_str - environ[corrected_name] = value_str - return environ - - -class _WSGIMiddleware: - def __init__(self, app: WSGIApp, workers: int = 10): - warnings.warn( - "Uvicorn's native WSGI implementation is deprecated, you " - "should switch to a2wsgi (`pip install a2wsgi`).", - DeprecationWarning, - ) - self.app = app - self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=workers) - - async def __call__( - self, - scope: HTTPScope, - receive: ASGIReceiveCallable, - send: ASGISendCallable, - ) -> None: - assert scope["type"] == "http" - instance = WSGIResponder(self.app, self.executor, scope) - await instance(receive, send) - - -class WSGIResponder: - def __init__( - self, - app: WSGIApp, - executor: concurrent.futures.ThreadPoolExecutor, - scope: HTTPScope, - ): - self.app = app - self.executor = executor - self.scope = scope - self.status = None - self.response_headers = None - self.send_event = asyncio.Event() - self.send_queue: deque[ASGISendEvent | None] = deque() - self.loop: asyncio.AbstractEventLoop = asyncio.get_event_loop() - self.response_started = False - self.exc_info: ExcInfo | None = 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 = ( - await receive() # type: ignore[assignment] - ) - body.write(body_message.get("body", b"")) - more_body = body_message.get("more_body", False) - 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) - sender = self.loop.create_task(self.sender(send)) - try: - await asyncio.wait_for(wsgi, None) - finally: - self.send_queue.append(None) - self.send_event.set() - await asyncio.wait_for(sender, None) - 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: - while True: - if self.send_queue: - message = self.send_queue.popleft() - if message is None: - return - await send(message) - else: - await self.send_event.wait() - self.send_event.clear() - - def start_response( - self, - status: str, - 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] - http_response_start_event: HTTPResponseStartEvent = { - "type": "http.response.start", - "status": status_code, - "headers": headers, - } - self.send_queue.append(http_response_start_event) - self.loop.call_soon_threadsafe(self.send_event.set) - - def wsgi(self, environ: Environ, start_response: StartResponse) -> None: - for chunk in self.app(environ, start_response): # type: ignore - response_body: HTTPResponseBodyEvent = { - "type": "http.response.body", - "body": chunk, - "more_body": True, - } - self.send_queue.append(response_body) - self.loop.call_soon_threadsafe(self.send_event.set) - - empty_body: HTTPResponseBodyEvent = { - "type": "http.response.body", - "body": b"", - "more_body": False, - } - self.send_queue.append(empty_body) - self.loop.call_soon_threadsafe(self.send_event.set) - - -try: - from a2wsgi import WSGIMiddleware -except ModuleNotFoundError: # pragma: no cover - WSGIMiddleware = _WSGIMiddleware # type: ignore[misc, assignment] diff --git a/venv/lib/python3.11/site-packages/uvicorn/protocols/__init__.py b/venv/lib/python3.11/site-packages/uvicorn/protocols/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/protocols/__init__.py +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/protocols/__pycache__/__init__.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/protocols/__pycache__/__init__.cpython-311.pyc Binary files differdeleted file mode 100644 index 5ff273e..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/protocols/__pycache__/__init__.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/protocols/__pycache__/utils.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/protocols/__pycache__/utils.cpython-311.pyc Binary files differdeleted file mode 100644 index da51e43..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/protocols/__pycache__/utils.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/protocols/http/__init__.py b/venv/lib/python3.11/site-packages/uvicorn/protocols/http/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/protocols/http/__init__.py +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/protocols/http/__pycache__/__init__.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/protocols/http/__pycache__/__init__.cpython-311.pyc Binary files differdeleted file mode 100644 index c56186b..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/protocols/http/__pycache__/__init__.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/protocols/http/__pycache__/auto.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/protocols/http/__pycache__/auto.cpython-311.pyc Binary files differdeleted file mode 100644 index a598e8a..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/protocols/http/__pycache__/auto.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/protocols/http/__pycache__/flow_control.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/protocols/http/__pycache__/flow_control.cpython-311.pyc Binary files differdeleted file mode 100644 index a925cb4..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/protocols/http/__pycache__/flow_control.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/protocols/http/__pycache__/h11_impl.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/protocols/http/__pycache__/h11_impl.cpython-311.pyc Binary files differdeleted file mode 100644 index 2379bb6..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/protocols/http/__pycache__/h11_impl.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/protocols/http/__pycache__/httptools_impl.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/protocols/http/__pycache__/httptools_impl.cpython-311.pyc Binary files differdeleted file mode 100644 index ba76184..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/protocols/http/__pycache__/httptools_impl.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/protocols/http/auto.py b/venv/lib/python3.11/site-packages/uvicorn/protocols/http/auto.py deleted file mode 100644 index a14bec1..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/protocols/http/auto.py +++ /dev/null @@ -1,15 +0,0 @@ -from __future__ import annotations - -import asyncio - -AutoHTTPProtocol: type[asyncio.Protocol] -try: - import httptools # noqa -except ImportError: # pragma: no cover - from uvicorn.protocols.http.h11_impl import H11Protocol - - AutoHTTPProtocol = H11Protocol -else: # pragma: no cover - from uvicorn.protocols.http.httptools_impl import HttpToolsProtocol - - AutoHTTPProtocol = HttpToolsProtocol diff --git a/venv/lib/python3.11/site-packages/uvicorn/protocols/http/flow_control.py b/venv/lib/python3.11/site-packages/uvicorn/protocols/http/flow_control.py deleted file mode 100644 index 893a26c..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/protocols/http/flow_control.py +++ /dev/null @@ -1,64 +0,0 @@ -import asyncio - -from uvicorn._types import ( - ASGIReceiveCallable, - ASGISendCallable, - HTTPResponseBodyEvent, - HTTPResponseStartEvent, - Scope, -) - -CLOSE_HEADER = (b"connection", b"close") - -HIGH_WATER_LIMIT = 65536 - - -class FlowControl: - def __init__(self, transport: asyncio.Transport) -> None: - self._transport = transport - self.read_paused = False - self.write_paused = False - self._is_writable_event = asyncio.Event() - self._is_writable_event.set() - - async def drain(self) -> None: - await self._is_writable_event.wait() - - def pause_reading(self) -> None: - if not self.read_paused: - self.read_paused = True - self._transport.pause_reading() - - def resume_reading(self) -> None: - if self.read_paused: - self.read_paused = False - self._transport.resume_reading() - - def pause_writing(self) -> None: - if not self.write_paused: - self.write_paused = True - self._is_writable_event.clear() - - def resume_writing(self) -> None: - if self.write_paused: - self.write_paused = False - self._is_writable_event.set() - - -async def service_unavailable(scope: "Scope", receive: "ASGIReceiveCallable", send: "ASGISendCallable") -> None: - response_start: "HTTPResponseStartEvent" = { - "type": "http.response.start", - "status": 503, - "headers": [ - (b"content-type", b"text/plain; charset=utf-8"), - (b"connection", b"close"), - ], - } - await send(response_start) - - response_body: "HTTPResponseBodyEvent" = { - "type": "http.response.body", - "body": b"Service Unavailable", - "more_body": False, - } - await send(response_body) diff --git a/venv/lib/python3.11/site-packages/uvicorn/protocols/http/h11_impl.py b/venv/lib/python3.11/site-packages/uvicorn/protocols/http/h11_impl.py deleted file mode 100644 index d0f2b2a..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/protocols/http/h11_impl.py +++ /dev/null @@ -1,547 +0,0 @@ -from __future__ import annotations - -import asyncio -import http -import logging -from typing import Any, Callable, Literal, cast -from urllib.parse import unquote - -import h11 -from h11._connection import DEFAULT_MAX_INCOMPLETE_EVENT_SIZE - -from uvicorn._types import ( - ASGI3Application, - ASGIReceiveEvent, - ASGISendEvent, - HTTPRequestEvent, - HTTPResponseBodyEvent, - HTTPResponseStartEvent, - HTTPScope, -) -from uvicorn.config import Config -from uvicorn.logging import TRACE_LOG_LEVEL -from uvicorn.protocols.http.flow_control import ( - CLOSE_HEADER, - HIGH_WATER_LIMIT, - FlowControl, - service_unavailable, -) -from uvicorn.protocols.utils import ( - get_client_addr, - get_local_addr, - get_path_with_query_string, - get_remote_addr, - is_ssl, -) -from uvicorn.server import ServerState - - -def _get_status_phrase(status_code: int) -> bytes: - try: - return http.HTTPStatus(status_code).phrase.encode() - except ValueError: - return b"" - - -STATUS_PHRASES = {status_code: _get_status_phrase(status_code) for status_code in range(100, 600)} - - -class H11Protocol(asyncio.Protocol): - def __init__( - self, - config: Config, - server_state: ServerState, - app_state: dict[str, Any], - _loop: asyncio.AbstractEventLoop | None = None, - ) -> None: - if not config.loaded: - config.load() - - self.config = config - self.app = config.loaded_app - self.loop = _loop or asyncio.get_event_loop() - self.logger = logging.getLogger("uvicorn.error") - self.access_logger = logging.getLogger("uvicorn.access") - self.access_log = self.access_logger.hasHandlers() - self.conn = h11.Connection( - h11.SERVER, - config.h11_max_incomplete_event_size - if config.h11_max_incomplete_event_size is not None - else DEFAULT_MAX_INCOMPLETE_EVENT_SIZE, - ) - self.ws_protocol_class = config.ws_protocol_class - self.root_path = config.root_path - self.limit_concurrency = config.limit_concurrency - self.app_state = app_state - - # Timeouts - self.timeout_keep_alive_task: asyncio.TimerHandle | None = None - self.timeout_keep_alive = config.timeout_keep_alive - - # Shared server state - self.server_state = server_state - self.connections = server_state.connections - self.tasks = server_state.tasks - - # Per-connection state - self.transport: asyncio.Transport = None # type: ignore[assignment] - self.flow: FlowControl = None # type: ignore[assignment] - self.server: tuple[str, int] | None = None - self.client: tuple[str, int] | None = None - self.scheme: Literal["http", "https"] | None = None - - # Per-request state - self.scope: HTTPScope = None # type: ignore[assignment] - self.headers: list[tuple[bytes, bytes]] = None # type: ignore[assignment] - self.cycle: RequestResponseCycle = None # type: ignore[assignment] - - # Protocol interface - def connection_made( # type: ignore[override] - self, transport: asyncio.Transport - ) -> None: - self.connections.add(self) - - self.transport = transport - self.flow = FlowControl(transport) - self.server = get_local_addr(transport) - self.client = get_remote_addr(transport) - self.scheme = "https" if is_ssl(transport) else "http" - - if self.logger.level <= TRACE_LOG_LEVEL: - prefix = "%s:%d - " % self.client if self.client else "" - self.logger.log(TRACE_LOG_LEVEL, "%sHTTP connection made", prefix) - - def connection_lost(self, exc: Exception | None) -> None: - self.connections.discard(self) - - if self.logger.level <= TRACE_LOG_LEVEL: - prefix = "%s:%d - " % self.client if self.client else "" - self.logger.log(TRACE_LOG_LEVEL, "%sHTTP connection lost", prefix) - - if self.cycle and not self.cycle.response_complete: - self.cycle.disconnected = True - if self.conn.our_state != h11.ERROR: - event = h11.ConnectionClosed() - try: - self.conn.send(event) - except h11.LocalProtocolError: - # Premature client disconnect - pass - - if self.cycle is not None: - self.cycle.message_event.set() - if self.flow is not None: - self.flow.resume_writing() - if exc is None: - self.transport.close() - self._unset_keepalive_if_required() - - def eof_received(self) -> None: - pass - - def _unset_keepalive_if_required(self) -> None: - if self.timeout_keep_alive_task is not None: - self.timeout_keep_alive_task.cancel() - self.timeout_keep_alive_task = None - - def _get_upgrade(self) -> bytes | None: - connection = [] - upgrade = None - for name, value in self.headers: - if name == b"connection": - connection = [token.lower().strip() for token in value.split(b",")] - if name == b"upgrade": - upgrade = value.lower() - if b"upgrade" in connection: - return upgrade - return None - - def _should_upgrade_to_ws(self) -> bool: - if self.ws_protocol_class is None: - if self.config.ws == "auto": - msg = "Unsupported upgrade request." - self.logger.warning(msg) - msg = "No supported WebSocket library detected. Please use \"pip install 'uvicorn[standard]'\", or install 'websockets' or 'wsproto' manually." # noqa: E501 - self.logger.warning(msg) - return False - return True - - def data_received(self, data: bytes) -> None: - self._unset_keepalive_if_required() - - self.conn.receive_data(data) - self.handle_events() - - def handle_events(self) -> None: - while True: - try: - event = self.conn.next_event() - except h11.RemoteProtocolError: - msg = "Invalid HTTP request received." - self.logger.warning(msg) - self.send_400_response(msg) - return - - if event is h11.NEED_DATA: - break - - elif event is h11.PAUSED: - # This case can occur in HTTP pipelining, so we need to - # stop reading any more data, and ensure that at the end - # of the active request/response cycle we handle any - # events that have been buffered up. - self.flow.pause_reading() - break - - elif isinstance(event, h11.Request): - self.headers = [(key.lower(), value) for key, value in event.headers] - raw_path, _, query_string = event.target.partition(b"?") - path = unquote(raw_path.decode("ascii")) - full_path = self.root_path + path - full_raw_path = self.root_path.encode("ascii") + raw_path - self.scope = { - "type": "http", - "asgi": { - "version": self.config.asgi_version, - "spec_version": "2.4", - }, - "http_version": event.http_version.decode("ascii"), - "server": self.server, - "client": self.client, - "scheme": self.scheme, # type: ignore[typeddict-item] - "method": event.method.decode("ascii"), - "root_path": self.root_path, - "path": full_path, - "raw_path": full_raw_path, - "query_string": query_string, - "headers": self.headers, - "state": self.app_state.copy(), - } - - upgrade = self._get_upgrade() - if upgrade == b"websocket" and self._should_upgrade_to_ws(): - self.handle_websocket_upgrade(event) - return - - # 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 - ): - app = service_unavailable - message = "Exceeded concurrency limit." - self.logger.warning(message) - else: - app = self.app - - # When starting to process a request, disable the keep-alive - # timeout. Normally we disable this when receiving data from - # client and set back when finishing processing its request. - # However, for pipelined requests processing finishes after - # already receiving the next request and thus the timer may - # be set here, which we don't want. - self._unset_keepalive_if_required() - - self.cycle = RequestResponseCycle( - scope=self.scope, - conn=self.conn, - transport=self.transport, - flow=self.flow, - logger=self.logger, - access_logger=self.access_logger, - access_log=self.access_log, - default_headers=self.server_state.default_headers, - message_event=asyncio.Event(), - on_response=self.on_response_complete, - ) - task = self.loop.create_task(self.cycle.run_asgi(app)) - task.add_done_callback(self.tasks.discard) - self.tasks.add(task) - - elif isinstance(event, h11.Data): - if self.conn.our_state is h11.DONE: - continue - self.cycle.body += event.data - if len(self.cycle.body) > HIGH_WATER_LIMIT: - self.flow.pause_reading() - self.cycle.message_event.set() - - elif isinstance(event, h11.EndOfMessage): - if self.conn.our_state is h11.DONE: - self.transport.resume_reading() - self.conn.start_next_cycle() - continue - self.cycle.more_body = False - self.cycle.message_event.set() - - def handle_websocket_upgrade(self, event: h11.Request) -> None: - if self.logger.level <= TRACE_LOG_LEVEL: - prefix = "%s:%d - " % self.client if self.client else "" - self.logger.log(TRACE_LOG_LEVEL, "%sUpgrading to WebSocket", prefix) - - self.connections.discard(self) - output = [event.method, b" ", event.target, b" HTTP/1.1\r\n"] - for name, value in self.headers: - output += [name, b": ", value, b"\r\n"] - output.append(b"\r\n") - protocol = self.ws_protocol_class( # type: ignore[call-arg, misc] - config=self.config, - server_state=self.server_state, - app_state=self.app_state, - ) - protocol.connection_made(self.transport) - protocol.data_received(b"".join(output)) - self.transport.set_protocol(protocol) - - def send_400_response(self, msg: str) -> None: - reason = STATUS_PHRASES[400] - headers: list[tuple[bytes, bytes]] = [ - (b"content-type", b"text/plain; charset=utf-8"), - (b"connection", b"close"), - ] - event = h11.Response(status_code=400, headers=headers, reason=reason) - output = self.conn.send(event) - self.transport.write(output) - - output = self.conn.send(event=h11.Data(data=msg.encode("ascii"))) - self.transport.write(output) - - output = self.conn.send(event=h11.EndOfMessage()) - self.transport.write(output) - - self.transport.close() - - def on_response_complete(self) -> None: - self.server_state.total_requests += 1 - - if self.transport.is_closing(): - return - - # 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) - - # Unpause data reads if needed. - self.flow.resume_reading() - - # Unblock any pipelined events. - if self.conn.our_state is h11.DONE and self.conn.their_state is h11.DONE: - self.conn.start_next_cycle() - self.handle_events() - - def shutdown(self) -> None: - """ - Called by the server to commence a graceful shutdown. - """ - if self.cycle is None or self.cycle.response_complete: - event = h11.ConnectionClosed() - self.conn.send(event) - self.transport.close() - else: - self.cycle.keep_alive = False - - def pause_writing(self) -> None: - """ - Called by the transport when the write buffer exceeds the high water mark. - """ - self.flow.pause_writing() - - def resume_writing(self) -> None: - """ - Called by the transport when the write buffer drops below the low water mark. - """ - self.flow.resume_writing() - - def timeout_keep_alive_handler(self) -> None: - """ - Called on a keep-alive connection if no new data is received after a short - delay. - """ - if not self.transport.is_closing(): - event = h11.ConnectionClosed() - self.conn.send(event) - self.transport.close() - - -class RequestResponseCycle: - def __init__( - self, - scope: HTTPScope, - conn: h11.Connection, - transport: asyncio.Transport, - flow: FlowControl, - logger: logging.Logger, - access_logger: logging.Logger, - access_log: bool, - default_headers: list[tuple[bytes, bytes]], - message_event: asyncio.Event, - on_response: Callable[..., None], - ) -> None: - self.scope = scope - self.conn = conn - self.transport = transport - self.flow = flow - self.logger = logger - self.access_logger = access_logger - self.access_log = access_log - self.default_headers = default_headers - self.message_event = message_event - self.on_response = on_response - - # Connection state - self.disconnected = False - self.keep_alive = True - self.waiting_for_100_continue = conn.they_are_waiting_for_100_continue - - # Request state - self.body = b"" - self.more_body = True - - # Response state - self.response_started = False - self.response_complete = False - - # ASGI exception wrapper - async def run_asgi(self, app: ASGI3Application) -> None: - try: - result = await app( # type: ignore[func-returns-value] - self.scope, self.receive, self.send - ) - except BaseException as exc: - msg = "Exception in ASGI application\n" - self.logger.error(msg, exc_info=exc) - if not self.response_started: - await self.send_500_response() - else: - self.transport.close() - else: - if result is not None: - msg = "ASGI callable should return None, but returned '%s'." - self.logger.error(msg, result) - self.transport.close() - elif not self.response_started and not self.disconnected: - msg = "ASGI callable returned without starting response." - self.logger.error(msg) - await self.send_500_response() - elif not self.response_complete and not self.disconnected: - msg = "ASGI callable returned without completing response." - self.logger.error(msg) - self.transport.close() - finally: - self.on_response = lambda: None - - async def send_500_response(self) -> None: - response_start_event: HTTPResponseStartEvent = { - "type": "http.response.start", - "status": 500, - "headers": [ - (b"content-type", b"text/plain; charset=utf-8"), - (b"connection", b"close"), - ], - } - await self.send(response_start_event) - response_body_event: HTTPResponseBodyEvent = { - "type": "http.response.body", - "body": b"Internal Server Error", - "more_body": False, - } - await self.send(response_body_event) - - # ASGI interface - async def send(self, message: ASGISendEvent) -> None: - message_type = message["type"] - - if self.flow.write_paused and not self.disconnected: - await self.flow.drain() - - if self.disconnected: - return - - if not self.response_started: - # Sending response status line and headers - if message_type != "http.response.start": - msg = "Expected ASGI message 'http.response.start', but got '%s'." - raise RuntimeError(msg % message_type) - message = cast("HTTPResponseStartEvent", message) - - self.response_started = True - self.waiting_for_100_continue = False - - status = message["status"] - headers = self.default_headers + list(message.get("headers", [])) - - if CLOSE_HEADER in self.scope["headers"] and CLOSE_HEADER not in headers: - headers = headers + [CLOSE_HEADER] - - if self.access_log: - self.access_logger.info( - '%s - "%s %s HTTP/%s" %d', - get_client_addr(self.scope), - self.scope["method"], - get_path_with_query_string(self.scope), - self.scope["http_version"], - status, - ) - - # Write response status line and headers - reason = STATUS_PHRASES[status] - response = h11.Response(status_code=status, headers=headers, reason=reason) - output = self.conn.send(event=response) - self.transport.write(output) - - elif not self.response_complete: - # Sending response body - if message_type != "http.response.body": - msg = "Expected ASGI message 'http.response.body', but got '%s'." - raise RuntimeError(msg % message_type) - message = cast("HTTPResponseBodyEvent", message) - - body = message.get("body", b"") - more_body = message.get("more_body", False) - - # Write response body - data = b"" if self.scope["method"] == "HEAD" else body - output = self.conn.send(event=h11.Data(data=data)) - self.transport.write(output) - - # Handle response completion - if not more_body: - self.response_complete = True - self.message_event.set() - output = self.conn.send(event=h11.EndOfMessage()) - self.transport.write(output) - - else: - # Response already sent - msg = "Unexpected ASGI message '%s' sent, after response already completed." - raise RuntimeError(msg % message_type) - - if self.response_complete: - if self.conn.our_state is h11.MUST_CLOSE or not self.keep_alive: - self.conn.send(event=h11.ConnectionClosed()) - self.transport.close() - self.on_response() - - 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") - output = self.conn.send(event=event) - self.transport.write(output) - self.waiting_for_100_continue = False - - if not self.disconnected and not self.response_complete: - self.flow.resume_reading() - await self.message_event.wait() - self.message_event.clear() - - if self.disconnected or self.response_complete: - return {"type": "http.disconnect"} - - message: HTTPRequestEvent = { - "type": "http.request", - "body": self.body, - "more_body": self.more_body, - } - self.body = b"" - return message diff --git a/venv/lib/python3.11/site-packages/uvicorn/protocols/http/httptools_impl.py b/venv/lib/python3.11/site-packages/uvicorn/protocols/http/httptools_impl.py deleted file mode 100644 index 997c6bb..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/protocols/http/httptools_impl.py +++ /dev/null @@ -1,575 +0,0 @@ -from __future__ import annotations - -import asyncio -import http -import logging -import re -import urllib -from asyncio.events import TimerHandle -from collections import deque -from typing import Any, Callable, Literal, cast - -import httptools - -from uvicorn._types import ( - ASGI3Application, - ASGIReceiveEvent, - ASGISendEvent, - HTTPRequestEvent, - HTTPResponseBodyEvent, - HTTPResponseStartEvent, - HTTPScope, -) -from uvicorn.config import Config -from uvicorn.logging import TRACE_LOG_LEVEL -from uvicorn.protocols.http.flow_control import ( - CLOSE_HEADER, - HIGH_WATER_LIMIT, - FlowControl, - service_unavailable, -) -from uvicorn.protocols.utils import ( - get_client_addr, - get_local_addr, - get_path_with_query_string, - get_remote_addr, - is_ssl, -) -from uvicorn.server import ServerState - -HEADER_RE = re.compile(b'[\x00-\x1F\x7F()<>@,;:[]={} \t\\"]') -HEADER_VALUE_RE = re.compile(b"[\x00-\x1F\x7F]") - - -def _get_status_line(status_code: int) -> bytes: - try: - phrase = http.HTTPStatus(status_code).phrase.encode() - except ValueError: - phrase = b"" - 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)} - - -class HttpToolsProtocol(asyncio.Protocol): - def __init__( - self, - config: Config, - server_state: ServerState, - app_state: dict[str, Any], - _loop: asyncio.AbstractEventLoop | None = None, - ) -> None: - if not config.loaded: - config.load() - - self.config = config - self.app = config.loaded_app - self.loop = _loop or asyncio.get_event_loop() - self.logger = logging.getLogger("uvicorn.error") - self.access_logger = logging.getLogger("uvicorn.access") - self.access_log = self.access_logger.hasHandlers() - self.parser = httptools.HttpRequestParser(self) - self.ws_protocol_class = config.ws_protocol_class - self.root_path = config.root_path - self.limit_concurrency = config.limit_concurrency - self.app_state = app_state - - # Timeouts - self.timeout_keep_alive_task: TimerHandle | None = None - self.timeout_keep_alive = config.timeout_keep_alive - - # Global state - self.server_state = server_state - self.connections = server_state.connections - self.tasks = server_state.tasks - - # Per-connection state - self.transport: asyncio.Transport = None # type: ignore[assignment] - self.flow: FlowControl = None # type: ignore[assignment] - 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() - - # Per-request state - self.scope: HTTPScope = None # type: ignore[assignment] - self.headers: list[tuple[bytes, bytes]] = None # type: ignore[assignment] - self.expect_100_continue = False - self.cycle: RequestResponseCycle = None # type: ignore[assignment] - - # Protocol interface - def connection_made( # type: ignore[override] - self, transport: asyncio.Transport - ) -> None: - self.connections.add(self) - - self.transport = transport - self.flow = FlowControl(transport) - self.server = get_local_addr(transport) - self.client = get_remote_addr(transport) - self.scheme = "https" if is_ssl(transport) else "http" - - if self.logger.level <= TRACE_LOG_LEVEL: - prefix = "%s:%d - " % self.client if self.client else "" - self.logger.log(TRACE_LOG_LEVEL, "%sHTTP connection made", prefix) - - def connection_lost(self, exc: Exception | None) -> None: - self.connections.discard(self) - - if self.logger.level <= TRACE_LOG_LEVEL: - prefix = "%s:%d - " % self.client if self.client else "" - self.logger.log(TRACE_LOG_LEVEL, "%sHTTP connection lost", prefix) - - if self.cycle and not self.cycle.response_complete: - self.cycle.disconnected = True - if self.cycle is not None: - self.cycle.message_event.set() - if self.flow is not None: - self.flow.resume_writing() - if exc is None: - self.transport.close() - self._unset_keepalive_if_required() - - self.parser = None - - def eof_received(self) -> None: - pass - - def _unset_keepalive_if_required(self) -> None: - if self.timeout_keep_alive_task is not None: - self.timeout_keep_alive_task.cancel() - self.timeout_keep_alive_task = None - - def _get_upgrade(self) -> bytes | None: - connection = [] - upgrade = None - for name, value in self.headers: - if name == b"connection": - connection = [token.lower().strip() for token in value.split(b",")] - if name == b"upgrade": - upgrade = value.lower() - if b"upgrade" in connection: - return upgrade - return None - - def _should_upgrade_to_ws(self, upgrade: bytes | None) -> bool: - if upgrade == b"websocket" and self.ws_protocol_class is not None: - return True - if self.config.ws == "auto": - msg = "Unsupported upgrade request." - self.logger.warning(msg) - msg = "No supported WebSocket library detected. Please use \"pip install 'uvicorn[standard]'\", or install 'websockets' or 'wsproto' manually." # noqa: E501 - self.logger.warning(msg) - return False - - def _should_upgrade(self) -> bool: - upgrade = self._get_upgrade() - return self._should_upgrade_to_ws(upgrade) - - def data_received(self, data: bytes) -> None: - self._unset_keepalive_if_required() - - try: - self.parser.feed_data(data) - except httptools.HttpParserError: - msg = "Invalid HTTP request received." - self.logger.warning(msg) - self.send_400_response(msg) - return - except httptools.HttpParserUpgrade: - upgrade = self._get_upgrade() - if self._should_upgrade_to_ws(upgrade): - self.handle_websocket_upgrade() - - def handle_websocket_upgrade(self) -> None: - if self.logger.level <= TRACE_LOG_LEVEL: - prefix = "%s:%d - " % self.client if self.client else "" - self.logger.log(TRACE_LOG_LEVEL, "%sUpgrading to WebSocket", prefix) - - self.connections.discard(self) - method = self.scope["method"].encode() - output = [method, b" ", self.url, b" HTTP/1.1\r\n"] - for name, value in self.scope["headers"]: - output += [name, b": ", value, b"\r\n"] - output.append(b"\r\n") - protocol = self.ws_protocol_class( # type: ignore[call-arg, misc] - config=self.config, - server_state=self.server_state, - app_state=self.app_state, - ) - protocol.connection_made(self.transport) - protocol.data_received(b"".join(output)) - self.transport.set_protocol(protocol) - - def send_400_response(self, msg: str) -> None: - content = [STATUS_LINE[400]] - for name, value in self.server_state.default_headers: - content.extend([name, b": ", value, b"\r\n"]) - content.extend( - [ - 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", - msg.encode("ascii"), - ] - ) - self.transport.write(b"".join(content)) - self.transport.close() - - def on_message_begin(self) -> None: - self.url = b"" - self.expect_100_continue = False - self.headers = [] - self.scope = { # type: ignore[typeddict-item] - "type": "http", - "asgi": {"version": self.config.asgi_version, "spec_version": "2.4"}, - "http_version": "1.1", - "server": self.server, - "client": self.client, - "scheme": self.scheme, # type: ignore[typeddict-item] - "root_path": self.root_path, - "headers": self.headers, - "state": self.app_state.copy(), - } - - # Parser callbacks - def on_url(self, url: bytes) -> None: - self.url += url - - def on_header(self, name: bytes, value: bytes) -> None: - name = name.lower() - if name == b"expect" and value.lower() == b"100-continue": - self.expect_100_continue = True - self.headers.append((name, value)) - - def on_headers_complete(self) -> None: - http_version = self.parser.get_http_version() - method = self.parser.get_method() - self.scope["method"] = method.decode("ascii") - if http_version != "1.1": - self.scope["http_version"] = http_version - if self.parser.should_upgrade() and self._should_upgrade(): - return - parsed_url = httptools.parse_url(self.url) - raw_path = parsed_url.path - path = raw_path.decode("ascii") - if "%" in path: - path = urllib.parse.unquote(path) - full_path = self.root_path + path - full_raw_path = self.root_path.encode("ascii") + raw_path - self.scope["path"] = full_path - self.scope["raw_path"] = full_raw_path - self.scope["query_string"] = parsed_url.query or b"" - - # 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 - ): - app = service_unavailable - message = "Exceeded concurrency limit." - self.logger.warning(message) - else: - app = self.app - - existing_cycle = self.cycle - self.cycle = RequestResponseCycle( - scope=self.scope, - transport=self.transport, - flow=self.flow, - logger=self.logger, - access_logger=self.access_logger, - access_log=self.access_log, - default_headers=self.server_state.default_headers, - message_event=asyncio.Event(), - expect_100_continue=self.expect_100_continue, - keep_alive=http_version != "1.0", - on_response=self.on_response_complete, - ) - if existing_cycle is None or existing_cycle.response_complete: - # Standard case - start processing the request. - task = self.loop.create_task(self.cycle.run_asgi(app)) - task.add_done_callback(self.tasks.discard) - self.tasks.add(task) - else: - # Pipelined HTTP requests need to be queued up. - self.flow.pause_reading() - 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: - return - self.cycle.body += body - if len(self.cycle.body) > HIGH_WATER_LIMIT: - self.flow.pause_reading() - 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: - return - self.cycle.more_body = False - self.cycle.message_event.set() - - def on_response_complete(self) -> None: - # Callback for pipelined HTTP requests to be started. - self.server_state.total_requests += 1 - - if self.transport.is_closing(): - return - - self._unset_keepalive_if_required() - - # Unpause data reads if needed. - self.flow.resume_reading() - - # Unblock any pipelined events. If there are none, arm the - # Keep-Alive timeout instead. - if self.pipeline: - cycle, app = self.pipeline.pop() - task = self.loop.create_task(cycle.run_asgi(app)) - task.add_done_callback(self.tasks.discard) - self.tasks.add(task) - else: - self.timeout_keep_alive_task = self.loop.call_later( - self.timeout_keep_alive, self.timeout_keep_alive_handler - ) - - def shutdown(self) -> None: - """ - Called by the server to commence a graceful shutdown. - """ - if self.cycle is None or self.cycle.response_complete: - self.transport.close() - else: - self.cycle.keep_alive = False - - def pause_writing(self) -> None: - """ - Called by the transport when the write buffer exceeds the high water mark. - """ - self.flow.pause_writing() - - def resume_writing(self) -> None: - """ - Called by the transport when the write buffer drops below the low water mark. - """ - self.flow.resume_writing() - - def timeout_keep_alive_handler(self) -> None: - """ - Called on a keep-alive connection if no new data is received after a short - delay. - """ - if not self.transport.is_closing(): - self.transport.close() - - -class RequestResponseCycle: - def __init__( - self, - scope: HTTPScope, - transport: asyncio.Transport, - flow: FlowControl, - logger: logging.Logger, - access_logger: logging.Logger, - access_log: bool, - default_headers: list[tuple[bytes, bytes]], - message_event: asyncio.Event, - expect_100_continue: bool, - keep_alive: bool, - on_response: Callable[..., None], - ): - self.scope = scope - self.transport = transport - self.flow = flow - self.logger = logger - self.access_logger = access_logger - self.access_log = access_log - self.default_headers = default_headers - self.message_event = message_event - self.on_response = on_response - - # Connection state - self.disconnected = False - self.keep_alive = keep_alive - self.waiting_for_100_continue = expect_100_continue - - # Request state - self.body = b"" - self.more_body = True - - # Response state - self.response_started = False - self.response_complete = False - self.chunked_encoding: bool | None = None - self.expected_content_length = 0 - - # ASGI exception wrapper - async def run_asgi(self, app: ASGI3Application) -> None: - try: - result = await app( # type: ignore[func-returns-value] - self.scope, self.receive, self.send - ) - except BaseException as exc: - msg = "Exception in ASGI application\n" - self.logger.error(msg, exc_info=exc) - if not self.response_started: - await self.send_500_response() - else: - self.transport.close() - else: - if result is not None: - msg = "ASGI callable should return None, but returned '%s'." - self.logger.error(msg, result) - self.transport.close() - elif not self.response_started and not self.disconnected: - msg = "ASGI callable returned without starting response." - self.logger.error(msg) - await self.send_500_response() - elif not self.response_complete and not self.disconnected: - msg = "ASGI callable returned without completing response." - self.logger.error(msg) - self.transport.close() - finally: - self.on_response = lambda: None - - async def send_500_response(self) -> None: - response_start_event: HTTPResponseStartEvent = { - "type": "http.response.start", - "status": 500, - "headers": [ - (b"content-type", b"text/plain; charset=utf-8"), - (b"connection", b"close"), - ], - } - await self.send(response_start_event) - response_body_event: HTTPResponseBodyEvent = { - "type": "http.response.body", - "body": b"Internal Server Error", - "more_body": False, - } - await self.send(response_body_event) - - # ASGI interface - async def send(self, message: ASGISendEvent) -> None: - message_type = message["type"] - - if self.flow.write_paused and not self.disconnected: - await self.flow.drain() - - if self.disconnected: - return - - if not self.response_started: - # Sending response status line and headers - if message_type != "http.response.start": - msg = "Expected ASGI message 'http.response.start', but got '%s'." - raise RuntimeError(msg % message_type) - message = cast("HTTPResponseStartEvent", message) - - self.response_started = True - self.waiting_for_100_continue = False - - status_code = message["status"] - headers = self.default_headers + list(message.get("headers", [])) - - if CLOSE_HEADER in self.scope["headers"] and CLOSE_HEADER not in headers: - headers = headers + [CLOSE_HEADER] - - if self.access_log: - self.access_logger.info( - '%s - "%s %s HTTP/%s" %d', - get_client_addr(self.scope), - self.scope["method"], - get_path_with_query_string(self.scope), - self.scope["http_version"], - status_code, - ) - - # Write response status line and headers - content = [STATUS_LINE[status_code]] - - for name, value in headers: - if HEADER_RE.search(name): - raise RuntimeError("Invalid HTTP header name.") - if HEADER_VALUE_RE.search(value): - raise RuntimeError("Invalid HTTP header value.") - - name = name.lower() - if name == b"content-length" and self.chunked_encoding is None: - self.expected_content_length = int(value.decode()) - self.chunked_encoding = False - elif name == b"transfer-encoding" and value.lower() == b"chunked": - self.expected_content_length = 0 - self.chunked_encoding = True - elif name == b"connection" and value.lower() == b"close": - 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): - # Neither content-length nor transfer-encoding specified - self.chunked_encoding = True - content.append(b"transfer-encoding: chunked\r\n") - - content.append(b"\r\n") - self.transport.write(b"".join(content)) - - elif not self.response_complete: - # Sending response body - if message_type != "http.response.body": - msg = "Expected ASGI message 'http.response.body', but got '%s'." - raise RuntimeError(msg % message_type) - - body = cast(bytes, message.get("body", b"")) - more_body = message.get("more_body", False) - - # Write response body - if self.scope["method"] == "HEAD": - self.expected_content_length = 0 - elif self.chunked_encoding: - if body: - content = [b"%x\r\n" % len(body), body, b"\r\n"] - else: - content = [] - if not more_body: - content.append(b"0\r\n\r\n") - self.transport.write(b"".join(content)) - else: - num_bytes = len(body) - if num_bytes > self.expected_content_length: - raise RuntimeError("Response content longer than Content-Length") - else: - self.expected_content_length -= num_bytes - self.transport.write(body) - - # Handle response completion - if not more_body: - if self.expected_content_length != 0: - raise RuntimeError("Response content shorter than Content-Length") - self.response_complete = True - self.message_event.set() - if not self.keep_alive: - self.transport.close() - self.on_response() - - else: - # Response already sent - msg = "Unexpected ASGI message '%s' sent, after response already completed." - raise RuntimeError(msg % message_type) - - 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 - - if not self.disconnected and not self.response_complete: - self.flow.resume_reading() - await self.message_event.wait() - self.message_event.clear() - - if self.disconnected or self.response_complete: - return {"type": "http.disconnect"} - message: HTTPRequestEvent = {"type": "http.request", "body": self.body, "more_body": self.more_body} - self.body = b"" - return message diff --git a/venv/lib/python3.11/site-packages/uvicorn/protocols/utils.py b/venv/lib/python3.11/site-packages/uvicorn/protocols/utils.py deleted file mode 100644 index 4e65806..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/protocols/utils.py +++ /dev/null @@ -1,57 +0,0 @@ -from __future__ import annotations - -import asyncio -import urllib.parse - -from uvicorn._types import WWWScope - - -class ClientDisconnected(IOError): - ... - - -def get_remote_addr(transport: asyncio.Transport) -> tuple[str, int] | None: - socket_info = transport.get_extra_info("socket") - if socket_info is not None: - try: - info = socket_info.getpeername() - return (str(info[0]), int(info[1])) if isinstance(info, tuple) else None - except OSError: # pragma: no cover - # This case appears to inconsistently occur with uvloop - # bound to a unix domain socket. - return None - - info = transport.get_extra_info("peername") - if info is not None and isinstance(info, (list, tuple)) and len(info) == 2: - return (str(info[0]), int(info[1])) - return None - - -def get_local_addr(transport: asyncio.Transport) -> tuple[str, int] | None: - socket_info = transport.get_extra_info("socket") - if socket_info is not None: - info = socket_info.getsockname() - - return (str(info[0]), int(info[1])) if isinstance(info, tuple) else None - info = transport.get_extra_info("sockname") - if info is not None and isinstance(info, (list, tuple)) and len(info) == 2: - return (str(info[0]), int(info[1])) - return None - - -def is_ssl(transport: asyncio.Transport) -> bool: - return bool(transport.get_extra_info("sslcontext")) - - -def get_client_addr(scope: WWWScope) -> str: - client = scope.get("client") - if not client: - return "" - return "%s:%d" % client - - -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")) - return path_with_query_string diff --git a/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/__init__.py b/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/__init__.py +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/__pycache__/__init__.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/__pycache__/__init__.cpython-311.pyc Binary files differdeleted file mode 100644 index d216ab9..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/__pycache__/__init__.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/__pycache__/auto.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/__pycache__/auto.cpython-311.pyc Binary files differdeleted file mode 100644 index e8c06fa..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/__pycache__/auto.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/__pycache__/websockets_impl.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/__pycache__/websockets_impl.cpython-311.pyc Binary files differdeleted file mode 100644 index 334a441..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/__pycache__/websockets_impl.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/__pycache__/wsproto_impl.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/__pycache__/wsproto_impl.cpython-311.pyc Binary files differdeleted file mode 100644 index 3b1911e..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/__pycache__/wsproto_impl.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/auto.py b/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/auto.py deleted file mode 100644 index 08fd136..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/auto.py +++ /dev/null @@ -1,21 +0,0 @@ -from __future__ import annotations - -import asyncio -import typing - -AutoWebSocketsProtocol: typing.Callable[..., asyncio.Protocol] | None -try: - import websockets # noqa -except ImportError: # pragma: no cover - try: - import wsproto # noqa - except ImportError: - AutoWebSocketsProtocol = None - else: - from uvicorn.protocols.websockets.wsproto_impl import WSProtocol - - AutoWebSocketsProtocol = WSProtocol -else: - from uvicorn.protocols.websockets.websockets_impl import WebSocketProtocol - - AutoWebSocketsProtocol = WebSocketProtocol diff --git a/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/websockets_impl.py b/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/websockets_impl.py deleted file mode 100644 index 6d098d5..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/websockets_impl.py +++ /dev/null @@ -1,388 +0,0 @@ -from __future__ import annotations - -import asyncio -import http -import logging -from typing import Any, Literal, Optional, Sequence, cast -from urllib.parse import unquote - -import websockets -from websockets.datastructures import Headers -from websockets.exceptions import ConnectionClosed -from websockets.extensions.permessage_deflate import ServerPerMessageDeflateFactory -from websockets.legacy.server import HTTPResponse -from websockets.server import WebSocketServerProtocol -from websockets.typing import Subprotocol - -from uvicorn._types import ( - ASGISendEvent, - WebSocketAcceptEvent, - WebSocketCloseEvent, - WebSocketConnectEvent, - WebSocketDisconnectEvent, - WebSocketReceiveEvent, - WebSocketResponseBodyEvent, - WebSocketResponseStartEvent, - WebSocketScope, - WebSocketSendEvent, -) -from uvicorn.config import Config -from uvicorn.logging import TRACE_LOG_LEVEL -from uvicorn.protocols.utils import ( - ClientDisconnected, - get_local_addr, - get_path_with_query_string, - get_remote_addr, - is_ssl, -) -from uvicorn.server import ServerState - - -class Server: - closing = False - - def register(self, ws: WebSocketServerProtocol) -> None: - pass - - def unregister(self, ws: WebSocketServerProtocol) -> None: - pass - - def is_serving(self) -> bool: - return not self.closing - - -class WebSocketProtocol(WebSocketServerProtocol): - extra_headers: list[tuple[str, str]] - - def __init__( - self, - config: Config, - server_state: ServerState, - app_state: dict[str, Any], - _loop: asyncio.AbstractEventLoop | None = None, - ): - if not config.loaded: - config.load() - - self.config = config - self.app = config.loaded_app - self.loop = _loop or asyncio.get_event_loop() - self.root_path = config.root_path - self.app_state = app_state - - # Shared server state - self.connections = server_state.connections - self.tasks = server_state.tasks - - # Connection state - self.transport: asyncio.Transport = None # type: ignore[assignment] - self.server: tuple[str, int] | None = None - self.client: tuple[str, int] | None = None - self.scheme: Literal["wss", "ws"] = None # type: ignore[assignment] - - # Connection events - self.scope: WebSocketScope - self.handshake_started_event = asyncio.Event() - self.handshake_completed_event = asyncio.Event() - self.closed_event = asyncio.Event() - self.initial_response: HTTPResponse | None = None - self.connect_sent = False - self.lost_connection_before_handshake = False - self.accepted_subprotocol: Subprotocol | None = None - - self.ws_server: Server = Server() # type: ignore[assignment] - - extensions = [] - if self.config.ws_per_message_deflate: - extensions.append(ServerPerMessageDeflateFactory()) - - super().__init__( - ws_handler=self.ws_handler, - ws_server=self.ws_server, # type: ignore[arg-type] - max_size=self.config.ws_max_size, - max_queue=self.config.ws_max_queue, - ping_interval=self.config.ws_ping_interval, - ping_timeout=self.config.ws_ping_timeout, - extensions=extensions, - logger=logging.getLogger("uvicorn.error"), - ) - self.server_header = None - self.extra_headers = [ - (name.decode("latin-1"), value.decode("latin-1")) for name, value in server_state.default_headers - ] - - def connection_made( # type: ignore[override] - self, transport: asyncio.Transport - ) -> None: - self.connections.add(self) - self.transport = transport - self.server = get_local_addr(transport) - self.client = get_remote_addr(transport) - self.scheme = "wss" if is_ssl(transport) else "ws" - - if self.logger.isEnabledFor(TRACE_LOG_LEVEL): - prefix = "%s:%d - " % self.client if self.client else "" - self.logger.log(TRACE_LOG_LEVEL, "%sWebSocket connection made", prefix) - - super().connection_made(transport) - - 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.handshake_completed_event.set() - super().connection_lost(exc) - if exc is None: - self.transport.close() - - def shutdown(self) -> None: - self.ws_server.closing = True - if self.handshake_completed_event.is_set(): - self.fail_connection(1012) - else: - self.send_500_response() - self.transport.close() - - def on_task_complete(self, task: asyncio.Task) -> None: - self.tasks.discard(task) - - 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. - - Our behavior here is to start the ASGI application, and then wait - for either `accept` or `close` in order to determine if we should - close the connection. - """ - path_portion, _, query_string = path.partition("?") - - websockets.legacy.handshake.check_request(headers) - - subprotocols = [] - for header in headers.get_all("Sec-WebSocket-Protocol"): - subprotocols.extend([token.strip() for token in header.split(",")]) - - asgi_headers = [ - (name.encode("ascii"), value.encode("ascii", errors="surrogateescape")) - for name, value in headers.raw_items() - ] - path = unquote(path_portion) - full_path = self.root_path + path - full_raw_path = self.root_path.encode("ascii") + path_portion.encode("ascii") - - self.scope = { - "type": "websocket", - "asgi": {"version": self.config.asgi_version, "spec_version": "2.4"}, - "http_version": "1.1", - "scheme": self.scheme, - "server": self.server, - "client": self.client, - "root_path": self.root_path, - "path": full_path, - "raw_path": full_raw_path, - "query_string": query_string.encode("ascii"), - "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) - self.tasks.add(task) - await self.handshake_started_event.wait() - return self.initial_response - - def process_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. - """ - return self.accepted_subprotocol - - 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"content-length: " + str(len(msg)).encode("ascii") + b"\r\n", - b"connection: close\r\n", - b"\r\n", - msg, - ] - self.transport.write(b"".join(content)) - # Allow handler task to terminate cleanly, as websockets doesn't cancel it by - # itself (see https://github.com/encode/uvicorn/issues/920) - self.handshake_started_event.set() - - async def ws_handler( # type: ignore[override] - self, protocol: WebSocketServerProtocol, path: str - ) -> Any: - """ - This is the main handler function for the 'websockets' implementation - to call into. We just wait for close then return, and instead allow - 'send' and 'receive' events to drive the flow. - """ - self.handshake_completed_event.set() - await self.wait_closed() - - async def run_asgi(self) -> None: - """ - Wrapper around the ASGI callable, handling exceptions and unexpected - termination states. - """ - try: - result = await self.app(self.scope, self.asgi_receive, self.asgi_send) - except ClientDisconnected: - self.closed_event.set() - self.transport.close() - except BaseException as exc: - self.closed_event.set() - msg = "Exception in ASGI application\n" - self.logger.error(msg, exc_info=exc) - if not self.handshake_started_event.is_set(): - self.send_500_response() - else: - await self.handshake_completed_event.wait() - self.transport.close() - else: - self.closed_event.set() - if not self.handshake_started_event.is_set(): - msg = "ASGI callable returned without sending handshake." - self.logger.error(msg) - self.send_500_response() - self.transport.close() - elif result is not None: - msg = "ASGI callable should return None, but returned '%s'." - self.logger.error(msg, result) - await self.handshake_completed_event.wait() - self.transport.close() - - async def asgi_send(self, message: ASGISendEvent) -> None: - message_type = message["type"] - - if not self.handshake_started_event.is_set(): - if message_type == "websocket.accept": - message = cast("WebSocketAcceptEvent", message) - self.logger.info( - '%s - "WebSocket %s" [accepted]', - self.scope["client"], - get_path_with_query_string(self.scope), - ) - self.initial_response = None - self.accepted_subprotocol = cast(Optional[Subprotocol], message.get("subprotocol")) - if "headers" in message: - self.extra_headers.extend( - # ASGI spec requires bytes - # But for compatibility we need to convert it to strings - (name.decode("latin-1"), value.decode("latin-1")) - for name, value in message["headers"] - ) - self.handshake_started_event.set() - - elif message_type == "websocket.close": - message = cast("WebSocketCloseEvent", message) - self.logger.info( - '%s - "WebSocket %s" 403', - self.scope["client"], - get_path_with_query_string(self.scope), - ) - self.initial_response = (http.HTTPStatus.FORBIDDEN, [], b"") - 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', 'websocket.close', " - "or 'websocket.http.response.start' but got '%s'." - ) - raise RuntimeError(msg % message_type) - - elif not self.closed_event.is_set() and self.initial_response is None: - await self.handshake_completed_event.wait() - - try: - if message_type == "websocket.send": - message = cast("WebSocketSendEvent", message) - bytes_data = message.get("bytes") - text_data = message.get("text") - data = text_data if bytes_data is None else bytes_data - await self.send(data) # type: ignore[arg-type] - - elif message_type == "websocket.close": - message = cast("WebSocketCloseEvent", message) - code = message.get("code", 1000) - reason = message.get("reason", "") or "" - await self.close(code, reason) - self.closed_event.set() - - else: - 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 - - 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' " "or response already completed." - raise RuntimeError(msg % message_type) - - async def asgi_receive( - self, - ) -> WebSocketDisconnectEvent | WebSocketConnectEvent | WebSocketReceiveEvent: - if not self.connect_sent: - self.connect_sent = True - return {"type": "websocket.connect"} - - await self.handshake_completed_event.wait() - - if self.lost_connection_before_handshake: - # If the handshake failed or the app closed before handshake completion, - # use 1006 Abnormal Closure. - return {"type": "websocket.disconnect", "code": 1006} - - if self.closed_event.is_set(): - return {"type": "websocket.disconnect", "code": 1005} - - try: - data = await self.recv() - except ConnectionClosed as exc: - self.closed_event.set() - if self.ws_server.closing: - return {"type": "websocket.disconnect", "code": 1012} - return {"type": "websocket.disconnect", "code": exc.code} - - if isinstance(data, str): - return {"type": "websocket.receive", "text": data} - return {"type": "websocket.receive", "bytes": data} diff --git a/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/wsproto_impl.py b/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/wsproto_impl.py deleted file mode 100644 index c926252..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/protocols/websockets/wsproto_impl.py +++ /dev/null @@ -1,377 +0,0 @@ -from __future__ import annotations - -import asyncio -import logging -import typing -from typing import Literal -from urllib.parse import unquote - -import wsproto -from wsproto import ConnectionType, events -from wsproto.connection import ConnectionState -from wsproto.extensions import Extension, PerMessageDeflate -from wsproto.utilities import LocalProtocolError, RemoteProtocolError - -from uvicorn._types import ( - ASGISendEvent, - WebSocketAcceptEvent, - WebSocketCloseEvent, - WebSocketEvent, - WebSocketResponseBodyEvent, - WebSocketResponseStartEvent, - WebSocketScope, - WebSocketSendEvent, -) -from uvicorn.config import Config -from uvicorn.logging import TRACE_LOG_LEVEL -from uvicorn.protocols.utils import ( - ClientDisconnected, - get_local_addr, - get_path_with_query_string, - get_remote_addr, - is_ssl, -) -from uvicorn.server import ServerState - - -class WSProtocol(asyncio.Protocol): - def __init__( - self, - config: Config, - server_state: ServerState, - app_state: dict[str, typing.Any], - _loop: asyncio.AbstractEventLoop | None = None, - ) -> None: - if not config.loaded: - config.load() - - self.config = config - self.app = config.loaded_app - self.loop = _loop or asyncio.get_event_loop() - self.logger = logging.getLogger("uvicorn.error") - self.root_path = config.root_path - self.app_state = app_state - - # Shared server state - self.connections = server_state.connections - self.tasks = server_state.tasks - self.default_headers = server_state.default_headers - - # Connection state - self.transport: asyncio.Transport = None # type: ignore[assignment] - self.server: tuple[str, int] | None = None - self.client: tuple[str, int] | None = None - self.scheme: Literal["wss", "ws"] = None # type: ignore[assignment] - - # WebSocket state - self.queue: asyncio.Queue[WebSocketEvent] = asyncio.Queue() - 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 - self.writable = asyncio.Event() - self.writable.set() - - # Buffers - self.bytes = b"" - self.text = "" - - # Protocol interface - - def connection_made( # type: ignore[override] - self, transport: asyncio.Transport - ) -> None: - self.connections.add(self) - self.transport = transport - self.server = get_local_addr(transport) - self.client = get_remote_addr(transport) - self.scheme = "wss" if is_ssl(transport) else "ws" - - if self.logger.level <= TRACE_LOG_LEVEL: - prefix = "%s:%d - " % self.client if self.client else "" - self.logger.log(TRACE_LOG_LEVEL, "%sWebSocket connection made", prefix) - - def connection_lost(self, exc: Exception | None) -> None: - code = 1005 if self.handshake_complete else 1006 - self.queue.put_nowait({"type": "websocket.disconnect", "code": code}) - self.connections.remove(self) - - if self.logger.level <= TRACE_LOG_LEVEL: - prefix = "%s:%d - " % self.client if self.client else "" - self.logger.log(TRACE_LOG_LEVEL, "%sWebSocket connection lost", prefix) - - self.handshake_complete = True - if exc is None: - self.transport.close() - - def eof_received(self) -> None: - pass - - def data_received(self, data: bytes) -> None: - try: - self.conn.receive_data(data) - except RemoteProtocolError as err: - # TODO: Remove `type: ignore` when wsproto fixes the type annotation. - self.transport.write(self.conn.send(err.event_hint)) # type: ignore[arg-type] # noqa: E501 - self.transport.close() - else: - self.handle_events() - - def handle_events(self) -> None: - for event in self.conn.events(): - if isinstance(event, events.Request): - self.handle_connect(event) - elif isinstance(event, events.TextMessage): - self.handle_text(event) - elif isinstance(event, events.BytesMessage): - self.handle_bytes(event) - elif isinstance(event, events.CloseConnection): - self.handle_close(event) - elif isinstance(event, events.Ping): - self.handle_ping(event) - - def pause_writing(self) -> None: - """ - Called by the transport when the write buffer exceeds the high water mark. - """ - self.writable.clear() - - def resume_writing(self) -> None: - """ - Called by the transport when the write buffer drops below the low water mark. - """ - self.writable.set() - - def shutdown(self) -> None: - if self.handshake_complete: - self.queue.put_nowait({"type": "websocket.disconnect", "code": 1012}) - output = self.conn.send(wsproto.events.CloseConnection(code=1012)) - self.transport.write(output) - else: - self.send_500_response() - self.transport.close() - - def on_task_complete(self, task: asyncio.Task) -> None: - self.tasks.discard(task) - - # Event handlers - - def handle_connect(self, event: events.Request) -> None: - headers = [(b"host", event.host.encode())] - headers += [(key.lower(), value) for key, value in event.extra_headers] - raw_path, _, query_string = event.target.partition("?") - 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 = { - "type": "websocket", - "asgi": {"version": self.config.asgi_version, "spec_version": "2.4"}, - "http_version": "1.1", - "scheme": self.scheme, - "server": self.server, - "client": self.client, - "root_path": self.root_path, - "path": full_path, - "raw_path": full_raw_path, - "query_string": query_string.encode("ascii"), - "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()) - task.add_done_callback(self.on_task_complete) - self.tasks.add(task) - - def handle_text(self, event: events.TextMessage) -> None: - self.text += event.data - if event.message_finished: - self.queue.put_nowait({"type": "websocket.receive", "text": self.text}) - self.text = "" - if not self.read_paused: - self.read_paused = True - self.transport.pause_reading() - - def handle_bytes(self, event: events.BytesMessage) -> None: - self.bytes += event.data - # todo: we may want to guard the size of self.bytes and self.text - if event.message_finished: - self.queue.put_nowait({"type": "websocket.receive", "bytes": self.bytes}) - self.bytes = b"" - if not self.read_paused: - self.read_paused = True - self.transport.pause_reading() - - def handle_close(self, event: events.CloseConnection) -> None: - if self.conn.state == ConnectionState.REMOTE_CLOSING: - self.transport.write(self.conn.send(event.response())) - self.queue.put_nowait({"type": "websocket.disconnect", "code": event.code}) - self.transport.close() - - def handle_ping(self, event: events.Ping) -> None: - 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"), - ] - 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: - try: - result = await self.app(self.scope, self.receive, self.send) - except ClientDisconnected: - self.transport.close() - except BaseException: - self.logger.exception("Exception in ASGI application\n") - self.send_500_response() - self.transport.close() - else: - if not self.handshake_complete: - msg = "ASGI callable returned without completing handshake." - self.logger.error(msg) - self.send_500_response() - self.transport.close() - elif result is not None: - msg = "ASGI callable should return None, but returned '%s'." - self.logger.error(msg, result) - self.transport.close() - - async def send(self, message: ASGISendEvent) -> None: - await self.writable.wait() - - message_type = message["type"] - - if not self.handshake_complete: - if message_type == "websocket.accept": - message = typing.cast(WebSocketAcceptEvent, message) - self.logger.info( - '%s - "WebSocket %s" [accepted]', - self.scope["client"], - get_path_with_query_string(self.scope), - ) - subprotocol = message.get("subprotocol") - extra_headers = self.default_headers + list(message.get("headers", [])) - extensions: list[Extension] = [] - if self.config.ws_per_message_deflate: - extensions.append(PerMessageDeflate()) - if not self.transport.is_closing(): - self.handshake_complete = True - output = self.conn.send( - wsproto.events.AcceptConnection( - subprotocol=subprotocol, - extensions=extensions, - extra_headers=extra_headers, - ) - ) - self.transport.write(output) - - elif message_type == "websocket.close": - self.queue.put_nowait({"type": "websocket.disconnect", "code": 1006}) - self.logger.info( - '%s - "WebSocket %s" 403', - self.scope["client"], - get_path_with_query_string(self.scope), - ) - self.handshake_complete = True - self.close_sent = True - event = events.RejectConnection(status_code=403, headers=[]) - output = self.conn.send(event) - 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', 'websocket.close' " - "or 'websocket.http.response.start' " - "but got '%s'." - ) - raise RuntimeError(msg % message_type) - - elif not self.close_sent and not self.response_started: - try: - if message_type == "websocket.send": - message = typing.cast(WebSocketSendEvent, message) - bytes_data = message.get("bytes") - text_data = message.get("text") - data = text_data if bytes_data is None else bytes_data - output = self.conn.send(wsproto.events.Message(data=data)) # type: ignore - if not self.transport.is_closing(): - self.transport.write(output) - - elif message_type == "websocket.close": - message = typing.cast(WebSocketCloseEvent, message) - 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)) - 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'." - raise RuntimeError(msg % message_type) - except LocalProtocolError as exc: - raise ClientDisconnected from exc - 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'." - raise RuntimeError(msg % message_type) - - async def receive(self) -> WebSocketEvent: - message = await self.queue.get() - if self.read_paused and self.queue.empty(): - self.read_paused = False - self.transport.resume_reading() - return message diff --git a/venv/lib/python3.11/site-packages/uvicorn/py.typed b/venv/lib/python3.11/site-packages/uvicorn/py.typed deleted file mode 100644 index 8b13789..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/py.typed +++ /dev/null @@ -1 +0,0 @@ - diff --git a/venv/lib/python3.11/site-packages/uvicorn/server.py b/venv/lib/python3.11/site-packages/uvicorn/server.py deleted file mode 100644 index bfce1b1..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/server.py +++ /dev/null @@ -1,335 +0,0 @@ -from __future__ import annotations - -import asyncio -import contextlib -import logging -import os -import platform -import signal -import socket -import sys -import threading -import time -from email.utils import formatdate -from types import FrameType -from typing import TYPE_CHECKING, Generator, Sequence, Union - -import click - -from uvicorn.config import Config - -if TYPE_CHECKING: - from uvicorn.protocols.http.h11_impl import H11Protocol - from uvicorn.protocols.http.httptools_impl import HttpToolsProtocol - from uvicorn.protocols.websockets.websockets_impl import WebSocketProtocol - from uvicorn.protocols.websockets.wsproto_impl import WSProtocol - - Protocols = Union[H11Protocol, HttpToolsProtocol, WSProtocol, WebSocketProtocol] - -HANDLED_SIGNALS = ( - signal.SIGINT, # Unix signal 2. Sent by Ctrl+C. - signal.SIGTERM, # Unix signal 15. Sent by `kill <pid>`. -) -if sys.platform == "win32": # pragma: py-not-win32 - HANDLED_SIGNALS += (signal.SIGBREAK,) # Windows signal 21. Sent by Ctrl+Break. - -logger = logging.getLogger("uvicorn.error") - - -class ServerState: - """ - Shared servers state that is available between all protocol instances. - """ - - def __init__(self) -> None: - self.total_requests = 0 - self.connections: set[Protocols] = set() - self.tasks: set[asyncio.Task[None]] = set() - self.default_headers: list[tuple[bytes, bytes]] = [] - - -class Server: - def __init__(self, config: Config) -> None: - self.config = config - self.server_state = ServerState() - - self.started = False - self.should_exit = False - self.force_exit = False - self.last_notified = 0.0 - - self._captured_signals: list[int] = [] - - def run(self, sockets: list[socket.socket] | None = None) -> None: - self.config.setup_event_loop() - return asyncio.run(self.serve(sockets=sockets)) - - async def serve(self, sockets: list[socket.socket] | None = None) -> None: - with self.capture_signals(): - await self._serve(sockets) - - async def _serve(self, sockets: list[socket.socket] | None = None) -> None: - process_id = os.getpid() - - config = self.config - if not config.loaded: - config.load() - - self.lifespan = config.lifespan_class(config) - - message = "Started server process [%d]" - color_message = "Started server process [" + click.style("%d", fg="cyan") + "]" - logger.info(message, process_id, extra={"color_message": color_message}) - - await self.startup(sockets=sockets) - if self.should_exit: - return - await self.main_loop() - await self.shutdown(sockets=sockets) - - message = "Finished server process [%d]" - color_message = "Finished server process [" + click.style("%d", fg="cyan") + "]" - logger.info(message, process_id, extra={"color_message": color_message}) - - async def startup(self, sockets: list[socket.socket] | None = None) -> None: - await self.lifespan.startup() - if self.lifespan.should_exit: - self.should_exit = True - return - - config = self.config - - def create_protocol( - _loop: asyncio.AbstractEventLoop | None = None, - ) -> asyncio.Protocol: - return config.http_protocol_class( # type: ignore[call-arg] - config=config, - server_state=self.server_state, - app_state=self.lifespan.state, - _loop=_loop, - ) - - loop = asyncio.get_running_loop() - - listeners: Sequence[socket.SocketType] - if sockets is not None: - # Explicitly passed a list of open sockets. - # We use this when the server is run from a Gunicorn worker. - - def _share_socket( - sock: socket.SocketType, - ) -> socket.SocketType: # pragma py-linux pragma: py-darwin - # Windows requires the socket be explicitly shared across - # multiple workers (processes). - from socket import fromshare # type: ignore[attr-defined] - - sock_data = sock.share(os.getpid()) # type: ignore[attr-defined] - return fromshare(sock_data) - - self.servers: list[asyncio.base_events.Server] = [] - for sock in sockets: - 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) - 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) - assert server.sockets is not None # mypy - listeners = server.sockets - self.servers = [server] - - elif config.uds is not None: # pragma: py-win32 - # Create a socket using UNIX domain socket. - uds_perms = 0o666 - if os.path.exists(config.uds): - uds_perms = os.stat(config.uds).st_mode - server = await loop.create_unix_server( - create_protocol, path=config.uds, ssl=config.ssl, backlog=config.backlog - ) - os.chmod(config.uds, uds_perms) - assert server.sockets is not None # mypy - listeners = server.sockets - self.servers = [server] - - else: - # Standard case. Create a socket from a host/port pair. - try: - server = await loop.create_server( - create_protocol, - host=config.host, - port=config.port, - ssl=config.ssl, - backlog=config.backlog, - ) - except OSError as exc: - logger.error(exc) - await self.lifespan.shutdown() - sys.exit(1) - - assert server.sockets is not None - listeners = server.sockets - self.servers = [server] - - if sockets is None: - self._log_started_message(listeners) - else: - # We're most likely running multiple workers, so a message has already been - # logged by `config.bind_socket()`. - pass - - self.started = True - - def _log_started_message(self, listeners: Sequence[socket.SocketType]) -> None: - config = self.config - - if config.fd is not None: # pragma: py-win32 - sock = listeners[0] - logger.info( - "Uvicorn running on socket %s (Press CTRL+C to quit)", - sock.getsockname(), - ) - - elif config.uds is not None: # pragma: py-win32 - logger.info("Uvicorn running on unix socket %s (Press CTRL+C to quit)", config.uds) - - else: - addr_format = "%s://%s:%d" - host = "0.0.0.0" if config.host is None else config.host - if ":" in host: - # It's an IPv6 address. - addr_format = "%s://[%s]:%d" - - port = config.port - if port == 0: - port = listeners[0].getsockname()[1] - - 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)" - logger.info( - message, - protocol_name, - host, - port, - extra={"color_message": color_message}, - ) - - async def main_loop(self) -> None: - counter = 0 - should_exit = await self.on_tick(counter) - while not should_exit: - counter += 1 - counter = counter % 864000 - await asyncio.sleep(0.1) - should_exit = await self.on_tick(counter) - - async def on_tick(self, counter: int) -> bool: - # Update the default headers, once per second. - if counter % 10 == 0: - current_time = time.time() - current_date = formatdate(current_time, usegmt=True).encode() - - if self.config.date_header: - date_header = [(b"date", current_date)] - else: - date_header = [] - - 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: - if current_time - self.last_notified > self.config.timeout_notify: - self.last_notified = current_time - await self.config.callback_notify() - - # Determine if we should exit. - if self.should_exit: - return True - if self.config.limit_max_requests is not None: - return self.server_state.total_requests >= self.config.limit_max_requests - return False - - async def shutdown(self, sockets: list[socket.socket] | None = None) -> None: - logger.info("Shutting down") - - # Stop accepting new connections. - for server in self.servers: - server.close() - for sock in sockets or []: - sock.close() - - # Request shutdown on all existing connections. - for connection in list(self.server_state.connections): - connection.shutdown() - await asyncio.sleep(0.1) - - # When 3.10 is not supported anymore, use `async with asyncio.timeout(...):`. - try: - await asyncio.wait_for( - self._wait_tasks_to_complete(), - timeout=self.config.timeout_graceful_shutdown, - ) - except asyncio.TimeoutError: - logger.error( - "Cancel %s running task(s), timeout graceful shutdown exceeded", - len(self.server_state.tasks), - ) - for t in self.server_state.tasks: - if sys.version_info < (3, 9): # pragma: py-gte-39 - t.cancel() - else: # pragma: py-lt-39 - t.cancel(msg="Task cancelled, timeout graceful shutdown exceeded") - - # Send the lifespan shutdown event, and wait for application shutdown. - if not self.force_exit: - await self.lifespan.shutdown() - - async def _wait_tasks_to_complete(self) -> None: - # Wait for existing connections to finish sending responses. - if self.server_state.connections and not self.force_exit: - msg = "Waiting for connections to close. (CTRL+C to force quit)" - logger.info(msg) - while self.server_state.connections and not self.force_exit: - await asyncio.sleep(0.1) - - # Wait for existing tasks to complete. - if self.server_state.tasks and not self.force_exit: - msg = "Waiting for background tasks to complete. (CTRL+C to force quit)" - logger.info(msg) - while self.server_state.tasks and not self.force_exit: - await asyncio.sleep(0.1) - - for server in self.servers: - await server.wait_closed() - - @contextlib.contextmanager - def capture_signals(self) -> Generator[None, None, None]: - # Signals can only be listened to from the main thread. - if threading.current_thread() is not threading.main_thread(): - yield - return - # always use signal.signal, even if loop.add_signal_handler is available - # this allows to restore previous signal handlers later on - original_handlers = {sig: signal.signal(sig, self.handle_exit) for sig in HANDLED_SIGNALS} - try: - yield - finally: - for sig, handler in original_handlers.items(): - signal.signal(sig, handler) - # If we did gracefully shut down due to a signal, try to - # trigger the expected behaviour now; multiple signals would be - # done LIFO, see https://stackoverflow.com/questions/48434964 - for captured_signal in reversed(self._captured_signals): - signal.raise_signal(captured_signal) - - def handle_exit(self, sig: int, frame: FrameType | None) -> None: - self._captured_signals.append(sig) - if self.should_exit and sig == signal.SIGINT: - self.force_exit = True - else: - self.should_exit = True diff --git a/venv/lib/python3.11/site-packages/uvicorn/supervisors/__init__.py b/venv/lib/python3.11/site-packages/uvicorn/supervisors/__init__.py deleted file mode 100644 index c90f24e..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/supervisors/__init__.py +++ /dev/null @@ -1,23 +0,0 @@ -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] -else: - try: - from uvicorn.supervisors.watchfilesreload import ( - WatchFilesReload as ChangeReload, - ) - except ImportError: # pragma: no cover - try: - from uvicorn.supervisors.watchgodreload import ( - WatchGodReload as ChangeReload, - ) - except ImportError: - from uvicorn.supervisors.statreload import StatReload as ChangeReload - -__all__ = ["Multiprocess", "ChangeReload"] diff --git a/venv/lib/python3.11/site-packages/uvicorn/supervisors/__pycache__/__init__.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/supervisors/__pycache__/__init__.cpython-311.pyc Binary files differdeleted file mode 100644 index a382a61..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/supervisors/__pycache__/__init__.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/supervisors/__pycache__/basereload.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/supervisors/__pycache__/basereload.cpython-311.pyc Binary files differdeleted file mode 100644 index 7745978..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/supervisors/__pycache__/basereload.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/supervisors/__pycache__/multiprocess.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/supervisors/__pycache__/multiprocess.cpython-311.pyc Binary files differdeleted file mode 100644 index f448ec4..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/supervisors/__pycache__/multiprocess.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/supervisors/__pycache__/statreload.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/supervisors/__pycache__/statreload.cpython-311.pyc Binary files differdeleted file mode 100644 index ebfb6a2..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/supervisors/__pycache__/statreload.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/supervisors/__pycache__/watchfilesreload.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/supervisors/__pycache__/watchfilesreload.cpython-311.pyc Binary files differdeleted file mode 100644 index 536049f..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/supervisors/__pycache__/watchfilesreload.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/supervisors/__pycache__/watchgodreload.cpython-311.pyc b/venv/lib/python3.11/site-packages/uvicorn/supervisors/__pycache__/watchgodreload.cpython-311.pyc Binary files differdeleted file mode 100644 index c92ed1a..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/supervisors/__pycache__/watchgodreload.cpython-311.pyc +++ /dev/null diff --git a/venv/lib/python3.11/site-packages/uvicorn/supervisors/basereload.py b/venv/lib/python3.11/site-packages/uvicorn/supervisors/basereload.py deleted file mode 100644 index 1c791a8..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/supervisors/basereload.py +++ /dev/null @@ -1,121 +0,0 @@ -from __future__ import annotations - -import logging -import os -import signal -import sys -import threading -from pathlib import Path -from socket import socket -from types import FrameType -from typing import Callable, Iterator - -import click - -from uvicorn._subprocess import get_subprocess -from uvicorn.config import Config - -HANDLED_SIGNALS = ( - signal.SIGINT, # Unix signal 2. Sent by Ctrl+C. - signal.SIGTERM, # Unix signal 15. Sent by `kill <pid>`. -) - -logger = logging.getLogger("uvicorn.error") - - -class BaseReload: - def __init__( - self, - config: Config, - target: Callable[[list[socket] | None], None], - sockets: list[socket], - ) -> None: - self.config = config - self.target = target - self.sockets = sockets - self.should_exit = threading.Event() - self.pid = os.getpid() - self.is_restarting = False - self.reloader_name: str | None = None - - def signal_handler(self, sig: int, frame: FrameType | None) -> None: - """ - A signal handler that is registered with the parent process. - """ - if sys.platform == "win32" and self.is_restarting: - self.is_restarting = False # pragma: py-not-win32 - else: - self.should_exit.set() # pragma: py-win32 - - def run(self) -> None: - self.startup() - for changes in self: - if changes: - logger.warning( - "%s detected changes in %s. Reloading...", - self.reloader_name, - ", ".join(map(_display_path, changes)), - ) - self.restart() - - self.shutdown() - - def pause(self) -> None: - if self.should_exit.wait(self.config.reload_delay): - raise StopIteration() - - def __iter__(self) -> Iterator[list[Path] | None]: - return self - - def __next__(self) -> list[Path] | None: - return self.should_restart() - - def startup(self) -> None: - message = f"Started reloader process [{self.pid}] using {self.reloader_name}" - color_message = "Started reloader process [{}] using {}".format( - click.style(str(self.pid), fg="cyan", bold=True), - click.style(str(self.reloader_name), fg="cyan", bold=True), - ) - logger.info(message, extra={"color_message": color_message}) - - 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.start() - - def restart(self) -> None: - if sys.platform == "win32": # pragma: py-not-win32 - self.is_restarting = True - assert self.process.pid is not None - os.kill(self.process.pid, signal.CTRL_C_EVENT) - else: # pragma: py-win32 - self.process.terminate() - self.process.join() - - self.process = get_subprocess(config=self.config, target=self.target, sockets=self.sockets) - self.process.start() - - def shutdown(self) -> None: - if sys.platform == "win32": - self.should_exit.set() # pragma: py-not-win32 - else: - self.process.terminate() # pragma: py-win32 - self.process.join() - - for sock in self.sockets: - sock.close() - - 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: - raise NotImplementedError("Reload strategies should override should_restart()") - - -def _display_path(path: Path) -> str: - try: - return f"'{path.relative_to(Path.cwd())}'" - except ValueError: - return f"'{path}'" diff --git a/venv/lib/python3.11/site-packages/uvicorn/supervisors/multiprocess.py b/venv/lib/python3.11/site-packages/uvicorn/supervisors/multiprocess.py deleted file mode 100644 index e091672..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/supervisors/multiprocess.py +++ /dev/null @@ -1,70 +0,0 @@ -from __future__ import annotations - -import logging -import os -import signal -import threading -from multiprocessing.context import SpawnProcess -from socket import socket -from types import FrameType -from typing import Callable - -import click - -from uvicorn._subprocess import get_subprocess -from uvicorn.config import Config - -HANDLED_SIGNALS = ( - signal.SIGINT, # Unix signal 2. Sent by Ctrl+C. - signal.SIGTERM, # Unix signal 15. Sent by `kill <pid>`. -) - -logger = logging.getLogger("uvicorn.error") - - -class Multiprocess: - def __init__( - self, - config: Config, - target: Callable[[list[socket] | None], None], - sockets: list[socket], - ) -> None: - self.config = config - self.target = target - self.sockets = sockets - self.processes: list[SpawnProcess] = [] - self.should_exit = threading.Event() - self.pid = os.getpid() - - def signal_handler(self, sig: int, frame: FrameType | None) -> None: - """ - A signal handler that is registered with the parent process. - """ - self.should_exit.set() - - def run(self) -> None: - self.startup() - self.should_exit.wait() - self.shutdown() - - def startup(self) -> None: - 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.start() - self.processes.append(process) - - def shutdown(self) -> None: - for process in self.processes: - process.terminate() - process.join() - - 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}) diff --git a/venv/lib/python3.11/site-packages/uvicorn/supervisors/statreload.py b/venv/lib/python3.11/site-packages/uvicorn/supervisors/statreload.py deleted file mode 100644 index 70d0a6d..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/supervisors/statreload.py +++ /dev/null @@ -1,52 +0,0 @@ -from __future__ import annotations - -import logging -from pathlib import Path -from socket import socket -from typing import Callable, Iterator - -from uvicorn.config import Config -from uvicorn.supervisors.basereload import BaseReload - -logger = logging.getLogger("uvicorn.error") - - -class StatReload(BaseReload): - def __init__( - self, - config: Config, - target: Callable[[list[socket] | None], None], - sockets: list[socket], - ) -> None: - super().__init__(config, target, sockets) - self.reloader_name = "StatReload" - self.mtimes: dict[Path, float] = {} - - if config.reload_excludes or config.reload_includes: - logger.warning("--reload-include and --reload-exclude have no effect unless " "watchfiles is installed.") - - def should_restart(self) -> list[Path] | None: - self.pause() - - for file in self.iter_py_files(): - try: - mtime = file.stat().st_mtime - except OSError: # pragma: nocover - continue - - old_time = self.mtimes.get(file) - if old_time is None: - self.mtimes[file] = mtime - continue - elif mtime > old_time: - return [file] - return None - - def restart(self) -> None: - self.mtimes = {} - return super().restart() - - def iter_py_files(self) -> Iterator[Path]: - for reload_dir in self.config.reload_dirs: - for path in list(reload_dir.rglob("*.py")): - yield path.resolve() diff --git a/venv/lib/python3.11/site-packages/uvicorn/supervisors/watchfilesreload.py b/venv/lib/python3.11/site-packages/uvicorn/supervisors/watchfilesreload.py deleted file mode 100644 index 292a7ba..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/supervisors/watchfilesreload.py +++ /dev/null @@ -1,88 +0,0 @@ -from __future__ import annotations - -from pathlib import Path -from socket import socket -from typing import Callable - -from watchfiles import watch - -from uvicorn.config import Config -from uvicorn.supervisors.basereload import BaseReload - - -class FileFilter: - def __init__(self, config: Config): - default_includes = ["*.py"] - self.includes = [default for default in default_includes if default not in config.reload_excludes] - self.includes.extend(config.reload_includes) - self.includes = list(set(self.includes)) - - default_excludes = [".*", ".py[cod]", ".sw.*", "~*"] - self.excludes = [default for default in default_excludes if default not in config.reload_includes] - self.exclude_dirs = [] - for e in config.reload_excludes: - p = Path(e) - try: - is_dir = p.is_dir() - except OSError: # pragma: no cover - # gets raised on Windows for values like "*.py" - is_dir = False - - if is_dir: - self.exclude_dirs.append(p) - else: - self.excludes.append(e) - self.excludes = list(set(self.excludes)) - - 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 - - for exclude_pattern in self.excludes: - if path.match(exclude_pattern): - return False - - return True - return False - - -class WatchFilesReload(BaseReload): - def __init__( - self, - config: Config, - target: Callable[[list[socket] | None], None], - sockets: list[socket], - ) -> None: - super().__init__(config, target, sockets) - self.reloader_name = "WatchFiles" - self.reload_dirs = [] - for directory in config.reload_dirs: - if Path.cwd() not in directory.parents: - self.reload_dirs.append(directory) - if Path.cwd() not in self.reload_dirs: - self.reload_dirs.append(Path.cwd()) - - self.watch_filter = FileFilter(config) - self.watcher = watch( - *self.reload_dirs, - watch_filter=None, - stop_event=self.should_exit, - # using yield_on_timeout here mostly to make sure tests don't - # hang forever, won't affect the class's behavior - yield_on_timeout=True, - ) - - def should_restart(self) -> list[Path] | None: - self.pause() - - changes = next(self.watcher) - if changes: - unique_paths = {Path(c[1]) for c in changes} - return [p for p in unique_paths if self.watch_filter(p)] - return None diff --git a/venv/lib/python3.11/site-packages/uvicorn/supervisors/watchgodreload.py b/venv/lib/python3.11/site-packages/uvicorn/supervisors/watchgodreload.py deleted file mode 100644 index 6f248fa..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/supervisors/watchgodreload.py +++ /dev/null @@ -1,152 +0,0 @@ -from __future__ import annotations - -import logging -import warnings -from pathlib import Path -from socket import socket -from typing import TYPE_CHECKING, Callable - -from watchgod import DefaultWatcher - -from uvicorn.config import Config -from uvicorn.supervisors.basereload import BaseReload - -if TYPE_CHECKING: - import os - - DirEntry = os.DirEntry[str] - -logger = logging.getLogger("uvicorn.error") - - -class CustomWatcher(DefaultWatcher): - def __init__(self, root_path: Path, config: Config): - default_includes = ["*.py"] - self.includes = [default for default in default_includes if default not in config.reload_excludes] - self.includes.extend(config.reload_includes) - self.includes = list(set(self.includes)) - - default_excludes = [".*", ".py[cod]", ".sw.*", "~*"] - self.excludes = [default for default in default_excludes if default not in config.reload_includes] - self.excludes.extend(config.reload_excludes) - self.excludes = list(set(self.excludes)) - - self.watched_dirs: dict[str, bool] = {} - self.watched_files: dict[str, bool] = {} - self.dirs_includes = set(config.reload_dirs) - self.dirs_excludes = set(config.reload_dirs_excludes) - self.resolved_root = root_path - super().__init__(str(root_path)) - - def should_watch_file(self, entry: DirEntry) -> bool: - cached_result = self.watched_files.get(entry.path) - if cached_result is not None: - return cached_result - - entry_path = Path(entry) - - # cwd is not verified through should_watch_dir, so we need to verify here - if entry_path.parent == Path.cwd() and Path.cwd() not in self.dirs_includes: - 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): - self.watched_files[entry.path] = False - return False - self.watched_files[entry.path] = True - return True - self.watched_files[entry.path] = False - return False - - def should_watch_dir(self, entry: DirEntry) -> bool: - cached_result = self.watched_dirs.get(entry.path) - if cached_result is not None: - return cached_result - - entry_path = Path(entry) - - if entry_path in self.dirs_excludes: - self.watched_dirs[entry.path] = False - return False - - for exclude_pattern in self.excludes: - if entry_path.match(exclude_pattern): - is_watched = False - if entry_path in self.dirs_includes: - is_watched = True - - for directory in self.dirs_includes: - if directory in entry_path.parents: - is_watched = True - - if is_watched: - logger.debug( - "WatchGodReload detected a new excluded dir '%s' in '%s'; " "Adding to exclude list.", - entry_path.relative_to(self.resolved_root), - str(self.resolved_root), - ) - self.watched_dirs[entry.path] = False - self.dirs_excludes.add(entry_path) - return False - - if entry_path in self.dirs_includes: - self.watched_dirs[entry.path] = True - return True - - for directory in self.dirs_includes: - if directory in entry_path.parents: - self.watched_dirs[entry.path] = True - return True - - for include_pattern in self.includes: - if entry_path.match(include_pattern): - logger.info( - "WatchGodReload detected a new reload dir '%s' in '%s'; " "Adding to watch list.", - str(entry_path.relative_to(self.resolved_root)), - str(self.resolved_root), - ) - self.dirs_includes.add(entry_path) - self.watched_dirs[entry.path] = True - return True - - self.watched_dirs[entry.path] = False - return False - - -class WatchGodReload(BaseReload): - def __init__( - self, - config: Config, - target: Callable[[list[socket] | None], None], - sockets: list[socket], - ) -> None: - warnings.warn( - '"watchgod" is deprecated, you should switch ' "to watchfiles (`pip install watchfiles`).", - DeprecationWarning, - ) - super().__init__(config, target, sockets) - self.reloader_name = "WatchGod" - self.watchers = [] - reload_dirs = [] - for directory in config.reload_dirs: - if Path.cwd() not in directory.parents: - reload_dirs.append(directory) - if Path.cwd() not in reload_dirs: - reload_dirs.append(Path.cwd()) - for w in reload_dirs: - self.watchers.append(CustomWatcher(w.resolve(), self.config)) - - def should_restart(self) -> list[Path] | None: - self.pause() - - for watcher in self.watchers: - change = watcher.check() - if change != set(): - return list({Path(c[1]) for c in change}) - - return None diff --git a/venv/lib/python3.11/site-packages/uvicorn/workers.py b/venv/lib/python3.11/site-packages/uvicorn/workers.py deleted file mode 100644 index 3b46471..0000000 --- a/venv/lib/python3.11/site-packages/uvicorn/workers.py +++ /dev/null @@ -1,107 +0,0 @@ -from __future__ import annotations - -import asyncio -import logging -import signal -import sys -from typing import Any - -from gunicorn.arbiter import Arbiter -from gunicorn.workers.base import Worker - -from uvicorn.config import Config -from uvicorn.main import Server - - -class UvicornWorker(Worker): - """ - A worker class for Gunicorn that interfaces with an ASGI consumer callable, - rather than a WSGI callable. - """ - - CONFIG_KWARGS: dict[str, Any] = {"loop": "auto", "http": "auto"} - - def __init__(self, *args: Any, **kwargs: Any) -> None: - super().__init__(*args, **kwargs) - - logger = logging.getLogger("uvicorn.error") - logger.handlers = self.log.error_log.handlers - logger.setLevel(self.log.error_log.level) - logger.propagate = False - - logger = logging.getLogger("uvicorn.access") - logger.handlers = self.log.access_log.handlers - logger.setLevel(self.log.access_log.level) - logger.propagate = False - - config_kwargs: dict = { - "app": None, - "log_config": None, - "timeout_keep_alive": self.cfg.keepalive, - "timeout_notify": self.timeout, - "callback_notify": self.callback_notify, - "limit_max_requests": self.max_requests, - "forwarded_allow_ips": self.cfg.forwarded_allow_ips, - } - - if self.cfg.is_ssl: - ssl_kwargs = { - "ssl_keyfile": self.cfg.ssl_options.get("keyfile"), - "ssl_certfile": self.cfg.ssl_options.get("certfile"), - "ssl_keyfile_password": self.cfg.ssl_options.get("password"), - "ssl_version": self.cfg.ssl_options.get("ssl_version"), - "ssl_cert_reqs": self.cfg.ssl_options.get("cert_reqs"), - "ssl_ca_certs": self.cfg.ssl_options.get("ca_certs"), - "ssl_ciphers": self.cfg.ssl_options.get("ciphers"), - } - config_kwargs.update(ssl_kwargs) - - if self.cfg.settings["backlog"].value: - config_kwargs["backlog"] = self.cfg.settings["backlog"].value - - config_kwargs.update(self.CONFIG_KWARGS) - - self.config = Config(**config_kwargs) - - def init_process(self) -> None: - self.config.setup_event_loop() - super().init_process() - - def init_signals(self) -> None: - # Reset signals so Gunicorn doesn't swallow subprocess return codes - # other signals are set up by Server.install_signal_handlers() - # See: https://github.com/encode/uvicorn/issues/894 - for s in self.SIGNALS: - signal.signal(s, signal.SIG_DFL) - - signal.signal(signal.SIGUSR1, self.handle_usr1) - # Don't let SIGUSR1 disturb active requests by interrupting system calls - signal.siginterrupt(signal.SIGUSR1, False) - - def _install_sigquit_handler(self) -> None: - """Install a SIGQUIT handler on workers. - - - https://github.com/encode/uvicorn/issues/1116 - - https://github.com/benoitc/gunicorn/issues/2604 - """ - - loop = asyncio.get_running_loop() - loop.add_signal_handler(signal.SIGQUIT, self.handle_exit, signal.SIGQUIT, None) - - async def _serve(self) -> None: - self.config.app = self.wsgi - server = Server(config=self.config) - self._install_sigquit_handler() - await server.serve(sockets=self.sockets) - if not server.started: - sys.exit(Arbiter.WORKER_BOOT_ERROR) - - def run(self) -> None: - return asyncio.run(self._serve()) - - async def callback_notify(self) -> None: - self.notify() - - -class UvicornH11Worker(UvicornWorker): - CONFIG_KWARGS = {"loop": "asyncio", "http": "h11"} |