o
    eI-                     @  s6  d dl mZ d dlZd dlZd dlZd dl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 dd	lmZ dd
lmZ ddlmZ ddlmZ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ddedddddddd?d9d:Z'		d@dAd=d>Z(dS )B    )annotationsN)AnyOptionalSequenceType   )ClientProtocol)HeadersLike)ClientExtensionFactory) enable_client_permessage_deflate)validate_subprotocols)
USER_AGENT)Response)
CONNECTINGOPENEvent)
LoggerLikeOriginSubprotocol)	parse_uri   )
Connection)Deadline)connectunix_connectClientConnectionc                      sV   e Zd ZdZ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  
    Threaded 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.

    Args:
        socket: Socket connected to a WebSocket server.
        protocol: Sans-I/O connection.
        close_timeout: Timeout for closing the connection in seconds.

    
   close_timeoutsocketsocket.socketprotocolr   r   Optional[float]returnNonec                  s$   |  t  | _t j|||d d S )Nr   )	threadingr   response_rcvdsuper__init__)selfr   r!   r   	__class__ FD:\Projects\ConvertPro\env\Lib\site-packages\websockets/sync/client.pyr(   1   s   

zClientConnection.__init__Nadditional_headersOptional[HeadersLike]user_agent_headerOptional[str]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	|sK| 
  | j  td| jdu r]| 
  | j  td| jjturs| j| j | 
  | j  | jjdur}| jjdS )z1
        Perform the opening handshake.

        )Zexpected_stateNz
User-Agentztimed out during handshakez"connection closed during handshake)Zsend_contextr   r!   r   requestheadersupdatesend_requestr&   waitZclose_socketZrecv_events_threadjoinTimeoutErrorresponseConnectionErrorstater   r   handshake_exc)r)   r.   r0   r2   r,   r,   r-   	handshake@   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)r:   
isinstancer   r&   setr'   process_event)r)   r?   r*   r,   r-   rB   d   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&   rA   )r)   r*   r,   r-   rC   r   s   zClientConnection.recv_events)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>   rB   rC   __classcell__r,   r,   r*   r-   r      s    $r   Fdeflater   i   )sockssl_contextserver_hostnameunixpathorigin
extensionssubprotocolsr.   r0   compressionopen_timeoutr   max_sizeloggercreate_connectionuristrrJ   Optional[socket.socket]rK   Optional[ssl.SSLContext]rL   r1   rM   boolrN   rO   Optional[Origin]rP   *Optional[Sequence[ClientExtensionFactory]]rQ   Optional[Sequence[Subprotocol]]r.   r/   r0   rR   rS   r"   r   rT   Optional[int]rU   Optional[LoggerLike]rV    Optional[Type[ClientConnection]]r#   c             	   C  s  t | }|js|durtd|r*|du r|du rtd|dur)|dur)tdn|du s0J |dur8t| |dkrAt|}n|durLtd| t|}|du rVt}z|du r|rxttj	tj
}||  |dusrJ || nt|j|jf| }|d |s|tjtjd |jr|du rt }|du r|j}||  |j||d}|d t||||t||d	}||||d
}||	|
|  W |S  ty   |dur|   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::

        async with websockets.sync.client.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_context: 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.
        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.

    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.

    Nz5ssl_context argument is incompatible with a ws:// URIzmissing path argumentz(path and sock arguments are incompatiblerI   zunsupported compression: T)rL   )rO   rP   rQ   r<   rT   rU   r   )r   secure	TypeErrorr   r   
ValueErrorr   r   r   AF_UNIXSOCK_STREAM
settimeoutr2   r   rV   hostport
setsockoptIPPROTO_TCPTCP_NODELAYsslcreate_default_contextwrap_socketr   r   r>   	Exceptionclose)rW   rJ   rK   rL   rM   rN   rO   rP   rQ   r.   r0   rR   rS   r   rT   rU   rV   Zwsurideadliner!   
connectionr,   r,   r-   r   ~   s   S



r   kwargsr   c                 K  s6   |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 is identical to :func:`connect`, except for the additional
    ``path`` argument. 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_context`` is provided, to
            ``wss://localhost/``.

    NrK   zws://localhost/zwss://localhost/T)rW   rM   rN   r,   )getr   )rN   rW   rt   r,   r,   r-   r   /  s
   r   )$rW   rX   rJ   rY   rK   rZ   rL   r1   rM   r[   rN   r1   rO   r\   rP   r]   rQ   r^   r.   r/   r0   r1   rR   r1   rS   r"   r   r"   rT   r_   rU   r`   rV   ra   r#   r   )NN)rN   r1   rW   r1   rt   r   r#   r   ))
__future__r   r   rm   r%   typingr   r   r   r   clientr   Zdatastructuresr	   Zextensions.baser
   Zextensions.permessage_deflater   r4   r   httpr   Zhttp11r   r!   r   r   r   r   r   r   rW   r   rs   r   utilsr   __all__r   r   r   r,   r,   r,   r-   <module>   sP    i 3