e iUdZddlmZddlZddlZddlZddlZddlmZddl m Z m Z m Z ddl mZddlmZmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZm Z m!Z!m"Z"m#Z#m$Z$ddl%m&Z&m'Z'ddl(m)Z)m*Z*m+Z+m,Z,m-Z-ddl.m/Z/m0Z0ddl1m2Z2ddl3m4Z4m5Z5ddl6m7Z7ddl1m8Z8m9Z9m:Z:erddl;mZ>ddl?m@Z@ddlAmBZBddlCmDZDmEZEmFZFddlGmHZHmIZIe"dZJe d eKe>gdfZLe d eKeMzgdfZNe d e0gdfZOe d gdfZPe d eQeMgdfZReSeKeQfZTeSeKe-fZUeed!"ZVd#eWd$<eGd%d&ZXGd'd(eZYGd)d*e0ZZGd+d,eZe4Z[Gd-d.eZe5Z\dzWebSocketRetryStrategy.Ls 9;O:PrH)default_factoryzset[CurlECode]codesN) __name__ __module__ __qualname____doc__r>__annotations__r@rCr rLrGrHrIr<r<8so  EEENNNN!E2P2PQQQEQQQQQQrHr<cZeZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdZdZdZdS) WsCloseCodez?See: https://www.iana.org/assignments/websocket/websocket.xhtmliiiiiiiiiiiiiii i i N)rMrNrOrPOK GOING_AWAYPROTOCOL_ERRORUNSUPPORTED_DATAUNKNOWNABNORMAL_CLOSURE INVALID_DATAPOLICY_VIOLATIONMESSAGE_TOO_BIGMANDATORY_EXTENSIONINTERNAL_ERRORSERVICE_RESTARTTRY_AGAIN_LATER BAD_GATEWAY TLS_HANDSHAKE UNAUTHORIZED FORBIDDENTIMEOUTrGrHrIrSrSOsrII BJNGLONOOKMLIGGGrHrSc(eZdZdZ d d fd ZxZS) WebSocketErrorzWebSocket-specific error.rmessagestrcode$WsCloseCode | CurlECode | Literal[0]returnNonecLt||dSrE)super__init__)selfrirk __class__s rIrqzWebSocketError.__init__is% $'''''rH)r)rirjrkrlrmrn)rMrNrOrPrq __classcell__rss@rIrhrhfsO##JK(((((((((((rHrhceZdZdZdS)WebSocketClosedzWebSocket is already closed.NrMrNrOrPrGrHrIrwrwos'&&&rHrwceZdZdZdS)WebSocketTimeoutzWebSocket operation timed out.NrxrGrHrIrzrzus)(((rHrzfutasyncio.Future[None]rmrncT |ddS#t$rYdSwxYw)af 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 since this is frequently called. N) set_result_InvalidStateError)r{s rI_safe_set_resultr{sA  t      s  ''ceZdZUdZded<dddddZed dZed!dZed"dZ e d#dZ e d$dZ d%dZ dS)& BaseWebSocket_curl autoclose _close_code _close_reasondebugclosedztuple[str, ...] __slots__TF)rrcurlCurl | NotSetTyperr=rrmrncZ||_||_d|_d|_||_d|_dS)NFr)rrrrrs rIrqzBaseWebSocket.__init__s4)- ('+)-  ! rHr!cxt|jtrt|j|_|jS)z;Return reference to Curl associated with current WebSocket.)r) isinstancerr)r!rrrs rIrzBaseWebSocket.curls4 dj* - - 0DJ///DJzrH int | Nonec|jS)zThe WebSocket close reason, if the connection has been closed.)rrs rI close_reasonzBaseWebSocket.close_reasons !!rHrkrBreasonbytesc2tjd||zS)N!H)structpack)rkrs rI_pack_close_framezBaseWebSocket._pack_close_frames{4&&//rHframetuple[int, str]ct|dkrtj}d}n tjd|d}|dd}nU#t $r }tdtj|d}~wt$r }tdtj |d}~wwxYw|tjks |dks|dkrtd |tj ||fS) NrrrzInvalid close messagezInvalid close framerTizInvalid close code: ) lenrSrYr unpack_fromdecodeUnicodeDecodeErrorrhr[ ExceptionrW)rrkres rI_unpack_close_framez!BaseWebSocket._unpack_close_frames u::>>#+DFF )$66q9qrr))++%   $+[-E   $);+E  {***dTkkTT\\$1411;3MV|s#7A B.&B B.B))B.cFd|_|jdS)z$Terminate the underlying connection.TN)rrclosers rI terminatezBaseWebSocket.terminates!  rHN)rrrr=rr=rmrn)rmr!)rmr)rmr)rkrBrrrmr)rrrmrrmrn)rMrNrOrrQrqpropertyrrr staticmethodrrrrGrHrIrrs "I=APU""""""X    X """X"000\0\0rHr)openrdatarierrorc eZdZdZdZefddddddddddpfdZdqdZdrdZdsd!Z ddddedd"dddddd#ddddddd$dddd%dfdtdRZ dudTZ dvdVZ dwdWZ edXdxd\ZejfdydaZdzdbZd{dcZd|ddZeded}diZd~djZdddkZejdlfddoZxZS)r6z)A WebSocket implementation using libcurl.)skip_utf8_validation _emitters keep_runningTFN)rrron_openon_closeon_data on_messageon_errorrrrr=rrrON_OPEN_T | NonerON_CLOSE_T | NonerON_DATA_T | NonerON_MESSAGE_T | NonerON_ERROR_T | Nonermrnct|||||_d|_i|_|r ||jd<|r ||jd<|r ||jd<|r ||jd<| r | |jd<dSdS) 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)`` rrrFrrrrirN)rprqrrr) rrrrrrrrrrrrss rIrqzWebSocket.__init__s4 diuEEE*>!"'HJ  -%,DN6 "  /&.DN7 #  -%,DN6 "  3(2DN9 %  /&.DN7 # # # / /rHc2|jrtd|S)NWebSocket is closedrrwrs rI__iter__zWebSocket.__iter__ s ; 9!"788 8 rHrc`|\}}|tjzrt|SrE)recvr CLOSE StopIterationrrmsgflagss rI__next__zWebSocket.__next__s.YY[[ U :# #   rH event_typeEventTypeLiteralargs+str | bytes | int | CurlWsFrame | CurlErrorc$|j|}|rs ||g|R}dS#t$rZ}|jd}|r |||}n&tjd|dt dYd}~dSYd}~dSd}~wwxYwdS)NrzWebSocket callback 'z' failedr) stacklevel)rgetrwarningswarnr#)rrrrcallback_rerror_callbacks rI_emitzWebSocket._emits 261C1CJ1O1O   HT)D)))   ?C~?Q?Q@@"&tQ//AAMCzCCC'#$AAAAA    s ) B A BB zgzip, deflate, brrrurlrjparams\dict[str, object] | list[object] | tuple[str, int | list[str] | dict[str, str | int]] | NoneheadersHeaderTypes | NonecookiesCookieTypes | Noneauthtuple[str, str] | Nonetimeout+float | tuple[float, float] | object | Noneallow_redirectsbool | CurlFollow | str max_redirectsrBproxiesProxySpec | Noneproxyr proxy_authverify bool | Nonerefereraccept_encoding impersonateBrowserTypeLiteral | Noneja3akamaiperkextra_fp&ExtraFingerprints | ExtraFpDict | Nonedefault_headersquotestr | Literal[False] http_versionCurlHttpVersion | None interfacecertstr | tuple[str, str] | Nonemax_recv_speed curl_optionsdict[CurlOpt, str] | Noner+cL|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|}|tjd}||S)!aG 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 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: which interface to use. 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. rmethodGETr params_listN headers_list cookies_listrrrr proxies_listrr verify_listrrrrrrrrrrrrrrrrG)rr*setoptr CONNECT_ONLYperform)rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrs rIconnectzWebSocket.connect,sZY     5  v       G ,O (-  % "z v G ,O! "$ # $% &6' () *X+ ,,O- .%/ 0&1 2 i3 4*>5 67 8&9 @ KK,a 0 0  rHtuple[bytes, CurlWsFrame]c|jrtd|j\}}|jt jzrx ||\|_|_ n9#t$r,}|j |_| |j d}~wwxYw|j r| ||fS)z2Receive a single curl websocket fragment as bytes.WebSocket is already closedN)rrwrws_recvrr rrrrrhrkrr)rrchunkrrs rI recv_fragmentzWebSocket.recv_fragments ; A!"?@@ @y((** u ;) )  7;7O7OPU7V7V4 $"4"4!   $%6  16"""   ~  e|s"A++ B!5'BB!tuple[bytes, int]cg}d}|jtj}|tkrt dt j |\}}|j }| ||j dkr|tj zdkrnGnE#t$r8}|jt jkrt#|gggd\}}}nYd}~nd}~wwxYwd||fS)z Receive a frame as bytes. libcurl splits frames into fragments, so we have to collect all the chunks for a frame. rInvalid active socketT?NrH)rgetinfor ACTIVESOCKETrrhrNO_CONNECTION_AVAILABLErrappend bytesleftr CONTr"rkAGAINrjoin)rrchunksrsock_fdrrrrs rIrzWebSocket.recvs  !)##H$9:: o % % ')J   #1133 u  e$$$?a''EJO,Cq,H,H   6Y_,,%gYB<5AA   6Y_,,&,R'B&D&DOAy!$L,-CDD!KHHHH   f Fs7||## s?C D.%>D)(D))D.cB||tjS)zVSend a binary frame. Args: payload: binary data to send. r4r BINARYrrr+s rI send_binaryzWebSocket.send_binary yy*"3444rHcB||tjS)ztSend a binary frame, alias of :meth:`send_binary`. Args: payload: binary data to send. r6r8s rI send_byteszWebSocket.send_bytesr:rHcB||tjS)zRSend a text frame. Args: payload: text data to send. r4r r&r8s rIsend_strzWebSocket.send_str# yy*/222rHr objectrCallable[..., str]c>|||S)zSend a JSON frame. Args: payload: data to send. dumps: JSON encoder, default is json.dumps. r?rrr+rs rI send_jsonzWebSocket.send_json+s}}UU7^^,,,rHcB||tjS)zMSend a ping frame. Args: payload: data to send. )r4r PINGr8s rIpingzWebSocket.ping6r@rHc `|r|j|fi|}|jtj}|t krt dtj| dg}d|_ |j r. | \}}|j }| d||| ||jdkr|tjzdksrd|jvrd|} |tjzrz|jss | } n_#t,$rP} t.j|_|t.jt dt.j| d } ~ wwxYw| } |tjzs|tjzr| d| g}|tjzr,d |_ | d |jpd|jpd n#t<$r} | jtj krtC|gggd \}}}n[| d| |j"s=t.j#} tI| t r| j} || Yd } ~ nd } ~ wwxYw|j ,d Sd S)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 rrTrrrirHz Invalid UTF-8NFrrrr)%rrrrrrrhrrrrrrrrr rrr!r&rrrrSr[rrr7rrr"rkr rrrYr) rrrkwargsrr#r"rrrremit_msgrrks rI run_foreverzWebSocket.run_forever>s  , S++F++A)##H$9:: o % % ')J  6! / . #1133 u  65%000 e$$$1,,1HA1M1M..((6**C / '9R '%47JJLLHH1%%%/:/GD, JJ{'?@@@"0 /1I###$%%$' 118uz7N8 9h777:++Y(-D%JJw(8(=At?Q?WUWXXX   6Y_,,$gYB<A F  FA6H J!BJJ!rHrkric|||}||tj}|dS)znClose the connection. Args: code: close code. message: close reason. N)rr4r rr)rrrkrirrs rIrzWebSocket.closesE$$T733 IIc:+ , , rH)rrrr=rr=rr=rrrrrrrrrrrmrn)rmr6rmr)rrrrrmrn)6rrjrrrrrrrrrrrrrrBrrrrrrrrrrrrrrrrrrrrrrrr=rrrrrrrrrrBrrrmr+)rmr)rmr)rmrj)rr(rmr5)r+r,rr rmrB)r+rrmrB)r+r)r+rjrmrB)r+rArrBrmrB)r+r,rmrB)r)rrjrmrn)rkrBrir)rMrNrOrPrr(rqrrrrrrr' json_loadsr*r r7r4r9r<r?r:rFrIrMrSrUrrtrus@rIr6r6s[33I#*(/%*$(&*$(*.&*(/(/(/(/(/(/(/(/T  @ &*&*'+?F37$( -1""&915!;? $&(/3 $-126Apppppd,''''@$$$$8B'------^555555553333?L - - - - - -3333EEEEEN!,         rHc eZdZUdZdZdZded<dddd ddd d d d ddd dbfd%Zedcd'Z eddd(Z ded)Z dfd+Z dgd2Z dfd3Zdhd5Zdid8Zdjd9Zd d:dkd>Zd d:dld@Zed dAdmdEZejd fdndJZdodKZdodLZdpdMZedNdqdRZdrdTZej dUdVfdsdYZ!djfdZ Z"djd[Z#djd\Z$dtd^Z%dudvd_Z&djfd` Z'dwdaZ(xZ)S)xAsyncWebSocketz< 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 ClassVar[int]_MAX_CURL_FRAME_SIZETF Ng{Gzt?gMbP?i@) rrrecv_queue_sizesend_queue_sizemax_send_batch_sizecoalesce_framesrbrecv_time_slicesend_time_slicemax_message_sizereblock_on_recv_queue_fullrSr3rr!rr=rrjrBrkrlrmrbWebSocketRetryStrategy | Nonernr?rorprerqrmrnc 6t|||||_d|_d|_d|_t j|_tj|_ t j |_ d|_ d|_t j||_t j||_||_||_| p t)|_| |_| |_d|_| |_| |_||_dS)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() Note: Architecture: This uses a decoupled 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. 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. See also: - https://curl.se/libcurl/c/curl_ws_recv.html - https://curl.se/libcurl/c/curl_ws_send.html rNF)maxsize)rprqrSrTrUr`asyncioLockrV threadingrWEventrarXrYQueuerZr[r\r]r<rbr^r_rcrdrerf)rrrSrrrrjrkrlrmrbrnrorprerqrss rIrqzAsyncWebSocket.__init__s| diuEEE/6 7;  !&)0/8~/?/?07 596:>Em#? ? ? &@&@AADJzrHc4|jS)z6Returns the current number of items in the send queue.)r[qsizers rIrkzAsyncWebSocket.send_queue_sizes%%'''rHc|js|jrdS|jr|jrdS|jo|j 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)rr`rXdonerYrs rIis_alivezAsyncWebSocket.is_alivesa ; $* 5 ? t3355 5$@)9)>)>)@)@AArHr+c K|S)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. rGrs rI __aenter__zAsyncWebSocket.__aenter__+s  rHexc_typetype[BaseException] | Noneexc_valBaseException | Noneexc_tb object | Nonec>K|d{VdS)zQ On exiting the context manager, close the WebSocket connection. N)r)rrrrrs rI __aexit__zAsyncWebSocket.__aexit__5s.jjllrHc2|jrtd|S)NzWebSocket has been closedrrs rI __aiter__zAsyncWebSocket.__aiter__@s ; ?!"=>> > rHrcK |d{V\}}n#t$r tdwxYw|tjzrt|SrE)rrwStopAsyncIterationr rrs rI __anext__zAsyncWebSocket.__anext__Esp /#yy{{******JC / / /$$ . / :# # %$ $ s"5excrc\|js|jdS||_|dS)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)rrcr)rrrs rI_finalize_connectionz#AsyncWebSocket._finalize_connectionOs9" ; $3? F$'! rHc|jdS|jrtdtt|jtj|_ |j tkrtdtj dt|d}|j||d|_|j||d |_dS) 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.)rkz WebSocket-z#xz-read)namez-write)rXr`rwrrBrrrrrUrrhrridr~ create_task _read_loop _write_looprY)rrws_ids rI_start_io_taskszAsyncWebSocket._start_io_tasksfs ? & F   B!"@AA AS$)"3"3H4I"J"JKK =O + + (y/P  0"T((///)//0A0A5/XX900     %5%5%51  rHrr float | Nonerc*K|j|js|j |jS#tj$rYnwxYw|j|j|j|jrtdt j |j } t j ||jftj |d{V\}}nu#tj $rc|sM|}ttj 5|d{Vdddn #1swxYwYwxYw|su|}ttj 5|d{Vdddn #1swxYwY|j|jt!dt"j||vr|d{VS|}ttj 5|d{Vdddn #1swxYwY|jrJttj5|jcdddS#1swxYwY|j|jtd)aReceive 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: ``WebSocketError`` exceptions may have originated from a prior ``send()`` or ``recv()`` operation, 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)rcrerZ get_nowaitrv QueueEmptyrXrrwrrwaitFIRST_COMPLETEDCancelledErrorcancelrrzrOPERATION_TIMEDOUT)rrr queue_waiterrrs rIrzAsyncWebSocket.recvsH  $ 09L 0+ + &1133 3!    D   $ 0+ + ? "do&:&:&<&< "!"788 87>6I   # # % %7 7  #Lt/#3GD!!%   $$&& ' ''))g455''&&&&&&&&'''''''''''''''    ##%%A'011 # #"""""""" # # # # # # # # # # # # # # #(4//",i.J  4  %%%%%%% %    ! ! g, - -                           8',-- 8 8*5577 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8  $ 0+ +1222sv2AA01C""AE2 E; EE EE E FF"F HH #H I--I14I1rjcK||d{V\}}|tjzstdtj |dS#t$r }tdtj|d}~wwxYw)zmReceive a text frame. Args: timeout: how many seconds to wait before giving up. rNzNot a valid text framer%zInvalid UTF-8 in text frame)rr r&rhrSr[rr)rrrrrrs rIr'zAsyncWebSocket.recv_strs !IIgI66666666 e ' U !9;;STT T ;;w'' '!    -{/G  s A!! B +BB )rrrCallable[[str | bytes], T]r5cDK||d{V\}}|stdtj ||S#t$r }tdtj|d}~wt $r#}td|tj|d}~wwxYw)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: )rrhrSr[rr)rrrrrrrs rIr*zAsyncWebSocket.recv_jsons ' 22222222a  :KSend queue full (network slow) - hit timeout enqueuing message)rcrrwrYrrrjr. bytearray memoryviewrr[ put_nowaitrv QueueFullr`wait_forput TimeoutErrorrz)rrr+rrrrs rIr4zAsyncWebSocket.send#s*  $ 0+ + ; 9!"788 8   'D,<,A,A,C,C '!"LMM M gs # # %nnW--GG Z!7 8 8 %GnnG 9   ' '%(8 9 9 9 9 9  9 9 9 U%&JKKQTT(4/S8"!*(,,gu-=>>+*X &**GU+;<<<<<<<<<(4/S8544444+ 9s<.C F(F5D:9F:E EE4FFcRK||tjd{VS)zSend a binary frame. Args: payload: binary data to send. For more info, see the docstring for :meth:`send()` Nr6r8s rIr9zAsyncWebSocket.send_binaryb1YYw (9:::::::::rHcRK||tjd{VS)zSend a binary frame, alias of :meth:`send_binary`. Args: payload: binary data to send. For more info, see the docstring for :meth:`send()` Nr6r8s rIr<zAsyncWebSocket.send_byteslrrHcRK||tjd{VS)zSend a text frame. Args: payload: text data to send. For more info, see the docstring for :meth:`send()` Nr>r8s rIr?zAsyncWebSocket.send_strvs0YYw 888888888rHr rArrBcNK|||d{VS)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()` NrDrEs rIrFzAsyncWebSocket.send_jsons4]]55>>222222222rHr,cXKt|tr|d}nt|}t |t ddvr*t dt |tj| |tj d{VS)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%r~zPing frame has invalid length: N) rrjr.rrrangerhr TOO_LARGEr4r rH)rrr+ payload_bytess rIrIzAsyncWebSocket.pings gs # # +#NN733MM!'NNM }  U1c]] 2 2 F#m2D2DFF#  YY}jo>>>>>>>>>rHrHg@rkric K|j4d{V|jr dddd{VdSd|_ |jr|jsx|jq|||}t j|j |tj f|d{V| |d{Vn#t j tf$rYnwxYw|t!t j 5t j|j|d{V}dddn #1swxYwYn|#|t!t j 5t j|j|d{V}dddw#1swxYwYwxYwdddd{VdS#1d{VswxYwYdS)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)rVrrYrrcrrvrr[rr rflushrrhrrrar)rrrkrir close_framers rIrzAsyncWebSocket.closes# W W W W W W W W{  W W W W W W W W W W W W W WDK W$ . ,1133 .19*.)?)?g)N)NK!*(,,k:;K-LMM '**W---------(.9        g233WW%.t/E/J/J/L/LgVVVVVVVVAWWWWWWWWWWWWWWW   g233WW%.t/E/J/J/L/LgVVVVVVVVAWWWWWWWWWWWWWWWW5 W W W W W W W W W W W W W W W W W W W W W W W W W W W W W Ws G0G0BC  E! C&#E!%C&&E!)-G03E G0E G0E G0!.G3G  GG GG GG00 G:=G:c|j5|jr ddddSd|_|j} tj}n#t $rd}YnwxYw |t d|,||ur(||}n'tj||}n#t$r t |j r&|j j s|j d|jn#|jwxYwYnwxYwddddS#1swxYwYdS)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)rWr`rTrvr} RuntimeErrorr_terminate_helperrun_coroutine_threadsaferrprrS_closed push_curlraset)rrr~ current_looprrss rIrzAsyncWebSocket.terminates !! 1! 1 ! 1! 1! 1! 1! 1! 1! 1! 1 $D 59ZD $,..   $ $ $#  $ 1<&'ABBB + 0D0D(()?)?)A)ABBAA89O9O9Q9QSWXXA 1 1 11GG%%'''|5DL,@5 ..t444*..0000D*..000000 15! 1! 1! 1! 1! 1! 1! 1! 1! 1! 1! 1! 1! 1! 1! 1! 1! 1! 1sw EEAE AEAEA&B<;E< EA D.E.E  E EEEE#&E#c R -K|jj}|jj}|jj}|j}|j}|j}|j}|j }|j } || z} |j j } |j j } |j j} t|j j}t"j}t"j}t"j}t*j}t*j}t*j}||z}|j}|j}d}d}t6}d}g}d}|j}|j} |js |\} }!nS#t>$rE}"d}#|"j |krd}#n|"j |kr?tC|""-tG-fd|Drd}#nN|"j |krCtIdtJj&}$|"|$_'d|$_(|)|$Yd}"~"dS|#r|}% ||j*||%|%d{Vn#tV$rx}&|)tYd |&t"j-Yd}&~&|j*d kr" ||j*}'n#tV$rYnwxYwYd}"~"dSYd}"~"dSYd}"~"dSd}&~&wwxYw |j*d kr" ||j*}'nC#tV$rYn7wxYwn2#|j*d kr" ||j*}'w#tV$rYwwxYwwxYwYd}"~"| rf|"j | vr]|| krW|d z }|d |d z zz}(|(d z})|(t]|) |)z }(t_j0tcd|(d{VYd}"~"H|)|"Yd}"~"dSd}"~"wwxYw|!j2}*|dkrd}|*|zsE|tg| z }||kr@||)tYd|d|dt"j4dS|| |*|zs|!j5stg|d kr|dnd6|}+|d} ||+|*fnZ#t^j7$rH|s0|)tY|t"j8YdS||+|*fd{VYnwxYw|x},| krt_j0dd{V|,| z} |*|zr| || |*fnZ#t^j7$rH|s0|)tY|t"j8YdS|| |*fd{VYnwxYw|9| d{VdS|*|zri || |*fnZ#t^j7$rH|s0|)tY|t"j8YdS|| |*fd{VYnwxYw|jdSdS#t^j:$rYdStV$r }"|)|"Yd}"~"dSd}"~"wwxYw)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. )zerrno 11z resource temporarily unavailablezDReceive queue full; failing connection to preserve message integrityrFTc3 K|]}|vV dSrErG).0rerr_msgs rI z,AsyncWebSocket._read_loop..Ss'GG#sg~GGGGGGrHz.Connection closed unexpectedly by server (EOF)NzSocket closed unexpectedly: rtr$rg?gzMessage too large: z bytes (limit zF bytes). Consider increasing max_message_size or chunking the message.rH);rrrZrrr~time create_future add_reader remove_readerr^rbr>rLrCr?r@rr rF GOT_NOTHINGr rrrHrdrfrrclearrr"rkrjloweranyrwrSrZ __cause____suppress_context__rrUrrhrrrvsleepmaxrrrrr!r OUT_OF_MEMORY_handle_close_framer).rr curl_ws_recvqueue_put_nowait queue_putr~ loop_timerrr time_slice next_yieldretry_on_error retry_codes max_retries retry_basee_again e_recv_err e_nothing close_flag cont_flag ping_flag control_mask max_msg_size block_on_recv errno_11_msgsqueue_full_errset_fut_resultrecv_error_retriesr"msg_size chunks_append chunks_clearrrr should_retry final_exc read_futurerr retry_delayjitterrrinowrs. @rIrzAsyncWebSocket._read_loops.AE @Q   *    # +/))- <@>LE55 FFF).Lv(('+ :--'*1vv||~~GGGGGGGGG0+/L9,,5DL'866 /0 +9= 611)<<<#!>),V)9)9F1IIsxx?O?O % #$ >,,gu-=>>>>&0>>>#0' $ 9 9$2(6 8O%&%&!"!"!" !'"+)We,<"="==========> )y{{*z99%mA.........%(:%5  :%  LNNN 8((%8888",888,# 55 .~y?V W W#FF'i777777777778225999999999F9$ 8 8((%8888",888,# 55 .~y?V W W#FF'i777777777778ok^ 8^ 8^ 8^ 8^ 8@%    DD ) ) )  % %a ( ( ( ( ( ( ( ( ( )sW+ D/-W+/ M?:B"M:W+" M:0H  J? J 0JJ? M:I&%M:& I30M:2I33M:6W+<W+W+J  J? M:J.-M:. J;8M::J;;M:? K. KK. K* 'K.)K* *K..M:1W+7A"M:W+M:4W+:M??A.W+/AW+ QW+>R(W+R(%W+'R((AW+, S:9W+:>U8W+;UW+UW+1W+7 VW+>WW+WW+W W++X&= X&X!!X&c Ktjtjz}|j}|jj}|jj}|jj}|j}|j }|j }||z} |j s |d{V\} } || | d{Vs* ||j s| dSdS| tjzr |n|x} | krtjdd{V| |z} |n#|wxYw |d{V\} } | | fg} | tjzs{t!| |jkrc |\} }| | |f|tjzrn.n#tj$rYnwxYwt!| |jkc i}| D]\} }||zrZ|D]\}}|d||d{VsKt-t!| D] }| |j s| dSdS|x} | krtjdd{V| |z} ||| |d{VsJt-t!| D] }| |j s| dSdS|x} | krtjdd{V| |z} f||g| |D]t\}}|d||d{VsJt-t!| D] }| |j s| dSdSu t-t!| D] }| n.#t-t!| D] }| wxYw| ddtjzrn8n<#tj$rYn+t4$r}||Yd}~nd}~wwxYw|j s| dSdS#|j s| wwxYw)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. TNrrHrtr$)r rrH _send_payloadr[rr task_doner~rr_r]rrrvrrr\rritemsr!rr setdefaultrrr)rrcontrol_frame_flags send_payload queue_getqueue_get_nowait queue_doner~rrrr+rrbatchrdata_to_coalesce frame_grouppayloadsrrs rIrzAsyncWebSocket._write_loops:$.#3jo#E7;7I >B>N>R :>:J:U)-)9)C *.))-  1 %IKK*4 ] !(O %+49;;%6%6%6%6%6%6NGU %%1\'5%A%AAAAAAA#"# P; !      ! !c!:#33"!# $-9;;.C:==")-"2"22222222),z)9J# !%(9+49;;%6%6%6%6%6%6NGU?Fu=M > >#(:+;#;!*$)!*$+#5&&& %&"%jj4+DDD%)JL(.3WWNGU$'::W=M=S=S=U=U !F !F$9K1=(+(:(:K2&2&,&,&,&,&,&,&%/)/6"'s5zz!2!2))A&JLLLL) ; !      ! !Q09y{{(:z'I'I.5mA.>.>(>(>(>(>(>(>(>58:5E 0 6 6 8 8 8-9\'5-I-I'I'I'I'I'I'I!+$*""'s5zz!2!2))A&JLLLL) ; !      ! !=,59;;$6C:#E#E*1-*:*:$:$:$:$:$:$:$:14z1AJ!1 ; ;E2 F F M Mg V V V V6F5K5K5M5M''1K)5chhx6H6H+)V)V#V#V#V#V#V#V' &"'s5zz!2!2))A&JLLLL) ; !      ! !+'' "'s5zz!2!2))A&JLLLL)s5zz!2!2))A&JLLLL)Ry|j&66s9v%    D ) ) )  % %a ( ( ( ( ( ( ( ( ) ; !      ! !4; !     !s*Q"D Q"D Q"/D Q" D$$AQ")3FQ"F0-Q"/F00Q" AP)Q"%AP<)Q"BP )Q")P+*Q"+Q!Q"!R="R1R=3 R<RR=RR==SCurlWsFlag | intcK|jj}|j}|j}|j}|j}|j}t} |j} |j } || z} |j } tj }tj}d}||z}t|}t!|}d}d}||ks|dkr)|dkr"|||t#||z | z}t!|}|}||z|kr||z} |||}|dkr\|dkrdS|dkrN|dz }||kr3|t'd|dtjdSt+d||rd}||z }|x}| krt-jdd {V|| z} n(#t*$r}|j|kr|} || | ||d {Vn{#t2$rn}|t'd |tjYd }~| d kr || }n#t2$rYnwxYwYd }~dSYd }~dSYd }~dSd }~wwxYw | d kr || }n9#t2$rYn-wxYwn(#| d kr || }w#t2$rYwwxYwwxYwYd }~||Yd }~dSd }~wwxYw||k|dkr|dk"dS) zF Optimized low-level sender with fragmentation logic. rArTr$zWriter stalled (z attempts).Fz 0 bytes sentNz)Socket closed unexpectedly during write: rt)rr/r~rr add_writer remove_writerrrUr_rgrr r rrrminrrh WRITE_ERRORr"rvrrkrr)rrr+r curl_ws_sendr~rrrrrr#rrmax_frame_sizerrmax_zero_writes base_flagsview total_bytesr0 write_retriesr chunk_len current_flagsr2rr write_futurerrs rIrzAsyncWebSocket._send_payloadrs8 GKiFW *.))- <@>## $$$&&g455$$#OOOOOOO$$$$$$$$$$$$$$$$$$ $ $4''Y$++---- YYY()NOOUXXY#))++ >>## $$$&&g455$$#OOOOOOO$$$$$$$$$$$$$$$$$$ $ $ %%WXXX(>>## $$$&&g455$$#OOOOOOO$$$$$$$$$$$$$$$$$$ $ $9>>## $$$&&g455$$#OOOOOOO$$$$$$$$$$$$$$$$ $sAH! CCC% H!/D H! D(D##D((H! FF #F +H!< HHH!AJ# I8, J8I< <J?I< JcZKd|j|jfD}d} |D]}|}|rCtj||tjd{V\}}|D]}|}|jsi |j}|j n#tj tf$rYnwxYw|ji|j dkrtt5|j|j }dddn #1swxYwYtt5|j|j }dddn #1swxYwYd|_ t%|jr&|jjs|jd|jdS#|jwxYw)z)Utility method for connection terminationc>h|]}|||SrE)r)rts rI z3AsyncWebSocket._terminate_helper..s14 4 4 }QVVXX} }}rHr)rrNrt)rXrYrrvr ALL_COMPLETEDr[rrrr ValueErrorrUrrr~rrrprrSrrrar)rrtasks_to_cancel max_timeoutio_taskrpendingprss rIrz AsyncWebSocket._terminate_helpers4 4 ot'784 4 4   ( )* % %NN$$ ##*<#' ' 5$$$ 7 !##A AA&,,.. (3355A$..0000*J7E &,,.. }""i((?? // >>A???????????????i((?? // >>A???????????????DM GG     | -DL$8 - &&t,,,  " & & ( ( ( ( (D " & & ( ( ( (syA7H2C H C# H"C##;H E > H EHEH) F HFHFAHH*c8K ||\|_|_n##t$r}|j|_Yd}~nd}~wwxYw|jr5|js.||jp tj d{VdS| dS)z $+ **T-?@@ @ @ @ @ @ @ @ @ @ NN     s"' A AA)rSr3rr!rr=rr=rjrBrkrBrlrBrmr=rbrrrnr?ror?rprBrer=rqr=rmrn)rmr{)rmrB)rmr=)rmr+)rrrrrrrmrnrO)rrrmrnr)rrrmr)rrrmrj)rrrrrmr5)r+rrr rrrmrn)r+rrmrn)r+rjrmrn)r+rArrBrmrn)r+r,rmrn)rkrBrirrr?rmrn)r+rrr rmr=rE)rrrmrn)rirrmrn)*rMrNrOrPrrgrQrqrr~rkrrrrrrrrr'rPr*r r7r4r9r<r?r:rFrIrSrUrrrrrrrrrtrus@rIrRrRseI.+0////!!#% %26!&!& /$)-!VHVHVHVHVHVHVHVHpX (((X(BBBB&     .     D59i3i3i3i3i3i3V9=&-7 $ F'- $ =9=9=9=9=9~;;;;;;;;9999?L 3 3 3 3 3 3????4&.3QT*W*W*W*W*WX.1.1.1.1.1.1`h)h)h)h)TD!D!D!D!LjjjjX7$7$7$7$7$r1)1)1)1)1)1)f        rHrRc6eZdZdZdZddZdd Zdd ZddZdS)AsyncWebSocketContextz.Helper to enable simpler context manager usage_coro_objcoroAwaitable[AsyncWebSocket]rmrnc"||_d|_dSrEr/)rrr2s rIrqzAsyncWebSocketContext.__init__^s04 +/ rH)Generator[object, object, AsyncWebSocket]c4|jSrE)r0 __await__rs rIr7zAsyncWebSocketContext.__await__bsz##%%%rHrRc8K|jd{V|_|jSrEr/rs rIrz AsyncWebSocketContext.__aenter__es)*$$$$$$ yrHrrrrtbrcZK|jr!|jd{VdSdSrE)r1r)rrrrr9s rIrzAsyncWebSocketContext.__aexit__isF 9 $)//## # # # # # # # # # $ $rHN)r2r3rmrn)rmr5)rmrR)rrrrr9rrmrn) rMrNrOrPrrqr7rrrGrHrIr.r.Xso88!I0000&&&&$$$$$$rHr.)r{r|rmrn)crP __future__rrvrrxrrrcollections.abcrrr contextlibr dataclassesr r enumr functoolsr jsonr json_dumpsrrPrandomrrtypingrrrrrraiorrconstrrrrr rr!r"utilsr# exceptionsr%r&modelsr'r(r)r*typing_extensionsr+r,r-rr.rr/rr0r1r2rSr3r4r5r ON_DATA_Trj ON_MESSAGE_T ON_ERROR_T ON_OPEN_TrB ON_CLOSE_TtupleRECV_QUEUE_ITEMSEND_QUEUE_ITEMr:rQr<rSrhrwrzrrrr6rRr.rGrHrIrSs3#""""" ;;;;;;::::::::::(((((((($$$$$$$$$$$$IIIIIIIIIIIIIIII////////HHHHHHHHHHHHHH""""""""######........8888888888/&&&&&&''''''""""""$$$$$$$$$$$$OOOOOOOOOO00000000 A+uk:D@AI[%#+6<=L; 2D89J+,-I;S1478JE3J'OE:-.O&gjZHHH HHHH RRRRRRR R,'.(((((Y((('''''M''' )))))G)))     EEEEEEEEPFG||||| |||~ ]D&$$$$$$$$$$rH