jORdZddlmZddlZddlZddlZddlZddlmZddlm Z m Z m Z ddl m Z ddlmZmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZmZmZmZm Z m!Z!ddl"m#Z#m$Z$ddl%m&Z&m'Z'm(Z(m)Z)m*Z*ddl+m,Z,m-Z-ddl.m/Z/ddl0m1Z1m2Z2ddl3m4Z4ddl.m5Z5m6Z6m7Z7erddl8m9Z9ddl%m:Z:ddl+m;Z;ddlm?Z?ddl@mAZAddlBmCZCmDZDmEZEddlFmGZGmHZHedZIe d eJe;gdfZKe d eJeLzgdfZMe d e-gdfZNe d gdfZOe d ePeLgdfZQeReJePfZSeReJeTzeUze*ePzfZVeGd!d"ZWGd#d$eZXGd%d&e-ZYGd'd(eYe1ZZGd)d*eYe2Z[d4d+Z\Gd,d-Z]ed.Z^e!Gd/d e]Z_e!Gd0d1e]Z`e!Gd2d3Zay)5z0 The Curl CFFI WebSocket client implementation. ) annotationsN)InvalidStateError) AwaitableCallable Generator)suppress) dataclassfield)IntEnumdumpsloads)uniform)select) TYPE_CHECKINGFinalLiteralTypeVarcastfinal)CURL_SOCKET_BAD get_selector) CurlECode CurlFollowCurlInfoCurlOpt CurlWsFlag)Curl CurlError)CurlCffiWarning) SessionClosedTimeout)Response)NOT_SET NotSetTypeset_curl_options)Self)CurlHttpVersion) CurlWsFrame) Fingerprint) CookieTypes) HeaderTypes)BrowserTypeLiteralExtraFingerprints ExtraFpDict) AsyncSession ProxySpecT WebSocketcZeZdZUdZdZded<dZded<dZd ed <ed Z d ed<y)WebSocketRetryStrategyuQConfigurable WebSocket policy for retrying failed message receives. When enabled, each failed receive attempt will use exponential backoff with jitter. Calculation: ``delay * 2^(count - 1) ± 10%`` Args: retry: Enable or disable WebSocket message receive retry policy. delay: The base value (seconds) to compute the retry delay from. count: How many times to retry a receive operation before giving up. codes: Set of ``CurlECode`` values for which the receive operation should be retried. Default is ``CurlECode.RECV_ERROR``. Fboolretryg333333?floatdelayintcountc$tjhSN)r RECV_ERRORS/opt/euro-skaner/venv/lib/python3.12/site-packages/curl_cffi/requests/websockets.pyzWebSocketRetryStrategy.Hs9;O;O:PrD)default_factoryzset[CurlECode]codesN) __name__ __module__ __qualname____doc__r:__annotations__r<r?r rHrCrDrEr8r84s6 E4E5E3N!2PQE>QrDr8cXeZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdZdZdZy) WsCloseCodez?See: https://www.iana.org/assignments/websocket/websocket.xhtmliiiiiiiiiiiiiii i i N)rIrJrKrLOK GOING_AWAYPROTOCOL_ERRORUNSUPPORTED_DATAUNKNOWNABNORMAL_CLOSURE INVALID_DATAPOLICY_VIOLATIONMESSAGE_TOO_BIGMANDATORY_EXTENSIONINTERNAL_ERRORSERVICE_RESTARTTRY_AGAIN_LATER BAD_GATEWAY TLS_HANDSHAKE UNAUTHORIZED FORBIDDENTIMEOUTrCrDrErOrOKscI BJNGLONOOKMLIGrDrOc2eZdZdZ d dfd ZxZS)WebSocketErrorzWebSocket-specific error.c&t|||yrA)super__init__)selfmessagecode __class__s rErgzWebSocketError.__init__es $'rD)r)ristrrjz$WsCloseCode | CurlECode | Literal[0]returnNone)rIrJrKrLrg __classcell__rks@rErdrdbs/#JK(("F( ((rDrdceZdZdZy)WebSocketClosedzWebSocket is already closed.NrIrJrKrLrCrDrErrrrks'rDrrceZdZdZy)WebSocketTimeoutzWebSocket operation timed out.NrsrCrDrEruruqs)rDrucF |jdy#t$rYywxYw)as Called by the event loop when fd becomes readable/writable. We try to set_result() and silently ignore InvalidStateError which is raised if the future was already finished/cancelled concurrently. This avoids spurious 'Exception in callback' traces in uvloop/asyncio. Intentionally using try/except, cheaper than checking if the future is done. N) set_resultr)futs rE_safe_set_resultryws%  t    s   ceZdZUdZded<ddd ddZeddZedd Zedd Z e dd Z e dd Z dd Z y) BaseWebSocket_curl autoclose _close_code _close_reasondebugclosedztuple[str, ...] __slots__TF)r~rcX||_||_d|_d|_||_d|_y)NFr|)rhcurlr~rs rErgzBaseWebSocket.__init__s0)- ('+)-  ! rDct|jtrt|j|_|jS)z;Return reference to Curl associated with current WebSocket.)r) isinstancer}r(r rrhs rErzBaseWebSocket.curls, djj* -DJJ/DJzzrDc|jS)zThe WebSocket close reason, if the connection has been closed.)rrs rE close_reasonzBaseWebSocket.close_reasons!!!rDc4tjd||zS)N!H)structpack)rjreasons rE_pack_close_framezBaseWebSocket._pack_close_frames{{4&//rDct|dkrtj}d}||fS tjd|d}|ddj }|tjk(s |dks|dk\rtd |tj||fS#t $r }tdtj|d}~wt$r }tdtj|d}~wwxYw) NrrrzInvalid close messagezInvalid close framerPizInvalid close code: ) lenrOrUr unpack_fromdecodeUnicodeDecodeErrorrdrW ExceptionrS)framerjres rE_unpack_close_framez!BaseWebSocket._unpack_close_frames u:>#++DF&V|# ))$6q9qr))+{***dTkTT\$*4&1;3M3MV|& $+[-E-E $);+E+E s#,B C B44 C CC cFd|_|jjy)z$Terminate the underlying connection.TN)rrclosers rE terminatezBaseWebSocket.terminates  rDN)rCurl | NotSetTyper~r9rr9rmrn)rmr )rmz int | None)rm str | None)rjr>rbytesrmr)rrrmztuple[int, str]rmrn)rIrJrKrrMrgpropertyrrr staticmethodrrrrCrDrEr{r{s"I=APU"%"59"IM" "   ""000rDr{)openrdatarierrorceZdZdZdZefddddddddd dfdZd dZd!d Z d"d Z ddddedd dddddd ddddddd dddddf d#dZ d$dZ d%dZ d&dZ edd'dZej"f d(dZd)dZd*dZd+dZed d,dZd-dZd.d/dZej6dfd0dZxZS)1r6z)A WebSocket implementation using libcurl.)skip_utf8_validation _emitters keep_runningTFN)r~rron_openon_closeon_data on_messageon_errorct ||||||_d|_i|_|r||jd<|r||jd<|r||jd<|r||jd<| r| |jd<yy) a| Args: autoclose: whether to close the WebSocket after receiving a close frame. skip_utf8_validation: whether to skip UTF-8 validation for text frames in run_forever(). debug: print extra curl debug info. on_open: open callback, ``def on_open(ws)`` on_close: close callback, ``def on_close(ws, code, reason)`` on_data: raw data receive callback, ``def on_data(ws, data, frame)`` on_message: message receive callback, ``def on_message(ws, message)`` on_error: error callback, ``def on_error(ws, exception)`` rr~rFrrrrirN)rfrgrrr) rhrr~rrrrrrrrks rErgzWebSocket.__init__s4 diuE*>!"'HJ %,DNN6 " &.DNN7 # %,DNN6 " (2DNN9 % &.DNN7 # rDc4|jr td|S)NWebSocket is closedrrrrs rE__iter__zWebSocket.__iter__s ;;!"78 8 rDc^|j\}}|tjzrt|SrA)recvrCLOSE StopIterationrhmsgflagss rE__next__zWebSocket.__next__ s*YY[ U :## #  rDc|jj|}|r ||g|}yy#t$rV}|jjd}|r |||}n%tjd|dt dYd}~yYd}~yd}~wwxYw)NrzWebSocket callback 'z' failedr) stacklevel)rgetrwarningswarnr")rh event_typeargscallback_rerror_callbacks rE_emitzWebSocket._emits 261C1CJ1O  T)D)   ?C~~?Q?Q@"&tQ/AMM.zl(C'#$ s * B ABB zgzip, deflate, brrrcL|j}td id|ddd|dd|gdd|gdd|gd |d |d |d |d d| gd| d| dd| gd| d|d|d|d|d|d|d|d|d|d|d|d|d|}|jtjd}|j |S)!a Connect to the WebSocket. libcurl automatically handles pings and pongs. ref: https://curl.se/libcurl/c/libcurl-ws.html Args: url: url for the requests. params: query string for the requests. headers: headers to send. cookies: cookies to use. auth: HTTP basic auth, a tuple of (username, password), only basic auth is supported. timeout: how many seconds to wait before giving up. allow_redirects: whether to allow redirection. Can be a bool, a ``CurlFollow`` value, or the string ``"safe"``. max_redirects: max redirect counts, default 30, use -1 for unlimited. proxies: dict of proxies to use, prefer to use ``proxy`` if they are the same. format: ``{"http": proxy_url, "https": proxy_url}``. proxy: proxy to use, format: "http://user@pass:proxy_url". Can't be used with `proxies` parameter. proxy_auth: HTTP basic auth for proxy, a tuple of (username, password). verify: whether to verify https certs. referer: shortcut for setting referer header. accept_encoding: shortcut for setting accept-encoding header. impersonate: which browser version or fingerprint to impersonate. ja3: ja3 string to impersonate. akamai: akamai string to impersonate. perk: perk string to impersonate. extra_fp: extra fingerprints options, in complement to ja3 and akamai str. default_headers: whether to set default browser headers. default_encoding: Encoding for decoding content if charset is not found. Defaults to "utf-8". quote: Set characters to be quoted (percent-encoded). Default safe string is ``!#$%&'()*+,/:;=?@[]~``. If set to a string, the characters will be removed from the safe string. If set to ``False``, the URL is used as-is (you must encode it yourself). http_version: Limiting http version, defaults to http2. interface: interface name or local IP to bind to (bare IP = source address). cert: a tuple of (cert, key) filenames for client cert. max_recv_speed: maximum receive speed, bytes per second. curl_options: extra curl options to use. rmethodGETurl params_listN headers_list cookies_listauthtimeoutallow_redirects max_redirects proxies_listproxy proxy_auth verify_listrefereraccept_encoding impersonateja3akamaiperkextra_fpdefault_headersquote http_version interfacemax_recv_speedcert curl_optionsrrC)rr)setoptr CONNECT_ONLYperform)rhrparamsheaderscookiesrrrrproxiesrrverifyrrrrrrrrrrrrrrrrs rEconnectzWebSocket.connect)sgZYY     v        , (   " v  ,! "$# $% &' () *+ ,,- ./ 0&1 2 3 4*5 67 8&9 @ KK,,a 0  rDc|jr td|jj\}}|jt j zr; |j|\|_|_ |jr|j||fS#t$r2}|j|_|j|jd}~wwxYw)z2Receive a single curl websocket fragment as bytes.WebSocket is already closedN)rrrrws_recvrrrrrrrdrjrr~)rhchunkrrs rE recv_fragmentzWebSocket.recv_fragments ;;!"?@ @yy((* u ;;)) ) 7;7O7OPU7V4 $"4~~ e|" $%66  166"  sB C -CC chg}d}|jjtj}|tk(rt dt j |j\}}|jtjtjzzrD|j}|j||jdk(r|tjzdk(rndj)||fS#t $r<}|j"t j$k(rt'|gggd\}}}nYd}~Td}~wwxYw)z Receive a frame as bytes. libcurl splits frames into fragments, so we have to collect all the chunks for a frame. rInvalid active socket?NrD)rgetinfor ACTIVESOCKETrrdrNO_CONNECTION_AVAILABLErrrPINGPONGappend bytesleftCONTr!rjAGAINrjoin)rhchunksrsock_fdrrrrs rErzWebSocket.recvs !))##H$9$9: o % ')J)J  #113 u;;*//JOO"CD  e$??a'EJOO,Cq,H*xx&& 66Y__,%gYB5A f Fs7|#  66Y__,&,R'B&DOAy!$,-CD!K  s4C&& D8/>D32D33D8cB|j|tjS)zVSend a binary frame. Args: payload: binary data to send. rrBINARYrhrs rE send_binaryzWebSocket.send_binary yy*"3"344rDcB|j|tjS)ztSend a binary frame, alias of :meth:`send_binary`. Args: payload: binary data to send. rrs rE send_byteszWebSocket.send_bytesrrDcB|j|tjS)zRSend a text frame. Args: payload: text data to send. rrrrs rEsend_strzWebSocket.send_str' yy*//22rDr cx|tur|jt|dS|j||S)zSend a JSON frame. Args: payload: data to send. dumps: JSON encoder, default is json.dumps. ,: separators json_dumpsrrhrr s rE send_jsonzWebSocket.send_json/s5 J ==G !KL L}}U7^,,rDcB|j|tjS)zMSend a ping frame. Args: payload: data to send. )rrrrs rEpingzWebSocket.ping<r rDc |r|j|fi|}|jjtj}|t k(rt dtj|jdg}d|_ |jrN |j\}}|j}|jd|||j||jdk(r|tj zdk(swd|j"vr|dj%|} |tj&zr|j(s | j+} n| } |tj6zs|tj&zr|jd| g}|tj8zr6d |_ |jd |j2xsd|j:xsd |jrMy y #t,$rT} t.j0|_|j5t.j0t dt.j0| d } ~ wwxYw#t<$r} | j>tj@k(rtC|gggd \}}}n\|jd| |jDs=t.jF} tI| t r | j>} |j5| Yd } ~  d } ~ wwxYw)zRun the WebSocket forever. See :meth:`connect` for details on parameters. libcurl automatically handles pings and pongs. ref: https://curl.se/libcurl/c/libcurl-ws.html rrTrrrirDz Invalid UTF-8NFrrrr)%rrrrrrrdrrrrrrrrrrrrrrrrrOrWrrrrrr!rjrrrrUr) rhrkwargsrrrrrrremit_msgrrjs rE run_foreverzWebSocket.run_foreverDs`  S+F+A))##H$9$9: o % ')J)J  6! . #113 u  65%0 e$1,1HA1M.((6*C /9R9R%47JJLH$' 1 11uz7N 9h7:+++(-D%JJw(8(8(=At?Q?Q?WUWXG$ 2%/:/G/GD, JJ{'?'?@"0 /1I1I##$%%& 66Y__,$gYBH82GBH8 H5!AH00H55H88 KB KKrDc|j||}|j|tj}|j y)znClose the connection. Args: code: close code. message: close reason. N)rrrrr)rhrjrirrs rErzWebSocket.closes6$$T73 IIc:++ , rD)rrr~r9rr9rr9rzON_OPEN_T | NonerzON_CLOSE_T | NonerzON_DATA_T | NonerzON_MESSAGE_T | NonerzON_ERROR_T | Nonermrn)rmr6rmr)rEventTypeLiteralrz+str | bytes | int | CurlWsFrame | CurlErrorrmrn)6rrlrz\dict[str, object] | list[object] | tuple[str, int | list[str] | dict[str, str | int]] | NonerzHeaderTypes | NonerzCookieTypes | Nonertuple[str, str] | Nonerz+float | tuple[float, float] | object | Nonerzbool | CurlFollow | strrr>rzProxySpec | Nonerrrr4rz bool | Nonerrrrrz-BrowserTypeLiteral | str | Fingerprint | Nonerrrrrrrz&ExtraFingerprints | ExtraFpDict | Nonerr9rzstr | Literal[False]rzCurlHttpVersion | Nonerrrzstr | tuple[str, str] | Nonerr>rzdict[CurlOpt, str] | Nonermr*)rmztuple[bytes, CurlWsFrame])rmtuple[bytes, int])rmrl)rCallable[[str], T]rmr5)r str | bytesrrrmr>)rrrmr>)rr)rrlrmr>)robjectr Callable[..., str]rmr>)rr7rmr>)r)rrlrmrn)rjr>rir)rIrJrKrLrr'rgrrrrrrr  json_loadsr rrrrrrr(r*r,r0rOrQrrorps@rEr6r6s3I#*(/%*$(&*$(*.&*(/(/ (/ # (/  (/"(/$(/"(/((/$(/ (/T  $;  @ &*&*'+?F37$( -1""&9EI!;? $&(/3 $-126Ap p  p$p$p%p=p1pp"p !p"+#p$%p&'p($)p*C+p,-p./p01p293p45p6$7p8-9p:;p<+=p>?p@0ApB Cpd,#'J$8B'--/// /b553?I - -); -  -3EN!,  rDc eZdZUdZdZdZded<ddddd dd d d d ddd d/fdZed0dZ ed1dZ d2dZ d3dZ d4dZ d3dZd5dZd6dZd7dZd dd8dZd dd9dZed d d:dZej.d f d;dZdd#Zd?d$Zej@d%d&f d@d'Z!d7fd( Z"d7d)Z#d7d*Z$ dAd+Z%dBdCd,Z&d7fd- Z'dDd.Z(xZ)S)EAsyncWebSocketz< An asyncio WebSocket implementation using libcurl. )session_loop_sock_fd _close_lock_terminate_lock _read_task _write_task_receive_queue _send_queue_max_send_batch_size_coalesce_frames_recv_time_slice_send_time_slice _terminated_terminated_eventws_retry_transport_exception_max_message_sizedrain_on_error_block_on_recv_queue_fulliz Final[int]_MAX_CURL_FRAME_SIZETF@Ng{Gz?g{Gzt?i@) r~rrecv_queue_sizesend_queue_sizemax_send_batch_sizecoalesce_framesrLrecv_time_slicesend_time_slicemax_message_sizerOblock_on_recv_queue_fullc t||||||_d|_d|_d|_t j|_tj|_ t j|_ d|_ d|_t j||_t j||_||_||_| xs t)|_| |_| |_d|_| |_| |_||_y)aInitializes an Async WebSocket session. Do not instantiate this class directly. Use ``AsyncSession.ws_connect``. This class implements an async context manager, closing the connection automatically on exit: :: async with AsyncSession() as session: async with session.ws_connect("wss://api.example.com") as ws: await ws.send("Hello") msg = await ws.recv() Args: session (AsyncSession): The parent session object. curl (Curl): The underlying Curl handle. autoclose (bool): Automatically close on receiving a close frame. debug (bool): Enable verbose debug logging. recv_queue_size (int): Max number of incoming messages to buffer. send_queue_size (int): Max number of outgoing messages to buffer. max_send_batch_size (int): Max frames to coalesce per transmission. coalesce_frames (bool): Combine small frame payloads to improve throughput. ws_retry (WebSocketRetryStrategy): Retry configuration for failed receives. recv_time_slice (float): Max seconds to read messages before yielding. send_time_slice (float): Max seconds to write messages before yielding. max_message_size (int): Max size (bytes) of a single received message. drain_on_error (bool): Yield buffered messages before raising errors. block_on_recv_queue_full (bool): Behavior when the receive queue is full. If True (default), the reader blocks (may cause timeouts). If False, the connection fails immediately to prevent data loss. Note: Architecture: This uses a background I/O model. Network operations run in background tasks. Errors are raised in subsequent calls to send() or recv(). Performance: The time_slice defaults (5ms read / 1ms write) favor reading to compensate for libcurl's overhead. Increase these values to allocate more CPU time to I/O operations at the cost of event loop latency. See also: - https://curl.se/libcurl/c/curl_ws_recv.html - https://curl.se/libcurl/c/curl_ws_send.html rNF)maxsize)rfrgr=r>r?rJasyncioLockr@ threadingrAEventrKrBrCQueuerDrErFrGr8rLrHrIrMrNrOrP)rhr=rr~rrTrUrVrWrLrXrYrZrOr[rks rErgzAsyncWebSocket.__init__s| diuE/6 7;  !&)0/8~~/?07 596:>Emm#? rr_get_running_looprs rEloopzAsyncWebSocket.loops- :: %g&>&>&@ADJzzrDc6|jjS)z6Returns the current number of items in the send queue.)rEqsizers rErUzAsyncWebSocket.send_queue_sizes%%''rDc|js |jry|jr|jjry|jxr|jj S)a Checks if the background I/O tasks are still running. Returns ``False`` if either the read or write task has terminated due to an error or a clean shutdown. Note: This is a snapshot in time. A return value of ``True`` does not guarantee the next network operation will succeed, but ``False`` definitively indicates the connection is no longer active. F)rrJrBdonerCrs rEis_alivezAsyncWebSocket.is_alivesR ;;$** ??t335$$@)9)9)>)>)@AArDcK|Sw)a@Enable context manager usage for automatic session management and closure. This cannot be used to initiate a WebSocket connection, that must be done beforehand using the :meth:`AsyncSession.ws_connect()` factory method. Returns: Self: The instantiated AsyncWebSocket object. rCrs rE __aenter__zAsyncWebSocket.__aenter__1s  scK||jd{ytt5|jd{dddy767#1swYyxYww)zQ On exiting the context manager, close the WebSocket connection. N)rrr!)rhexc_typeexc_valexc_tbs rE __aexit__zAsyncWebSocket.__aexit__;s[  **,  )$ #jjl"" # # # # #s8AAAAAA AAAAc4|jr td|S)NzWebSocket has been closedrrs rE __aiter__zAsyncWebSocket.__aiter__Ks ;;!"=> > rDcK |jd{\}}|tjzrt|S7"#t$rtdwxYwwrA)rrrStopAsyncIterationrrrs rE __anext__zAsyncWebSocket.__anext__PsS /#yy{*JC :## #$ $ + /$$ . /s%A<:<A<A  Acd|js |jy||_|jy)alFinalize the connection into a terminal state. This method is called for all terminal conditions, including: - normal WebSocket closure - protocol errors - transport errors After this method is called, no further messages will be delivered and all ``recv()`` calls will fail. ``_finalize_connection()`` is intended for event-loop context, but ``terminate()`` is thread-safe. Args: exc (Exception): The exception object that gets raised. This does not have to be an error, enqueuing ``WebSocketClosed`` indicates closure. N)rrMr)rhexcs rE_finalize_connectionz#AsyncWebSocket._finalize_connectionZs+" ;;$33? $'! rDc |jy|jr tdtt|j j tj|_ |jtk(rtdtjdt|d}|jj!|j#|d|_|jj!|j%|d |_y) aStart the read/write I/O loop tasks. NOTE: This should be called only once after object creation by the factory. Once started, the tasks cannot be restarted again, this is a one-shot. Raises: WebSocketError: The WebSocket FD was invalid. NzWebSocket already terminatedzInvalid active socket.)rjz WebSocket-z#xz-reader)namez-writer)rBrJrrrr>rrrrr?rrdrridrf create_task _read_loop _write_looprC)rhws_ids rE_start_io_taskszAsyncWebSocket._start_io_tasksqs ?? &    !"@A AS$))"3"3H4I4I"JK ==O + (y/P/P  ""T(2/))// OO ugW$50  9900    wg%61 rDrc~K|j|js |j |jjS#tj $rYnwxYw|j |j|j |j jr tdt j|jj} t j||j ftj|d{7\}}nr#tj$r\|jsJ|j}ttj5|d{7ddd#1swYxYwwxYw|sg|j} |d{7S#tj$rYnwxYw|j |jt!dt"j$||vr |d{7S|j}ttj5|d{7dddn #1swYnxYw|jrIttj 5|jjcdddS#1swYnxYw|j |jtdw)a[Receive a WebSocket message. This method waits for and returns the next complete WebSocket message. Args: timeout: How many seconds to wait for a message before raising a timeout error. Returns: tuple[bytes, int]: A tuple with the received payload and flags. Raises: WebSocketTimeout: If the timeout expires. WebSocketClosed: If the connection is closed. WebSocketError: If a network-level transport error occurs. Notes: Message fragmentation and reassembly are handled automatically by the implementation, so callers will always receive complete messages. ``WebSocketError`` exceptions may have originated from prior ``send()`` or ``recv()`` operations, since all operations share the same transport state once a failure occurs. This method does not wait for additional messages after a transport error is detected. If ``drain_on_error=True``, subsequent calls to ``recv()`` will return any messages that were buffered in the receive queue at the time the reader failed, before the connection error is raised. Concurrent calls to ``recv()`` are supported and safe; each caller awaits the next available message and will receive distinct messages in FIFO order. If this coroutine is cancelled while a message is being received, that message may be dropped. Cancellation is treated as abandoning the receive operation. Nr return_whenrzWebSocket recv() timed outzConnection closed)rMrOrD get_nowaitr_ QueueEmptyrBrjrrr~rwaitFIRST_COMPLETEDCancelledErrorcancelrrurOPERATION_TIMEDOUT)rhr queue_waiterrjrs rErzAsyncWebSocket.recvs}N  $ $ 09L9L++ + &&113 3!!     $ $ 0++ + ?? "doo&:&:&<!"78 87>6I6I    # # %7  #LLt/#33GD!%% $$& '')g445'&&&' ' E  ##%A ))))))  ((4///",i.J.J  4 %%% %    ! g,, -         ',,- 8**557 8 8 8  $ $ 0++ +122s%J=AJ=AJ=AA9J=5DD DJ=A FE2#E&$E2) F2E; 7 FJ=F!FF! J=!F74J=6F77>J=5G86.J=$H9*H-+H90 J=9I>,J=*J J=J*J=cK|j|d{\}}|tjzstdtj  |j dS7F#t$r }tdtj |d}~wwxYww)zmReceive a text frame. Args: timeout: how many seconds to wait before giving up. rNzNot a valid text framerzInvalid UTF-8 in text frame)rrrrdrOrWrr)rhrrrrs rEr zAsyncWebSocket.recv_strs !IIgI66 e ' !9;;S;ST T ;;w' ' 7 "  -{/G/G  s3B A4B A!B ! B *BB  B )rrc8K|j|d{}|stdtj ||S7)#t$r }tdtj|d}~wt $r#}td|tj|d}~wwxYww)aReceive a JSON frame. Args: loads: JSON decoder, default is :meth:`json.loads`. timeout: how many seconds to wait before giving up. Raises: WebSocketError: Received frame is invalid or failed to decode JSON. rNz(Received empty frame, cannot decode JSONz Invalid UTF-8 in JSON text framezInvalid JSON payload: )r rdrOrWrr)rhrrrrs rEr zAsyncWebSocket.recv_jsons---88 :KBA BAB B A(( B4BBBc~K|j |j|jr td|j%|jj r tdt |t r|jd} |jj||fy#tj$r}|jr td||j |j||c tj|jj||f|d{7nM#tj$r}t!d|d}~wwxYw|jj||fd{7|j |j||js |jr td|Yd}~yd}~wwxYww)aSend a WebSocket message. Args: payload: Data to send (``str``/``bytes``/``bytearray``/``memoryview``). flags: Frame type flags (e.g., ``CurlWsFlag.TEXT`` / ``CurlWsFlag.BINARY``). timeout: Max seconds to wait if the send queue is full. Raises: CurlError: Network related exception occured. WebSocketClosed: The WebSocket has been closed. WebSocketTimeout: The send operation timed out. Note: There are no limits on the size of the message that can be sent. Large outbound messages are seamlessly broken down into optimal fragments using the ``CURLWS_CONT`` flag, arriving as a single logical message to the server. Warning: This method is non-blocking. It queues the message for immediate transmission. Use ``await ws.flush()`` after sending if you need to guarantee that the data has actually reached the socket. Nrz(WebSocket writer terminated; cannot sendrz"WebSocket connection is terminatedz>Send queue full (network slow) - hit timeout enqueuing messagez/Connection was terminated while waiting to send)rMrrrrCrjrrlr rE put_nowaitr_ QueueFullrJwait_forput TimeoutErrorru)rhrrrryrs rErzAsyncWebSocket.send5s<  $ $ 0++ + ;;!"78 8    'D,<,<,A,A,C!"LM M gs #nnW-G     ' '%(8 9   %&JKQTT((4//S8"!**((,,gu-=>++*X &&**GU+;<<<((4//S8{{d..%E/1 smBF=B#"F=#F:73F5+4D&D" D&%F5&E 9 EE  #F5-E0.AF50F=5F::F=c^K|j|tjd{S7w)zSend a binary frame. Args: payload: binary data to send. For more info, see the docstring for :meth:`send()` Nrrs rErzAsyncWebSocket.send_binary%YYw (9(9:::: $-+-c^K|j|tjd{S7w)zSend a binary frame, alias of :meth:`send_binary`. Args: payload: binary data to send. For more info, see the docstring for :meth:`send()` Nrrs rErzAsyncWebSocket.send_bytesrrc^K|j|tjd{S7w)zSend a text frame. Args: payload: text data to send. For more info, see the docstring for :meth:`send()` Nrrs rErzAsyncWebSocket.send_strs#YYw 8888rr cK|tur$|jt|dd{S|j||d{S7#7w)zSend a JSON frame. Args: payload: data to send. dumps: JSON encoder, default is :meth:`json.dumps()`. For more info, see the docstring for :meth:`send()` r"r%Nr'r)s rEr*zAsyncWebSocket.send_jsonsI J z'j'QRR R]]5>222S2s!(AAA A AAc Kt|tr|jd}n t|}t |dkDr&t dt |t j|j|tjd{S7w)zSend a ping frame. Args: payload: data to send. Raises: WebSocketError: The payload length is outside specification. For more info, see the docstring for :meth:`send()` r}zPing frame has invalid length: N) rrlr rrrdr TOO_LARGErrr)rhr payload_bytess rEr,zAsyncWebSocket.pingsy gs ##*>>'#:M!'NM }  # 1#m2D1EF##  YY}joo>>>>sBBB BrDg@c K|j4d{|jr dddd{yd|_|jj} |jr|jj s|j t|tr|jd}t|dkDr|dd}|j||}tj|jj|t j"f|d{|j%t'd||jj|z z d{|j-t/tj(5tj|j0j3t'd||jj|z z d{}ddddddd{y7777#tj(t*f$rYwxYw7F#1swYExYw#|j-t/tj(5tj|j0j3t'd||jj|z z d{7}dddw#1swYwxYwxYw7#1d{7swYyxYww)a Performs a graceful WebSocket closing handshake and terminates the connection. This method sends a WebSocket close frame to the peer, waits for queued outgoing messages to be sent, and then shuts down the connection. Args: code (int): Close code. Defaults to ``WsCloseCode.OK``. message (bytes): Close reason. Defaults to ``b""``. timeout (float): How long (in seconds) to wait for the connection to close gracefully before force-terminating. NTr{r)r@rrftimerCrjrMrrlr rrr_rrErrrflushmaxrrdrrrKr)rhrjrir close_start close_framers rErzAsyncWebSocket.closes{$##) ) {{) ) ) DK!%!1K" $$ ,,113119!'3/").."97|c)")$3-*.)?)?g)NK!**((,,k:;K;K-LM ' **CDIINN,<{,J!KL g223%....335CDIINN,<{,J!KLAK) ) ) ) , ((.9   g223%....335CDIINN,<{,J!KLAK) ) ) ) sK*G:K*K K*G=K*!KB;HHAHHH)KAH%H#H%!K) K*4K5K*=K*HHH H1H  H1#H%%H. *K1*KAK 5J8 6K ; KK KKK*K'K K'#K*cF|j5|jr dddyd|_|j} tj} | t d|$||ur |j |j}n$tj|j|}dddy#t $rd}YnwxYw#t$rL t|-|jjn#|jjwxYwYnwxYw#1swYyxYw)a5 Immediately terminates the connection without a graceful handshake. This method is a forceful shutdown that cancels all background I/O tasks and cleans up resources. It should be used for final cleanup or after an unrecoverable error. Unlike ``close()``, it does not attempt to send a close frame or wait for pending messages. It schedules the cleanup to run on the event loop and returns immediately. It does not wait for cleanup completion. This method is thread-safe, task-safe, and idempotent. NTzEvent loop not available)rArJr>r_re RuntimeErrorr~_terminate_helperrun_coroutine_threadsaferrfrrKset)rhrf current_looprrks rErzAsyncWebSocket.terminates ! ! 1 1 1 $D 59ZZD $,,.  1<&'ABB + 0D(()?)?)ABA889O9O9QSWXA/ 1 1  $#  $ 11G%'**..0D**..00  15 1 1sdDDB.AB?. B<9D;B<<D? D C2D2DDDDDD c  K|jj}|jj}|jj}|j }|j }|j}|j}|j}|j} || z} |jj} |jj} |jj} t|jj }t#t$j&}t#t$j(}t#t$j*}t#t,j.}t#t,j0}t,j2t,j4z|z}|j6}|j8}d}t:}d}g}d}|j<}|j>} |j@s1 |\}}|jf})|dkDrd}|)|zr|ti|z }||kDr8||jUt[d|d|dt$jjy|||)|zsD|jls8ti|d k(r|dndjo|}*|d} ||*|)f|| k\r'tajbdd{|| z} |)|zr,| |||)f|ju|d{y|j@s0yy#tB$r4} d}!| jD|k(rd}!n| jD|k(r$tG| jI}"d|"vsd|"vrPd}!nM| jD|k(r>tKdtLjN}#| |#_(d|#_)|jU|#Yd} ~ y|!r|}$ ||jV||$|$d{7n#tX$rv}%|jUt[d |%t$j\Yd}%~%|jVd k7r- ||jV}&n#tX$rYnwxYwYd} ~ yYd} ~ yYd} ~ yd}%~%wwxYw |jVd k7rZ ||jV}&nF#tX$rYn;wxYw#|jVd k7r# ||jV}&w#tX$rYwwxYwwxYwYd} ~ | rf| jD| vrX|| krS|d z }|d |d z zz}'|'d z}(|'t_|( |(z }'tajbted|'d{7Yd} ~ b|jU| Yd} ~ yd} ~ wwxYw#t`jp$rD|s+|jUt[|t$jrYy||*|)fd{7Y wxYw7#t`jp$rD|s+|jUt[|t$jrYy|||)fd{7YwxYw7#t`jv$rYytX$r} |jU| Yd} ~ yd} ~ wwxYww)a The main asynchronous task for reading incoming WebSocket frames. Attempts to read immediately and only registers an event loop reader if the socket returns EAGAIN (empty). It waits for the underlying socket to become readable, and upon being woken by the event loop, it drains all buffered data from libcurl until it receives an EAGAIN error. This error signals that the buffer is empty, and the loop returns to an idle state, waiting for the next readability event. This is "optimistic reading". To ensure cooperative multitasking during high-volume message streams, the loop yields control to the asyncio event loop periodically which is tracked using an operation counter. If the receive queue becomes full, ``await self._receive_queue.put()`` will block the reader loop and stall the socket read task. Thus, appropriate queue sizes should be set by the user, to match the speed at which they are expected to be consumed. If latency is a factor, a smaller queue size should be used. Conversely, a larger queue size provides burst message handling capacity. zDReceive queue full; failing connection to preserve message integrityrFTzerrno 11z resource temporarily unavailablez.Connection closed unexpectedly by server (EOF)NzSocket closed unexpectedly: r]r#rg?rzMessage too large: z bytes (limit zF bytes). Consider increasing max_message_size or chunking the message.rD)rrrB GOT_NOTHINGrrrrrrNrPryrclearrr!rjrllowerrrrOrV __cause____suppress_context__rzr?rrdrrr_sleeprrrrrrr OUT_OF_MEMORY_handle_close_framer)+rh curl_ws_recvqueue_put_nowait queue_putrf loop_timerrr time_slice next_yieldretry_on_error retry_codes max_retries retry_basee_again e_recv_err e_nothing close_flag cont_flag data_mask max_msg_size block_on_recvqueue_full_errset_fut_resultrecv_error_retriesrmsg_size chunks_append chunks_clearrrr should_retryerr_msg final_exc read_futureryr retry_delayjitterrris+ rErzAsyncWebSocket._read_loop0s.AE @Q@Q    * *     # # +/)))- <@LE5Z#[[%))*&9$E *H,.$11*&9(D..:^<<%< !* 3 3 "%("I-),V)9F1Isxx?O %#$ >,gu-=>!{j0%mmA...%.[:%= :% N 8(%8225999ckk!I).Lvv('+ :-'*1v||~&'1AWL+/L9,5DL'886 /0 +9= 611)<##0 $ 9 9$2(6 8O8O%&!" !'"+We,<"===>/#,,8, 55 .~y?V?V W#'7778:%%   )  % %a ( ( )s8GY  X& L0A"XY AX U$"XV2X# V5-XXXY  XY  U!BU0X4Y 5 UO OO R Q),QRU)P<;U< QUQU XY XY XY QR#U3RU RURUS &R98S 9 S S S S  U XAU.T1/U4X:U XY UX>V/XY  V/%V(&V/+X.V//X5>X 3X4Y 5 X XX X X  XY %Y 'Y /YY Y  Y cKtjtjztjz}t tj}|j }|j j}|j j}|j j}|j}|j}|j} || z} |js |d{\} } || | d{s& ||js|jyy| |zr |n|| k\r't!j"dd{|| z} | |d{\} } | | fg} | |zsVt%| |j&kr> |\} }| j)| |f||zrn t%| |j&kr> g}| D]X\} }||zr|j)| g|f |r#|dd|k(r|ddj)| E|j)| g|fZ|D]\}}|dj-||d{s@t/t%| D] }|  |js|jyy|| k\sqt!j"dd{|| z}  t/t%| D] }|  | dd|zrn|js|jyy7E737#|wxYw7#t j*$rYxwxYw77#t/t%| D] }| wxYw#t j0$rYt2$r}|j5|Yd}~d}~wwxYw#|js|jwwxYww)a The background task responsible for consuming the send queue and transmitting frames. To maximize performance, this loop hoists the configuration check and enters one of two distinct processing strategies: 1. Standard Mode (No Coalescing): The default, low-latency path. Messages are consumed one-by-one from the queue and transmitted immediately. This guarantees that one ``send()`` call results in exactly one WebSocket message, preserving logical message boundaries. 2. Coalescing Mode: An optimized throughput path for chatty streams. The loop greedily gathers multiple pending messages from the queue (up to ``max_send_batch_size`` and merges their payloads into a single transmission if they share the same flags (e.g., multiple text frames). This reduces system call overhead but does not preserve individual message boundaries. Features: - Cooperative Multitasking: Yields to the event loop periodically to prevent the writer from starving the reader task during high-volume transmission. - Control Frame Priority: PING and CLOSE frames are never coalesced; they trigger an immediate flush of any pending batched data before being sent. - Lifecycle Management: Automatically terminates the connection cleanly upon transmitting a CLOSE frame. Nrr]r#rD)rrrrr> _send_payloadrErr task_donerfrrIrGrrr_rrrFrrrrangerrrz)rhcontrol_frame_flagsr send_payload queue_getqueue_get_nowait queue_donerfrrrrrbatchr coalescedpayloads frame_grouprrs rErzAsyncWebSocket._write_loops:$.#3#3joo#E #Wj../ 7;7I7I >B>N>N>R>R :>:J:J:U:U)-)9)9)C)C *.)))-  11 %K*4 T !((+4;%6NGU %%1'5%AAA"# ~;; Q!:-!# %;*4")--"222)2z)AJ# !(+4;%6NGU6=e4D3EE!J.!%j4+D+DD&1A1C % gu-= >#(:#5$)$6 "%j4+D+DD) "/4INGU$':: ) 0 07)U1C D#,2q1AU1J$-bM!$4$;$;G$D$-$4$4wi5G$HI6?F1Hk)5chhx6H+)V#V#V &"'s5z!2)A&L) ;; - ){j8&-mmA&6 6 6-6[:-E F"'s5z!2)A&L)Ry|j0av;; ]&7 B3# &7$+#5#5& %&($W !7 "'s5z!2)A&L)%%   )  % %a ( ( ) ;; s9CO N"L'#N+ L07L*8L0=NO"L0( N1"L0L-L0"N5L<6)N "L?NBM M!M& NO% M0MM M/N O'N*L0-L00 L99N?MNMNMM"M??NN:N=N:N50N=5N::N==OOcK|jj}|j}|j}|j}|j }|j }t} |j} |j} || z} |j} ttj}ttj}d}||z}t!|}|j"}d}d}d}|}||ks |dk(r|dk(r||k(r||z | kDr || z}||z}n|}|} |||||}|dk(rM||z dk(ry|dz }||k\r.|j%t'd|dtj(yt+d||rd}||z }|| k\r't-j.dd {|| z} ||kr|dk(r|dk(ry7 #t*$r}|j0|k(r|} || | ||d {7nn#t2$rb}|j%t'd |tj4Yd }~| d k7r# || }n#t2$rYnwxYwYd }~yYd }~yYd }~yd }~wwxYw | d k7r< || }n2#t2$rYn'wxYw#| d k7r || }w#t2$rYwwxYwwxYwYd }~|j%|Yd }~yd }~wwxYww) zF Optimized low-level sender with fragmentation logic. r=rTr#zWriter stalled (z attempts).Fz 0 bytes sentNz)Socket closed unexpectedly during write: r])rrrfrr add_writer remove_writerryr?rIrQr>rrrr memoryviewnbytesrzrd WRITE_ERRORr!r_rrjrr)rhrr curl_ws_sendrfrrrrrrrrmax_frame_sizerrmax_zero_writes base_flagsview total_bytesr write_retries frame_end current_flagsrr write_futureryrs rErzAsyncWebSocket._send_payloads&GKiiFWFW *.)))- <@>#$$&g445$#OO$$$4'Y$$++- ##))+ >>#$$&g445$#OO$$$ %%WXX(>>#$$&g445$#OO$$$9>$$$!Y()NOUXXY$$$#$$>>#$$&g445$#OO$$$$s ;I05H3G4H 9I0G  G  G  I0H*GH9I0G7G5G7# I0- H99I02H8H9H= I0H G  GI0 G2! G--G22H5G77H<I0HH I0:I- I I I  I- I) %I--I0cK|j|jfDchc]}||js|}}d} |D]}|j}|rHt j ||tj d{\}}|D]}|j}|jjsP |jj}|jj|jjsP|jdk7rztt5|j j#|j}dddtt5|j j%|j}dddd|_ t&|Q|j*r1|j*j,s|j*j/d|j0j3ycc}w7#tjtf$rYwxYw#1swYxYw#1swYxYw#|j0j3wxYww)z)Utility method for connection terminationNr)rrr])rBrCrjrr_r ALL_COMPLETEDrErrrr ValueErrorr?rrrfrrrfrr=_closed push_curlrKr) rhttasks_to_cancel max_timeoutio_taskrpendingprks rErz AsyncWebSocket._terminate_helper,soot'7'784 }QVVX 4 4  ( )* %NN$ %#*<<#' ' 5 5$ 7 !#A A#&&,,.((335A$$..0&&,,.}}"i(? // >A?i(? // >A?DM G  ||DLL$8$8 &&t,  " " & & (_4  **J7 ????  " " & & (sIG?IAH?H8H?:4H.H? H?'&H' H?$&H3 AH?$ IH?H$ H?#H$$H?'H0,H?3H<8H??IIcK |j|\|_|_|j rq|j se|jtjk(rtjn|jxstj}|j|d{y|jy#t$r}|j|_Yd}~d}~wwxYw7=w)z>$++##{':'::&&8+..  **Z( ( ( NN  & vvD   & )s:CB0A7CCC0 C9C CCC)r=r3rr r~r9rr9rTr>rUr>rVr>rWr9rLzWebSocketRetryStrategy | NonerXr;rYr;rZr>rOr9r[r9rmrn)rmzasyncio.AbstractEventLoop)rmr>)rmr9)rmr*)rotype[BaseException] | NonerpBaseException | Nonerq object | Nonermrnr2)ryrrmrnr)r float | Nonermr5)rr rmrl)rr6rr rmr5)rz$str | bytes | bytearray | memoryviewrCurlWsFlag | intrr rmrn)rrrmrn)rrlrmrn)rr8r r9rmrn)rr7rmrn)rjr>rir7rr;rmrn)rzbytes | memoryview | bytearrayrr rmr9rA)rr rmrn)rirrmrn)*rIrJrKrLrrQrMrgrrfrUrkrmrrrtrwrzrrr r:r rrrrrrr(r*r,rOrQrrrrrrrrrorps@rEr<r<sI.(-*,""#% %26!%!& /$)-!VHVHVH  VH  VHVHVH!VHVH0VHVHVHVHVH #'!VH" #VHp ((B&#,#&# #  #  ." H59n3`9=&%/ $ "  F#-"3"3 $ I5I I I  IV;;9?I 3 3); 3  3?6 NN" ;;; ;  ;z+1ZV)p|!|k5k>Nk kZ7$r1)frDr<cDeZdZdZdZddZd dZd dZ d dZy) AsyncWebSocketContextz.Helper to enable simpler context manager usage_coro_objc ||_d|_yrAr )rhcoros rErgzAsyncWebSocketContext.__init__xs04 +/ rDc6|jjSrA)r __await__rs rErzAsyncWebSocketContext.__await__|szz##%%rDcXK|jd{|_|jS7wrAr rs rErmz AsyncWebSocketContext.__aenter__s#**$ yy%s *(*cK|jr`|#|jjd{ytt5|jjd{dddyy7A7#1swYyxYwwrA)rrrr!)rhrorytbs rErrzAsyncWebSocketContext.__aexit__sm 99iioo'''i(,))//+++,, ',,,s9,BA0BA4!A2"A4& B2A44A=9BN)rzAwaitable[AsyncWebSocket]rmrn)rmz)Generator[object, object, AsyncWebSocket])rmr<)rorryrrrrmrn) rIrJrKrLrrgrrmrrrCrDrEr r rsD8!I0& ,, ," ,  ,  ,rDr )rxzasyncio.Future[None]rmrn)brL __future__rr_rrarrcollections.abcrrr contextlibr dataclassesr r enumr jsonr r(rr:randomrrtypingrrrrrraiorrconstrrrrrrr r!utilsr" exceptionsr$r%modelsr&r'r(r)typing_extensionsr*r+r, fingerprintsr-rr.rr/rr0r1r2r=r3r4r5r ON_DATA_Trl ON_MESSAGE_T ON_ERROR_T ON_OPEN_Tr> ON_CLOSE_TtupleRECV_QUEUE_ITEM bytearrayrSEND_QUEUE_ITEMr8rOrdrrruryr{r3r6r<r rCrDrEr/s# %::($$FF/HH"#.88&'"*$$OO0 A+uk:D@AI[%#+6<=L; 2D89J+,-I;S1478JE3J'OEI- :J