,hRddlmZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z m Z mZmZmZddlmZddlmZmZmZmZddlmZmZmZmZddlmZmZm Z m!Z!m"Z"dd l#m$Z$m%Z%dd l&m'Z'm(Z(m)Z)m*Z*m+Z+dd lm,Z,m-Z-m.Z.d d l/m0Z0m1Z1m2Z2m3Z3m4Z4d dl5m6Z6dgZ7GddejTZ8 d ddZ9de9_:y)) annotationsN) AsyncIterable AsyncIterator AwaitableIterableMapping) TracebackType)AnyLiteralcastoverload)ConcurrencyErrorConnectionClosedConnectionClosedOK ProtocolError) DATA_OPCODES BytesLike CloseCodeFrameOpcode)RequestResponse)CLOSEDOPENEventProtocolState)Data LoggerLike Subprotocol) TimeoutErroraiteranextasyncio_timeoutasyncio_timeout_at) Assembler Connectionc6eZdZdZdddddd d/dZed0dZed0d Zed1d Zed2d Z ed3d Z ed4d Z d5dZ d6dZ d7dZed8dZed9dZed:d;dZd:d;dZeddZd:d>dZ d: d?dZd@dAdZdBdZd:dCdZdDdEdZdFdZdGd ZdBd!ZdBd"ZdBd#Zej:ed$ dHd%ZdBd&Z dId'Z!dJd(Z"dKd)Z#dBd*Z$dBd+Z%dBd,Z&dGd-Z'dBd.Z(y)Lr)aC :mod:`asyncio` 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.asyncio.client.ClientConnection` or :class:`~websockets.asyncio.server.ServerConnection`.  i) ping_interval ping_timeout close_timeout max_queue write_limitc||_||_||_||_t |t s||df}||_t |t r|df}||_tj|jjd|i|j_ |jj|_ |jj|_ |jj|_ d|_ d|_ tj |_|d|_d|_i|_d|_ d|_d|_|j"j1|_d|_t7j8|_y)N websocketrF)protocolr.r/r0 isinstanceintr1r2logging LoggerAdapterloggeriddebugrequestresponseasyncioget_running_looploopclose_deadlinefragmented_send_waiter pong_waiterslatencykeepalive_taskrecv_exc create_futureconnection_lost_waiterpaused collectionsdeque drain_waiters)selfr5r.r/r0r1r2s _/var/www/html/Resume-Scraper/venv/lib/python3.12/site-packages/websockets/asyncio/connection.py__init__zConnection.__init__4sk! *(* i %):"D)I" k3 '&-K& '44 MM $    "]]--B"&--"6"6 )]](( (, ()- ),,.  -1DH#OQ  :>/3 =AII  **,  **Y556 6 6  6s!A A'A AA A chK |jd{7#t$rYywxYww)aZ Iterate on incoming messages. The iterator calls :meth:`recv` and yields messages asynchronously 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)recvrrWs rO __aiter__zConnection.__aiter__s6  IIK'''!   s 2#! # /2/2c KywrgrhrNdecodes rOrrzConnection.recvs 8;c Kywrgrhrus rOrrzConnection.recvs ;>rwNc Kywrgrhrus rOrrzConnection.recvs >ArwcXK |jj|d{S7#t$rYnt$r tddt$r}|j 4d{7|j jtj|jd|jdddd{7n#1d{7swYnxYwYd}~nd}~wwxYwtj|jd{7|j j|j w)aq 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. Canceling :meth:`recv` is safe. There's no risk of losing data. The next invocation of :meth:`recv` will return the next message. This makes it possible to enforce a timeout by wrapping :meth:`recv` in :func:`~asyncio.timeout` or :func:`~asyncio.wait_for`. When the message is fragmented, :meth:`recv` waits until all fragments are received, reassembles them, and returns the whole message. Args: 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 coroutines call :meth:`recv` or :meth:`recv_streaming` concurrently. NzRcannot call recv while another coroutine is already running recv or recv_streaming at position ) recv_messagesgetEOFErrorrUnicodeDecodeError send_contextr5failr INVALID_DATAreasonstartr?shieldrI close_excrG)rNrvexcs rOrrzConnection.recvs^ ++//77 77   "< " ((*   ""**zzl- {;      nnT88999mm%%4==8sD*)')D*) CD*CC$A'%C)AB?- C8B;9C?C CC CD*C%D*D&D*cyrgrhrus rOrecv_streamingzConnection.recv_streamingDsKNrQcyrgrhrus rOrzConnection.recv_streamingGsNQrQcyrgrhrus rOrzConnection.recv_streamingJsQTrQcjK |jj|23d{}|7 6y#t$rYnt$r tddt$r}|j 4d{7|j jtj|jd|jdddd{7n#1d{7swYnxYwYd}~nd}~wwxYwtj|jd{7|j j|j w)a Receive the next message frame by frame. This method is designed for receiving fragmented messages. It returns an asynchronous 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`. Canceling :meth:`recv_streaming` before receiving the first frame is safe. Canceling it after receiving one or more frames leaves the iterator in a partially consumed state, making the connection unusable. Instead, you should close the connection with :meth:`close`. 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 coroutines call :meth:`recv` or :meth:`recv_streaming` concurrently. Nz\cannot call recv_streaming while another coroutine is already running recv or recv_streamingr{)r|get_iterr~rrrr5rrrrrr?rrIrrG)rNrvframers rOrzConnection.recv_streamingMs X #11::6B  e  B    "< " ((*   ""**zzl- {;      nnT88999mm%%4==8sD320.0202D3 C'D3C'C"-A0.C"2AC6 C"CC"C CC C"D3"C''%D3 D &D3c&K|j4tj|jd{|j4t|tr|j 4d{|dur*|j j|jn)|j j|jdddd{yt|tre|j 4d{|dur|j j|n|j j|dddd{yt|tr tdt|trt|} t|}|jJ|j"j%|_ t|tr|j 4d{|dur,|j j|jdn+|j j|jddddd{d}nt|trk|j 4d{|dur|j j|dn|j j|ddddd{d}n td|D]}t|trW|rU|j 4d{|j j'|jddddd{jt|trI|sG|j 4d{|j j'|ddddd{td|j 4d{|j j'dddddd{|jj1dd|_yt|t2rt5|} t7|d{}|jJ|j"j%|_ t|tr|durU|j 4d{|j j|jddddd{nT|j 4d{|j j|jddddd{d}nt|tr|durG|j 4d{|j j|ddddd{nF|j 4d{|j j|ddddd{d}n td |23d{}t|trW|rU|j 4d{|j j'|jddddd{pt|trI|sG|j 4d{|j j'|ddddd{td td 77[7#1d{7swYyxYw77#1d{7swYyxYw#t $rYywxYw7)7#1d{7swYxYw77b#1d{7swYsxYw7=7#1d{7swYxYw77#1d{7swYxYw77#1d{7swYxYw#t($rl|j 4d{7|j j+t,j.d dddd{7#1d{7swYxYwwxYw#|jj1dd|_wxYw7#t8$rYywxYw77u#1d{7swY1xYw7t7<#1d{7swYMxYw7%7#1d{7swYxYw77#1d{7swYxYw777p#1d{7swYxYw7]73#1d{7swY xYw6|j 4d{7|j j'dddddd{7n#1d{7swYnxYwnx#t($rl|j 4d{7|j j+t,j.d dddd{7#1d{7swYxYwwxYw|jj1dd|_y#|jj1dd|_wxYww) 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 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 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`.) 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. NFTzdata is a dict-like object)finz"iterable must contain bytes or strz#iterable must contain uniform typesrQzerror in fragmented messagez(async iterable must contain bytes or strz)async iterable must contain uniform typesz4data must be str, bytes, iterable, or async iterable)rCr?rr6strrr5 send_binaryencode send_textrr TypeErrorriternext StopIterationrArHsend_continuation Exceptionrrrl set_resultrr$r%StopAsyncIteration)rNmessagetextchunkschunkrachunkss rOsendzConnection.sends; H))5..! >5=MM--gnn.>?MM++GNN,<=  > > >  +((* 7 74<MM++G4MM--g6  7 7 7 )89 9 *']F V ..6 6*.))*A*A*CD '. 3eS)#002OO5= MM55elln%5P MM33ELLN3N OO "Fy1#002HH4< MM33Eu3E MM55e5G HH #F#$HII$OE!%-&#'#4#4#6WW MM;;ELLNPU;VWWW#E95f#'#4#4#6NN MM;;Eu;MNNN((MNNO ,,.CCMM33CT3BCC++66t<.2+ /GnG #Gn,..6 6*.))*A*A*CD '0 3eS)u}#'#4#4#6QQ MM55elln%5PQQQ$(#4#4#6OO MM33ELLN3NOO!Fy1t|#'#4#4#6FF MM33Eu3EFFF$(#4#4#6HH MM55e5GHH"F#$NOO$+UU%!%-&#'#4#4#6WW MM;;ELLNPU;VWWW#E95f#'#4#4#6NN MM;;Eu;MNNN((STT*RS Sc >  > > > > > 7 7 7 7 7"!  OOOOOHHHHHWWWWWNNNNN CCCCC  ,,.MM&&!005    ++66t<.2+-%  QQQQQOOOOO FFFFFHHHHHUWWWWWNNNNN $+ ,,.CCMM33CT3BCCCCC  ,,.MM&&!005    ++66t<.2+++66t<.2+s /hZ?h$h'[(h+A[ h[)h8[9h<<[#8 h[  ^ \  +^5\#6^9A\)9 ^\&=^\?^,]2 ^=]>+^)]*^-]! ^]%^<]7=^]= ^)]:*^.?h.`5<`2=`5-h/(eae,a  eae,a -e0,a& e'a#(/ea<eb9 ea?ebe"b e b e c/$b4%c/('eb7e,b=? e b: +e6c7e:c e#c$e4 hhh[[ [h h#[5)[, *[51h8 \h\h^ ^ \ \ \  ^&^)\</\2 0\<7 ^^] ] ]  ^^!]4 ']*(]4 / ^:^=^^ ^ ^`0^31`5+_2 `+_.,`2` 8_;9` `` $`//h2`55 a>hahee aa a e#e&a9,a/ -a94 e?ebb b eeb1$b' %b1,e4c/7e:e=c cc eec, c" c, 'ede d9' e2d53e9e ?e e eg*g,e/-g1+f. g'f*(g.g 4f75g <gg*#h*$hhcVK |j4d{|j+|jjtj dn|jj ||dddd{y7h7#1d{7swYyxYw#t$rYywxYww)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. Nzclose during fragmented message)rrCr5rrrl send_closer)rNcoders rOrkzConnection.closeis ((* ; ;..:MM&&!009 MM,,T6: ; ; ; ; ; ; ;    szB)BBBAB0 B;B<BB)BBB B BBB)B B&#B)%B&&B)c^Ktj|jd{y7w)z Wait until the connection is closed. :meth:`wait_closed` waits for the closing handshake to complete and for the TCP connection to terminate. N)r?rrIrWs rO wait_closedzConnection.wait_closeds nnT88999s #-+-cKt|tr t|}n.t|tr|j }n | t d|j 4d{||jvr td|||jvr;tjdtjd}|,||jvr;|jj}||jjf|j|<|j j#||cdddd{S77#1d{7swYyxYww)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: 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. 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 )r6rbytesrrrrrDrstructpackrandom getrandbitsrArHtimer5 send_ping)rNdata pong_waiters rOpingzConnection.pings%< dI &;D c ";;=D  <= =$$&  t(((&'VWW,$$*;*;";{{4););B)?@,$$*;*;";))113K(3DIINN4D&ED  d # MM # #D )       sVAE!D;"E%AD?;D? AD?) E5D=6E=E?EE E EcVKt|tr t|}n,t|tr|j }n t d|j 4d{|jj|dddd{y707#1d{7swYyxYww)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) r6rrrrrrr5 send_pongrNrs rOpongzConnection.pongs dI &;D c ";;=D<= =$$& * * MM # #D ) * * * * * * *sHAB)B B)#B? B) B B)B)B&B B&"B)ct|tsJ|jtvr|jj ||jt jur%|jt|jyy)zx Process one incoming event. This method is overridden in subclasses to handle the handshake. N) r6ropcoderr|putrPONGacknowledge_pingsrr)rNevents rO process_eventzConnection.process_events]%'' <<< '    " "5 ) <<6;; &  " "5#4 5 'rQcp||jvry|jj}d}g}|jjD]M\}\}}|j |||z }|j s|j |||k(sF||_n td|D]}|j|=y)z; Acknowledge pings when receiving a pong. Nz!solicited pong not found in pings) rDrAritemsappenddonerrEAssertionError)rNrpong_timestampping_idping_idsrping_timestamprEs rOrzConnection.acknowledge_pingss t(( ( )6:6G6G6M6M6O F 2G2k> OOG $$~5G##%&&w/$&  F!!DE E  +G!!'* +rQcF|jjtusJ|jj}|jj D]6\}}|j s|j||j8|jjy)z Raise ConnectionClosed in pending pings. They'll never receive a pong once the connection is closed. N) r5r^rrrDvaluesr set_exceptioncancelclear)rNrr_ping_timestamps rO abort_pingszConnection.abort_pingss}}""f,,mm%%,0,=,=,D,D,F ! (K##%))#.     ! !rQcK|jJd} tj|j|z d{|jd{}|jr|j j d|j T t|j 4d{|d{}dddd{|j j d777>767(#1d{7swY8xYw#tj$r|jr|j j d|j4d{7|jjtjddddd{7td#1d{7swYtdxYwwxYw#t$r |j j!d d YywxYww) zT Send a Ping frame and wait for a Pong frame at regular intervals. NgTz% sent keepalive pingz% received keepalive pongz&- timed out waiting for keepalive pongzkeepalive ping timeoutzKsend_context() should wait for connection_lost(), which cancels keepalive()zkeepalive ping failedexc_info)r.r?sleeprr<r:r/r&r#rr5rrrlrrerror)rNrErs rO keepalivezConnection.keepalive#s !!--& FmmD$6$6$@AAA%)IIK/ ::KK%%&=>$$0#243D3D#E88 -8&7G 88  ))*EF/B0 8 '8 8888#// :: KK--.VW#'#4#4#6 MM.. ) 8 8 8 -8  -8  F KK  5  E FsG'&F;CF;C!7F; C>$C#%C>(C).C%/C)3 C>>C'?C>F;!F;#C>%C)'C>)C;/C2 0C;7C>>AF8 E F8+F< F8F F8F4 F!F4 &F88F;;&G$!G'#G$$G'cz|j/|jj|j|_yy)zQ Run :meth:`keepalive` in a task, unless keepalive is disabled. N)r.rA create_taskrrFrWs rOstart_keepalivezConnection.start_keepaliveRs3    )"&))"7"78H"ID  *rQ)expected_statec&Kd}d}d}|jj|ur d|jjrHd}|j:|jJ|j j |jz|_ |j|jd{nHd}|j8|j,|j j |jz|_d}|rV t|j4d{t!j"|j$d{dddd{|rX|j*j-t!j"|j$d{|jj.|y7#t$r9}|jr|jjddd}d}|}Yd}~d}~wwxYw#ttf$rt$r.}|jjddd}d}|}Yd}~ASAS.S+ 'NN$**,&&"N!!-&&.*.))..*:T=O=O*OD'"O  0-d.A.ABFF!..)D)DEEEFF  NN "..!sJG6A"J #F1-F..F12A J>IH?I#I>I?I III>JJJ.F11 G3:/G.)J.G33J6H<#H71J7H<<J?IIII I II+J J J  Jc|jjD]}|r|jj|!|jj rC|j r|j j d |jj~|j r|j j d|jjy#ttf$rYwxYw)zl Send outgoing data. Raises: OSError: When a socket operations fails. zx half-closing TCP connectionzx closing TCP connectionN) r5 data_to_sendrUwrite can_write_eofr<r: write_eofOSError RuntimeErrorrkrs rOrzConnection.send_datasMM..0 +D$$T*>>//1zz ))*IJ002 zz ))*DENN((*% +$\2s>CC/.C/c,|j||_yy)z0 Set recv_exc, if not set yet. N)rG)rNrs rOrzConnection.set_recv_excs == DM !rQcttj|}t|j|j |j d|_|j|j||_ y)N)pauseresume) r r? Transportr(r1 pause_readingresume_readingr|set_write_buffer_limitsr2rU)rNrUs rOconnection_madezConnection.connection_madesY**I6 & ^^))++  * ))4+;+;<"rQc"|jj|jjtusJ|j ||j j |j|j|jj|jjd|jrOd|_ |jD]8}|jr||jd(|j|:yyNF)r5 receive_eofr^rrr|rkrrFrrIrrJrMrr)rNrwaiters rOconnection_lostzConnection.connection_losts !!#}}""f,, #   "     *    & & ( ##..t4 ;;DK,, 2{{}{))$/,,S1  2 rQc.|jrJd|_y)NT)rJrWs rO pause_writingzConnection.pause_writings;; rQc|jsJd|_|jD]$}|jr|jd&yr)rJrMrrrNrs rOresume_writingzConnection.resume_writings?{{ (( (F;;=!!$' (rQcK|jjrtjdd{|jr\|j j }|jj| |d{|jj|yy7m7##|jj|wxYww)Nr) rU is_closingr?rrJrArHrMrremovers rOrzConnection.drains >> $ $ &--" " " ;;YY,,.F    % %f - 2 ""))&1  #""))&1s:3CB#AC<B'B%B'C%B''CCc|jj||jj} |j|jjrD|j8|j,|jj|jz|_ |D]}|j|y#t$rD}|j r|j j dd|j|Yd}~d}~wwxYw)NrTr)r5 receive_dataevents_receivedrrr<r:rrr0rBrArr)rNreventsrrs rO data_receivedzConnection.data_received2s ""4(..0 # NN  == ' ' )!!-&&.*.))..*:T=O=O*OD' &E   u % & #zz !!">!N   c " " #sB>> D :DD c|jj|jj}|j|D]}|j |yrg)r5rrrr)rNrrs rO eof_receivedzConnection.eof_receivedLsQ !!#..0  &E   u % &rQ)r5rr. float | Noner/rr0rr1z*int | None | tuple[int | None, int | None]r2zint | tuple[int, int | None]returnNone)r r )r r)r zSubprotocol | None)r z int | None)r z str | None)r r))rmztype[BaseException] | NonernBaseException | NonerozTracebackType | Noner r )r AsyncIterator[Data])rv Literal[True]r r)rvLiteral[False]r rrg)rv bool | Noner r)rvr r zAsyncIterator[str])rvrr zAsyncIterator[bytes])rvrr r )rz+Data | Iterable[Data] | AsyncIterable[Data]rrr r )i)rr7rrr r )r r )rz Data | Noner zAwaitable[float])rQ)rrr r )rrr r )rrr r )rrr zAsyncIterator[None])rr r r )rUzasyncio.BaseTransportr r )rzException | Noner r ))__name__ __module__ __qualname____doc__rPpropertyrXr\r^r`rcrerirprsr rrrrrkrrrrrrrr contextlibasynccontextmanagerrrrrrrrrrrrrhrQrOr)r)'sC  ')%'&(@B49S S $ S # S $ S >S 2S  S n 9 9 9 9 # #)) ( ( * * 7, 7( 7( 7  7$;; >> AAC9JNN QQ TTB9N!VT<VTVT  VTp>:3j*6 6+<"*-F^J##!%b<b<  b<$b  ")"HJ0*==' ()BC &5 #!!),!!))D33_-'   s,D FA0FFzwebsockets.asyncio.server)F)r%zIterable[Connection]rrr&boolr r ); __future__rr?rKrr8rrrrouuidcollections.abcrrrrrtypesr typingr r r r r(rrrrframesrrrrrhttp11rrr5rrrrrrr r! compatibilityr#r$r%r&r'messagesr(__all__r)r,rrhrQrOr8s"  VV// GF&;;22  .w&!!w&R"#d>%d> d>d> d>P3 rQ