vKg؍SSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK J r J r J r SSK Jr SSKJr SSKJrJrJrJr SSKJrJrJrJrJr SS KJrJr SS KJ r J!r!J"r"J#r#J$r$ SS KJ%r%J&r&J'r' S S K(J)r) S SK*J+r+ S/r,"SS5r-g)) annotationsN)IterableIteratorMapping) TracebackType)Any)ConcurrencyErrorConnectionClosedConnectionClosedOK ProtocolError) DATA_OPCODES BytesLike CloseCodeFrameOpcode)RequestResponse)CLOSEDOPENEventProtocolState)Data LoggerLike Subprotocol) Assembler)Deadline Connectionc\rSrSrSrSrSSS.S"Sjjr\S#Sj5r\S#S j5r \S$S j5r \S%S j5r \S&S j5r \S'S j5r S(SjrS)SjrS*SjrS+S,SjjrS-S.SjjrS-S/Sjjr\R*S4S0SjjrS-S1SjjrS2S3SjjrS4SjrS5SjrS6Sjr\R:\S.S7Sjj5rS6Sjr S8Sjr!S6S jr"S!r#g)9r 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_timeout max_queuecLXlX lX0l[U[5(dUcUS4nX@l[ R"URRSU05URlURRUl URRUlURRUl SUl SUl [R"5Ul[R"5Ul[#UR UR R$UR R&S.6UlSUlSUl0UlSUl[R2"UR4SS9UlUR6R95 g)N websocket)pauseresumeFT)targetdaemon)socketprotocolr% isinstanceintr&logging LoggerAdapterloggeriddebugrequestresponse threadingLockprotocol_mutexrecv_flow_controlracquirerelease recv_messagessend_in_progressclose_deadline ping_waitersrecv_excThread recv_eventsrecv_events_threadstart)selfr-r.r%r&s Z/var/www/highfloat_scraper/venv/lib/python3.13/site-packages/websockets/sync/connection.py__init__Connection.__init__.sf  * i % %):"D)I" '44 MM $    "]]--B"&--"6"6 )]](( (, ()- )(nn."+!1' ^^((00))11 !&04;=/3 #,"2"2###  %%'c6URR5$)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- getsocknamerGs rH local_addressConnection.local_addressu{{&&((rKc6URR5$)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- getpeernamerNs rHremote_addressConnection.remote_addressrQrKc.URR$)a 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. )r.staterNs rHrWConnection.states}}"""rKc.URR$)zf Subprotocol negotiated during the opening handshake. :obj:`None` if no subprotocol was negotiated. )r. subprotocolrNs rHrZConnection.subprotocols}}(((rKc.URR$a 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. )r. close_coderNs rHr^Connection.close_codes}}'''rKc.URR$r])r. close_reasonrNs rHraConnection.close_reasons}})))rKcU$NrNs rH __enter__Connection.__enter__s rKcjUcUR5 gUR[R5 grd)closerINTERNAL_ERROR)rGexc_type exc_value tracebacks rH__exit__Connection.__exit__s%   JJL JJy// 0rKc#V# UR5v M![a gf=f7f)a 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 rNs rH__iter__Connection.__iter__s/ iik!!   s) &)&)NcURRX5$![a O[a [S5Se[a{nUR 5 UR R[RURSUR35 SSS5 SnAO!,(df  SnAO =fSnAff=fURR5 UR RURe)ar 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. 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 a string (: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 )r>getEOFErrorr UnicodeDecodeError send_contextr.failr INVALID_DATAreasonrFrEjoin close_excrB)rGtimeoutdecodeexcs rHrqConnection.recvs^ %%))': :   "< " ""$ ""**zzl- {;%$$$  $$&mm%%4==8s9 CCB=AB(B=( B: 2B=:B==Cc## URRU5ShvN gN![a O[a [S5Se[a{nUR 5 UR R[RURSUR35 SSS5 SnAO!,(df  SnAO =fSnAff=fURR5 UR RURe7f)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 return bytestrings (:class:`bytes`). This may be useful to optimize performance when decoding isn't needed. * Set ``decode=True`` to force UTF-8 decoding of Binary_ frames and return strings (:class:`str`). This is 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_streamingru)r>get_iterrwr rxryr.rzrr{r|rFrEr}r~rB)rGrrs rHrecv_streamingConnection.recv_streaming$sN ))226: : :  ;   "< " ""$ ""**zzl- {;%$$$  $$&mm%%4==8sfD *(*D * CD CC $AB5(C 0D 5 C ?C D C  C>D c [U[5(aUR5 UR(a [ S5eUSLa*UR R UR55 O)UR RUR55 SSS5 g[U[5(arUR5 UR(a [ S5eUSLaUR RU5 OUR R U5 SSS5 g[U[5(a [S5e[U[5(Ga~[U5n[U5n[U[5(aUR5 UR(a [ S5eSUlUSLa)UR R UR5SS9 O(UR RUR5SS9 SSS5 SnO[U[5(ayUR5 UR(a [ S5eSUlUSLaUR RUSS9 OUR R USS9 SSS5 SnO [S5eUHn[U[5(a]U(aVUR5 UR(deUR R!UR5SS9 SSS5 Mu[U[5(aOU(dHUR5 UR(deUR R!USS9 SSS5 M[S5e UR5 UR R!S SS9 SUlSSS5 g[S 5e!,(df  g=f!,(df  g=f![a gf=f!,(df  GN =f!,(df  GN=f!,(df  GM=f!,(df  GM=f!,(df  g=f![a e["aV UR5 UR R%[&R(S 5 SSS5 e!,(df  e=ff=f) 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 You may override this behavior with the ``text`` argument: * Set ``text=True`` to send a bytestring or bytes-like object (:class:`bytes`, :class:`bytearray`, or :class:`memoryview`) as 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. 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'data iterable must contain bytes or strz(data iterable must contain uniform typesrKzerror in fragmented messagez$data must be str, bytes, or iterable)r/strryr?r r. send_binaryencode send_textrr TypeErrorriternext StopIterationsend_continuation Exceptionrzrrj)rGmessagetextchunkschunkrs rHsendConnection.sendbsr gs # #""$((*25=MM--gnn.>?MM++GNN,<=%$ + +""$((*24<MM++G4MM--g6%$ ) )89 9 * *']F V > eS))**,00"2!:#15-5= MM55elln%5P MM33ELLN3N-"Fy11**,00"2!:#15-4< MM33Eu3E MM55e5G-#F#$MNN$E!%--&!..0#'#8#88#8 MM;;ELLNPU;V10$E955f!..0#'#8#88#8 MM;;Eu;M10((RSS$&&(MM33CT3B,1D))((BC CM%$%$,!   -,-,$1010)($  &&(MM&&!005)  )(  sA5O* AO;- P 9%Q7A:P0Q7AP.&AQ7-putrPONGacknowledge_pingsrr)rGevents rH process_eventConnection.process_eventpsc%'''' <<< '    " "5 ) <<6;; &  " "5#4 5 'rKcbUR XR;a SSS5 gSn/nURR5H-up$URU5 UR 5 X!:XdM- O [ S5eUHnURU M SSS5 g!,(df  g=f)z+ Acknowledge pings when receiving a pong. Nz!solicited pong not found in pings)r:rAitemsappendsetAssertionError)rGrping_idping_idsrs rHrConnection.acknowledge_pings~s  ,,,! GH!%!2!2!8!8!: ( ? "; %%HII#%%g.$!! sB AB 2%B  B.cUR URb3URRURR 55 SSS5 URR UR 5nUS:XaOUR URRU5 URR5nUR5 URR!5(a'URc[#UR$5UlSSS5 WHnUR'U5 M GM@UR URR)5 URR5nUR5 SSS5 WHnUR'U5 M UR-5 g!,(df  GN}=f![aonUR(aURRSSS9 UR URU5 SSS5 O!,(df  O=fSnAGM SnAff=f![aPnUR(aURRSSS9 URU5 SnASSS5 GMgSnAff=f!,(df  GN=f!,(df  GN7=f![abnURR+SSS9 UR URU5 SSS5 SnAGMq!,(df  SnAGN=fSnAff=f!UR-5 f=f)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. TNz! error while receiving dataexc_inforK! error while sending dataunexpected internal error)r;r@r- settimeoutrrq recv_bufsizerr5r3r: set_recv_excr. receive_dataevents_received send_dataclose_expectedrr%r receive_eoferror close_socket)rGrreventsrs rHrDConnection.recv_eventss^ //..: KK2243F3F3N3N3PQ0 ;;++D,=,=>D3;((MM..t4"]]::K6J2IAJ21KAK"K GG I#7I H5, I 5 I ?I K IK J/SnAff=f![[4a e[a+nURRSSS9 SnSnUnSnAGNSnAff=f!,(df  GN=f!,(df  N=f7f) 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)r:r.rWrr@rr%rrr5r3r r rrrEr}is_alive TimeoutErrorrrr~)rGrwait_for_closeraise_close_exc original_excrrs rHryConnection.send_contexts.-1  }}""n4%+}}3355)- $22:::.6t7I7I.J+ +( "&"&]!j ""*,,--55u5M  # # ( ( 1&&//11$++++,PQ #'((%%l3)       # # ( ( *--))| ; Y% +:: KK-- <)-. */*.'*  +3&'78 'KK%%&AD%Q&+N&*O#&L'! J)(sIH"GA H"?FH"BI.H4AI G1G H"GH"H4 HH"HH"" H1,I4 I>IcURR5(deURR5HnU(a]URb3UR R URR55 UR RU5 MgUR R[ R5 M g![a Mf=f)zz Send outgoing data. This method requires holding protocol_mutex. Raises: OSError: When a socket operations fails. N) r:lockedr. data_to_sendr@r-rrsendallshutdownSHUT_WROSErrorrs rHrConnection.send_datams""))++++MM..0D&&2KK**4+>+>+F+F+HI ##D)KK((81s$)C C C cnURR5(deURcXlgg)zN Set recv_exc, if not set yet. This method requires holding protocol_mutex. N)r:rrB)rGrs rHrConnection.set_recv_excs3""))++++ == M !rKcRURR[R5 URR 5 UR R 5 UR R[LdeURR 5 g![a Nzf=f)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_RDWRrrir.rrWrr>rNs rHrConnection.close_sockets  KK !1!1 2  !!#}}""f,,,   "   s)B B&%B&)r@r%r5r4r3r&rAr.r:rErBr;r>r6r7r?r-) r-z socket.socketr.rr% float | Noner&z*int | None | tuple[int | None, int | None]returnNone)rr)rr)rzSubprotocol | None)rz int | None)rz str | None)rr )rkztype[BaseException] | NonerlBaseException | NonermzTracebackType | Nonerr)rIterator[Data])NN)rrr bool | Nonerrrd)rrrr)rzData | Iterable[Data]rrrr)rr0r|rrr)rz Data | Nonerzthreading.Event)rK)rrrr)rrrr)rrrr)rr)rrrzIterator[None])rrrr)$__name__ __module__ __qualname____firstlineno____doc__rrIpropertyrOrTrWrZr^rarfrnrrrqrrrNORMAL_CLOSURErirrrrrD contextlibcontextmanagerrryrrr__static_attributes__rerKrHr r s L')@B C(C(C( $ C( > C( C(N ) ) ) ) # #)) ( ( * * 1, 1( 1( 1  1"C9J<9B!`D&`D`D  `DD!* 8 8@/b*6 6/0g R!%k<k<  k<krsf"  77 GF&;;22 .D#D#rK