Ë
    ·�©jZw  ã                  ó  — d dl mZ d dlZd dlZd dlZd dlZd dlZd dlZd dl	Z
d dlmZmZmZ d dlmZ d dlmZmZmZmZ ddlmZmZmZ ddlmZmZ dd	lmZmZm Z m!Z!m"Z" dd
l#m$Z$ ddl%m&Z& ddl'm(Z( ddl)m*Z*m+Z+ ddl,m-Z-m.Z. ddl/m0Z0m1Z1m2Z2m3Z3 ddl4m5Z5 ddlm6Z6m7Z7m8Z8m9Z9 ddl:m;Z;m<Z< ddl=m>Z> g d¢Z? e@ej‚                  j…                  dd«      «      ZC G d„ de>«      ZD G d„ d«      ZE	 	 d(	 	 	 	 	 	 	 d)d„ZF	 d dlGmHZH d dlIm0ZJ eHj–                  eHj–                  eHj˜                  eHj˜                  dœZMd d!d d!dœZN	 	 	 	 	 	 	 	 d*d"„ZO G d$„ d%ej¢                  «      ZRdd&œ	 	 	 	 	 	 	 	 	 d+d'„ZSy# eP$ r 	 	 	 	 	 	 	 	 d*d#„ZOY Œ9w xY w),é    )ÚannotationsN)ÚAsyncIteratorÚ	GeneratorÚSequence)ÚTracebackType)ÚAnyÚCallableÚLiteralÚcasté   )ÚClientProtocolÚbackoffÚprocess_exception)ÚHeadersÚHeadersLike)ÚInvalidProxyMessageÚInvalidProxyStatusÚInvalidStatusÚ
ProxyErrorÚSecurityError)ÚClientExtensionFactory)Ú enable_client_permessage_deflate)Úvalidate_subprotocols)Ú
USER_AGENTÚResponse)Ú
CONNECTINGÚEvent)ÚProxyÚ	get_proxyÚparse_proxyÚprepare_connect_request)ÚStreamReader)Ú
LoggerLikeÚOriginÚPathLikeÚSubprotocol)ÚWebSocketURIÚ	parse_urié   )Ú
Connection)ÚconnectÚunix_connectÚClientConnectionÚWEBSOCKETS_MAX_REDIRECTSÚ10c                  óp   ‡ — e Zd ZdZddddddœ	 	 	 	 	 	 	 	 	 	 	 	 	 dˆ fd„Zdef	 	 	 	 	 dd	„Zdˆ fd
„Zˆ xZS )r-   a  
    :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.

    é   é
   é   é €  ©Úping_intervalÚping_timeoutÚclose_timeoutÚ	max_queueÚwrite_limitc               ór   •— |  t         ‰| �  ||||||¬«       | j                  j                  «       | _        y )Nr5   )ÚsuperÚ__init__ÚloopÚcreate_futureÚresponse_rcvd)ÚselfÚprotocolr6   r7   r8   r9   r:   Ú	__class__s          €ú`/var/www/html/streamforge-license/venv/lib/python3.12/site-packages/websockets/asyncio/client.pyr=   zClientConnection.__init__A   sC   ø€ ñ 	Ü‰ÑØØ'Ø%Ø'ØØ#ð 	ô 	
ð 48·9±9×3JÑ3JÓ3LˆÕó    Nc              ƒ  ó¤  K  — | j                   j                  «       | _        |�%| j                  j                  j	                  |«       |�&| j                  j                  j                  d|«       | j                  t        ¬«      4 ƒd{  –—†  | j                   j                  | j                  «       ddd«      ƒd{  –—†  t        j                  | j                  | j                  gt        j                  ¬«      ƒ d{  –—†  | j                   j                  �| j                   j                  ‚y7 Œ©7 Œv# 1 ƒd{  –—†7  sw Y   Œ†xY w7 ŒJ­w)z1
        Perform the opening handshake.

        Nz
User-Agent)Úexpected_state)Úreturn_when)rB   r+   ÚrequestÚheadersÚupdateÚ
setdefaultÚsend_contextr   Úsend_requestÚasyncioÚwaitr@   Úconnection_lost_waiterÚFIRST_COMPLETEDÚhandshake_exc)rA   Úadditional_headersÚuser_agent_headers      rD   Ú	handshakezClientConnection.handshakeV   s  è ø€ ð —}‘}×,Ñ,Ó.ˆŒØÐ)Ø�L‰L× Ñ ×'Ñ'Ð(:Ô;ØÐ(Ø�L‰L× Ñ ×+Ñ+¨LÐ:KÔLØ×$Ñ$´JÐ$Ó?÷ 	5ñ 	5Ø�M‰M×&Ñ& t§|¡|Ô4÷	5÷ 	5ô �l‰lØ×Ñ ×!<Ñ!<Ð=Ü×/Ñ/ô
÷ 	
ð 	
ð �=‰=×&Ñ&Ð2Ø—-‘-×-Ñ-Ð-ð 3ð	5øð 	5ø÷ 	5÷ 	5ñ 	5úð	
úsU   ‚B	EÂD5ÂEÂ&D9Â5EÃ D7ÃAEÄEÄ2EÄ7EÄ9EÄ?EÅ EÅEc                ó¦   •— | j                   €5t        |t        «      sJ ‚|| _         | j                  j	                  d«       yt
        ‰| �  |«       y)z.
        Process one incoming event.

        N)ÚresponseÚ
isinstancer   r@   Ú
set_resultr<   Úprocess_event)rA   ÚeventrC   s     €rD   r[   zClientConnection.process_events   sI   ø€ ð �=‰=Ð Ü˜e¤XÔ.Ð.Ð.Ø!ˆDŒMØ×Ñ×)Ñ)¨$Õ/ô ‰GÑ! %Õ(rE   )rB   r   r6   úfloat | Noner7   r]   r8   r]   r9   ú*int | None | tuple[int | None, int | None]r:   úint | tuple[int, int | None]ÚreturnÚNone)rT   úHeadersLike | NonerU   ú
str | Noner`   ra   )r\   r   r`   ra   )	Ú__name__Ú
__module__Ú__qualname__Ú__doc__r=   r   rV   r[   Ú__classcell__)rC   s   @rD   r-   r-   (   s�   ø„ ñð8 ')Ø%'Ø&(Ø@BØ49ñMà ðMð $ð	Mð
 #ðMð $ðMð >ðMð 2ðMð 
õMð. 26Ø(2ð.à.ð.ð &ð.ð 
ó	.÷:)ñ )rE   r-   c                  óÚ   — e Zd ZdZdddddededdddeddd	ddd
œ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dd„Zdd„Zdd„Z	dd„Z
dd„Zdd„Z	 	 	 	 	 	 	 	 dd„Zdd„Zy)r+   u'  
    Connect to the WebSocket server at ``uri``.

    :func:`connect` should be treated as an asynchronous context manager
    yielding a :class:`ClientConnection`, which can then receive and send
    messages::

        from websockets.asyncio.client import connect

        async with connect(...) as websocket:
            ...

    The connection is closed automatically when exiting the context.

    :func:`connect` can also be treated 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.

    :func:`connect` can be awaited directly::

        websocket = await connect(...)

    In that case, you're responsible for closing the connection with
    :meth:`ClientConnection.close` when no longer needed.

    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: 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:`~websockets.client.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.
        reconnect_delays: Delays in seconds between reconnection attempts.
            Default is exponential backoff with 5s jitter, capped at 60s.
        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 ``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.

    * 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 configure ``ssl_handshake_timeout`` and ``ssl_shutdown_timeout``.

    * 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.

    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.

    NÚdeflateTr2   r1   i   r3   r4   )ÚoriginÚ
extensionsÚsubprotocolsÚcompressionrT   rU   Úproxyr   Úopen_timeoutr6   r7   r8   Úreconnect_delaysÚmax_sizer9   r:   ÚloggerÚcreate_connectionc               óä  ‡‡‡‡‡‡‡‡‡‡‡— || _         t        |«      | _        | j                  j                  s|j	                  d«      �t        d«      ‚‰�t        ‰«       |dk(  rt        ‰«      Šn|�t        d|› �«      ‚‰€t        j                  d«      Š‰€t        Š|| _        || _        || _        |	| _        |
| _        || _        ‰| _        || _        dˆˆˆˆˆˆˆˆˆˆˆfd„}|| _        y )NÚsslz-ssl argument is incompatible with a ws:// URIrj   zunsupported compression: zwebsockets.clientc                óF   •— t        | ‰	‰‰‰‰¬«      } ‰|‰
‰‰‰‰¬«      }|S )N)rk   rl   rm   rr   rs   r5   )r   )ÚurirB   Ú
connectionr8   rt   rl   rs   r9   rr   rk   r6   r7   rm   r:   s      €€€€€€€€€€€rD   Úfactoryz!connect.__init__.<locals>.factoryC  sE   ø€ ä%ØØØ%Ø)Ø!ØôˆHñ +ØØ+Ø)Ø+Ø#Ø'ôˆJð ÐrE   )rx   r'   r`   r-   )rx   r(   Úws_uriÚsecureÚgetÚ
ValueErrorr   r   ÚloggingÚ	getLoggerr-   rT   rU   ro   r   rp   rq   rs   Úcreate_connection_kwargsrz   )rA   rx   rk   rl   rm   rn   rT   rU   ro   r   rp   r6   r7   r8   rq   rr   r9   r:   rs   rt   Úkwargsrz   s     ```      ``` `````  rD   r=   zconnect.__init__  së   ÿú€ ð> ˆŒÜ “nˆŒØ�{‰{×!Ò! f§j¡j°Ó&7Ð&CÜÐLÓMÐMàÐ#Ü! ,Ô/à˜)Ò#Ü9¸*ÓE‰JØÐ$ÜÐ8¸¸ÐFÓGÐGàˆ>Ü×&Ñ&Ð':Ó;ˆFàÐ$Ü 0Ðà"4ˆÔØ!2ˆÔØˆŒ
Ø!2ˆÔØ(ˆÔØ 0ˆÔØˆŒØ(.ˆÔ%÷	÷ 	ð, ˆ�rE   c              ƒ  ó,  ‡ K  — t        j                  «       }‰ j                  j                  «       }‰ j                  }|j                  dd«      rd}|j                  d«      �d}|du rt        ‰ j                  «      }dˆ fd„}‰ j                  j                  rT|j                  dd«       |j                  d«      €t        d«      ‚|j                  d	‰ j                  j                  «       |j                  dd«      r  |j                  |fi |¤Žƒ d{  –—† \  }}|S |��ät        |«      }|j                  dd
 dk(  rRt!        |‰ j                  |j                  dd«      ¬«      ƒ d{  –—† } |j"                  |fd|i|¤Žƒ d{  –—† \  }}|S |j                  dd dk(  �rW|i i }}
}	|	j%                  «       D ]@  \  }}|j'                  d«      s|d	k(  r|||<   Œ"|j'                  d«      r	||
|dd <   Œ<||
|<   ŒB |j                  dk(  r.|
j                  dd«       |
j                  d«      €'t        d«      ‚|
j                  d«      �t        d«      ‚t)        |‰ j                  fd‰ j*                  i|
¤Žƒ d{  –—† } |«       }|j-                  |«       |j                  dd«      }|du rt/        j0                  «       }|�# |j2                  |||fi |¤Žƒ d{  –—† }|€J ‚|}|j5                  |«       |S t7        d«      ‚|j                  d«      €L|j                  d‰ j                  j                  «       |j                  d‰ j                  j8                  «        |j"                  |fi |¤Žƒ d{  –—† \  }}|S 7 �Œn7 �Œ7 �Œ7 �Œ7 Œ±7 Œ­w)zFOpen a TCP or Unix connection to the server, possibly through a proxy.ÚunixFNÚsockTc                 ó:   •— ‰ j                  ‰ j                  «      S ©N)rz   r{   ©rA   s   €rD   rz   z,connect.open_tcp_connection.<locals>.factoryh  s   ø€ Ø—<‘< §¡Ó,Ð,rE   rv   z*ssl=None is incompatible with a wss:// URIÚserver_hostnameé   ÚsocksÚ
local_addr)rŒ   é   ÚhttpÚproxy_é   Úhttpsz5proxy_ssl=None is incompatible with an https:// proxyz8proxy_ssl argument is incompatible with an http:// proxyrU   z&parse_proxy returned unsupported proxyÚhostÚport©r`   r-   )rO   Úget_running_loopr�   Úcopyro   r}   r   r{   r|   rL   r~   r’   ÚpopÚcreate_unix_connectionr    ÚschemeÚconnect_socks_proxyrt   ÚitemsÚ
startswithÚconnect_http_proxyrU   Úset_protocolÚ
ssl_moduleÚcreate_default_contextÚ	start_tlsÚconnection_madeÚAssertionErrorr“   )rA   r>   r‚   ro   rz   Ú_ry   Úproxy_parsedr…   Ú
all_kwargsÚproxy_kwargsÚkeyÚvalueÚ	transportrv   Únew_transports   `               rD   Úopen_tcp_connectionzconnect.open_tcp_connection[  sÃ  øè ø€ ä×'Ñ'Ó)ˆØ×.Ñ.×3Ñ3Ó5ˆà—
‘
ˆØ�:‰:�f˜eÔ$ØˆEØ�:‰:�fÓÐ)ØˆEØ�D‰=Ü˜dŸk™kÓ*ˆEõ	-ð �;‰;×ÒØ×Ñ˜e TÔ*Ø�z‰z˜%Ó Ð(Ü Ð!MÓNÐNØ×ÑÐ/°·±×1AÑ1AÔBà�:‰:�f˜eÔ$Ø"= $×"=Ñ"=¸gÑ"PÈÑ"P×P‰MˆAˆzØÐàÑÜ& uÓ-ˆLà×"Ñ" 2 AÐ&¨'Ò1ä0Ø Ø—K‘Kà%Ÿz™z¨,¸Ó=ô	÷ �ð '= d×&<Ñ&<Øñ'àð'ð ñ'÷ !‘��:ð
 "Ð!à×$Ñ$ R aÐ(¨FÓ2à39¸2¸r¨&˜L�
Ø",×"2Ñ"2Ó"4ò 2‘J�C˜Ø—~‘~ eÔ,°Ð7HÒ0HØ&+˜˜sšØŸ™¨Ô1Ø05˜ S¨¨ WÒ-à,1˜ SÒ)ð2ð  ×&Ñ&¨'Ò1Ø ×+Ñ+¨E°4Ô8Ø#×'Ñ'¨Ó.Ð6Ü(ØSóð ð $×'Ñ'¨Ó.Ð:Ü(ØVóð ô #5Ø Ø—K‘Kñ#ð '+×&<Ñ&<ð#ð #ñ	#÷ �	ñ %›Y�
Ø×&Ñ& zÔ2Ø—j‘j ¨Ó-�Ø˜$‘;Ü$×;Ñ;Ó=�CØ�?Ø*8¨$¯.©.Ø! :¨sñ+Ø6<ñ+÷ %�Mð )Ð4Ð4Ð4Ø -�IØ×*Ñ*¨9Ô5Ø!Ð!ô %Ð%MÓNÐNð �z‰z˜&Ó!Ð)Ø×!Ñ! &¨$¯+©+×*:Ñ*:Ô;Ø×!Ñ! &¨$¯+©+×*:Ñ*:Ô;à"8 $×"8Ñ"8¸Ñ"KÀFÑ"K×K‰MˆAˆzØÐðY Qùðùð!ùð<ùð%øð" Lúsp   ƒDNÄNÄANÅ+NÅ,NÆN
Æ	C4NÉ=NÉ>A NËNËBNÍ:NÍ;
NÎNÎ
NÎNÎNÎNc                óØ  — t        |t        «      r0|j                  j                  dv rd|j                  j                  v s|S | j
                  }t        j                  j                  | j                  |j                  j                  d   «      }t        |«      }| j                  j                  d«      �t        d|› d�«      S |j                  r|j                  st        d|› �«      S |j                  |j                  k7  s2|j                   |j                   k7  s|j"                  |j"                  k7  r´| j                  j                  dd«      rt        d	|› d
�«      S | j                  j                  d«      €| j                  j                  d«      �t        d	|› d�«      S | j$                  �8t'        d„ t'        | j$                  «      j)                  «       D «       «      | _        |S )z¬
        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.

        )é,  i-  i.  i/  i3  i4  ÚLocationr…   zcannot follow redirect to z with a preexisting socketz)cannot follow redirect to non-secure URI r„   Fz'cannot follow cross-origin redirect to z with a Unix socketr’   r“   z with an explicit host or portc              3  óN   K  — | ]  \  }}|j                  «       d vr||f–— Œ y­w))ÚauthorizationÚcookiezproxy-authorizationN)Úlower)Ú.0r¨   r©   s      rD   ú	<genexpr>z+connect.process_redirect.<locals>.<genexpr>þ  s2   è ø€ ò á&˜C ØŸ9™9›;ØQñRð ˜eœñùs   ‚#%)rY   r   rX   Ústatus_coderJ   r{   ÚurllibÚparseÚurljoinrx   r(   r�   r}   r~   r|   r   r’   r“   rT   r   Ú	raw_items)rA   ÚexcÚ
old_ws_uriÚnew_uriÚ
new_ws_uris        rD   Úprocess_redirectzconnect.process_redirectÀ  sÒ  € ô �sœMÔ*Ø—‘×(Ñ(ðñð ˜cŸl™l×2Ñ2Ñ2àˆJà—[‘[ˆ
Ü—,‘,×&Ñ& t§x¡x°·±×1EÑ1EÀjÑ1QÓRˆÜ˜wÓ'ˆ
ð ×(Ñ(×,Ñ,¨VÓ4Ð@ÜØ,¨W¨IÐ5OÐPóð ð
 ×Ò Z×%6Ò%6Ü Ð#LÈWÈIÐ!VÓWÐWð ×Ñ ×!2Ñ!2Ò2Ø�‰ *§/¡/Ò1Ø�‰ *§/¡/Ò1ð ×,Ñ,×0Ñ0°¸Ô?Ü!Ø=¸g¸Yð G)ð *óð ð ×-Ñ-×1Ñ1°&Ó9ÐEØ×0Ñ0×4Ñ4°VÓ<ÐHä!Ø=¸g¸Yð G4ð 5óð ð ×&Ñ&Ð2Ü*1ñä*1°$×2IÑ2IÓ*J×*TÑ*TÓ*Vôó+�Ô'ð ˆrE   c              ƒ  ó0  K  — 	 t        j                  | j                  «      4 ƒd {  –—†  t        t        «      D ]m  }| j                  «       ƒ d {  –—† }	 |j                  | j                  | j                  «      ƒ d {  –—†  |j                  «        |c cd d d «      ƒd {  –—†  S  t'        dt        › d�«      ‚7 Œ–7 Œn7 ŒA7 Œ# t         j                  $ r |j                  j                  «        ‚ t        $ re}|j                  j                  «        | j                  |«      }t        |t        «      r||u r‚ ||‚|| _        t#        |«      | _        Y d }~�Œ!d }~ww xY w# 1 ƒd {  –—†7  sw Y   y xY w# t(        $ r}t)        d«      |‚d }~ww xY w­w)Nz
more than z
 redirectsz"timed out during opening handshake)rO   Útimeoutrp   ÚrangeÚMAX_REDIRECTSr¬   rV   rT   rU   Ústart_keepaliveÚCancelledErrorrª   ÚabortÚ	Exceptionr¿   rY   rx   r(   r{   r   ÚTimeoutError)rA   r¤   ry   r»   Ú
exc_or_uris        rD   r+   zconnect.connect  s˜  è ø€ ð*	NÜ—‘ t×'8Ñ'8Ó9÷ %Pñ %PÜœ}Ó-ò $P�AØ'+×'?Ñ'?Ó'A×!A�Jð *Ø(×2Ñ2Ø ×3Ñ3Ø ×2Ñ2ó÷ ð ð< #×2Ñ2Ô4Ø)Ñ)÷G%P÷ %Pñ %Pð$PôH (¨*´]°OÀ:Ð(NÓOÐOðK%Pøà!Aøðøð	%Pùô #×1Ñ1ò Ø"×,Ñ,×2Ñ2Ô4ØÜ$ò %ð #×,Ñ,×2Ñ2Ô4à%)×%:Ñ%:¸3Ó%?˜
Ü% j´)Ô<à)¨SÑ0Ø %à&0°cÐ 9ð (2˜DœHÜ*3°JÓ*?˜DœKÝ$ûð)%ú÷%P÷ %Pñ %PûôN ò 	NäÐCÓDÈ#ÐMûð	NüsÎ   ‚F„#E9 §B>¨E9 «&E$ÁC ÁE$Á)CÂ CÂCÂE$ÂE9 Â$CÂ%E9 Â)FÂ*E$Â>E9 Ã E$ÃCÃE9 Ã6E!Ã<AEÅE$ÅE!Å!E$Å$E6Å*E-Å+E6Å2E9 Å5FÅ6E9 Å9	FÆFÆFÆFc                ó>   — | j                  «       j                  «       S r‡   )r+   Ú	__await__rˆ   s    rD   rË   zconnect.__await__7  s   € à�|‰|‹~×'Ñ'Ó)Ð)rE   c              ƒ  ór   K  — t        | d«      rt        d«      ‚| ƒ d {  –—† | _        | j                  S 7 Œ­w)Nry   zconnect() isn't reentrant)ÚhasattrÚRuntimeErrorry   rˆ   s    rD   Ú
__aenter__zconnect.__aenter__=  s4   è ø€ Ü�4˜Ô&ÜÐ:Ó;Ð;Ø $Ÿ*ˆŒØ�‰Ðð %ús   ‚7Ÿ5 7c              ƒ  óh   K  — 	 | j                   j                  «       ƒ d {  –—†  | ` y 7 Œ# | ` w xY w­wr‡   )ry   Úclose)rA   Úexc_typeÚ	exc_valueÚ	tracebacks       rD   Ú	__aexit__zconnect.__aexit__C  s1   è ø€ ð	 Ø—/‘/×'Ñ'Ó)×)Ð)à‘ð *ùà‘üs    ‚2„+ ¡)¢+ ¦2©+ «/¯2c               ó  K  — d }	 	 | 4 ƒd {  –—† }|­–— d d d «      ƒd {  –—†  d }Œ$7 Œ7 Œ	# 1 ƒd {  –—†7  sw Y   ŒxY w# t         $ r»}	 | j                  |«      }n# t         $ r}|}Y d }~nd }~ww xY w||u r‚ |�||‚|€| j                  «       }t        |«      }| j                  j                  d|t        j                  |«      d   j                  «       «       t        j                  |«      ƒ d {  –—†7   Y d }~ŒÙd }~ww xY w­w)Nz0connect failed; reconnecting in %.1f seconds: %sr   )rÇ   r   rq   Únextrs   ÚinforÔ   Úformat_exception_onlyÚstriprO   Úsleep)rA   Údelaysry   r»   Únew_excÚ
raised_excÚdelays          rD   Ú	__aiter__zconnect.__aiter__P  s  è ø€ Ø*.ˆØð"Ø÷ %ð % :Ø$Ó$÷%÷ %ðB �ðG ð%øð %ø÷ %÷ %ñ %ûäò +ð
)Ø"×4Ñ4°SÓ9‘GøÜ ò )Ø(•Gûð)úð
 ˜c‘>ØØÐ&Ø! sÐ*ð �>Ø!×2Ñ2Ó4�FÜ˜V›�Ø—‘× Ñ ØFØÜ×3Ñ3°CÓ8¸Ñ;×AÑAÓCôô
 —m‘m EÓ*×*Ö*ûð7+üs–   ‚D
‡A �*ŽA ‘.—A ¢,£A §D
ªA ¬A ®A ´7µA ¼A Á	DÁAÁDÁ	A4Á(A/Á*DÁ/A4Á4BDÃ7C:Ã8DÃ=D
ÄDÄD
)*rx   Ústrrk   zOrigin | Nonerl   z'Sequence[ClientExtensionFactory] | Nonerm   zSequence[Subprotocol] | Nonern   rc   rT   rb   rU   rc   ro   zstr | Literal[True] | Noner   z'Callable[[Exception], Exception | None]rp   r]   r6   r]   r7   r]   r8   r]   rq   zCallable[[], Generator[float]]rr   r^   r9   r^   r:   r_   rs   zLoggerLike | Nonert   ztype[ClientConnection] | Noner‚   r   r`   ra   r”   )r»   rÇ   r`   zException | str)r`   z&Generator[Any, None, ClientConnection])rÒ   ztype[BaseException] | NonerÓ   zBaseException | NonerÔ   zTracebackType | Noner`   ra   )r`   zAsyncIterator[ClientConnection])rd   re   rf   rg   r   r   r   r=   r¬   r¿   r+   rË   rÏ   rÕ   rà   © rE   rD   r+   r+   ƒ   s}  „ ñBðR !%Ø>BØ59Ø"+à15Ø(2Ø,0ØEVà%'Ø&(Ø%'Ø&(Ø;Bà?DØ@BØ49à$(à;?ñ7QàðQð
 ðQð <ðQð 3ðQð  ðQð /ðQð &ðQð *ðQð CðQð #ðQð  $ð!Qð" #ð#Qð$ $ð%Qð& 9ð'Qð* =ð+Qð, >ð-Qð. 2ð/Qð2 "ð3Qð6 9ð7Qð: ð;Qð< 
ó=QófcóJFóP+Nó^*óð	 à,ð	 ð (ð	 ð (ð		 ð
 
ó	 ô%rE   r+   c                óP   — |€|j                  d«      €d}nd}t        d|d| dœ|¤ŽS )aã  
    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/``.

    rv   zws://localhost/zwss://localhost/T)rx   r„   Úpathrâ   )r}   r+   )rä   rx   r‚   s      rD   r,   r,   x  s9   € ð* €{Ø�:‰:�eÓÐ$Ø#‰Cà$ˆCÜÐ;�s ¨DÑ;°FÑ;Ð;rE   )Ú	ProxyType)r   )Úsocks5hÚsocks5Úsocks4aÚsocks4TFc           	   ‹  óp  K  — t        t        | j                     | j                  | j                  | j
                  | j                  t        | j                     «      }	  |j                  |j                  |j                  fi |¤Žƒ d{  –—† S 7 Œ# t        $ r ‚ t        $ r}t        d«      |‚d}~ww xY w­w)z0Connect via a SOCKS proxy and return the socket.Nz failed to connect to SOCKS proxy)Ú
SocksProxyÚSOCKS_PROXY_TYPESr™   r’   r“   ÚusernameÚpasswordÚSOCKS_PROXY_RDNSr+   ÚOSErrorrÇ   r   )ro   r{   r‚   Úsocks_proxyr»   s        rD   rš   rš   ±  sž   è ø€ ô !Ü˜eŸl™lÑ+Ø�J‰JØ�J‰JØ�N‰NØ�N‰NÜ˜UŸ\™\Ñ*ó
ˆð	JØ,˜×,Ñ,¨V¯[©[¸&¿+¹+ÑPÈÑP×PÐPÐPùÜò 	ØÜò 	JÜÐ?Ó@ÀcÐIûð	Jüs<   ‚AB6Á+B Â	BÂ
B ÂB6ÂB ÂB3Â"B.Â.B3Â3B6c              ‹  ó    K  — t        d«      ‚­w)Nz6connecting through a SOCKS proxy requires python-socks)ÚImportError)ro   r{   r‚   s      rD   rš   rš   ›  s   è ø€ ô
 ÐRÓSÐSùs   ‚c                  óJ   — e Zd Z	 d	 	 	 	 	 d	d„Zd
d„Zdd„Zdd„Zd
d„Zdd„Zy)ÚHTTPProxyConnectionNc                óR  — || _         || _        || _        t        «       | _        t        j                  | j                  j                  | j                  j                  | j                  j                  d¬«      | _
        t        j                  «       }|j                  «       | _        y )NT)ro   )r{   ro   rU   r"   Úreaderr   r¸   Ú	read_lineÚ
read_exactÚread_to_eofÚparserrO   r•   r?   rX   )rA   r{   ro   rU   r>   s        rD   r=   zHTTPProxyConnection.__init__Ë  s}   € ð ˆŒØˆŒ
Ø!2ˆÔä"“nˆŒÜ—n‘nØ�K‰K×!Ñ!Ø�K‰K×"Ñ"Ø�K‰K×#Ñ#Øô	
ˆŒô ×'Ñ'Ó)ˆØ26×2DÑ2DÓ2Fˆ�rE   c                óª  — 	 t        | j                  «       y # t        $ rs}|j                  }d|j                  cxk  rdk  rn n| j
                  j                  |«       n)| j
                  j                  t        |«      «       Y d }~y Y d }~y d }~wt        $ r7}t        d«      }||_        | j
                  j                  |«       Y d }~y d }~ww xY w)NéÈ   r®   z0did not receive a valid HTTP response from proxy)r×   rû   ÚStopIterationr©   r¶   rX   rZ   Úset_exceptionr   rÇ   r   Ú	__cause__)rA   r»   rX   Ú	proxy_excs       rD   Ú
run_parserzHTTPProxyConnection.run_parserà  s©   € ð	3Ü�—‘ÕøÜò 	JØ—y‘yˆHØ�h×*Ñ*Ô0¨SÕ0Ø—‘×(Ñ(¨Õ2à—‘×+Ñ+Ô,>¸xÓ,H×IÑIô 3ûô ò 	3Ü+ØBóˆIð #&ˆIÔØ�M‰M×'Ñ'¨	×2Ñ2ûð	3ús!   ‚ ˜	C¡A$BÂCÂ-CÃCc                óÎ   — t        t        j                  |«      }|| _        | j                  j	                  t        | j                  | j                  | j                  «      «       y r‡   )	r   rO   Ú	Transportrª   Úwriter!   ro   r{   rU   )rA   rª   s     rD   r¢   z#HTTPProxyConnection.connection_madeð  sG   € Üœ×*Ñ*¨IÓ6ˆ	Ø"ˆŒØ�‰×ÑÜ# D§J¡J°·±¸T×=SÑ=SÓTõ	
rE   c                óZ   — | j                   j                  |«       | j                  «        y r‡   )r÷   Ú	feed_datar  )rA   Údatas     rD   Údata_receivedz!HTTPProxyConnection.data_received÷  s   € Ø�‰×Ñ˜dÔ#Ø�‰ÕrE   c                óX   — | j                   j                  «        | j                  «        y r‡   ©r÷   Úfeed_eofr  rˆ   s    rD   Úeof_receivedz HTTPProxyConnection.eof_receivedû  ó   € Ø�‰×ÑÔØ�‰ÕrE   c                óX   — | j                   j                  «        | j                  «        y r‡   r  )rA   r»   s     rD   Úconnection_lostz#HTTPProxyConnection.connection_lostÿ  r  rE   r‡   )r{   r'   ro   r   rU   rc   )r`   ra   )rª   zasyncio.BaseTransportr`   ra   )r  Úbytesr`   ra   )r»   zException | Noner`   ra   )	rd   re   rf   r=   r  r¢   r	  r  r  râ   rE   rD   rõ   rõ   Ê  sE   „ ð
 )-ð	GàðGð ðGð &ó	Gó*3ó 
óóôrE   rõ   )rU   c             ‹  ó8  ‡ ‡‡K  —  t        j                  «       j                  ˆ ˆˆfd„‰ j                  ‰ j                  fi |¤Žƒ d {  –—† \  }}	 |j
                  ƒ d {  –—†  |S 7 Œ7 Œ# t         j                  t        f$ r |j                  «        ‚ w xY w­w)Nc                 ó   •— t        ‰‰ ‰«      S r‡   )rõ   )ro   rU   r{   s   €€€rD   ú<lambda>z$connect_http_proxy.<locals>.<lambda>  s   ø€ Ô# F¨EÐ3DÓE€ rE   )	rO   r•   rt   r’   r“   rX   rÅ   rÇ   rÆ   )ro   r{   rU   r‚   rª   rB   s   ```   rD   r�   r�     s—   úè ø€ ð !M¤× 8Ñ 8Ó :× LÑ LÝEØ�
‰
Ø�
‰
ñ!ð ñ	!÷ Ñ€Iˆxðà×Ñ×Ðð
 Ððøð 	 ùÜ×"Ñ"¤IÐ.ò Ø�‰ÔØðüs<   …ABÁ	A(Á
BÁA, Á!A*Á"A, Á&BÁ*A, Á,+BÂB)NN)rä   zPathLike | Nonerx   rc   r‚   r   r`   r+   )ro   r   r{   r'   r‚   r   r`   zsocket.socket)
ro   r   r{   r'   rU   rc   r‚   r   r`   zasyncio.Transport)TÚ
__future__r   rO   r   ÚosÚsocketrv   rŸ   rÔ   Úurllib.parser·   Úcollections.abcr   r   r   Útypesr   Útypingr   r	   r
   r   Úclientr   r   r   Údatastructuresr   r   Ú
exceptionsr   r   r   r   r   Úextensions.baser   Úextensions.permessage_deflater   rJ   r   Úhttp11r   r   rB   r   r   ro   r   r   r    r!   Ústreamsr"   r#   r$   r%   r&   rx   r'   r(   ry   r*   Ú__all__ÚintÚenvironr}   rÃ   r-   r+   r,   Úpython_socksrå   Úpython_socks.async_.asynciorë   ÚSOCKS5ÚSOCKS4rì   rï   rš   ró   ÚProtocolrõ   r�   râ   rE   rD   ú<module>r+     sÞ  ðÝ "ã Û Û 	Û Û Û Û ß >Ñ >Ý ß /Ó /ç ?Ñ ?ß 1÷õ õ 5Ý LÝ +ß )ß (ß JÓ JÝ "ß >Ó >ß )Ý "ò :€á�B—J‘J—N‘NÐ#=¸tÓDÓE€ôW)�zô W)÷vrñ rðl !Øð<Ø
ð<à	ð<ð ð<ð ó	<ð:2JÝ&Ý?ð ×#Ñ#Ø×"Ñ"Ø×#Ñ#Ø×"Ñ"ñ	Ðð ØØØñ	ÐðJØðJàðJð ðJð 
ó	Jô27˜'×*Ñ*ô 7ð| %)ñ	Øðàðð "ð	ð
 ðð ôøðW ò TðTØðTàðTð ðTð 
õ	TðTús   Ã7E+ Å+E?Å>E?