vgUddlmZddlZddlZddlZddlZddlZddlm Z m Z m Z ddl m Z ddlmZmZddlmZmZddlmZdd lmZmZdd lmZdd lmZdd lmZdd lm Z m!Z!ddl"m#Z#m$Z$ddlm%Z%m&Z&m'Z'ddl(m)Z)m*Z*ddl+m,Z,m-Z-ddl.m/Z/gdZ0e1ej23ddZ4Gdde/Z5d&dZ6GddZ7 d'd(d%Z8dS))) annotationsN) AsyncIterator GeneratorSequence) TracebackType)AnyCallable)ClientProtocolbackoff) HeadersLike) InvalidStatus SecurityError)ClientExtensionFactory) enable_client_permessage_deflate)validate_subprotocols) USER_AGENTResponse) CONNECTINGEvent) LoggerLikeOrigin Subprotocol) WebSocketURI parse_uri) TimeoutErrorasyncio_timeout) Connection)connect unix_connectClientConnectionWEBSOCKETS_MAX_REDIRECTS10cLeZdZdZdddddddfdZdefddZdfd ZxZS) 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 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 ``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_limitprotocolr r+ float | Noner,r-r.*int | None | tuple[int | None, int | None]r/int | tuple[int, int | None]returnNonec|t|||||||j|_dS)Nr*)super__init__loop create_future response_rcvd)selfr0r+r,r-r.r/ __class__s V/var/www/pixelcanvas.ch/venv/lib/python3.11/site-packages/websockets/asyncio/client.pyr8zClientConnection.__init__8s\ %  '%'#    4893J3J3L3LNadditional_headersHeadersLike | Noneuser_agent_header str | NonecK|t4d{V|j|_||jj||r||jjd<|j|jdddd{Vn#1d{VswxYwYtj |j |j gtj d{V|jj |jj dS)z1 Perform the opening handshake. )expected_stateNz User-Agent) return_when) send_contextrr0r requestheadersupdate send_requestasynciowaitr;connection_lost_waiterFIRST_COMPLETED handshake_exc)r<r@rBs r> handshakezClientConnection.handshakeMs$$J$?? 5 5 5 5 5 5 5 5=0022DL!- $++,>???  G5F $\2 M & &t| 4 4 4  5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5l  !< =/           = & 2-- - 3 2sA0B&& B03B0eventrc|j:t|tsJ||_|jddSt |dS)z. Process one incoming event. N)response isinstancerr; set_resultr7 process_event)r<rRr=s r>rWzClientConnection.process_eventjsg = eX.. . . .!DM   ) )$ / / / / / GG ! !% ( ( ( ( (r?)r0r r+r1r,r1r-r1r.r2r/r3r4r5)r@rArBrCr4r5)rRrr4r5) __name__ __module__ __qualname____doc__r8rrQrW __classcell__)r=s@r>r"r"s8')%'&(@B49MMMMMMMM.26(2.....: ) ) ) ) ) ) ) ) ) )r?r"exc Exceptionr4Exception | Nonect|tttjfrdSt|t r|jjdvrdS|S)a 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. N)iiii)rUEOFErrorOSErrorrLrrrT status_code)r]s r>process_exceptionrdysZ:#'7+?@AAt#}%%#,*BG++ t Jr?czeZdZdZddddededddddddddd d@d,ZdAd.ZdBd2ZdCd4Z dAd5Z e Z dAd6Z dDd=Z dEd?ZdS)Fr uM 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. 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. 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. 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. 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. Ndeflater'r&ir(r))origin extensions subprotocolsr@rB compressionrd open_timeoutr+r,r-max_sizer.r/loggercreate_connectionuristrrg Origin | Nonerh'Sequence[ClientExtensionFactory] | NoneriSequence[Subprotocol] | Noner@rArBrCrjrd'Callable[[Exception], Exception | None]rkr1r+r,r-rl int | Noner.r2r/r3rmLoggerLike | Nonerntype[ClientConnection] | Nonekwargsrr4r5c V ||_t|dkrtn|td|t jdt d   f d }||_||f|_||_ | |_ |_ ||_ dS) Nrfzunsupported compression: zwebsockets.clientwsurirr4r"cT t|  }|  }|S)N)rgrhrirlrmr*)r )rzr0 connectionr-rnrhrmr.rlrgr+r,rir/s r>protocol_factoryz*connect.__init__..protocol_factory8s\%%)! H+*+)+#' J r?)rzrr4r") rorr ValueErrorlogging getLoggerr"r}handshake_argsrdrkrmconnection_kwargs)r<rorgrhrir@rBrjrdrkr+r,r-rlr.r/rmrnrxr}s ``` ```````` r>r8zconnect.__init__ s8  # !, / / / ) # #9*EEJJ  $FFFGG G >&':;;F  $ 0                 *!1   "3( !'r?r"cKtj}tjj}dfd }jrV|dd|dj| dtdn$| dtd | d d r|j |fi|d{V\}}nb| d 6|d j|dj |j|fi|d{V\}}|S)zCreate TCP or Unix connection.r4r"c.SN)r})r<rzsr>factoryz*connect.create_connection..factory^s((// /r?sslTserver_hostnameNz*ssl=None is incompatible with a wss:// URIz-ssl argument is incompatible with a ws:// URIunixFsockhostportr4r")rLget_running_looprrorcopysecure setdefaultrgetr~popcreate_unix_connectionrrn)r<r9rxr_r|rzs` @r>rnzconnect.create_connectionWs'))$(##',,.. 0 0 0 0 0 0 0 < R   eT * * *   / < < <zz%  ( !MNNN)zz%  , !PQQQ ::fe $ $ L"=$"=g"P"P"P"PPPPPPPMAzzzz&!!)!!&%*555!!&%*555"8$"8"K"KF"K"KKKKKKKMAzr?r]r^Exception | strct|tr|jjdvrd|jjvs|St |j}tj |j|jjd}t |}|j dtd|dS|j r|j std|S|j |j ks |j|jks|j|jkru|j dd rtd |d S|j d |j d td |dS|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.i/i3i4LocationrNzcannot follow redirect to z with a preexisting socketz)cannot follow redirect to non-secure URI rFz'cannot follow cross-origin redirect to z with a Unix socketrrz with an explicit host or port)rUrrTrcrIrrourllibparseurljoinrrr~rrrr)r<r] old_wsurinew_uri new_wsuris r>process_redirectzconnect.process_redirectss sM * *  (cl222Jdh'' ,&&tx1Ej1QRRg&&   ! % %f - - 9PWPPP    XI$4 X !VW!V!VWW W   0 0 0~//~//%))&%88 !*g***&**622>)--f55A!5g555 r?&Generator[Any, None, ClientConnection]cN|Sr)__await_impl__ __await__r<s r>rzconnect.__await__s ""$$..000r?cK t|j4d{VttD]}|d{V|_ |jj|jd{V|j|jccdddd{VS#tj $r|j t$r\}|j | |}t|tr ||_Yd}~||ur||d}~wwxYwt#dtd#1d{VswxYwYdS#t$$rt%ddwxYw)Nz more than z redirectsztimed out during handshake)rrkrange MAX_REDIRECTSrnr|rQrstart_keepaliverLCancelledErrorclose_transportr^rrUrprorr)r<rr] uri_or_excs r>rzconnect.__await_impl__s% G&t'899 P P P P P P P P}--PPA,0,B,B,D,D&D&D&D&D&D&DDO/7do79LMMMMMMMM277999#..= P P P P P P P P P P P P P P #177999$66677999%)%:%:3%?%? %j#66%'1DH$HHHH%,,!",#5%60((N](N(N(NOOOA P P P P P P P P P P P P P P P PD G G G;<<$ F Gs_E 7E B$0!E E $2D2A D- E %D--D22E  EE EE E;cK|d{VSrrs r> __aenter__zconnect.__aenter__szzzzzzr?exc_typetype[BaseException] | None exc_valueBaseException | None tracebackTracebackType | NonecHK|jd{VdSr)r|close)r<rrrs r> __aexit__zconnect.__aexit__s4 o##%%%%%%%%%%%r?AsyncIterator[ClientConnection]c 8Kd} |4d{V}|WVdddd{Vn#1d{VswxYwYd}n#t$r} ||}n#t$r }|}Yd}~nd}~wwxYw||ur||||t}t|}|jd|t jt||d tj |d{VYd}~ d}~wwxYw)NTz0connect failed; reconnecting in %.1f seconds: %sr) r^rdr nextrminforformat_exception_onlytypestriprLsleep)r<delaysr0r]new_exc raised_excdelays r> __aiter__zconnect.__aiter__s*.% $ #######8"NNNN###########################FC    )"44S99GG )))(GGGGGG) c>>&!s*>$YYFV    F3DIIsCCAFLLNN  mE*********;  % sR;'; 1;1; DAD A2&A-(D-A22BDD)&rorprgrqrhrrrirsr@rArBrCrjrCrdrtrkr1r+r1r,r1r-r1rlrur.r2r/r3rmrvrnrwrxrr4r5r)r]r^r4r)r4r)rrrrrrr4r5)r4r)rXrYrZr[rrdr8rnrrr__iter__rrrrr?r>r r sffZ!%>B5915(2"+EV%'&(%'&($@B49$(;?1I(I(I(I(I(I(V8;;;;~1111&G&G&G&GTH&&&&''''''r?r pathrCrorxrc Z||dd}nd}td|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/``. Nrzws://localhost/zwss://localhost/T)rorrr)rr )rrorxs r>r!r!sD* { ::e   $#CC$C  ;sD ; ;F ; ;;r?)r]r^r4r_)NN)rrCrorCrxrr4r )9 __future__rrLrosr urllib.parsercollections.abcrrrtypesrtypingrr clientr r datastructuresr exceptionsrrextensions.baserextensions.permessage_deflaterrIrhttp11rrr0rrrrrrorr compatibilityrrr|r__all__intenvironrrr"rdr r!rr?r>rsk"""""" >>>>>>>>>> ,,,,,,,,((((((55555555444444LLLLLL++++++))))))))((((((((4444444444))))))))88888888"""""" : 9 9BJNN#=tDDEE W)W)W)W)W)zW)W)W)t&&&&Tuuuuuuuur <<<<<<