o ïÅ[hÂðã@sPddlmZddlZddlZddlZddlZddlZddlZddlZddl Z ddl m Z m Z m Z mZmZmZmZmZmZmZmZmZddlmZddlmZddlmZmZmZmZm Z m!Z!ddl"m#Z#dd l$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/dd l m0Z0m1Z1m2Z2d d l3m4Z4d d l5m6Z6ddgZ7Gdd„dej8ƒZ9ddd„Z:dS)é)Ú annotationsN) ÚAnyÚ AsyncIterableÚ AsyncIteratorÚ AwaitableÚDequeÚDictÚIterableÚListÚMappingÚOptionalÚUnionÚcasté)ÚState)ÚHeaders)ÚConnectionClosedÚConnectionClosedErrorÚConnectionClosedOKÚ InvalidStateÚ PayloadTooBigÚ ProtocolError)Ú Extension) ÚOK_CLOSE_CODESÚ OP_BINARYÚOP_CLOSEÚOP_CONTÚOP_PINGÚOP_PONGÚOP_TEXTÚCloseÚOpcodeÚ prepare_ctrlÚ prepare_data)ÚDataÚ LoggerLikeÚ Subprotocolé)Úloop_if_py_lt_38)ÚFrameÚWebSocketCommonProtocolÚ broadcastc@s"eZdZUdZded<dZded<ddddd d d d dddd ddd œd–d%d&„Zd—d'd(„Zd—d)d*„Zd—d+d,„Z e d˜d-d.„ƒZ e d™d/d0„ƒZ e dšd1d2„ƒZ e d›d4d5„ƒZe d›d6d7„ƒZe dœd8d9„ƒZe dœd:d;„ƒZe d™dd?„ƒZddAdB„ZdždDdE„ZdŸdHdI„Zd d¡dNdO„Zd—dPdQ„Zd¢d£dUdV„Zd¤d¥dXdY„Zd¦d[d\„Zd—d]d^„Zd—d_d`„Zd§dadb„Zd¨ddde„Zd©dgdh„Z dªdldm„Z!d—dndo„Z"e#j$dpœd«drds„Z% d¢d¬dwdx„Z&d—dydz„Z'd—d{d|„Z(d—d}d~„Z)dœdd€„Z*d­d¡d‚dƒ„Z+d—d„d…„Z,d®dˆd‰„Z-d¯dŒd„Z.d—dŽd„Z/d—dd‘„Z0d°d’d“„Z1d—d”d•„Z2dS)±r*u" WebSocket connection. :class:`WebSocketCommonProtocol` provides APIs shared between WebSocket servers and clients. You shouldn't use it directly. Instead, use :class:`~websockets.client.WebSocketClientProtocol` or :class:`~websockets.server.WebSocketServerProtocol`. This documentation focuses on low-level details that aren't covered in the documentation of :class:`~websockets.client.WebSocketClientProtocol` and :class:`~websockets.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://www.rfc-editor.org/rfc/rfc6455.html#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://www.rfc-editor.org/rfc/rfc6455.html#section-5.5.3 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. See the discussion of :doc:`timeouts <../topics/timeouts>` for details. ``close_timeout`` needs to be a parameter of the protocol because websockets usually calls :meth:`close` implicitly upon exit: * on the client side, when :func:`~websockets.client.connect` is used 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.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 connection; defaults to ``logging.getLogger("websockets.protocol")``; see the :doc:`logging guide <../topics/logging>` for details. ping_interval: delay between keepalive pings in seconds; :obj:`None` to disable keepalive pings. ping_timeout: timeout for keepalive pings in seconds; :obj:`None` to disable 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` to disable the limit. max_queue: maximum number of incoming messages in receive buffer; :obj:`None` to disable the limit. read_limit: high-water mark of read buffer in bytes. write_limit: high-water mark of write buffer in bytes. ÚboolÚ is_clientZ undefinedÚstrÚsideNéié iF)ÚloggerÚ ping_intervalÚ ping_timeoutÚ close_timeoutÚmax_sizeÚ max_queueÚ read_limitÚ write_limitÚhostÚportÚsecureÚ legacy_recvÚloopÚtimeoutr2úOptional[LoggerLike]r3úOptional[float]r4r5r6ú Optional[int]r7r8Úintr9r:ú Optional[str]r;r<úOptional[bool]r=r>ú#Optional[asyncio.AbstractEventLoop]r?ÚreturnÚNonecCs¬| rt dt¡|durd}nt dt¡|dur|}| dur$t ¡} nt dt¡||_||_||_||_||_ ||_ ||_ t   ¡|_ |durNt d¡}ttj|ƒ}t |d|i¡|_ | tj¡|_| |_| |_| |_| |_| |_tj|d| d|_d |_d|_ tj!d it"| ƒ¤Ž|_#t$j%|_&|jrœ|j d ¡| | | g|_'d|_( d|_)d|_*d|_+|  ,¡|_-t. /¡|_0d|_1d|_2d|_3i|_4|d|_5||dS) Nzlegacy_recv is deprecatedé zrename timeout to close_timeoutzremove loop argumentzwebsockets.protocolÚ websocketr)Úlimitr>Fz= connection is CONNECTING©)6ÚwarningsÚwarnÚDeprecationWarningÚasyncioZget_event_loopr3r4r5r6r7r8r9ÚuuidÚuuid4ÚidÚloggingÚ getLoggerrÚLoggerÚ LoggerAdapterr2Ú isEnabledForÚDEBUGÚdebugr>Ú_hostÚ_portÚ_securer=Ú StreamReaderÚreaderÚ_pausedÚ _drain_waiterÚLockr(Ú _drain_lockrÚ CONNECTINGÚstateÚ extensionsZ subprotocolÚ close_rcvdÚ close_sentÚclose_rcvd_then_sentÚ create_futureÚconnection_lost_waiterÚ collectionsÚdequeÚmessagesÚ_pop_message_waiterÚ_put_message_waiterÚ_fragmented_message_waiterÚpingsÚtransfer_data_exc)Úselfr2r3r4r5r6r7r8r9r:r;r<r=r>r?rLrLú/home/ubuntu/experiments/live_experiments/Pythonexperiments/Otree/venv/lib/python3.10/site-packages/websockets/legacy/protocol.pyÚ__init__§sv          z WebSocketCommonProtocol.__init__cÃsV|j ¡r tdƒ‚|jsdS|j}|dus| ¡sJ‚|j ¡}||_|IdHdS)NzConnection lost)rkÚdoneÚConnectionResetErrorr`raZ cancelledr>rj©rtÚwaiterrLrLruÚ _drain_helper.s€  z%WebSocketCommonProtocol._drain_helpercÃsd|jdur|j ¡}|dur|‚|jdur)|j ¡r)tjdit|jƒ¤ŽIdH| ¡IdHdS)Nr)r) r_Ú exceptionÚ transportÚ is_closingrPÚsleepr(r>r{©rtÚexcrLrLruÚ_drain:s€    zWebSocketCommonProtocol._draincCsd|jtjusJ‚tj|_|jr|j d¡|j | ¡¡|_ |j |  ¡¡|_ |j |  ¡¡|_ dS)zŒ Callback when the WebSocket opening handshake completes. Enter the OPEN state and start the data transfer phase. z= connection is OPENN)rerrdÚOPENrZr2r>Ú create_taskÚ transfer_dataÚtransfer_data_taskÚkeepalive_pingÚkeepalive_ping_taskÚclose_connectionÚclose_connection_task©rtrLrLruÚconnection_openJs z'WebSocketCommonProtocol.connection_opencCó(|jrdnd}t d|›dt¡|jS)NÚremote_addressÚ local_addressúuse z[0] instead of host)r-rMrNrOr[©rtÚ alternativerLrLrur:]ózWebSocketCommonProtocol.hostcCr)NrŽrrz[1] instead of port)r-rMrNrOr\r‘rLrLrur;cr“zWebSocketCommonProtocol.portcCst dt¡|jS)Nzdon't use secure)rMrNrOr]r‹rLrLrur<is zWebSocketCommonProtocol.securercCó*z|j}Wn tyYdSw| d¡S)a( 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. NZsockname©r}ÚAttributeErrorZget_extra_info©rtr}rLrLrurpó   ÿ z%WebSocketCommonProtocol.local_addresscCr”)a) 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. NZpeernamer•r—rLrLrurŽ„r˜z&WebSocketCommonProtocol.remote_addresscCs|jtjuo |j ¡ S)a{ :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 )rerrƒr†rwr‹rLrLruÚopen˜s zWebSocketCommonProtocol.opencCs |jtjuS)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. )rerÚCLOSEDr‹rLrLruÚclosed¦s zWebSocketCommonProtocol.closedcCó&|jtjurdS|jdurdS|jjS)zø WebSocket close code, defined in `section 7.1.5 of RFC 6455`_. .. _section 7.1.5 of RFC 6455: https://www.rfc-editor.org/rfc/rfc6455.html#section-7.1.5 :obj:`None` if the connection isn't closed yet. Néî)rerršrgÚcoder‹rLrLruÚ close_code±ó  z"WebSocketCommonProtocol.close_codecCrœ)zú WebSocket close reason, defined in `section 7.1.6 of RFC 6455`_. .. _section 7.1.6 of RFC 6455: https://www.rfc-editor.org/rfc/rfc6455.html#section-7.1.6 :obj:`None` if the connection isn't closed yet. NÚ)rerršrgÚreasonr‹rLrLruÚ close_reasonÃr z$WebSocketCommonProtocol.close_reasonúAsyncIterator[Data]cCs,z | ¡IdHVqtyYdSw)a< Iterate on incoming messages. The iterator exits normally when the connection is closed with the close code 1000 (OK) or 1001(going away). It raises a :exc:`~websockets.exceptions.ConnectionClosedError` exception when the connection is closed with any other code. TN)Úrecvrr‹rLrLruÚ __aiter__Õs€ ÿ ÿz!WebSocketCommonProtocol.__aiter__r$cÃsÈ|jdur tdƒ‚t|jƒdkrO|j ¡}||_ztj||jgfdtj it |jƒ¤ŽIdHWd|_nd|_w|  ¡sH|j rAdS|  ¡IdHt|jƒdks|j ¡}|jdurb|j d¡d|_|S)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.wait_for`. Returns: Data: A string (:class:`str`) for a Text_ frame. A bytestring (:class:`bytes`) for a Binary_ frame. .. _Text: https://www.rfc-editor.org/rfc/rfc6455.html#section-5.6 .. _Binary: https://www.rfc-editor.org/rfc/rfc6455.html#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 messagerZ return_when)roÚ RuntimeErrorÚlenrnr>rjrPÚwaitr†ZFIRST_COMPLETEDr(rwr=Ú ensure_openÚpopleftrpÚ set_result)rtZpop_message_waiterÚmessagerLrLrur¥ås6€ ÿ ÿþýé   zWebSocketCommonProtocol.recvr­ú0Union[Data, Iterable[Data], AsyncIterable[Data]]c Ãs¬| ¡IdH|jdurt |j¡IdH|jdus t|ttttfƒr6t |ƒ\}}|  d||¡IdHdSt|t ƒr?t dƒ‚t|t ƒrÃtt t|ƒ}t|ƒ}zt|ƒ}Wn ty_YdSwt |ƒ\}}t ¡|_zMz3|  d||¡IdH|D]}t |ƒ\}}||kr‰t dƒ‚|  dt|¡IdHqy|  dtd¡IdHWn ty¬| d¡‚wW|j d¡d|_dS|j d¡d|_wt|tƒrRt|ƒ |¡}z t|ƒ |¡IdH}Wn tyæYdSwt |ƒ\}}t ¡|_zUz:|  d||¡IdH|2z 3dHW}t |ƒ\}}||krt dƒ‚|  dt|¡IdHq6|  dtd¡IdHWnty;| d¡‚wW|j d¡d|_dS|j d¡d|_wt dƒ‚) 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://www.rfc-editor.org/rfc/rfc6455.html#section-5.6 .. _Binary: https://www.rfc-editor.org/rfc/rfc6455.html#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://www.rfc-editor.org/rfc/rfc6455.html#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 (Union[Data, Iterable[Data], AsyncIterable[Data]): 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 typesóéóz)data must be str, bytes-like, or iterable)rªrqrPÚshieldÚ isinstancer.ÚbytesÚ bytearrayÚ memoryviewr#Ú write_framer Ú TypeErrorr rr$ÚiterÚnextÚ StopIterationÚFuturerÚ ExceptionÚfail_connectionr¬rÚtyper¦Ú __anext__ÚStopAsyncIteration)rtr­ÚopcodeÚdataZ iter_messageZ message_chunkZconfirm_opcodeZ aiter_messagerLrLruÚsend4s†€7  ÿ     ÿ     üþ  ÿ ÿ ÿ    ü üþ  ÿzWebSocketCommonProtocol.sendéèr¡ržr¢c Ãs¬ztj| t||ƒ¡|jfit|jƒ¤ŽIdHWntjy(| ¡Ynwztj|j |jfit|jƒ¤ŽIdHWn tjtj fyJYnwt  |j ¡IdHdS)ae 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) rPÚwait_forÚwrite_close_framer r5r(r>Ú TimeoutErrorr½r†ÚCancelledErrorr±rŠ)rtržr¢rLrLruÚcloseÔs,€þý ü þýÿzWebSocketCommonProtocol.closecÃst |j¡IdHdS)a9 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)rPr±rkr‹rLrLruÚ wait_closed s€ z#WebSocketCommonProtocol.wait_closedrÂúOptional[Data]úAwaitable[None]cÃsœ| ¡IdH|durt|ƒ}||jvrtdƒ‚|dus"||jvr4t dt d¡¡}|dus"||jvs"|j  ¡|j|<|  dt |¡IdHt   |j|¡S)a Send a Ping_. .. _Ping: https://www.rfc-editor.org/rfc/rfc6455.html#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 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 (Optional[Data]): payload of the ping; a string will be encoded to UTF-8; or :obj:`None` to generate a payload containing four random bytes. Returns: ~asyncio.Future: A future that will be completed when the corresponding pong is received. You can ignore it if you don't intend to wait. :: pong_waiter = await ws.ping() await pong_waiter # only if you want to wait for the pong 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!Ir1T)rªr"rrr§ÚstructÚpackÚrandomÚ getrandbitsr>rjr¶rrPr±©rtrÂrLrLruÚpings€% ÿzWebSocketCommonProtocol.pingr¯cÃs0| ¡IdHt|ƒ}| dt|¡IdHdS)a< Send a Pong_. .. _Pong: https://www.rfc-editor.org/rfc/rfc6455.html#section-5.5.3 An unsolicited pong may serve as a unidirectional heartbeat. Canceling :meth:`pong` is discouraged. If :meth:`pong` doesn't return immediately, it means the write buffer is full. If you don't want to wait, you should close the connection. Args: data (Data): payload of the pong; a string will be encoded to UTF-8. Raises: ConnectionClosed: when the connection is closed. NT)rªr"r¶rrÑrLrLruÚpongRs€zWebSocketCommonProtocol.pongrcCs^|jdur |jjtvr |jdur |jjtvr t|j|j|jƒ}n t|j|j|jƒ}|j|_|S©N) rgržrrhrrirrsÚ __cause__r€rLrLruÚconnection_closed_excns    ýýz-WebSocketCommonProtocol.connection_closed_exccÃsˆ|jtjur|j ¡rt |j¡IdH| ¡‚dS|jtj ur%| ¡‚|jtj ur8t |j¡IdH| ¡‚|jtj us@J‚t dƒ‚)zŠ Check that the WebSocket connection is open. Raise :exc:`~websockets.exceptions.ConnectionClosed` if it isn't. Nz*WebSocket connection isn't established yet) rerrƒr†rwrPr±rŠrÖršÚCLOSINGrdrr‹rLrLrurª…s€    z#WebSocketCommonProtocol.ensure_openc ÃsäzR | ¡IdH}|durWdS|jdur?t|jƒ|jkr?|j ¡|_zt |j¡IdHWd|_nd|_wt|jƒ|jks|j  |¡|j durS|j   d¡d|_ qtj yd}z||_ ‚d}~wty~}z||_ | d¡WYd}~dSd}~wtttfy›}z||_ | d¡WYd}~dSd}~wtyµ}z||_ | d¡WYd}~dSd}~wtyÏ}z||_ | d¡WYd}~dSd}~wtyñ}z|jjddd||_ | d ¡WYd}~dSd}~ww) z‘ Read incoming messages and put them in a queue. This coroutine runs in a task until the closing handshake is started. TNiêriïiñzdata transfer failed©Úexc_infor°)Ú read_messager7r¨rnr>rjrprPr±Úappendror¬rÈrsrr½ÚConnectionErrorrÇÚEOFErrorÚUnicodeDecodeErrorrr¼r2Úerror)rtr­rrLrLrur…§sX€  û   ꀀ€€€€ùz%WebSocketCommonProtocol.transfer_datacƒsF|j|jdIdH}|durdS|jtkrd}n |jtkr!d}ntdƒ‚|jr3|r0|j d¡S|jSg‰|j‰|r[t   d¡}|dd‰ˆdurQd‡‡fd d„ }nd‡‡‡fdd„ }nˆdurgd‡fdd„ }nd‡‡fdd„ }||ƒ|js—|jˆdIdH}|dur‡tdƒ‚|jt krtdƒ‚||ƒ|jrv|ržd  ˆ¡Sd  ˆ¡S)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. )r6NTFzunexpected opcodezutf-8Ústrict)ÚerrorsÚframer)rGrHcsˆ ˆ |j|j¡¡dSrÔ)rÛÚdecoderÂÚfin©râ)ÚchunksÚdecoderrLrurÛsz4WebSocketCommonProtocol.read_message..appendcs6ˆ ˆ |j|j¡¡tˆtƒsJ‚ˆt|jƒ8‰dSrÔ)rÛrãrÂrär²rCr¨rå©rærçr6rLrurÛscsˆ |j¡dSrÔ)rÛrÂrå)rærLrurÛscs,ˆ |j¡tˆtƒs J‚ˆt|jƒ8‰dSrÔ)rÛrÂr²rCr¨rå)rær6rLrurÛ#s zincomplete fragmented messager¡r¯)râr)rGrH) Úread_data_framer6rÁrrrrärÂrãÚcodecsÚgetincrementaldecoderrÚjoin)rtrâÚtextZdecoder_factoryrÛrLrèrurÚìs@€      ú z$WebSocketCommonProtocol.read_messageúOptional[Frame]cÃs. | |¡IdH}|jtkr7t |j¡|_|jdurd|_z|  |j|j¡IdHWdSt y6YdSw|jt krX|j t jurWz | |j¡IdHWnHt yVYn@wn>|jtkr”|j|jvr“d}g}|j ¡D]\}}| |¡| ¡s~| d¡||jkr…nqlJdƒ‚|D]}|j|=qŒn|Sq)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. TNFzping_id is in self.pings)Ú read_framerÁrr ÚparserÂrgrhrirÆrrrerrƒrÓrrrÚitemsrÛrwr¬)rtr6râZping_idZping_idsrÒrLrLruré6sN€    ýý   þý     ÿ €Ïz'WebSocketCommonProtocol.read_data_framer)cÃs<tj|jj|j ||jdIdH}|jr|j d|¡|S)z; Read a single frame from the connection. )Úmaskr6rfNz< %s)r)Úreadr_Z readexactlyr-rfrZr2)rtr6rârLrLrurïss€ üz"WebSocketCommonProtocol.read_framerärÁr³cCs@t|t|ƒ|ƒ}|jr|j d|¡|j|jj|j|jddS)Nz> %s)ròrf)r)r!rZr2Úwriter}r-rf)rträrÁrÂrârLrLruÚwrite_frame_sync‚s ýz(WebSocketCommonProtocol.write_frame_syncc Ãs€z)|j4IdHš| ¡IdHWdƒIdHWdS1IdHs#wYWdSty?| ¡| ¡IdHYdSwrÔ)rcr‚rÜr½rªr‹rLrLruÚdrainŒs€2þ ûzWebSocketCommonProtocol.drain©Ú_staterøcÃs@|j|urtd|jj›dƒ‚| |||¡| ¡IdHdS)Nz#Cannot write to a WebSocket in the z state)rerÚnamerõrö)rträrÁrÂrørLrLrur¶›s€ ÿz#WebSocketCommonProtocol.write_framerÉr úOptional[bytes]cÃsp|jtjur6tj|_|jr|j d¡||_|jdurd|_|dur'|  ¡}|j dt |tjdIdHdSdS)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÷) rerrƒr×rZr2rhrgriÚ serializer¶r)rtrÉrÂrLrLrurƦs€   óz)WebSocketCommonProtocol.write_close_framecÃs |jdurdSzY tj|jfit|jƒ¤ŽIdH|j d¡| ¡IdH}|jduraztj ||jfit|jƒ¤ŽIdH|j d¡Wntj y`|jrV|j d¡|  dd¡YWdSwq tj yj‚t ysYdSty„|jjddd YdSw) 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 pongr°zkeepalive ping timeoutzkeepalive ping failedrØ)r3rPrr(r>r2rZrÒr4rÅrÇr½rÈrr¼rß)rtZ pong_waiterrLrLrur‡ÁsF€ ÿ þ  þ ý  üé  ÿz&WebSocketCommonProtocol.keepalive_pingcÃsPzžt|dƒrz|jIdHWn tjyYnwt|dƒr$|j ¡|jrFt|dƒrF| ¡IdHr=W| ¡IdHdS|j rF|j   d¡|j   ¡r‚|j   ¡sŒ|j rY|j   d¡|j  ¡| ¡IdHroW| ¡IdHdS|j r–|j   d¡W| ¡IdHdSW| ¡IdHdSW| ¡IdHdSW| ¡IdHdS| ¡IdHw)a’ 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. r†Nrˆú!! timed out waiting for TCP closezx half-closing TCP connection)Úhasattrr†rPrÈrˆÚcancelr-Úwait_for_connection_lostÚclose_transportrZr2r}Z can_write_eofr~Ú write_eofr‹rLrLrur‰øs@€ ÿ  í   úññú"z(WebSocketCommonProtocol.close_connectioncÃsˆ|j ¡r |j ¡r dS|jr|j d¡|j ¡| ¡IdHr$dS|jr-|j d¡|jr6|j d¡|j ¡| ¡IdHdS)z, Close the TCP connection. Nzx closing TCP connectionrýzx aborting TCP connection) rkrwr}r~rZr2rÉrÚabortr‹rLrLrur+s€     z'WebSocketCommonProtocol.close_transportcÃsZ|j ¡s(ztjt |j¡|jfit|jƒ¤ŽIdHWn tjy'Ynw|j ¡S)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) rkrwrPrÅr±r5r(r>rÇr‹rLrLrurJs€  þýÿ z0WebSocketCommonProtocol.wait_for_connection_lostrcCsª|jr |j d|¡t|dƒr|j ¡|dkrC|jtjurCt||ƒ}tj |_|jr0|j d¡|j dus7J‚||_ |  dt | ¡¡t|dƒsS|j | ¡¡|_dSdS)a‹ 7.1.7. Fail the WebSocket Connection This requires: 1. Stopping all processing of incoming data, which means cancelling :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 %dr†rrûNTrŠ)rZr2rþr†rÿrerrƒr r×rgrhrõrrür>r„r‰rŠ)rtržr¢rÉrLrLrur½`s      ÿz'WebSocketCommonProtocol.fail_connectioncCs>|jtjusJ‚| ¡}|j ¡D] }| |¡| ¡qdS)zŠ Raise ConnectionClosed in pending keepalive pings. They'll never receive a pong once the connection is closed. N)rerršrÖrrÚvaluesÚ set_exceptionrÿ)rtrrÒrLrLruÚ abort_pingsšs   úz#WebSocketCommonProtocol.abort_pingsr}úasyncio.BaseTransportcCs.ttj|ƒ}| |j¡||_|j |¡dS)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)rrPÚ TransportZset_write_buffer_limitsr9r}r_Z set_transportr—rLrLruÚconnection_made®s  z'WebSocketCommonProtocol.connection_maderúOptional[Exception]cCs¦tj|_|j d¡| ¡|j d¡ |jdur*|dur$|j  ¡n|j  |¡|j s/dS|j }|dur8dSd|_ |  ¡rAdS|durL| d¡dS|  |¡dS)z= 7.1.4. The WebSocket Connection is Closed. z= connection is CLOSEDN)rršrer2rZrrkr¬r_Úfeed_eofrr`rarw)rtrrzrLrLruÚconnection_lostÃs(     z'WebSocketCommonProtocol.connection_lostcCs|jrJ‚d|_dS)NT)r`r‹rLrLruÚ pause_writingês  z%WebSocketCommonProtocol.pause_writingcCsB|jsJ‚d|_|j}|durd|_| ¡s| d¡dSdSdS)NF)r`rarwr¬ryrLrLruÚresume_writingîs ýz&WebSocketCommonProtocol.resume_writingcCs|j |¡dSrÔ)r_Z feed_datarÑrLrLruÚ data_receivedøsz%WebSocketCommonProtocol.data_receivedcCs|j ¡dS)aª 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)r_r r‹rLrLruÚ eof_receivedûs z$WebSocketCommonProtocol.eof_received)r2r@r3rAr4rAr5rAr6rBr7rBr8rCr9rCr:rDr;rBr<rEr=r,r>rFr?rArGrH)rGrH)rGrD)rGrB)rGrE)rGr)rGr,)rGr¤)rGr$)r­r®rGrH)rÄr¡)ržrCr¢r.rGrHrÔ)rÂrËrGrÌ)r¯)rÂr$rGrH)rGr)rGrË)r6rBrGrî)r6rBrGr))rär,rÁrCrÂr³rGrH) rär,rÁrCrÂr³rørCrGrH)rÉr rÂrúrGrH)rr¡)r}rrGrH)rr rGrH)rÂr³rGrH)3Ú__name__Ú __module__Ú __qualname__Ú__doc__Ú__annotations__r/rvr{r‚rŒÚpropertyr:r;r<rrŽr™r›rŸr£r¦r¥rÃrÉrÊrÒrÓrÖrªr…rÚrérïrõrörrƒr¶rÆr‡r‰rrr½rr r r rrrrLrLrLrur*?s’ d ï              O ! 9 8   " E J =  ÿ ÿ  7 3   :   '  Ú websocketsú!Iterable[WebSocketCommonProtocol]r­r$rGrHcCsbt|ttttfƒs tdƒ‚t|ƒ\}}|D]}|jtj urq|j dur't dƒ‚|  d||¡qdS)ar 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://www.rfc-editor.org/rfc/rfc6455.html#section-5.6 .. _Binary: https://www.rfc-editor.org/rfc/rfc6455.html#section-5.6 :func:`broadcast` pushes the message synchronously to all connections even if their write buffers are overflowing. There's no backpressure. :func:`broadcast` skips silently connections that aren't open in order to avoid errors on connections where the closing handshake is in progress. 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 low values for ``ping_interval`` and ``ping_timeout`` to prevent excessive memory usage by slow connections when you use :func:`broadcast`. Unlike :meth:`~websockets.server.WebSocketServerProtocol.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. Args: websockets (Iterable[WebSocketCommonProtocol]): WebSocket connections to which the message will be sent. message (Data): message to send. Raises: RuntimeError: if a connection is busy sending a fragmented message. TypeError: if ``message`` doesn't have a supported type. zdata must be str or bytes-likeNz!busy sending a fragmented messageT) r²r.r³r´rµr·r#rerrƒrqr§rõ)rr­rÁrÂrJrLrLrur+ s&   ù)rrr­r$rGrH);Ú __future__rrPrêrlrTrÏrÍrQrMÚtypingrrrrrrr r r r r rÚ connectionrZdatastructuresrÚ exceptionsrrrrrrrfrÚframesrrrrrrrr r!r"r#r$r%r&Z compatibilityr(Zframingr)Ú__all__ÚProtocolr*r+rLrLrLruÚs@ 8    4  W