iSSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK r SSK r SSK r SSK r SSKJrJrJrJrJr SSKJrJrJrJr SSKJr SSKJr SSKJrJrJ r J!r!J"r"J#r# SS K$J%r% SS K&J'r'J(r(J)r)J*r*J+r+J,r,J-r-J.r.J/r/J0r0 SS K1J2r2 SS KJ3r3J4r4J5r5J6r6J7r7 S SK8J9r9J:r:J;r; S/r<"SS\Rz5r>SSSjjr?S\?l@g)) annotationsN) AsyncIterable AsyncIterator AwaitableIterableMapping)AnyCallableDequecast)asyncio_timeout)Headers)ConnectionClosedConnectionClosedErrorConnectionClosedOK InvalidState PayloadTooBig ProtocolError) Extension) OK_CLOSE_CODES OP_BINARYOP_CLOSEOP_CONTOP_PINGOP_PONGOP_TEXTClose CloseCodeOpcode)State) BytesLikeDataDataLike LoggerLike Subprotocol)Frame prepare_ctrl prepare_dataWebSocketCommonProtocolc&\rSrSr%SrS\S'SrS\S'SS S SS S S S SSSS SSS.SSj5r \ S?Sj5r \ S@Sj5r\ SASj5r\ SASj5r\ SBSj5r\ SBSj5r\ S?Sj5r\ S>Sj5rSCSjrSDSjrSESjr\R2S4SFS jjrS=S!jrSGSHS"jjrSISJS#jjrSKS$jrS=S%jrS=S&jr SLS'jr!SMS(jr"SNS)jr#SOS*jr$S=S+jr%\&RNS,.SPS-jjr(SGSQS.jjr)S=S/jr*S=S0jr+S=S1jr,SBS2jr-\R\S4SFS3jjr/S=S4jr0SRS5jr1SSS6jr2S=S7jr3S=S8jr4STS9jr5S=S:jr6S;r7g)Ur+6u) WebSocket connection. :class:`WebSocketCommonProtocol` provides APIs shared between WebSocket servers and clients. You shouldn't use it directly. Instead, use :class:`~websockets.legacy.client.WebSocketClientProtocol` or :class:`~websockets.legacy.server.WebSocketServerProtocol`. This documentation focuses on low-level details that aren't covered in the documentation of :class:`~websockets.legacy.client.WebSocketClientProtocol` and :class:`~websockets.legacy.server.WebSocketServerProtocol` for the sake of simplicity. Once the connection is open, a Ping_ frame is sent every ``ping_interval`` seconds. This serves as a keepalive. It helps keeping the connection open, especially in the presence of proxies with short timeouts on inactive connections. Set ``ping_interval`` to :obj:`None` to disable this behavior. .. _Ping: https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.2 If the corresponding Pong_ frame isn't received within ``ping_timeout`` seconds, the connection is considered unusable and is closed with code 1011. This ensures that the remote endpoint remains responsive. Set ``ping_timeout`` to :obj:`None` to disable this behavior. .. _Pong: https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.3 See the discussion of :doc:`keepalive <../../topics/keepalive>` for details. The ``close_timeout`` parameter defines a maximum wait time for completing the closing handshake and terminating the TCP connection. For legacy reasons, :meth:`close` completes in at most ``5 * close_timeout`` seconds for clients and ``4 * close_timeout`` for servers. ``close_timeout`` is a parameter of the protocol because websockets usually calls :meth:`close` implicitly upon exit: * on the client side, when using :func:`~websockets.legacy.client.connect` as a context manager; * on the server side, when the connection handler terminates. To apply a timeout to any other API, wrap it in :func:`~asyncio.timeout` or :func:`~asyncio.wait_for`. The ``max_size`` parameter enforces the maximum size for incoming messages in bytes. The default value is 1 MiB. If a larger message is received, :meth:`recv` will raise :exc:`~websockets.exceptions.ConnectionClosedError` and the connection will be closed with code 1009. The ``max_queue`` parameter sets the maximum length of the queue that holds incoming messages. The default value is ``32``. Messages are added to an in-memory queue when they're received; then :meth:`recv` pops from that queue. In order to prevent excessive memory consumption when messages are received faster than they can be processed, the queue must be bounded. If the queue fills up, the protocol stops processing incoming data until :meth:`recv` is called. In this situation, various receive buffers (at least in :mod:`asyncio` and in the OS) will fill up, then the TCP receive window will shrink, slowing down transmission to avoid packet loss. Since Python can use up to 4 bytes of memory to represent a single character, each connection may use up to ``4 * max_size * max_queue`` bytes of memory to store incoming messages. By default, this is 128 MiB. You may want to lower the limits, depending on your application's requirements. The ``read_limit`` argument sets the high-water limit of the buffer for incoming bytes. The low-water limit is half the high-water limit. The default value is 64 KiB, half of asyncio's default (based on the current implementation of :class:`~asyncio.StreamReader`). The ``write_limit`` argument sets the high-water limit of the buffer for outgoing bytes. The low-water limit is a quarter of the high-water limit. The default value is 64 KiB, equal to asyncio's default (based on the current implementation of ``FlowControlMixin``). See the discussion of :doc:`memory usage <../../topics/memory>` for details. Args: logger: Logger for this server. It defaults to ``logging.getLogger("websockets.protocol")``. See the :doc:`logging guide <../../topics/logging>` for details. ping_interval: Interval between keepalive pings in seconds. :obj:`None` disables keepalive. ping_timeout: Timeout for keepalive pings in seconds. :obj:`None` disables timeouts. close_timeout: Timeout for closing the connection in seconds. For legacy reasons, the actual timeout is 4 or 5 times larger. max_size: Maximum size of incoming messages in bytes. :obj:`None` disables the limit. max_queue: Maximum number of incoming messages in receive buffer. :obj:`None` disables the limit. read_limit: High-water mark of read buffer in bytes. write_limit: High-water mark of write buffer in bytes. bool is_client undefinedstrsideNi iF)logger ping_interval ping_timeout close_timeoutmax_size max_queue read_limit write_limithostportsecure legacy_recvlooptimeoutclU (a"S[5 UcSnO"S[5 UcUnU c[R"5n O"S[5 X lX0lX@lXPlX`l Xpl Xl [R"5UlUc[R "S5n[R""USU05UlUR'[R(5UlXlXlXlXlXl[R6"US-U S9UlS UlSUl[>R@Ul!UR*(aUR$R+S 5 U U U /Ul"SUl#SUl$SUl%SUl&U RO5Ul([RRT"5Ul+SUl,SUl-SUl.0Ul/S Ul0U SUl1U U g) Nzlegacy_recv is deprecated zrename timeout to close_timeoutzremove loop argumentzwebsockets.protocol websocketr )limitrAFz= connection is CONNECTINGr)2warningswarnDeprecationWarningasyncioget_event_loopr6r7r8r9r:r;r<uuiduuid4idlogging getLogger LoggerAdapterr5 isEnabledForDEBUGdebugrA_host_port_securer@ StreamReaderreader_paused _drain_waiterr! CONNECTINGstate extensions subprotocol close_rcvd close_sentclose_rcvd_then_sent create_futureconnection_lost_waiter collectionsdequemessages_pop_message_waiter_put_message_waiter_fragmented_message_waiterpingslatencytransfer_data_exc)selfr5r6r7r8r9r:r;r<r=r>r?r@rArBs W/home/mande/repo/quber/.venv/lib/python3.13/site-packages/websockets/legacy/protocol.py__init__ WebSocketCommonProtocol.__init__s&  MM57I J ?G MM;=O P  #M <))+D MM02D E*(* "$&"ZZ\B >&&'<=F")"7"7d@S"T )((7     & **qtL  :> %% :: KK  : ; 4 0 1,./31)-(,15! =A> %~~((**mmA&&&  """'"s$A2B4B5B B BBcUR[RLde[RUlUR(aUR R S5 UR RUR55Ul UR RUR55Ul UR RUR55Ul g)zt Callback when the WebSocket opening handshake completes. Enter the OPEN state and start the data transfer phase. z= connection is OPENN)r]r!r\OPENrTr5rA create_task transfer_datatransfer_data_taskkeepalive_pingkeepalive_ping_taskclose_connectionclose_connection_taskrns roconnection_open'WebSocketCommonProtocol.connection_openJszzU-----ZZ :: KK  4 5"&))"7"78J8J8L"M#'99#8#89L9L9N#O %)YY%:%:4;P;P;R%S"rrcUR(aSOSn[R"SUS3[5 UR$)Nremote_address local_addressuse z[0] instead of host)r/rGrHrIrUrn alternatives ror=WebSocketCommonProtocol.host]3*...&o  [M)<=?QRzzrrcUR(aSOSn[R"SUS3[5 UR$)Nrrrz[1] instead of port)r/rGrHrIrVrs ror>WebSocketCommonProtocol.portcrrrcP[R"S[5 UR$)Nzdon't use secure)rGrHrIrWrs ror?WebSocketCommonProtocol.secureis (*<=||rrc^URnURS5$![a gf=f)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`. :obj:`None` if the TCP connection isn't established yet. socknameNr}get_extra_infoAttributeErrorrnr}s ror%WebSocketCommonProtocol.local_addressp7 8I++J7 7    ,,c^URnURS5$![a gf=f)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`. :obj:`None` if the TCP connection isn't established yet. peernameNrrs ror&WebSocketCommonProtocol.remote_addressrrcUR[RL=(a URR 5(+$)aK :obj:`True` when the connection is open; :obj:`False` otherwise. This attribute may be used to detect disconnections. However, this approach is discouraged per the EAFP_ principle. Instead, you should handle :exc:`~websockets.exceptions.ConnectionClosed` exceptions. .. _EAFP: https://docs.python.org/3/glossary.html#term-eafp )r]r!rrrtrs roopenWebSocketCommonProtocol.opens.zzUZZ'N0G0G0L0L0N,NNrrc:UR[RL$)z :obj:`True` when the connection is closed; :obj:`False` otherwise. Be aware that both :attr:`open` and :attr:`closed` are :obj:`False` during the opening and closing sequences. )r]r!CLOSEDrs roclosedWebSocketCommonProtocol.closedszzU\\))rrcUR[RLagURc[R $URR $)z WebSocket close code, defined in `section 7.1.5 of RFC 6455`_. .. _section 7.1.5 of RFC 6455: https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.5 :obj:`None` if the connection isn't closed yet. N)r]r!rr`rABNORMAL_CLOSUREcoders ro close_code"WebSocketCommonProtocol.close_codes= ::U\\ ) __ $-- -??'' 'rrcUR[RLagURcgURR$)z WebSocket close reason, defined in `section 7.1.6 of RFC 6455`_. .. _section 7.1.6 of RFC 6455: https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.6 :obj:`None` if the connection isn't closed yet. N)r]r!rr`reasonrs ro close_reason$WebSocketCommonProtocol.close_reasons4 ::U\\ ) __ $??)) )rrcl# UR5IShvN 7v MN ![a gf=f7f)a% Iterate on incoming messages. The iterator exits normally when the connection is closed with the close code 1000 (OK) or 1001 (going away) or without a close code. It raises a :exc:`~websockets.exceptions.ConnectionClosedError` exception when the connection is closed with any other code. N)recvrrs ro __aiter__!WebSocketCommonProtocol.__aiter__s5  IIK'''!   s 4$" $ 1414c# URb [S5e[UR5S::aURR 5nXl[ R"XR/[ RS9IShvN SUlUR5(d*UR(agUR5IShvN [UR5S::aMURR5nURb"URRS5 SUlU$N!SUlf=fNx7f)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 connection 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. Canceling :meth:`recv` is safe. There's no risk of losing the next message. The next invocation of :meth:`recv` will return it. This makes it possible to enforce a timeout by wrapping :meth:`recv` in :func:`~asyncio.timeout` or :func:`~asyncio.wait_for`. Returns: A string (:class:`str`) for a Text_ frame. 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. RuntimeError: If two coroutines call :meth:`recv` concurrently. NzPcannot call recv while another coroutine is already waiting for the next messager) return_when)rh RuntimeErrorlenrgrArcrJwaitrFIRST_COMPLETEDrtr@ ensure_openpopleftri set_result)rnpop_message_waitermessages rorWebSocketCommonProtocol.recvs*<  # # /: $-- A%7;yy7N7N7P '9 $ 0ll')@)@A ' 7 7 ,0( &**,,##**,,,-$-- A%2--'')  # # /  $ $ / / 5'+D $5 ,0(-sDAE1D9D7D9 AE E E,A E7D99 EEc# UR5IShvN URb7[R"UR5IShvN URbM7[ U[ [ [[45(a([U5up#URSX#5IShvN g[ U[5(a [S5e[ U[5(a[U5n[U5n[U5up#UR"R%5UlURSX#5IShvN UH?n[U5upcXb:wa [S5eURS[&U5IShvN MA URS[&S5IShvN URR3S5 SUlg[ U[45(Ga#[7[8[4[:/[<[:4[?U5R@5"U5n[7[8[<[:/[B[:4[?U5RD5"U5IShvN n[U5up#UR"R%5UlURSX#5IShvN UShvN n[U5upcXb:wa [S5eURS[&U5IShvN MG[S5eGNGNGNk![ a gf=fGNGNGN![([R*4a! UR-[.R05 ef=f!URR3S5 SUlf=fGN'![Fa gf=fNNN URS[&S5IShvN O>![([R*4a! UR-[.R05 ef=fURR3S5 SUlg!URR3S5 SUlf=f7f)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 or an asynchronous 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 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`.) Canceling :meth:`send` is discouraged. Instead, you should close the connection with :meth:`close`. Indeed, there are only two situations where :meth:`send` may yield control to the event loop and then get canceled; in both cases, :meth:`close` has the same effect and is more clear: 1. The write buffer is full. If you don't want to wait until enough data is sent, your only alternative is to close the connection. :meth:`close` will likely time out then abort the TCP connection. 2. ``message`` is an asynchronous iterator that yields control. Stopping in the middle of a fragmented message will cause a protocol error and the connection will be closed. 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. TypeError: If ``message`` doesn't have a supported type. NTzdata is a dict-like objectFz data contains inconsistent typesrrz)data must be str, bytes-like, or iterable)$rrjrJshield isinstancer1bytes bytearray memoryviewr* write_framer TypeErrorriternext StopIterationrArcr ExceptionCancelledErrorfail_connectionrINTERNAL_ERRORrrr r r$rtyperr __anext__StopAsyncIteration)rnropcodedata iter_messagefragmentconfirm_opcode aiter_messages rosendWebSocketCommonProtocol.send4sl   --9..!@!@A A A--9 gUIzB C C'0LF""46 6 6 ) )89 9 * *=L  -(1LF.2ii.E.E.GD + 7&&uf;;;!-H+7+A(N%/'(JKK**5'4@@@ !-&&tWc::://::4@26/ / /!-12M(4KKLW ''M "&mH56 (8KKL'11" "!! (1LF.2ii.E.E.GD + 7&&uf;;;'4A(+7+A(N%/'(JKK**5'4@@@ GH HI ! B 7!  <A;w556 $$Y%=%=>  //::4@26/!&  <AA '4&&tWc:::w556 $$Y%=%=>  ;//::4@26///::4@26/svQL 4Q L QAQ&L'AQ- L8,Q%L-:L$;AL-;L'<"L-L*L-$A>Q#AN+N,N0,QO 2N%3O 9N+=N'>N+8O 9N):O QQQ L!Q L!!Q$L-'L-*L--;M((M++$NQN N"Q!N""Q%O 'N+)O +O O O P/ ;PP/ #Q/$QQrc# [UR5IShvN UR[X55IShvN SSS5IShvN [UR5IShvN URIShvN SSS5IShvN [R"UR5IShvN gNNNt!,IShvN (df  N=f![R a UR 5 Nf=fNNN{!,IShvN (df  N=f![R [R4a Nf=fN7f)a Perform the closing handshake. :meth:`close` waits for the other end to complete the handshake and for the TCP connection to terminate. As a consequence, there's no need to await :meth:`wait_closed` after :meth:`close`. :meth:`close` is idempotent: it doesn't do anything once the connection is closed. Wrapping :func:`close` in :func:`~asyncio.create_task` is safe, given that errors during connection termination aren't particularly useful. Canceling :meth:`close` is discouraged. If it takes too long, you can set a shorter ``close_timeout``. If you don't want to wait, let the Python process exit, then the OS will take care of closing the TCP connection. Args: code: WebSocket close code. reason: WebSocket close reason. N) rr8write_close_framerrJ TimeoutErrorrrrrr)rnrrs rocloseWebSocketCommonProtocol.closes8 #&t'9'9::,,U4-@AAA;: 't'9'9::----;: nnT778881;A;:::## #  "  # ;-;:::$$g&<&<=    9sEC CC CCC C CC D*.D /D*2DD D D*DD*#E:E;EC CC C C CC EC $DEDE D* DD*D'D  D'#D*&E'D**$EEEEc`# [R"UR5IShvN gN7f)a  Wait until the connection is closed. This coroutine is identical to the :attr:`closed` attribute, except it can be awaited. This can make it easier to detect connection termination, regardless of its cause, in tasks that interact with the WebSocket connection. N)rJrrdrs ro wait_closed#WebSocketCommonProtocol.wait_closedsnnT88999s $.,.c # UR5IShvN Ub [U5nXR;a [S5eUbXR;aA[R "S[ R"S55nUcM0XR;aMAURR5n[R"5nX#4URU'URS[U5IShvN [R"U5$NN7f)a Send a Ping_. .. _Ping: https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.2 A ping may serve as a keepalive, as a check that the remote endpoint received all messages up to this point, or to measure :attr:`latency`. Canceling :meth:`ping` is discouraged. If :meth:`ping` doesn't return immediately, it means the write buffer is full. If you don't want to wait, you should close the connection. Canceling the :class:`~asyncio.Future` returned by :meth:`ping` has no effect. Args: data: Payload of the ping. A string will be encoded to UTF-8. If ``data`` is :obj:`None`, the payload is four random bytes. Returns: A future that will be completed when the corresponding pong is received. You can ignore it if you don't intend to wait. The result of the future is the latency of the connection in seconds. :: pong_waiter = await ws.ping() # only if you want to wait for the corresponding pong latency = await pong_waiter Raises: ConnectionClosed: When the connection is closed. RuntimeError: If another ping was sent with the same data and the corresponding pong wasn't received yet. Nz-already waiting for a pong with the same dataz!Ir4T)rr)rkrstructpackrandom getrandbitsrArctime perf_counterrrrJr)rnr pong_waiterping_timestamps ropingWebSocketCommonProtocol.pingsJ    %D :: NO Oldjj0;;tV%7%7%;5 SnAgSnAff=f7f)zy Read incoming messages and put them in a queue. This coroutine runs in a task until the closing handshake is started. TNzdata transfer failedexc_info) read_messager:rrgrArcrirJrappendrhrrrmrrrPROTOCOL_ERRORConnectionErrorrEOFErrorsslSSLErrorrUnicodeDecodeError INVALID_DATArMESSAGE_TOO_BIGrr5errorr)rnrrs ror%WebSocketCommonProtocol.transfer_datas= ; $ 1 1 33?>>-dmm,>37993J3J3L0<")..1I1I"JJJ7;D4 dmm,> $$W-++7,,77=/3D,-3K7;D4%% %( "  ;%( "  !9!9 : :xF =&) "  !;!; < <! 9%( "  !7!7 8 8 <%( "  !:!: ; ; ; KK  4t  D%( "  !9!9 : : ;sJ D"DD"J AD"1#DDD*D"AD"D DD""J 6D== J  %E4/J 4'J %GJ  J %G<7J < J  %H3.J 3 J ?J?J J  J c^^^# URURS9IShvN nUcgUR[:XaSnO"UR[:XaSnO [ S5eUR (a`[UR[5(a [S5eU(aURR5$[UR5$/mURmU(a4[R"S5nU"SS 9mTc SUU4S jjnO SUUU4S jjnOTc SU4S jjnO SUU4S jjnU"U5 UR (d_URTS9IShvN nUc [ S5eUR[:wa [ S5eU"U5 UR (dM_U(aSR!T5$SR!T5$GNNx7f)z Read a single message from the connection. Re-assemble data frames if the message is fragmented. Return :obj:`None` when the closing handshake is started. )r9NTFzunexpected opcodez.only compressed outgoing frames use memoryviewzutf-8strict)errorscp>TRTRURUR55 gr)rdecoderfin)framedecoder fragmentss ror4WebSocketCommonProtocol.read_message..append s$$$W^^EJJ %JKrrc>TRTRURUR55 [ T[ 5(deT[ UR5-mgr)rrrrrintr)rrrr9s rorrsI$$W^^EJJ %JK%h4444EJJ/Hrrc<>TRUR5 gr)rr)rrs rorrs$$UZZ0rrc>TRUR5 [T[5(deT[ UR5-mgr)rrrrr)rrr9s rorr"s:$$UZZ0%h4444EJJ/Hrrzincomplete fragmented messagerrr)rr(returnNone)read_data_framer9rrrrrrrrAssertionErrorrrcodecsgetincrementaldecoderrjoin)rnrtextdecoder_factoryrrrr9s @@@ror$WebSocketCommonProtocol.read_messages**DMM*BB = <<7 "D \\Y &D 34 4 99%**j11$%UVV*.5::$$& EE%**4E E%' == $::7CO%X6GLL 0011 00 u ))...AAE}#$CDD||w&#$788 5M ))))))44)))44ACrBs)GGD;GGA G+*GGc# URU5IShvN nUR[:Xai[R"UR 5UlURbSUlURUR UR 5IShvN gUR[:XaCUR[RLa%URUR 5IShvN OOUR[ :XaUR UR";a[$R&"5nSn/nUR"R)5H[unupgUR+U5 UR-5(dUR/X7- 5 XBR :XdMRX7- Ul O [3S5eUHnUR"U M OU$GMGNGNG![a gf=fGN![a N(f=f7f)z Read a single data frame from the connection. Process control frames received before the next data frame. Return :obj:`None` if a close frame is encountered before any data frame. NFz!solicited pong not found in pings) read_framerrrparserr`rarbrrrr]r!rrrrkrritemsrrtrrlr")rnr9rpong_timestampping_idping_idsrrs ror!'WebSocketCommonProtocol.read_data_frame4s//(33E||x'#(++ejj"9??.05D-00%**MMM(::+"ii 333,(::+%)%6%6%8N#G!HBF**BRBRBT>!>+ 0*//11'22>3RS"jj0+9+JDL! CU--PQQ#+ JJw/$,  g3N'4+sHGAH+)GGG2H G1*G.+G1/B1H$5HG G+(H*G++H.G11 G>;H=G>>Hc# [R"URRUR(+UUR S9IShvN nUR (aURR SU5 U$N37f)z+ Read a single frame from the connection. )maskr9r^Nz< %s)r(readrY readexactlyr/r^rTr5)rnr9rs ror*"WebSocketCommonProtocol.read_framessb jj KK # #^^#    :: KK  fe ,  sAB A> 4Bc[U[U5U5nUR(aURRSU5 UR UR RUR URS9 g)Nz> %s)r2r^)r(r rTr5writer}r/r^)rnrrrrs rowrite_frame_sync(WebSocketCommonProtocol.write_frame_syncs[c6&>40 :: KK  fe , NN   rrc# UR5IShvN gN![a, UR5 UR5IShvN gf=f7fr)rrrrrs rodrainWebSocketCommonProtocol.drainsG %++-   %  """$ $ $  %s=AA-A A AAAA_statec# URULa#[SURRS35eURXU5 UR 5IShvN gN7f)Nz#Cannot write to a WebSocket in the z state)r]rnamer8r;)rnrrrr>s ror#WebSocketCommonProtocol.write_framesV ::V #5djjoo5FfM  c40jjlsAA"A A"c# UR[RLa[RUlUR(aUR R S5 XlURbSUlUcUR5nURS[U[RS9IShvN ggN7f)z Write a close frame if and only if the connection state is OPEN. This dedicated coroutine must be used for writing close frames to ensure that at most one close frame is sent on a given connection. = connection is CLOSINGNTr=) r]r!rrrTr5rar`rb serializerr)rnrrs ror)WebSocketCommonProtocol.write_close_frames :: #DJzz !!";<#O*,0)|(""44 "N N N $ OsB3B>5B<6B>ch# URcg[R"UR5IShvN UR(aURRS5 UR 5IShvN nUR be[UR 5IShvN UIShvN SSS5IShvN UR(aURRS5 MNNzNPNHN:!,IShvN (df  NO=f![RaO UR(aURRS5 UR[RS5 gf=f![a g[a URRSSS9 gf=f7f) a Send a Ping frame and wait for a Pong frame at regular intervals. This coroutine exits when the connection terminates and one of the following happens: - :meth:`ping` raises :exc:`ConnectionClosed`, or - :meth:`close_connection` cancels :attr:`keepalive_ping_task`. NTz% sending keepalive pingz% received keepalive pongz&- timed out waiting for keepalive pongzkeepalive ping timeoutzkeepalive ping failedr)r6rJrrTr5rr7rrrrrrrr)rnrs ror&WebSocketCommonProtocol.keepalive_pings\    %  FmmD$6$6777::KK%%&@A$(IIK/ $$0#243D3D#E#E #.-- $F#E  :: KK--.IJ!70$F . $F#E#E#E#//:: KK--.VW,,%444    F KK  5  E FsF2$E=C3AE=:C5;E= D&C7'D*C=0C91C=5 DC;0D1E=5E=7D9C=;D=DD  DDA E:7E=8F29E::E== F/F2 #F/,F2.F//F2c8# [US5(aURIShvN [US5(aURR 5 UR (at[US5(acUR5IShvN (aUR5IShvN gUR(aURRS5 URR5(aUR(aURRS5 URR5 UR5IShvN (aUR5IShvN gUR(aURRS5 UR5IShvN gGN![Ra GNf=fGNPGN5![[4a Nf=fNNNC!UR5IShvN f=f7f)aZ 7.1.1. Close the WebSocket Connection When the opening handshake succeeds, :meth:`connection_open` starts this coroutine in a task. It waits for the data transfer phase to complete then it closes the TCP connection cleanly. When the opening handshake fails, :meth:`fail_connection` does the same. There's no data transfer phase in that case. rNr!- timed out waiting for TCP closezx half-closing TCP connection)hasattrrrJrrcancelr/wait_for_connection_lostclose_transportrTr5r} can_write_eof write_eofOSErrorrrs ror(WebSocketCommonProtocol.close_connections( )t1221111 t233((//1~~'$0D"E"E668882&&( ( (1::KK%%&IJ~~++--::KK%%&EF NN,,.66888&&( ( ( ::KK%%&IJ &&( ( (I2--94 ) .9 )$&&( ( (sHG<F?F<F?A G< G G<H(G)H.A7G<&G G<G6 G<H1G82H7,G<#H6G:7H<F??GG<GG<H G30G<2G33G<8H:H<HHHHcn# URR5(a URR5(agUR(aUR R S5 URR 5 UR5IShvN (agUR(aUR R S5 UR(aUR R S5 URR5 UR5IShvN gNN7f)z Close the TCP connection. Nzx closing TCP connectionrIzx aborting TCP connection) rdrtr}r~rTr5rrLabortrs rorM'WebSocketCommonProtocol.close_transport"s  & & + + - -$..2K2K2M2M  :: KK  8 9 ..0 0 0  :: KK  A B :: KK  9 : ++--- 1 .s%BD5D1BD5+D3,D53D5c# URR5(dW[UR5IShvN [R "UR5IShvN SSS5IShvN URR5$NVN0N"!,IShvN (df  N7=f![R a NPf=f7f)z Wait until the TCP connection is closed or ``self.close_timeout`` elapses. Return :obj:`True` if the connection is closed and :obj:`False` otherwise. N)rdrtrr8rJrrrs rorL0WebSocketCommonProtocol.wait_for_connection_lost?s**//11 *4+=+=>>!..)D)DEEE?>**//11?E?>>>''  s C B3BB3$B$B%B) B34B5B39C B3BB3B0B" B0,B3/C 0B33C C  C  C cUR(aURRSU5 [US5(aURR 5 U[ R :waUR[RLa[X5n[RUlUR(aURRS5 URbeX0l URS[UR!55 [US5(d/UR"R%UR'55Ulgg)a2 7.1.7. Fail the WebSocket Connection This requires: 1. Stopping all processing of incoming data, which means canceling :attr:`transfer_data_task`. The close code will be 1006 unless a close frame was received earlier. 2. Sending a close frame with an appropriate code if the opening handshake succeeded and the other side is likely to process it. 3. Closing the connection. :meth:`close_connection` takes care of this once :attr:`transfer_data_task` exits after being canceled. (The specification describes these steps in the opposite order.) z!! failing connection with code %drrCNTr)rTr5rJrrKrrr]r!rrrr`rar8rrDrArrr)rnrrrs ror'WebSocketCommonProtocol.fail_connectionRs. :: KK  A4 H 4- . .  # # * * , 9-- -$** 2J$'EDJzz !!";< ??* **#O  ! !$%//2C Dt455)-)>)>t?T?T?V)WD &6rrcUR[RLdeUR5nURR 5H&up#UR U5 UR5 M( g)zr Raise ConnectionClosed in pending keepalive pings. They'll never receive a pong once the connection is closed. N)r]r!rrrkvalues set_exceptionrK)rnrr_ping_timestamps ro abort_pings#WebSocketCommonProtocol.abort_pingss_zzU\\)))((*,0JJ,=,=,? (K  % %c *    -@rrc[[RU5nURUR5 XlUR RU5 g)a Configure write buffer limits. The high-water limit is defined by ``self.write_limit``. The low-water limit currently defaults to ``self.write_limit // 4`` in :meth:`~asyncio.WriteTransport.set_write_buffer_limits`, which should be all right for reasonable use cases of this library. This is the earliest point where we can get hold of the transport, which means it's the best point for configuring it. N)r rJ Transportset_write_buffer_limitsr<r}rY set_transportrs roconnection_made'WebSocketCommonProtocol.connection_madesC**I6 ))$*:*:;" !!),rrc4[RUlUR(aURRS5 UR 5 UR RS5 URb9UcURR5 OURRU5 UR(dgURnUcgSUl UR5(agUcURS5 gURU5 g)z- 7.1.4. The WebSocket Connection is Closed. z= connection is CLOSEDN)r!rr]rTr5r]rdrrYfeed_eofr[rZr[rt)rnrrxs roconnection_lost'WebSocketCommonProtocol.connection_losts \\ :: KK  6 7  ##..t4 {{&;KK((*KK--c2<<''F~!%D {{}}{!!$'$$S)rrc8UR(aeSUlg)NT)rZrs ro pause_writing%WebSocketCommonProtocol.pause_writings<< rrcUR(deSUlURnUb/SUlUR5(dURS5 ggg)NF)rZr[rtrrws roresume_writing&WebSocketCommonProtocol.resume_writingsQ||| ##  !%D ;;==!!$'! rrc:URRU5 gr)rY feed_datars ro data_received%WebSocketCommonProtocol.data_receiveds d#rrc8URR5 g)ar Close the transport after receiving EOF. The WebSocket protocol has its own closing handshake: endpoints close the TCP or TLS connection after sending and receiving a close frame. As a consequence, they never need to write after receiving EOF, so there's no reason to keep the transport open by returning :obj:`True`. Besides, that doesn't work on TLS connections. N)rYrfrs ro eof_received$WebSocketCommonProtocol.eof_receiveds rr)$r[rjrUrZrhrVrirWrr`rbrar8rdrTr^rNrrlr@r5rAr:r9rgr6r7rkr;rYr]r_rmrr}r<)r5zLoggerLike | Noner6 float | Noner7rvr8rvr9 int | Noner:rwr;rr<rr= str | Noner>rwr? bool | Noner@r.rAz asyncio.AbstractEventLoop | NonerBrvrr )rr )rrx)rrw)rry)rr )rr.)rzAsyncIterator[Data])rr#)rz7DataLike | Iterable[DataLike] | AsyncIterable[DataLike]rr )rrrr1rr r)rzDataLike | NonerzAwaitable[float])rr)rr$rr )rr)rz Data | None)r9rwrz Frame | None)r9rwrr()rr.rrrr"rr ) rr.rrrr"r>rrr )rrrzBytesLike | Nonerr )r}zasyncio.BaseTransportrr )rzException | Nonerr )rrrr )8__name__ __module__ __qualname____firstlineno____doc____annotations__r2rpryrrpropertyr=r>r?rrrrrrrrrrNORMAL_CLOSURErrrrrrrrr!r*r8r;r!rrrrrrMrLrrr]rcrgrjrmrqrt__static_attributes__rrror+r+6s_HOD# %)&(%'&*$ $ "!15 $#M7"M7$ M7 # M7 $ M7M7M7M7M7M7M7M7M7 /!M7"#M7$ %M7` # T&   88&88& O O**(("**""L\ZIHZI ZI|,,595959  59n :9+v46. IDD;LI5V=~   %IN   !$ ,5 BE   6:OO"2O O6-F^4)l.:2*..<X<X<X  <X|!(-*%*N($ rrc.[U[[[[45(d [ S5eU(a$[ RSSS:a [S5e/n[U5upEUHnUR[RLaM"URbAU(a[S5nWRU5 OUR R#S5 MpUR%SXE5 M U(aW(a [1S U5egg![&a|nU(a([S 5nXlWRU5 SnAMUR R#S [*R,"U5S R/55 SnAGM$SnAff=f) a Broadcast a message to several WebSocket connections. 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 :func:`broadcast` pushes the message synchronously to all connections even if their write buffers are overflowing. There's no backpressure. If you broadcast messages faster than a connection can handle them, messages will pile up in its write buffer until the connection times out. Keep ``ping_interval`` and ``ping_timeout`` low to prevent excessive memory usage from slow connections. Unlike :meth:`~websockets.legacy.protocol.WebSocketCommonProtocol.send`, :func:`broadcast` doesn't support sending fragmented messages. Indeed, fragmentation is useful for sending large messages without buffering them in memory, while :func:`broadcast` buffers one copy per connection as fast as possible. :func:`broadcast` skips connections that aren't open in order to avoid errors on connections where the closing handshake is in progress. :func:`broadcast` ignores failures to write the message on some connections. It continues writing to other connections. On Python 3.11 and above, you may set ``raise_exceptions`` to :obj:`True` to record failures and raise all exceptions in a :pep:`654` :exc:`ExceptionGroup`. While :func:`broadcast` makes more sense for servers, it works identically with clients, if you have a use case for opening connections to many servers and broadcasting a message to them. Args: websockets: WebSocket connections to which the message will be sent. message: Message to send. raise_exceptions: Whether to raise an exception in case of failures. Raises: TypeError: If ``message`` doesn't have a supported type. zdata must be str or bytes-likeNr ) z.raise_exceptions requires at least Python 3.11zsending a fragmented messagez/skipped broadcast: sending a fragmented messageTzfailed to write messagez.skipped broadcast: failed to write message: %srzskipped broadcast)rr1rrrrsys version_info ValueErrorr*r]r!rrjrrr5warningr8rr tracebackformat_exception_onlystripExceptionGroup) websocketsrraise_exceptions exceptionsrrrEr|write_exceptions ro broadcastrs^d gUIzB C C899   BQ ' )MN N (LF ??%** ,   / / ;()GH !!),  ((E    & &tV : 6J0*==' ()BC &5#!!),,  ((D33ODQGMMO sD F)FAFFzwebsockets.legacy.server)F)rz!Iterable[WebSocketCommonProtocol]rr$rr.rr )A __future__rrJr#rerOrr rrrrrLrGcollections.abcrrrrrtypingr r r r asyncio.compatibilityrdatastructuresrrrrrrrrr^rframesrrrrrrrrrr protocolr!r"r#r$r%r&framingr(r)r*__all__Protocolr+rr{rrrrors"   VV--3$#   GG66 % %Hg..Hh.#X>1X> X>X> X>x2 rr