A>qjzddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl mZmZmZddlmZddlmZmZmZmZddlmZmZmZmZddlmZmZm Z m!Z!dd l"m#Z#m$Z$dd l%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+dd lm,Z,m-Z-m.Z.m/Z/m0Z0d d l1m2Z2d dl3m4Z4dgZ5GddZ6ddd ddZ7de7_8y)) annotationsN)IterableIteratorMapping) TracebackType)AnyLiteralSelfoverload)ConcurrencyErrorConnectionClosedConnectionClosedOK ProtocolError) DATA_OPCODESPONG CloseCodeFrame)RequestResponse)CLOSED CONNECTINGOPENEventProtocolState) BytesLikeDataDataLike LoggerLike Subprotocol) Assembler)Deadline Connectionc~eZdZdZdZddddd d/dZed0dZed0d Zed1d Z ed2d Z ed3d Z ed4d Z d5dZ d6dZd7dZed8dZed9dZed:d8dZe d: d9dZe d; ddZed:d?dZd:d?dZdd d@dZej*df dAdZ d:d d! dBd"ZdCdDd#ZdEd$ZdFd%ZdGd&ZdGd'ZdGd(ZdGd)Zej@e!d* dHd+Z"dGd,Z#dId-Z$dGd.Z%y)Jr%a? :mod:`threading` implementation of a WebSocket connection. :class:`Connection` provides APIs shared between WebSocket servers and clients. You shouldn't use it directly. Instead, use :class:`~websockets.sync.client.ClientConnection` or :class:`~websockets.sync.server.ServerConnection`. i ) ping_interval ping_timeout close_timeout max_queuecp||_||_||_||_||_t |t s||d}}n|\}}tj|jjd|i|j_ |jj|_ |jj|_ |jj|_ d|_ d|_ tj|_tj|_t%|||j"j&|j"j(|_d|_d|_i|_d|_ d|_d|_tj8|j:d|_|j<j?y)N websocket)pauseresumeFgTtargetdaemon) socketprotocolr*r+r, isinstanceintlogging LoggerAdapterloggeriddebugrequestresponse threadingLockprotocol_mutexrecv_flow_controlr#acquirerelease recv_messagesclose_deadlinesend_in_progress pending_pingslatencykeepalive_threadrecv_excThread recv_eventsrecv_events_threadstart) selfsockr6r*r+r,r-max_queue_high max_queue_lows Y/opt/rentech/trading_bot/.venv/lib/python3.12/site-packages/websockets/sync/connection.py__init__zConnection.__init__1s   *(* i %):,5tMN,5 )NM '44 MM $    "]]--B"&--"6"6 )]](( (, ()- )(nn."+!1'  ((00))11  04!&PR!  :>/3 #,"2"2###  %%'c6|jjS)z Local address of the connection. For IPv4 connections, this is a ``(host, port)`` tuple. The format of the address depends on the address family. See :meth:`~socket.socket.getsockname`. )r5 getsocknamerQs rU local_addresszConnection.local_address{{&&((rWc6|jjS)z Remote address of the connection. For IPv4 connections, this is a ``(host, port)`` tuple. The format of the address depends on the address family. See :meth:`~socket.socket.getpeername`. )r5 getpeernamerZs rUremote_addresszConnection.remote_addressr\rWc.|jjS)aI State of the WebSocket connection, defined in :rfc:`6455`. This attribute is provided for completeness. Typical applications shouldn't check its value. Instead, they should call :meth:`~recv` or :meth:`send` and handle :exc:`~websockets.exceptions.ConnectionClosed` exceptions. )r6staterZs rUrazConnection.states}}"""rWc.|jjS)z~ Subprotocol negotiated during the opening handshake. :obj:`None` if no subprotocol was negotiated. )r6 subprotocolrZs rUrczConnection.subprotocols}}(((rWc.|jjSa) State of the WebSocket connection, defined in :rfc:`6455`. This attribute is provided for completeness. Typical applications shouldn't check its value. Instead, they should inspect attributes of :exc:`~websockets.exceptions.ConnectionClosed` exceptions. )r6 close_coderZs rUrfzConnection.close_codes}}'''rWc.|jjSre)r6 close_reasonrZs rUrhzConnection.close_reasons}})))rWc|SNrZs rU __enter__zConnection.__enter__s rWch||jy|jtjyrj)closerINTERNAL_ERROR)rQexc_type exc_value tracebacks rU__exit__zConnection.__exit__s%   JJL JJy// 0rWc#RK |j#t$rYywxYww)aC Iterate on incoming messages. The iterator calls :meth:`recv` and yields messages in an infinite loop. It exits when the connection is closed normally. It raises a :exc:`~websockets.exceptions.ConnectionClosedError` exception after a protocol error or a network failure. N)recvrrZs rU__iter__zConnection.__iter__s0 iik!!   s' $'$'cyrjrkrQtimeoutdecodes rUruzConnection.recvILrWcyrjrkrxs rUruzConnection.recvLOrWNcyrjrkrxs rUruzConnection.recvsSVrWcyrjrkrxs rUruzConnection.recvsrWcyrjrkrxs rUruzConnection.recv srWc |jj||S#t$rYnt$r tddt$rs}|j 5|j jtj|jd|jdddn #1swYnxYwYd}~nd}~wwxYw|jj|j j|j)a Receive the next message. When the connection is closed, :meth:`recv` raises :exc:`~websockets.exceptions.ConnectionClosed`. Specifically, it raises :exc:`~websockets.exceptions.ConnectionClosedOK` after a normal closure and :exc:`~websockets.exceptions.ConnectionClosedError` after a protocol error or a network failure. This is how you detect the end of the message stream. If ``timeout`` is :obj:`None`, block until a message is received. If ``timeout`` is set, wait up to ``timeout`` seconds for a message to be received and return it, else raise :exc:`TimeoutError`. If ``timeout`` is ``0`` or negative, check if a message has been received already and return it, else raise :exc:`TimeoutError`. When the message is fragmented, :meth:`recv` waits until all fragments are received, reassembles them, and returns the whole message. Args: timeout: Timeout for receiving a message in seconds. decode: Set this flag to override the default behavior of returning :class:`str` or :class:`bytes`. See below for details. Returns: A string (:class:`str`) for a Text_ frame or a bytestring (:class:`bytes`) for a Binary_ frame. .. _Text: https://datatracker.ietf.org/doc/html/rfc6455#section-5.6 .. _Binary: https://datatracker.ietf.org/doc/html/rfc6455#section-5.6 You may override this behavior with the ``decode`` argument: * Set ``decode=False`` to disable UTF-8 decoding of Text_ frames and return a bytestring (:class:`bytes`). This improves performance when decoding isn't needed, for example if the message contains JSON and you're using a JSON library that expects a bytestring. * Set ``decode=True`` to force UTF-8 decoding of Binary_ frames and return strings (:class:`str`). This may be useful for servers that send binary frames instead of text frames. Raises: ConnectionClosed: When the connection is closed. ConcurrencyError: If two threads call :meth:`recv` or :meth:`recv_streaming` concurrently. zOcannot call recv while another thread is already running recv or recv_streamingN at position )rFgetEOFErrorr UnicodeDecodeError send_contextr6failr INVALID_DATAreasonrPrOjoin close_excrL)rQryrzexcs rUruzConnection.recvs` %%))'6: :   "< " ""$  ""**zzl- {;     $$&mm%%4==8s3 B8B8B3AB" B3"B+ 'B33B8cyrjrkrQrzs rUrecv_streamingzConnection.recv_streamingVsFIrWcyrjrkrs rUrzConnection.recv_streamingYr{rWcyrjrkrs rUrzConnection.recv_streaming\r}rWc#K |jj|Ed{y7#t$rYnt$r tddt$rs}|j 5|j jtj|jd|jdddn #1swYnxYwYd}~nd}~wwxYw|jj|j j|jw)a Receive the next message frame by frame. This method is designed for receiving fragmented messages. It returns an iterator that yields each fragment as it is received. This iterator must be fully consumed. Else, future calls to :meth:`recv` or :meth:`recv_streaming` will raise :exc:`~websockets.exceptions.ConcurrencyError`, making the connection unusable. :meth:`recv_streaming` raises the same exceptions as :meth:`recv`. Args: decode: Set this flag to override the default behavior of returning :class:`str` or :class:`bytes`. See below for details. Returns: An iterator of strings (:class:`str`) for a Text_ frame or bytestrings (:class:`bytes`) for a Binary_ frame. .. _Text: https://datatracker.ietf.org/doc/html/rfc6455#section-5.6 .. _Binary: https://datatracker.ietf.org/doc/html/rfc6455#section-5.6 You may override this behavior with the ``decode`` argument: * Set ``decode=False`` to disable UTF-8 decoding of Text_ frames and yield bytestrings (:class:`bytes`). This improves performance when decoding isn't needed. * Set ``decode=True`` to force UTF-8 decoding of Binary_ frames and yield strings (:class:`str`). This may be useful for servers that send binary frames instead of text frames. Raises: ConnectionClosed: When the connection is closed. ConcurrencyError: If two threads call :meth:`recv` or :meth:`recv_streaming` concurrently. NzYcannot call recv_streaming while another thread is already running recv or recv_streamingr)rFget_iterrr rrr6rrrrrPrOrrrL)rQrzrs rUrzConnection.recv_streaming_sN ))226: : :  ;   "< " ""$  ""**zzl- {;     $$&mm%%4==8sZD*(*D* CDCB?!AB.% B?.B7 3B?:D?C>D)textct|tr|j5|jr t d|dur*|j j |jn)|j j|jdddyt|trl|j5|jr t d|dur|j j|n|j j |dddyt|tr tdt|tr]t|} t|} t|tr|j5|jr t dd|_|dur,|j j |jdn+|j j|jddddd}nt|try|j5|jr t dd|_|dur|j j|dn|j j |ddddd}n td|D]}t|trU|rS|j5|jsJ|j j!|jddddht|trG|sE|j5|jsJ|j j!|ddddtd|j5|j j!d dd|_dddyytd #1swYyxYw#1swYyxYw#t$rYywxYw#1swYxYw#1swYcxYw#1swY`xYw#1swYmxYw#1swYpxYw#t$rt"$rQ|j5|j j%t&j(d ddd#1swYxYwwxYw) aF Send a message. A string (:class:`str`) is sent as a Text_ frame. A bytestring or bytes-like object (:class:`bytes`, :class:`bytearray`, or :class:`memoryview`) is sent as a Binary_ frame. .. _Text: https://datatracker.ietf.org/doc/html/rfc6455#section-5.6 .. _Binary: https://datatracker.ietf.org/doc/html/rfc6455#section-5.6 You may override this behavior with the ``text`` argument: * Set ``text=True`` to send an UTF-8 bytestring or bytes-like object (:class:`bytes`, :class:`bytearray`, or :class:`memoryview`) in a Text_ frame. This improves performance when the message is already UTF-8 encoded, for example if the message contains JSON and you're using a JSON library that produces a bytestring. * Set ``text=False`` to send a string (:class:`str`) in a Binary_ frame. This may be useful for servers that expect binary frames instead of text frames. :meth:`send` also accepts an iterable of strings, bytestrings, or bytes-like objects to enable fragmentation_. Each item is treated as a message fragment and sent in its own frame. All items must be of the same type, or else :meth:`send` will raise a :exc:`TypeError` and the connection will be closed. .. _fragmentation: https://datatracker.ietf.org/doc/html/rfc6455#section-5.4 :meth:`send` rejects dict-like objects because this is often an error. (If you really want to send the keys of a dict-like object as fragments, call its :meth:`~dict.keys` method and pass the result to :meth:`send`.) When the connection is closed, :meth:`send` raises :exc:`~websockets.exceptions.ConnectionClosed`. Specifically, it raises :exc:`~websockets.exceptions.ConnectionClosedOK` after a normal connection closure and :exc:`~websockets.exceptions.ConnectionClosedError` after a protocol error or a network failure. Args: message: Message to send. text: Force sending in a Text_ or Binary_ frame. Raises: ConnectionClosed: When the connection is closed. ConcurrencyError: If the connection is sending a fragmented message. TypeError: If ``message`` doesn't have a supported type. z=cannot call send while another thread is already running sendFNTzdata is a dict-like object)finz"iterable must contain bytes or strz#iterable must contain uniform typesrWzerror in fragmented messagez$data must be str, bytes, or iterable)r7strrrHr r6 send_binaryencode send_textrr TypeErrorriternext StopIterationsend_continuation Exceptionrrro)rQmessagerchunkschunkrs rUsendzConnection.sends)v gs #""$ >((*W5=MM--gnn.>?MM++GNN,<= > > +""$ 7((*W4<MM++G4MM--g6 7 7 )89 9 *']F V > eS)**, O00"2!:#15-5= MM55elln%5P MM33ELLN3N O"Fy1**, H00"2!:#15-4< MM33Eu3E MM55e5G H#F#$HII$ OE!%-&!..0W#'#8#88#8 MM;;ELLNPU;VWW$E95f!..0N#'#8#88#8 MM;;Eu;MNN((MNN O&&(2MM33CT3B,1D)22(BC CI > > 7 7*!   O O H H$WWNN22$  &&(MM&&!005    sA/N)9AN5 O P9A:O3+PAO<=P9:O*3+P,O7 %P/%PP)N25N> O  O OPO'"P*O4 /P7P <PP  P"Q32+Q& Q3&Q/ +Q3c |j5|jr+|jjtj dn|jj ||dddy#1swYyxYw#t$rYywxYw)ar Perform the closing handshake. :meth:`close` waits for the other end to complete the handshake and for the TCP connection to terminate. :meth:`close` is idempotent: it doesn't do anything once the connection is closed. Args: code: WebSocket close code. reason: WebSocket close reason. zclose during fragmented messageN)rrHr6rrro send_closer)rQcoders rUrnzConnection.close?s|& ""$ ;((MM&&!009 MM,,T6: ; ; ;    s/A;AA/&A;/A84A;8A;; BBF ack_on_closecXt|tr t|}n.t|tr|j }n | t d|j 5||jvr td|||jvr;tjdtjd}|,||jvr;tj}tj }|||f|j|<|j"j%||cdddS#1swYyxYw)a[ Send a Ping_. .. _Ping: https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.2 A ping may serve as a keepalive or as a check that the remote endpoint received all messages up to this point Args: data: Payload of the ping. A :class:`str` will be encoded to UTF-8. If ``data`` is :obj:`None`, the payload is four random bytes. ack_on_close: when this option is :obj:`True`, the event will also be set when the connection is closed. While this avoids getting stuck waiting for a pong that will never arrive, it requires checking that the state of the connection is still ``OPEN`` to confirm that a pong was received, rather than the connection being closed. Returns: An event that will be set when the corresponding pong is received. You can ignore it if you don't intend to wait. :: pong_received = ws.ping() # only if you want to wait for the corresponding pong pong_received.wait() Raises: ConnectionClosed: When the connection is closed. ConcurrencyError: If another ping was sent with the same data and the corresponding pong wasn't received yet. Ndata must be str or bytes-likez-already waiting for a pong with the same dataz!I )r7rbytesrrrrrIr structpackrandom getrandbitsr@rtime monotonicr6 send_ping)rQdatar pong_receivedping_timestamps rUpingzConnection.pingbsP dI &;D c ";;=D  <= =    !t)))&'VWW,$$*<*<"<{{4););B)?@,$$*<*<"<&OO-M!^^-N(5~|'TD  t $ MM # #D )  ! ! !sAD 1D AD  D)ct|tr t|}n,t|tr|j }n t d|j 5|jj|dddy#1swYyxYw)ab Send a Pong_. .. _Pong: https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.3 An unsolicited pong may serve as a unidirectional heartbeat. Args: data: Payload of the pong. A :class:`str` will be encoded to UTF-8. Raises: ConnectionClosed: When the connection is closed. rN) r7rrrrrrr6 send_pongrQrs rUpongzConnection.pongsk dI &;D c ";;=D<= =     * MM # #D ) * * *s A>>Bct|tsJ|jtvr|jj ||jt ur%|jt|jyy)zx Process one incoming event. This method is overridden in subclasses to handle the handshake. N) r7ropcoderrFputracknowledge_pingsrr)rQevents rU process_eventzConnection.process_events\%''' <<< '    " "5 ) <<4   " "5#4 5 rWc|j5||jvr dddytj}d}g}|jj D];\}\}}}|j ||j ||k(s1||z |_n td|D]}|j|= dddy#1swYyxYw)z; Acknowledge pings when receiving a pong. Nz!solicited pong not found in pings) rBrIrritemsappendsetrJAssertionError)rQrpong_timestampping_idping_idsrr _ack_on_closes rUrzConnection.acknowledge_pingss   04--- 0 0 "^^-NGH ##))+ J(!!#d?#1N#BDL J%%HII$ 0&&w/ 03 0 0 0sB?A"B? ,B??Cc|jjsJ|jjtusJ|j j D]\}}}|s |j|j jy)zK Acknowledge pending pings when the connection is closed. N) rBlockedr6rarrIvaluesrclear)rQr_ping_timestamprs rUterminate_pending_pingsz"Connection.terminate_pending_pingss| ""))+++}}""f,,,<@$$0$))$*;*;<:: KK--.IJ:: KK--.VW!..0 MM.. ) 8 8 8 7(  F KK  5  E FsUA E/E1B-E/+E# E/E/ E E/E  E/#E,(E//&FFc|jAtj|jd|_|jj yy)zS Run :meth:`keepalive` in a thread, unless keepalive is disabled. NTr2)r*r@rMrrKrPrZs rUstart_keepalivezConnection.start_keepalivesF    )$-$4$4~~%D !  ! ! ' ' ) *rWcd} |sV |j5 ddd|j3|jj|jj |jj |j }|dk(rn|j5|jj||jj} |j|jj!rD|jt#|j$|_|jj&t(urd}dddD]}|j+||sV|j5|jj-|jj}|jdddD]}|j+| |j1y#1swYxYw#t$rf}|jr|jjdd|j5|j|dddn #1swYnxYwYd}~d}~wwxYw#t$rM}|jr|jjdd|j|Yd}~dddSd}~wwxYw#1swYxYw#1swYxYw#t$r[}|jj/dd|j5|j|dddn #1swYnxYwYd}~bd}~wwxYw#|j1wxYw) z Read incoming data from the socket and process events. Run this method in a thread as long as the connection is alive. ``recv_events()`` exits immediately when ``self.socket`` is closed. FNz! error while receiving dataTrrW! error while sending dataunexpected internal error)rCrGr5 settimeoutryru recv_bufsizerr=r;rB set_recv_excr6 receive_dataevents_received send_dataclose_expectedr$r,rarr receive_eofr close_socket)rQclose_expected_while_connectingrreventsrs rUrNzConnection.recv_events+s$+0'b 5//**6 ..t/B/B/J/J/LM;;++D,=,=>D3;((CMM..t4"]]::B;9CJ$.E&&u-.6L$$ ! ))+668  !   *""5) *    } ! zz )):%)*,,/))#./// 8% :: KK-- <)-.))#.+CC CCX ! !( ' KK  9D  I$$ '!!#& ' ' ' '    sK G-G A,G-K6J8 IAJ89"K K)AK. KL9 G*%G-- I65I+I= II IKIK J5(:J0"J8& K0J55J88K=KK K L6)L1L L1L( $L1+L91L66L99M )expected_statec#Kd}d}d}|j5|jj|ur[ d|jjr*d}|jJt |j |_ |jn*d}|jt |j |_d}ddd|r|jJ|jjd}|jj!||jj#r7|Jt%d}d}|j5|j'|ddd|rA|j)|jj!|jj*|y#t$r:}|jr|jjddd}d}|}Yd}~"d}~wwxYw#ttf$rt$r.}|jjddd}d}|}Yd}~kd}~wwxYw#1swYuxYw#1swYxYww) a Create a context for writing to the connection from user code. On entry, :meth:`send_context` acquires the connection lock and checks that the connection is open; on exit, it writes outgoing data to the socket and releases the connection lock:: with self.send_context(): self.protocol.send_text(message.encode()) When the connection isn't open on entry, when the connection is expected to close on exit, or when an unexpected error happens, terminating the connection, :meth:`send_context` waits until the connection is closed then raises :exc:`~websockets.exceptions.ConnectionClosed`. FNTrrr)raise_if_elapsedz"timed out while closing connection)rBr6rarrGr$r,rrr=r;rr rryrOrr TimeoutErrorrrr)rQrwait_for_closeraise_close_exc original_excrrys rUrzConnection.send_contexts:.-1  0 '}}""n4$+}}335)- $22:::.6t7I7I.J+ +( "&&&.*243E3E*FD'"&a0 'n &&2 22))1151IG  # # ( ( 1&&//1$++++,PQ #'((4%%l34       # # ( ( *--))| ; Y% +:: KK-- <)-. */*.'*  +1&'78 'KK%%&AD%Q&+N&*O#&L'0 '0 'H44sH?H&GAH&8F+H&3BH?9H3 A H? G /GH&GH&H#5#HH&H##H&&H0+H?3H<8H?c|jjsJ|jjD]}|r[|j3|j j |jj|j j|` |j jt jy#t$rYwxYw)z\ Send outgoing data. This method requires holding protocol_mutex. N) rBrr6 data_to_sendrGr5rrysendallshutdownSHUT_WROSErrorrs rUrzConnection.send_datas""))+++MM..0 D&&2KK**4+>+>+F+F+HI ##D)KK((8 s)C CCcd|jjsJ|j||_yy)z Set recv_exc, if not set yet. This method requires holding protocol_mutex and must be called only from the thread running recv_events(). N)rBrrL)rQrs rUrzConnection.set_recv_exc#s2""))+++ == DM !rWc |jjtj |jj |j 5|j j|j jtusJ|jj |jdddy#t$rYwxYw#t$rYwxYw#1swYyxYw)z Shutdown and close socket. Close message assembler. Calling close_socket() guarantees that recv_events() terminates. Indeed, recv_events() may block only on socket.recv() or on recv_messages.put(). N) r5r SHUT_RDWRrrnrBr6rrarrFrrZs rUrzConnection.close_socket/s  KK !1!1 2  KK     + MM % % '==&&&0 00    $ $ &  ( ( * + +       + +s/)B>C A#C> C  C  CCC%)rRz socket.socketr6rr* float | Noner+rr,rr-z*int | None | tuple[int | None, int | None]returnNone)rr)rr)rzSubprotocol | None)rz int | None)rz str | None)rr )rpztype[BaseException] | NonerqBaseException | NonerrzTracebackType | Nonerr)rIterator[Data])ryrrz Literal[True]rr)ryrrzLiteral[False]rrrj)NN)ryrrz bool | Nonerr)rzrrz Iterator[str])rzrrzIterator[bytes])rzrrr)rzDataLike | Iterable[DataLike]rrrr)rzCloseCode | intrrrr)rzDataLike | Nonerboolrzthreading.Event)rW)rrrr)rrrr)rrrr)rr)rrrzIterator[None])rrrr)&__name__ __module__ __qualname____doc__rrVpropertyr[r_rarcrfrhrlrsrvr rurrrNORMAL_CLOSURErnrrrrrrrrN contextlibcontextmanagerrrrrrrkrWrUr%r%"s L')%'&(@B[([([( $ [( # [($[(>[( [(~ ) ) ) ) # #)) ( ( * * 1, 1( 1( 1  1(LL OO VV &*#7E BF#4? D9LII LL OO<9D! `D.`D `D  `DH!* 8 8!!!  !J!%<!# <!<! <!  <!|*6 60B #$FL *v p!%j<j<  j<j.send_messages* & & ""((4  **# 01O PI%%i0%%--I   : ++[9'B$$&%  & # ,-F GI*9I'%%i0%%--H!77HKQQS '  s6D7AD7,B;; D4A&D/*D7/D44D77ENzskipped broadcast)rr%rrrk) r7rrrr concurrentfuturesThreadPoolExecutormapExceptionGroup) connectionsrr rkwargsrexecutorrrs `` @@rU broadcastr"Vs@'3'+u}m+ .." GY '%)T\k} 344&( B    . . 8 80H \;/0J0*=='00s >B++B4zwebsockets.sync.server) rzIterable[Connection]rrr rrrr rrr)9 __future__rconcurrent.futuresrr r9rr5rr@rrruuidcollections.abcrrrtypesrtypingrr r r rr rrrframesrrrrhttp11rrr6rrrrrrrrrr r!messagesr#utilsr$__all__r%r"rrkrWrUr.s"   77// :9&GGGG .k+k+p!# p>%p> p> p>  p>  p> p>h0 rW