@tushar-br/desktop 1.0.283 → 1.0.284

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/websockets/asyncio/client.py

@@ -1,804 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import logging
-import os
-import socket
-import ssl as ssl_module
-import traceback
-import urllib.parse
-from collections.abc import AsyncIterator, Generator, Sequence
-from types import TracebackType
-from typing import Any, Callable, Literal, cast
-
-from ..client import ClientProtocol, backoff
-from ..datastructures import HeadersLike
-from ..exceptions import (
-    InvalidMessage,
-    InvalidProxyMessage,
-    InvalidProxyStatus,
-    InvalidStatus,
-    ProxyError,
-    SecurityError,
-)
-from ..extensions.base import ClientExtensionFactory
-from ..extensions.permessage_deflate import enable_client_permessage_deflate
-from ..headers import validate_subprotocols
-from ..http11 import USER_AGENT, Response
-from ..protocol import CONNECTING, Event
-from ..proxy import Proxy, get_proxy, parse_proxy, prepare_connect_request
-from ..streams import StreamReader
-from ..typing import LoggerLike, Origin, Subprotocol
-from ..uri import WebSocketURI, parse_uri
-from .compatibility import TimeoutError, asyncio_timeout
-from .connection import Connection
-
-
-__all__ = ["connect", "unix_connect", "ClientConnection"]
-
-MAX_REDIRECTS = int(os.environ.get("WEBSOCKETS_MAX_REDIRECTS", "10"))
-
-
-class ClientConnection(Connection):
-    """
-    :mod:`asyncio` implementation of a WebSocket client connection.
-
-    :class:`ClientConnection` provides :meth:`recv` and :meth:`send` coroutines
-    for receiving and sending messages.
-
-    It supports asynchronous iteration to receive messages::
-
-        async for message in websocket:
-            await process(message)
-
-    The iterator exits normally when the connection is closed with code
-    1000 (OK) or 1001 (going away) or without a close code. It raises a
-    :exc:`~websockets.exceptions.ConnectionClosedError` when the connection is
-    closed with any other code.
-
-    The ``ping_interval``, ``ping_timeout``, ``close_timeout``, ``max_queue``,
-    and ``write_limit`` arguments have the same meaning as in :func:`connect`.
-
-    Args:
-        protocol: Sans-I/O connection.
-
-    """
-
-    def __init__(
-        self,
-        protocol: ClientProtocol,
-        *,
-        ping_interval: float | None = 20,
-        ping_timeout: float | None = 20,
-        close_timeout: float | None = 10,
-        max_queue: int | None | tuple[int | None, int | None] = 16,
-        write_limit: int | tuple[int, int | None] = 2**15,
-    ) -> None:
-        self.protocol: ClientProtocol
-        super().__init__(
-            protocol,
-            ping_interval=ping_interval,
-            ping_timeout=ping_timeout,
-            close_timeout=close_timeout,
-            max_queue=max_queue,
-            write_limit=write_limit,
-        )
-        self.response_rcvd: asyncio.Future[None] = self.loop.create_future()
-
-    async def handshake(
-        self,
-        additional_headers: HeadersLike | None = None,
-        user_agent_header: str | None = USER_AGENT,
-    ) -> None:
-        """
-        Perform the opening handshake.
-
-        """
-        async with self.send_context(expected_state=CONNECTING):
-            self.request = self.protocol.connect()
-            if additional_headers is not None:
-                self.request.headers.update(additional_headers)
-            if user_agent_header is not None:
-                self.request.headers.setdefault("User-Agent", user_agent_header)
-            self.protocol.send_request(self.request)
-
-        await asyncio.wait(
-            [self.response_rcvd, self.connection_lost_waiter],
-            return_when=asyncio.FIRST_COMPLETED,
-        )
-
-        # self.protocol.handshake_exc is set when the connection is lost before
-        # receiving a response, when the response cannot be parsed, or when the
-        # response fails the handshake.
-
-        if self.protocol.handshake_exc is not None:
-            raise self.protocol.handshake_exc
-
-    def process_event(self, event: Event) -> None:
-        """
-        Process one incoming event.
-
-        """
-        # First event - handshake response.
-        if self.response is None:
-            assert isinstance(event, Response)
-            self.response = event
-            self.response_rcvd.set_result(None)
-        # Later events - frames.
-        else:
-            super().process_event(event)
-
-
-def process_exception(exc: Exception) -> Exception | None:
-    """
-    Determine whether a connection error is retryable or fatal.
-
-    When reconnecting automatically with ``async for ... in connect(...)``, if a
-    connection attempt fails, :func:`process_exception` is called to determine
-    whether to retry connecting or to raise the exception.
-
-    This function defines the default behavior, which is to retry on:
-
-    * :exc:`EOFError`, :exc:`OSError`, :exc:`asyncio.TimeoutError`: network
-      errors;
-    * :exc:`~websockets.exceptions.InvalidStatus` when the status code is 500,
-      502, 503, or 504: server or proxy errors.
-
-    All other exceptions are considered fatal.
-
-    You can change this behavior with the ``process_exception`` argument of
-    :func:`connect`.
-
-    Return :obj:`None` if the exception is retryable i.e. when the error could
-    be transient and trying to reconnect with the same parameters could succeed.
-    The exception will be logged at the ``INFO`` level.
-
-    Return an exception, either ``exc`` or a new exception, if the exception is
-    fatal i.e. when trying to reconnect will most likely produce the same error.
-    That exception will be raised, breaking out of the retry loop.
-
-    """
-    # This catches python-socks' ProxyConnectionError and ProxyTimeoutError.
-    # Remove asyncio.TimeoutError when dropping Python < 3.11.
-    if isinstance(exc, (OSError, TimeoutError, asyncio.TimeoutError)):
-        return None
-    if isinstance(exc, InvalidMessage) and isinstance(exc.__cause__, EOFError):
-        return None
-    if isinstance(exc, InvalidStatus) and exc.response.status_code in [
-        500,  # Internal Server Error
-        502,  # Bad Gateway
-        503,  # Service Unavailable
-        504,  # Gateway Timeout
-    ]:
-        return None
-    return exc
-
-
-# This is spelled in lower case because it's exposed as a callable in the API.
-class connect:
-    """
-    Connect to the WebSocket server at ``uri``.
-
-    This coroutine returns a :class:`ClientConnection` instance, which you can
-    use to send and receive messages.
-
-    :func:`connect` may be used as an asynchronous context manager::
-
-        from websockets.asyncio.client import connect
-
-        async with connect(...) as websocket:
-            ...
-
-    The connection is closed automatically when exiting the context.
-
-    :func:`connect` can be used as an infinite asynchronous iterator to
-    reconnect automatically on errors::
-
-        async for websocket in connect(...):
-            try:
-                ...
-            except websockets.exceptions.ConnectionClosed:
-                continue
-
-    If the connection fails with a transient error, it is retried with
-    exponential backoff. If it fails with a fatal error, the exception is
-    raised, breaking out of the loop.
-
-    The connection is closed automatically after each iteration of the loop.
-
-    Args:
-        uri: URI of the WebSocket server.
-        origin: Value of the ``Origin`` header, for servers that require it.
-        extensions: List of supported extensions, in order in which they
-            should be negotiated and run.
-        subprotocols: List of supported subprotocols, in order of decreasing
-            preference.
-        compression: The "permessage-deflate" extension is enabled by default.
-            Set ``compression`` to :obj:`None` to disable it. See the
-            :doc:`compression guide <../../topics/compression>` for details.
-        additional_headers (HeadersLike | None): Arbitrary HTTP headers to add
-            to the handshake request.
-        user_agent_header: Value of  the ``User-Agent`` request header.
-            It defaults to ``"Python/x.y.z websockets/X.Y"``.
-            Setting it to :obj:`None` removes the header.
-        proxy: If a proxy is configured, it is used by default. Set ``proxy``
-            to :obj:`None` to disable the proxy or to the address of a proxy
-            to override the system configuration. See the :doc:`proxy docs
-            <../../topics/proxies>` for details.
-        process_exception: When reconnecting automatically, tell whether an
-            error is transient or fatal. The default behavior is defined by
-            :func:`process_exception`. Refer to its documentation for details.
-        open_timeout: Timeout for opening the connection in seconds.
-            :obj:`None` disables the timeout.
-        ping_interval: Interval between keepalive pings in seconds.
-            :obj:`None` disables keepalive.
-        ping_timeout: Timeout for keepalive pings in seconds.
-            :obj:`None` disables timeouts.
-        close_timeout: Timeout for closing the connection in seconds.
-            :obj:`None` disables the timeout.
-        max_size: Maximum size of incoming messages in bytes.
-            :obj:`None` disables the limit. You may pass a ``(max_message_size,
-            max_fragment_size)`` tuple to set different limits for messages and
-            fragments when you expect long messages sent in short fragments.
-        max_queue: High-water mark of the buffer where frames are received.
-            It defaults to 16 frames. The low-water mark defaults to ``max_queue
-            // 4``. You may pass a ``(high, low)`` tuple to set the high-water
-            and low-water marks. If you want to disable flow control entirely,
-            you may set it to ``None``, although that's a bad idea.
-        write_limit: High-water mark of write buffer in bytes. It is passed to
-            :meth:`~asyncio.WriteTransport.set_write_buffer_limits`. It defaults
-            to 32 KiB. You may pass a ``(high, low)`` tuple to set the
-            high-water and low-water marks.
-        logger: Logger for this client.
-            It defaults to ``logging.getLogger("websockets.client")``.
-            See the :doc:`logging guide <../../topics/logging>` for details.
-        create_connection: Factory for the :class:`ClientConnection` managing
-            the connection. Set it to a wrapper or a subclass to customize
-            connection handling.
-
-    Any other keyword arguments are passed to the event loop's
-    :meth:`~asyncio.loop.create_connection` method.
-
-    For example:
-
-    * You can set ``ssl`` to a :class:`~ssl.SSLContext` to enforce TLS settings.
-      When connecting to a ``wss://`` URI, if ``ssl`` isn't provided, a TLS
-      context is created with :func:`~ssl.create_default_context`.
-
-    * You can set ``server_hostname`` to override the host name from ``uri`` in
-      the TLS handshake.
-
-    * You can set ``host`` and ``port`` to connect to a different host and port
-      from those found in ``uri``. This only changes the destination of the TCP
-      connection. The host name from ``uri`` is still used in the TLS handshake
-      for secure connections and in the ``Host`` header.
-
-    * You can set ``sock`` to provide a preexisting TCP socket. You may call
-      :func:`socket.create_connection` (not to be confused with the event loop's
-      :meth:`~asyncio.loop.create_connection` method) to create a suitable
-      client socket and customize it.
-
-    When using a proxy:
-
-    * Prefix keyword arguments with ``proxy_`` for configuring TLS between the
-      client and an HTTPS proxy: ``proxy_ssl``, ``proxy_server_hostname``,
-      ``proxy_ssl_handshake_timeout``, and ``proxy_ssl_shutdown_timeout``.
-    * Use the standard keyword arguments for configuring TLS between the proxy
-      and the WebSocket server: ``ssl``, ``server_hostname``,
-      ``ssl_handshake_timeout``, and ``ssl_shutdown_timeout``.
-    * Other keyword arguments are used only for connecting to the proxy.
-
-    Raises:
-        InvalidURI: If ``uri`` isn't a valid WebSocket URI.
-        InvalidProxy: If ``proxy`` isn't a valid proxy.
-        OSError: If the TCP connection fails.
-        InvalidHandshake: If the opening handshake fails.
-        TimeoutError: If the opening handshake times out.
-
-    """
-
-    def __init__(
-        self,
-        uri: str,
-        *,
-        # WebSocket
-        origin: Origin | None = None,
-        extensions: Sequence[ClientExtensionFactory] | None = None,
-        subprotocols: Sequence[Subprotocol] | None = None,
-        compression: str | None = "deflate",
-        # HTTP
-        additional_headers: HeadersLike | None = None,
-        user_agent_header: str | None = USER_AGENT,
-        proxy: str | Literal[True] | None = True,
-        process_exception: Callable[[Exception], Exception | None] = process_exception,
-        # Timeouts
-        open_timeout: float | None = 10,
-        ping_interval: float | None = 20,
-        ping_timeout: float | None = 20,
-        close_timeout: float | None = 10,
-        # Limits
-        max_size: int | None | tuple[int | None, int | None] = 2**20,
-        max_queue: int | None | tuple[int | None, int | None] = 16,
-        write_limit: int | tuple[int, int | None] = 2**15,
-        # Logging
-        logger: LoggerLike | None = None,
-        # Escape hatch for advanced customization
-        create_connection: type[ClientConnection] | None = None,
-        # Other keyword arguments are passed to loop.create_connection
-        **kwargs: Any,
-    ) -> None:
-        self.uri = uri
-
-        if subprotocols is not None:
-            validate_subprotocols(subprotocols)
-
-        if compression == "deflate":
-            extensions = enable_client_permessage_deflate(extensions)
-        elif compression is not None:
-            raise ValueError(f"unsupported compression: {compression}")
-
-        if logger is None:
-            logger = logging.getLogger("websockets.client")
-
-        if create_connection is None:
-            create_connection = ClientConnection
-
-        def protocol_factory(uri: WebSocketURI) -> ClientConnection:
-            # This is a protocol in the Sans-I/O implementation of websockets.
-            protocol = ClientProtocol(
-                uri,
-                origin=origin,
-                extensions=extensions,
-                subprotocols=subprotocols,
-                max_size=max_size,
-                logger=logger,
-            )
-            # This is a connection in websockets and a protocol in asyncio.
-            connection = create_connection(
-                protocol,
-                ping_interval=ping_interval,
-                ping_timeout=ping_timeout,
-                close_timeout=close_timeout,
-                max_queue=max_queue,
-                write_limit=write_limit,
-            )
-            return connection
-
-        self.proxy = proxy
-        self.protocol_factory = protocol_factory
-        self.additional_headers = additional_headers
-        self.user_agent_header = user_agent_header
-        self.process_exception = process_exception
-        self.open_timeout = open_timeout
-        self.logger = logger
-        self.connection_kwargs = kwargs
-
-    async def create_connection(self) -> ClientConnection:
-        """Create TCP or Unix connection."""
-        loop = asyncio.get_running_loop()
-        kwargs = self.connection_kwargs.copy()
-
-        ws_uri = parse_uri(self.uri)
-
-        proxy = self.proxy
-        if kwargs.get("unix", False):
-            proxy = None
-        if kwargs.get("sock") is not None:
-            proxy = None
-        if proxy is True:
-            proxy = get_proxy(ws_uri)
-
-        def factory() -> ClientConnection:
-            return self.protocol_factory(ws_uri)
-
-        if ws_uri.secure:
-            kwargs.setdefault("ssl", True)
-            kwargs.setdefault("server_hostname", ws_uri.host)
-            if kwargs.get("ssl") is None:
-                raise ValueError("ssl=None is incompatible with a wss:// URI")
-        else:
-            if kwargs.get("ssl") is not None:
-                raise ValueError("ssl argument is incompatible with a ws:// URI")
-
-        if kwargs.pop("unix", False):
-            _, connection = await loop.create_unix_connection(factory, **kwargs)
-        elif proxy is not None:
-            proxy_parsed = parse_proxy(proxy)
-            if proxy_parsed.scheme[:5] == "socks":
-                # Connect to the server through the proxy.
-                sock = await connect_socks_proxy(
-                    proxy_parsed,
-                    ws_uri,
-                    local_addr=kwargs.pop("local_addr", None),
-                )
-                # Initialize WebSocket connection via the proxy.
-                _, connection = await loop.create_connection(
-                    factory,
-                    sock=sock,
-                    **kwargs,
-                )
-            elif proxy_parsed.scheme[:4] == "http":
-                # Split keyword arguments between the proxy and the server.
-                all_kwargs, proxy_kwargs, kwargs = kwargs, {}, {}
-                for key, value in all_kwargs.items():
-                    if key.startswith("ssl") or key == "server_hostname":
-                        kwargs[key] = value
-                    elif key.startswith("proxy_"):
-                        proxy_kwargs[key[6:]] = value
-                    else:
-                        proxy_kwargs[key] = value
-                # Validate the proxy_ssl argument.
-                if proxy_parsed.scheme == "https":
-                    proxy_kwargs.setdefault("ssl", True)
-                    if proxy_kwargs.get("ssl") is None:
-                        raise ValueError(
-                            "proxy_ssl=None is incompatible with an https:// proxy"
-                        )
-                else:
-                    if proxy_kwargs.get("ssl") is not None:
-                        raise ValueError(
-                            "proxy_ssl argument is incompatible with an http:// proxy"
-                        )
-                # Connect to the server through the proxy.
-                transport = await connect_http_proxy(
-                    proxy_parsed,
-                    ws_uri,
-                    user_agent_header=self.user_agent_header,
-                    **proxy_kwargs,
-                )
-                # Initialize WebSocket connection via the proxy.
-                connection = factory()
-                transport.set_protocol(connection)
-                ssl = kwargs.pop("ssl", None)
-                if ssl is True:
-                    ssl = ssl_module.create_default_context()
-                if ssl is not None:
-                    new_transport = await loop.start_tls(
-                        transport, connection, ssl, **kwargs
-                    )
-                    assert new_transport is not None  # help mypy
-                    transport = new_transport
-                connection.connection_made(transport)
-            else:
-                raise AssertionError("unsupported proxy")
-        else:
-            # Connect to the server directly.
-            if kwargs.get("sock") is None:
-                kwargs.setdefault("host", ws_uri.host)
-                kwargs.setdefault("port", ws_uri.port)
-            # Initialize WebSocket connection.
-            _, connection = await loop.create_connection(factory, **kwargs)
-        return connection
-
-    def process_redirect(self, exc: Exception) -> Exception | str:
-        """
-        Determine whether a connection error is a redirect that can be followed.
-
-        Return the new URI if it's a valid redirect. Else, return an exception.
-
-        """
-        if not (
-            isinstance(exc, InvalidStatus)
-            and exc.response.status_code
-            in [
-                300,  # Multiple Choices
-                301,  # Moved Permanently
-                302,  # Found
-                303,  # See Other
-                307,  # Temporary Redirect
-                308,  # Permanent Redirect
-            ]
-            and "Location" in exc.response.headers
-        ):
-            return exc
-
-        old_ws_uri = parse_uri(self.uri)
-        new_uri = urllib.parse.urljoin(self.uri, exc.response.headers["Location"])
-        new_ws_uri = parse_uri(new_uri)
-
-        # If connect() received a socket, it is closed and cannot be reused.
-        if self.connection_kwargs.get("sock") is not None:
-            return ValueError(
-                f"cannot follow redirect to {new_uri} with a preexisting socket"
-            )
-
-        # TLS downgrade is forbidden.
-        if old_ws_uri.secure and not new_ws_uri.secure:
-            return SecurityError(f"cannot follow redirect to non-secure URI {new_uri}")
-
-        # Apply restrictions to cross-origin redirects.
-        if (
-            old_ws_uri.secure != new_ws_uri.secure
-            or old_ws_uri.host != new_ws_uri.host
-            or old_ws_uri.port != new_ws_uri.port
-        ):
-            # Cross-origin redirects on Unix sockets don't quite make sense.
-            if self.connection_kwargs.get("unix", False):
-                return ValueError(
-                    f"cannot follow cross-origin redirect to {new_uri} "
-                    f"with a Unix socket"
-                )
-
-            # Cross-origin redirects when host and port are overridden are ill-defined.
-            if (
-                self.connection_kwargs.get("host") is not None
-                or self.connection_kwargs.get("port") is not None
-            ):
-                return ValueError(
-                    f"cannot follow cross-origin redirect to {new_uri} "
-                    f"with an explicit host or port"
-                )
-
-        return new_uri
-
-    # ... = await connect(...)
-
-    def __await__(self) -> Generator[Any, None, ClientConnection]:
-        # Create a suitable iterator by calling __await__ on a coroutine.
-        return self.__await_impl__().__await__()
-
-    async def __await_impl__(self) -> ClientConnection:
-        try:
-            async with asyncio_timeout(self.open_timeout):
-                for _ in range(MAX_REDIRECTS):
-                    self.connection = await self.create_connection()
-                    try:
-                        await self.connection.handshake(
-                            self.additional_headers,
-                            self.user_agent_header,
-                        )
-                    except asyncio.CancelledError:
-                        self.connection.transport.abort()
-                        raise
-                    except Exception as exc:
-                        # Always close the connection even though keep-alive is
-                        # the default in HTTP/1.1 because create_connection ties
-                        # opening the network connection with initializing the
-                        # protocol. In the current design of connect(), there is
-                        # no easy way to reuse the network connection that works
-                        # in every case nor to reinitialize the protocol.
-                        self.connection.transport.abort()
-
-                        uri_or_exc = self.process_redirect(exc)
-                        # Response is a valid redirect; follow it.
-                        if isinstance(uri_or_exc, str):
-                            self.uri = uri_or_exc
-                            continue
-                        # Response isn't a valid redirect; raise the exception.
-                        if uri_or_exc is exc:
-                            raise
-                        else:
-                            raise uri_or_exc from exc
-
-                    else:
-                        self.connection.start_keepalive()
-                        return self.connection
-                else:
-                    raise SecurityError(f"more than {MAX_REDIRECTS} redirects")
-
-        except TimeoutError as exc:
-            # Re-raise exception with an informative error message.
-            raise TimeoutError("timed out during opening handshake") from exc
-
-    # ... = yield from connect(...) - remove when dropping Python < 3.11
-
-    __iter__ = __await__
-
-    # async with connect(...) as ...: ...
-
-    async def __aenter__(self) -> ClientConnection:
-        return await self
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_value: BaseException | None,
-        traceback: TracebackType | None,
-    ) -> None:
-        await self.connection.close()
-
-    # async for ... in connect(...):
-
-    async def __aiter__(self) -> AsyncIterator[ClientConnection]:
-        delays: Generator[float] | None = None
-        while True:
-            try:
-                async with self as protocol:
-                    yield protocol
-            except Exception as exc:
-                # Determine whether the exception is retryable or fatal.
-                # The API of process_exception is "return an exception or None";
-                # "raise an exception" is also supported because it's a frequent
-                # mistake. It isn't documented in order to keep the API simple.
-                try:
-                    new_exc = self.process_exception(exc)
-                except Exception as raised_exc:
-                    new_exc = raised_exc
-
-                # The connection failed with a fatal error.
-                # Raise the exception and exit the loop.
-                if new_exc is exc:
-                    raise
-                if new_exc is not None:
-                    raise new_exc from exc
-
-                # The connection failed with a retryable error.
-                # Start or continue backoff and reconnect.
-                if delays is None:
-                    delays = backoff()
-                delay = next(delays)
-                self.logger.info(
-                    "connect failed; reconnecting in %.1f seconds: %s",
-                    delay,
-                    traceback.format_exception_only(exc)[0].strip(),
-                )
-                await asyncio.sleep(delay)
-                continue
-
-            else:
-                # The connection succeeded. Reset backoff.
-                delays = None
-
-
-def unix_connect(
-    path: str | None = None,
-    uri: str | None = None,
-    **kwargs: Any,
-) -> connect:
-    """
-    Connect to a WebSocket server listening on a Unix socket.
-
-    This function accepts the same keyword arguments as :func:`connect`.
-
-    It's only available on Unix.
-
-    It's mainly useful for debugging servers listening on Unix sockets.
-
-    Args:
-        path: File system path to the Unix socket.
-        uri: URI of the WebSocket server. ``uri`` defaults to
-            ``ws://localhost/`` or, when a ``ssl`` argument is provided, to
-            ``wss://localhost/``.
-
-    """
-    if uri is None:
-        if kwargs.get("ssl") is None:
-            uri = "ws://localhost/"
-        else:
-            uri = "wss://localhost/"
-    return connect(uri=uri, unix=True, path=path, **kwargs)
-
-
-try:
-    from python_socks import ProxyType
-    from python_socks.async_.asyncio import Proxy as SocksProxy
-
-except ImportError:
-
-    async def connect_socks_proxy(
-        proxy: Proxy,
-        ws_uri: WebSocketURI,
-        **kwargs: Any,
-    ) -> socket.socket:
-        raise ImportError("connecting through a SOCKS proxy requires python-socks")
-
-else:
-    SOCKS_PROXY_TYPES = {
-        "socks5h": ProxyType.SOCKS5,
-        "socks5": ProxyType.SOCKS5,
-        "socks4a": ProxyType.SOCKS4,
-        "socks4": ProxyType.SOCKS4,
-    }
-
-    SOCKS_PROXY_RDNS = {
-        "socks5h": True,
-        "socks5": False,
-        "socks4a": True,
-        "socks4": False,
-    }
-
-    async def connect_socks_proxy(
-        proxy: Proxy,
-        ws_uri: WebSocketURI,
-        **kwargs: Any,
-    ) -> socket.socket:
-        """Connect via a SOCKS proxy and return the socket."""
-        socks_proxy = SocksProxy(
-            SOCKS_PROXY_TYPES[proxy.scheme],
-            proxy.host,
-            proxy.port,
-            proxy.username,
-            proxy.password,
-            SOCKS_PROXY_RDNS[proxy.scheme],
-        )
-        # connect() is documented to raise OSError.
-        # socks_proxy.connect() doesn't raise TimeoutError; it gets canceled.
-        # Wrap other exceptions in ProxyError, a subclass of InvalidHandshake.
-        try:
-            return await socks_proxy.connect(ws_uri.host, ws_uri.port, **kwargs)
-        except OSError:
-            raise
-        except Exception as exc:
-            raise ProxyError("failed to connect to SOCKS proxy") from exc
-
-
-class HTTPProxyConnection(asyncio.Protocol):
-    def __init__(
-        self,
-        ws_uri: WebSocketURI,
-        proxy: Proxy,
-        user_agent_header: str | None = None,
-    ):
-        self.ws_uri = ws_uri
-        self.proxy = proxy
-        self.user_agent_header = user_agent_header
-
-        self.reader = StreamReader()
-        self.parser = Response.parse(
-            self.reader.read_line,
-            self.reader.read_exact,
-            self.reader.read_to_eof,
-            proxy=True,
-        )
-
-        loop = asyncio.get_running_loop()
-        self.response: asyncio.Future[Response] = loop.create_future()
-
-    def run_parser(self) -> None:
-        try:
-            next(self.parser)
-        except StopIteration as exc:
-            response = exc.value
-            if 200 <= response.status_code < 300:
-                self.response.set_result(response)
-            else:
-                self.response.set_exception(InvalidProxyStatus(response))
-        except Exception as exc:
-            proxy_exc = InvalidProxyMessage(
-                "did not receive a valid HTTP response from proxy"
-            )
-            proxy_exc.__cause__ = exc
-            self.response.set_exception(proxy_exc)
-
-    def connection_made(self, transport: asyncio.BaseTransport) -> None:
-        transport = cast(asyncio.Transport, transport)
-        self.transport = transport
-        self.transport.write(
-            prepare_connect_request(self.proxy, self.ws_uri, self.user_agent_header)
-        )
-
-    def data_received(self, data: bytes) -> None:
-        self.reader.feed_data(data)
-        self.run_parser()
-
-    def eof_received(self) -> None:
-        self.reader.feed_eof()
-        self.run_parser()
-
-    def connection_lost(self, exc: Exception | None) -> None:
-        self.reader.feed_eof()
-        if exc is not None:
-            self.response.set_exception(exc)
-
-
-async def connect_http_proxy(
-    proxy: Proxy,
-    ws_uri: WebSocketURI,
-    user_agent_header: str | None = None,
-    **kwargs: Any,
-) -> asyncio.Transport:
-    transport, protocol = await asyncio.get_running_loop().create_connection(
-        lambda: HTTPProxyConnection(ws_uri, proxy, user_agent_header),
-        proxy.host,
-        proxy.port,
-        **kwargs,
-    )
-
-    try:
-        # This raises exceptions if the connection to the proxy fails.
-        await protocol.response
-    except Exception:
-        transport.close()
-        raise
-
-    return transport