o
    g.                     @  s0  d dl mZ d dlZd dlZd dlZd dlZd dlmZ d dl	m
Z
 ddlmZ ddl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	mZmZmZ ddlmZ ddl m!Z! ddl"m#Z# g dZ$G dd de!Z%dddddddeddddddddd?d:d;Z&		d@dAd=d>Z'dS )B    )annotationsN)Sequence)Any   )ClientProtocol)HeadersLike)ClientExtensionFactory) enable_client_permessage_deflate)validate_subprotocols)
USER_AGENTResponse)
CONNECTINGEvent)
LoggerLikeOriginSubprotocol)	parse_uri   )
Connection)Deadline)connectunix_connectClientConnectionc                      sX   e Zd ZdZdddd fddZdedfd ddZd! fddZd" fddZ  Z	S )#r   a  
    :mod:`threading` implementation of a WebSocket client connection.

    :class:`ClientConnection` provides :meth:`recv` and :meth:`send` methods for
    receiving and sending messages.

    It supports iteration to receive messages::

        for message in websocket:
            process(message)

    The iterator exits normally when the connection is closed with close 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 ``close_timeout`` and ``max_queue`` arguments have the same meaning as
    in :func:`connect`.

    Args:
        socket: Socket connected to a WebSocket server.
        protocol: Sans-I/O connection.

    
      close_timeout	max_queuesocketsocket.socketprotocolr   r   float | Noner   *int | None | tuple[int | None, int | None]returnNonec                  s&   |  t  | _t j||||d d S )Nr   )	threadingr   response_rcvdsuper__init__)selfr   r    r   r   	__class__ M/var/www/visachat/venv/lib/python3.10/site-packages/websockets/sync/client.pyr(   4   s   

zClientConnection.__init__Nadditional_headersHeadersLike | Noneuser_agent_header
str | Nonetimeoutc                 C  s   | j td* | j | _|dur| jj| |dur"|| jjd< | j| j W d   n1 s3w   Y  | j	|sBt
d| jjdurL| jjdS )z1
        Perform the opening handshake.

        )expected_stateNz
User-Agentztimed out during handshake)send_contextr   r    r   requestheadersupdatesend_requestr&   waitTimeoutErrorhandshake_exc)r)   r.   r0   r2   r,   r,   r-   	handshakeE   s   
zClientConnection.handshakeeventr   c                   s<   | j du rt|tsJ || _ | j  dS t | dS )z.
        Process one incoming event.

        N)response
isinstancer   r&   setr'   process_event)r)   r=   r*   r,   r-   rA   a   s
   
zClientConnection.process_eventc                   s(   zt    W | j  dS | j  w )zI
        Read incoming data from the socket and process events.

        N)r'   recv_eventsr&   r@   )r)   r*   r,   r-   rB   o   s   zClientConnection.recv_events)
r   r   r    r   r   r!   r   r"   r#   r$   )r.   r/   r0   r1   r2   r!   r#   r$   )r=   r   r#   r$   )r#   r$   )
__name__
__module____qualname____doc__r(   r   r<   rA   rB   __classcell__r,   r,   r*   r-   r      s    r   deflater   i   r   )socksslserver_hostnameorigin
extensionssubprotocolsr.   r0   compressionopen_timeoutr   max_sizer   loggercreate_connectionuristrrI   socket.socket | NonerJ   ssl_module.SSLContext | NonerK   r1   rL   Origin | NonerM   'Sequence[ClientExtensionFactory] | NonerN   Sequence[Subprotocol] | Noner.   r/   r0   rO   rP   r!   r   rQ   
int | Noner   r"   rR   LoggerLike | NonerS   type[ClientConnection] | Nonekwargsr   r#   c                K  s:  |du rd|v r| d}tdt t| }|js"|dur"td| dd}| dd}|rH|du r<|du r<td|durH|durHtd	|durPt| |	d
krYt|}n|	durdtd|	 t	|
}|du rnt
}z|du r|rttjtj}||  |dusJ || n|d|  tj|j|jffi |}|d |s|tjtjd |jr|du rt }|du r|j}||  |j||d}|d t||||||d}|||||d}W n ty   |dur|   w z||||  W |S  ty   |  |j !   w )a	  
    Connect to the WebSocket server at ``uri``.

    This function returns a :class:`ClientConnection` instance, which you can
    use to send and receive messages.

    :func:`connect` may be used as a context manager::

        from websockets.sync.client import connect

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

    The connection is closed automatically when exiting the context.

    Args:
        uri: URI of the WebSocket server.
        sock: Preexisting TCP socket. ``sock`` overrides the host and port
            from ``uri``. You may call :func:`socket.create_connection` to
            create a suitable TCP socket.
        ssl: Configuration for enabling TLS on the connection.
        server_hostname: Host name for the TLS handshake. ``server_hostname``
            overrides the host name from ``uri``.
        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.
        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.
        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.
        open_timeout: Timeout for opening the connection in seconds.
            :obj:`None` disables the timeout.
        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.
        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.
        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 :func:`~socket.create_connection`.

    Raises:
        InvalidURI: If ``uri`` isn't a valid WebSocket URI.
        OSError: If the TCP connection fails.
        InvalidHandshake: If the opening handshake fails.
        TimeoutError: If the opening handshake times out.

    Nssl_contextzssl_context was renamed to sslz-ssl argument is incompatible with a ws:// URIunixFpathzmissing path argumentz(path and sock arguments are incompatiblerH   zunsupported compression: r2   T)rK   )rL   rM   rN   rQ   rR   r   )"popwarningswarnDeprecationWarningr   secure
ValueErrorr
   r	   r   r   r   AF_UNIXSOCK_STREAM
settimeoutr2   r   
setdefaultrS   hostport
setsockoptIPPROTO_TCPTCP_NODELAY
ssl_modulecreate_default_contextwrap_socketr   	Exceptioncloser<   close_socketrecv_events_threadjoin)rT   rI   rJ   rK   rL   rM   rN   r.   r0   rO   rP   r   rQ   r   rR   rS   r^   wsurir`   ra   deadliner    
connectionr,   r,   r-   r   {   s   ]






r   ra   c                 K  sD   |du r| ddu r| ddu r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`` is provided, to
            ``wss://localhost/``.

    NrJ   r_   zws://localhost/zwss://localhost/T)rT   r`   ra   r,   )getr   )ra   rT   r^   r,   r,   r-   r   A  s
   r   )$rT   rU   rI   rV   rJ   rW   rK   r1   rL   rX   rM   rY   rN   rZ   r.   r/   r0   r1   rO   r1   rP   r!   r   r!   rQ   r[   r   r"   rR   r\   rS   r]   r^   r   r#   r   )NN)ra   r1   rT   r1   r^   r   r#   r   )(
__future__r   r   rJ   rq   r%   rc   collections.abcr   typingr   clientr   datastructuresr   extensions.baser   extensions.permessage_deflater	   r6   r
   http11r   r   r    r   r   r   r   r   rT   r   r{   r   utilsr   __all__r   r   r   r,   r,   r,   r-   <module>   sP    e H