gwddlmZddlZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z m Z mZmZddlmZmZmZmZddlmZmZmZmZmZddlmZmZdd lmZm Z m!Z!m"Z"m#Z#dd l m$Z$m%Z%m&Z&d d l'm(Z(d d l)m*Z*dgZ+GddZ,y)) annotationsN) TracebackType)AnyIterableIteratorMapping)ConcurrencyErrorConnectionClosedConnectionClosedOK ProtocolError) DATA_OPCODES BytesLike CloseCodeFrameOpcode)RequestResponse)CLOSEDOPENEventProtocolState)Data LoggerLike Subprotocol) Assembler)Deadline Connectionc@eZdZdZdZdd ddZeddZeddZeddZ dd Z d d Z d!d Z d"d#d Z d!dZd$dZej"dfd%dZd"d&dZd'd(dZd)dZd*dZd+dZej2ed d,dZd+dZd-dZd+dZy ).r 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 ) close_timeoutcr||_||_||_tj|jj d|i|j_|jj |_ |jj |_ |jj|_d|_ d|_ tj|_ t|_d|_d|_i|_tj$|j&d|_|j(j+d|_y)N websocketFT)targetdaemon)socketprotocolr#logging LoggerAdapterloggeriddebugrequestresponse threadingLockprotocol_mutexr recv_messagessend_in_progressclose_deadline ping_waitersThread recv_eventsrecv_events_threadstartrecv_exc)selfr(r)r#s O/var/www/openai/venv/lib/python3.12/site-packages/websockets/sync/connection.py__init__zConnection.__init__-s   * '44 MM $    "]]--B"&--"6"6 )]](( (, ()- )(nn.'[!&04;= #,"2"2###  %%'/3 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`. )r( getsocknamer=s r> local_addresszConnection.local_addressi{{&&((r@c6|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`. )r( getpeernamerCs r>remote_addresszConnection.remote_addressvrEr@c.|jjS)z~ Subprotocol negotiated during the opening handshake. :obj:`None` if no subprotocol was negotiated. )r) subprotocolrCs r>rJzConnection.subprotocols}}(((r@c|SNrCs r> __enter__zConnection.__enter__s r@ch||jy|jtjyrL)closerINTERNAL_ERROR)r=exc_type exc_value tracebacks r>__exit__zConnection.__exit__s%   JJL JJy// 0r@c#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)recvr rCs r>__iter__zConnection.__iter__s0 iik!!   s' $'$'Nc |jj|S#t$r<|jj |j j |jt$r tddwxYw)aB 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 and no message is received within ``timeout`` seconds, raise :exc:`TimeoutError`. Set ``timeout`` to ``0`` to check if a message was already received. If the message is fragmented, wait until all fragments are received, reassemble them, and return the whole message. 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 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) r4getEOFErrorr:joinr) close_excr<r )r=timeouts r>rWzConnection.recvsu@ %%))'2 2 =  # # ( ( *--))t}} < "<  s AA6c# K |jjD]}|y#t$r<|jj |j j |jt$r tddwxYww)a6 Receive the next message frame by frame. If the message is fragmented, yield each fragment as it is received. The iterator must be fully consumed, or else the connection will become unusable. :meth:`recv_streaming` raises the same exceptions as :meth:`recv`. 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 Raises: ConnectionClosed: When the connection is closed. ConcurrencyError: If two threads call :meth:`recv` or :meth:`recv_streaming` concurrently. zYcannot call recv_streaming while another thread is already running recv or recv_streamingN) r4get_iterr[r:r\r)r]r<r )r=frames r>recv_streamingzConnection.recv_streamings~. ++446 7 =  # # ( ( *--))t}} < "<  sB#(BABBct|trZ|j5|jr t d|j j |jdddyt|trL|j5|jr t d|j j|dddyt|tr tdt|tr t|} t|} t|tred}|j5|jr t dd|_|j j |jddddnrt|trWd}|j5|jr t dd|_|j j|ddddn 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#1swYHxYw#1swYUxYw#1swY`xYw#1swYmxYw#1swYpxYw#t$rt"$rQ|j5|j j%t&j(d ddd#1swYxYwwxYw) a 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 :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. 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 sendNzdata is a dict-like objectTF)finz'data iterable must contain bytes or strz(data iterable must contain uniform typesr@zerror in fragmented messagez$data must be str, bytes, or iterable) isinstancestr send_contextr5r r) send_textencoder send_binaryr TypeErrorriternext StopIterationsend_continuation ExceptionfailrrQ)r=messagechunkschunktexts r>sendzConnection.sendswT gs #""$((*2 ''(89 %$ +""$((*2 ))'2 %$ )89 9 *']F V D eS)D**,00"2!:#15- //!LLN %0-, y1 D**,00"2!:#15- 11! %2-,$$MNN$E!%-$!..0#'#8#88#8 MM;; % $)<10 $E95d!..0#'#8#88#8 MM;; %$)<10((RSS!$&&&(MM33CT3B,1D))((BC CM%$%$&!  -,-,"1010)($  &&(MM&&!005)  )  sAL  3L? L! "M0-A L07+M0",M*%M0%M$4M0 LL! L-,L-0L:5M0=MM0 M M0M! M0$M-)M00"O+O= OO Oc |j5|jr+|jjtj dn|jj ||dddy#1swYyxYw#t$rYywxYw)a Perform the closing handshake. :meth:`close` waits for the other end to complete the handshake, for the TCP connection to terminate, and for all incoming messages to be read with :meth:`recv`. :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)rgr5r)rqrrQ send_closer )r=codereasons r>rPzConnection.closess  ""$((MM&&!009 MM,,T6:%$$    s/A;AA/&A;/A84A;8A;; BBc*t|tr t|}n.t|tr|j }n | t d|j 5||jvr td|||jvr;tjdtjd}|,||jvr;tj}||j|<|jj!||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. 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_event = ws.ping() pong_event.wait() # only if you want to wait for the pong 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 )rerbytesrfrirkrgr7r structpackrandom getrandbitsr1rr) send_ping)r=data pong_waiters r>pingzConnection.pings8 dI &;D c ";;=D  <= =    t(((&'VWW,$$*;*;";{{4););B)?@,$$*;*;";$//+K&1D  d # MM # #D )! sAD 1D ?D  Dct|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. r}N) rerrrfrirkrgr) send_pongr=rs r>pongzConnection.pongsb dI &;D c ";;=D<= =    MM # #D )! s A>>Bct|tsJ|jtvr|jj ||jt jur%|jt|jyy)zx Process one incoming event. This method is overridden in subclasses to handle the handshake. N) reropcoderr4putrPONGacknowledge_pingsrr)r=events r> process_eventzConnection.process_events`%''' <<< '    " "5 ) <<6;; &  " "5#4 5 'r@cR|j5||jvr dddyd}g}|jjD]-\}}|j||j ||k(s-n t d|D]}|j|= dddy#1swYyxYw)z; Acknowledge pings when receiving a pong. Nz!solicited pong not found in pings)r3r7itemsappendsetAssertionError)r=rping_idping_idsrs r>rzConnection.acknowledge_pings s  4,,,! GH!%!2!2!8!8!: ( d? "; %%HII#%%g.$!! sBA B1"BB&c |j3|jj|jj|jj |j }|dk(rn|j5|jj||jj} |j|jjr&|jt!|j"|_ddd D]}|j%| "|j5|jj)|jjrJ|jddd|j-y#t $rf}|jr|jjdd|j5|j|dddn #1swYnxYwYd}~d}~wwxYw#t $rM}|jr|jjdd|j|Yd}~ddd/d}~wwxYw#1swY]xYw#t&$rYPwxYw#1swYxYw#t $r[}|jj+dd|j5|j|dddn #1swYnxYwYd}~ed}~wwxYw#|j-wxYw)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 the ``self.socket`` is closed. TNzerror while receiving dataexc_infor@error while sending dataunexpected internal error)r6r( settimeoutr^rW recv_bufsizerpr.r,r3 set_recv_excr) receive_dataevents_received send_dataclose_expectedrr#rr[ receive_eoferror close_socket)r=rexceventsrs r>r9zConnection.recv_events#s|R  **6 ..t/B/B/J/J/LM;;++D,=,=>D3;((MM..t4"]]::J K*)K%8K K%K K%K-%K**K--K?)expected_statec#LKd}d}d}|j5|jj|ur[ d|jjr*d}|jJt |j |_ |jnd}d}ddd|r|j |j }n|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}~vd}~wwxYw#1swYxYw#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:: 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)r3r)staterr6rr#rrpr.r,r r rr^r:r\is_alive TimeoutErrorrrr])r=rwait_for_closeraise_close_exc original_excrr^s r>rgzConnection.send_contexts.-1  }}""n4"+}}335)- $22:::.6t7I7I.J+ +("&"&W!d ""*,,--55u5M  # # ( ( 1&&//1$++++,PQ #'((%%l3)       # # ( ( *--))| ; S%+:: KK--.HSW-X*/*.'* +3&'78 'KK%%&AD%Q&+N&*O#&L'! D)(sH$H GAH 8E<H  BH$H0A H$< F?/F:4H :F??H H#H=H HH  HH$H!H$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. Raises: OSError: When a socket operations fails. N) r3lockedr) data_to_sendr6r(rr^sendallshutdownSHUT_WROSErrorrs r>rzConnection.send_datas""))+++MM..0D&&2KK**4+>+>+F+F+HI ##D)KK((81s)C CCcd|jjsJ|j||_yy)zf Set recv_exc, if not set yet. This method requires holding protocol_mutex. N)r3rr<)r=rs r>rzConnection.set_recv_excs2""))+++ == DM !r@cN |jjtj|jj |j j |j jtusJ|jj y#t$rYxwxYw)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) r(r SHUT_RDWRrrPr)rrrr4rCs r>rzConnection.close_socket s  KK !1!1 2  !!#}}""f,,,   "   s)B B$#B$)r(z socket.socketr)rr# float | NonereturnNone)rr)rzSubprotocol | None)rr )rRztype[BaseException] | NonerSBaseException | NonerTzTracebackType | Nonerr)rzIterator[Data]rL)r^rrr)rrzData | Iterable[Data]rr)rzintr{rfrr)rz Data | Nonerzthreading.Event)r@)rrrr)rrrr)rrrr)rr)rrrzIterator[None])rrrr)__name__ __module__ __qualname____doc__rr?propertyrDrHrJrNrUrXrWrbrvrNORMAL_CLOSURErPrrrrr9 contextlibcontextmanagerrrgrrrrMr@r>r r s: L') 838383 $ 83  83x ) ) ) ))) 1, 1( 1( 1  1"*X"HQDf!* 8 8@/b*6 6/0[ z!%h<h<  h<hrsc"  33 GF&;;22 .C #C #r@