vKg(SSKrSSKJr SSKJr SSKJr SSKJr SSK r SSK r SSK r SSK r SSK r SSKrSSKJrJrJr SSKrSSKrSSKJrJr SSKJr SSKJr SS KJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r' SSK(r\RRS :aSS K*J+r+ \,"\-"\.\R^RaS 5SS 55S:r1Sr2Sr3Sr4Sr5\ Rl"S5r7Sr8"SS5r9\SS\3\4\2\2S.Sj5r:SS\3\4S.Sjr;S9SS\3\4\2\2S.SjjrSS\3\4S.Sjr?\3\44Sjr@S\3\4\2\2\RS .S!jrB"S"S#\C5rD"S$S%\D5rE"S&S'\D5rF"S(S)\C5rG"S*S+\D5rH"S,S-5rI"S.S/5rJ"S0S15rKS2rL"S3S4\RR5rO"S5S65rP"S7S85rQg):N) OrderedDict)asynccontextmanager)partial) ip_address)ListOptionalUnion)ConnectionType WSConnection)ConnectionState) AcceptConnection BytesMessageCloseConnectionPingPongRejectConnection RejectDataRequest TextMessage) )BaseExceptionGroup.)r<iiztrio-websocketcH[U[R5(aS$U$N isinstancetrio Cancelledexcs T/var/www/highfloat_scraper/venv/lib/python3.13/site-packages/trio_websocket/_impl.py_ignore_cancelr'-sc4>>224;;c.\rSrSrSrSrSrSrSrSr g)_preserve_current_exception1aA context manager which should surround an ``__exit__`` or ``__aexit__`` handler or the contents of a ``finally:`` block. It ensures that any exception that was being handled upon entry is not masked by a `trio.Cancelled` raised within the body of the context manager. https://github.com/python-trio/trio/issues/1559 https://gitter.im/python-trio/general?at=5faf2293d37a1a13d6a582cf _armedcSUlgNFr,selfs r&__init__$_preserve_current_exception.__init__=s  r(cB[R"5SSLUlg)Nr)sysexc_infor-r0s r& __enter__%_preserve_current_exception.__enter__@sllnQ't3 r(cUbUR(dg[(a([RR [ U5nUSL$[ U[5(aURS5nUSL$[ U5nUSL$)NFc@[U[R5(+$rr r$s r&6_preserve_current_exception.__exit__..Js 3PTP^P^@_<_r() r-_TRIO_MULTI_ERRORr" MultiErrorfilterr'r!rsubgroup)r1tyvaluetbfiltered_exceptions r&__exit__$_preserve_current_exception.__exit__Cs =   !%!7!7!N  "T)) 1 2 2!&0_!` "T))"0!6 !T))r(N) __name__ __module__ __qualname____firstlineno____doc__ __slots__r2r7rE__static_attributes__r(r&r*r*1sI4 *r(r*) subprotocols extra_headersmessage_queue_sizemax_message_sizeconnect_timeoutdisconnect_timeoutcZ# [R"5IShvN n [R"U5 [XUX#UUUUS9 IShvN n SSS5 W 7v [R"U 5 U R5IShvN SSS5 SSS5IShvN gNN]!,(df  Na=f![Ra [ Se[ a n [U eSn A ff=fNe!,(df  Ni=f![Ra [Sef=f![R"U 5 W R5IShvN SSS5 f!,(df  f=f![Ra [Sef=f=fN!,IShvN (df  g=f7f)aS Open a WebSocket client connection to a host. This async context manager connects when entering the context manager and disconnects when exiting. It yields a :class:`WebSocketConnection` instance. :param str host: The host to connect to. :param int port: The port to connect to. :param str resource: The resource, i.e. URL path. :param Union[bool, ssl.SSLContext] use_ssl: If this is an SSL context, then use that context. If this is ``True`` then use default SSL context. If this is ``False`` then disable SSL. :param subprotocols: An iterable of strings representing preferred subprotocols. :param list[tuple[bytes,bytes]] extra_headers: A list of 2-tuples containing HTTP header key/value pairs to send with the connection request. Note that headers used by the WebSocket protocol (e.g. ``Sec-WebSocket-Accept``) will be overwritten. :param int message_queue_size: The maximum number of messages that will be buffered in the library's internal message queue. :param int max_message_size: The maximum message size as measured by ``len()``. If a message is received that is larger than this size, then the connection is closed with code 1009 (Message Too Big). :param float connect_timeout: The number of seconds to wait for the connection before timing out. :param float disconnect_timeout: The number of seconds to wait when closing the connection before timing out. :raises HandshakeError: for any networking error, client-side timeout (:exc:`ConnectionTimeout`, :exc:`DisconnectionTimeout`), or server rejection (:exc:`ConnectionRejected`) during handshakes. Nuse_sslrOrPrQrR) r" open_nursery fail_afterconnect_websocket TooSlowErrorConnectionTimeoutOSErrorHandshakeErroracloseDisconnectionTimeout) hostportresourcerWrOrPrQrRrSrT new_nursery connectiones r&open_websocketrgPsPJ  ""k (1#4[L"/'9%5 $77 2 5  5__%78$++---9!#""721    .# - ( a ' (.98$$ 5*4 5 5__%78$++---988$$ 5*4 5%#"""s8F+B'F+FB<B+ B) B+B<D!D5C1 C/ C1D F+!F"F+)B++ B9 5B<8F9B<<$C, C''C,,F/C11 C? ;D>F?DDF!F #E-9E E E E-F  E* &E-)F *E--F F  FF+F(F  F($F+)rOrPrQrRc Z# USLa[R"5n O5USLaSn O-[U[R5(aUn O [ S5e[ R SU cSOSXU5 U c[R"X5IShvN n O[R"XU SS9IShvN n US ;aUn OUS U3n [U [[R5U UXVUUS 9n URU R5 U R R#5IShvN U $NN{N 7f) ae Return an open WebSocket client connection to a host. This function is used to specify a custom nursery to run connection background tasks in. The caller is responsible for closing the connection. If you don't need a custom nursery, you should probably use :func:`open_websocket` instead. :param nursery: A Trio nursery to run background tasks in. :param str host: The host to connect to. :param int port: The port to connect to. :param str resource: The resource, i.e. URL path. :param Union[bool, ssl.SSLContext] use_ssl: If this is an SSL context, then use that context. If this is ``True`` then use default SSL context. If this is ``False`` then disable SSL. :param subprotocols: An iterable of strings representing preferred subprotocols. :param list[tuple[bytes,bytes]] extra_headers: A list of 2-tuples containing HTTP header key/value pairs to send with the connection request. Note that headers used by the WebSocket protocol (e.g. ``Sec-WebSocket-Accept``) will be overwritten. :param int message_queue_size: The maximum number of messages that will be buffered in the library's internal message queue. :param int max_message_size: The maximum message size as measured by ``len()``. If a message is received that is larger than this size, then the connection is closed with code 1009 (Message Too Big). :rtype: WebSocketConnection TFNz1`use_ssl` argument must be bool or ssl.SSLContextzConnecting to ws%s://%s:%d%ss) ssl_contexthttps_compatible)P:rapathclient_subprotocolsclient_extra_headersrQrR)sslcreate_default_contextr! SSLContext TypeErrorloggerdebugr"open_tcp_streamopen_ssl_over_tcp_streamWebSocketConnectionr r CLIENT start_soon _reader_task_open_handshakewait) nurseryrarbrcrWrOrPrQrRrkstream host_headerres r&rZrZs(@$002 E  GS^^ , , KLL LL/!sDB++D7744T#d<< y av& $V^**+  (-) +J z../  $ $ ) ) +++ #8<,s7B D+ D% D++D',A2D+D)D+'D+)D+c :[X5upp[XXX#UUXgS9 $)a  Open a WebSocket client connection to a URL. This async context manager connects when entering the context manager and disconnects when exiting. It yields a :class:`WebSocketConnection` instance. :param str url: A WebSocket URL, i.e. `ws:` or `wss:` URL scheme. :param ssl_context: Optional SSL context used for ``wss:`` URLs. A default SSL context is used for ``wss:`` if this argument is ``None``. :type ssl_context: ssl.SSLContext or None :param subprotocols: An iterable of strings representing preferred subprotocols. :param list[tuple[bytes,bytes]] extra_headers: A list of 2-tuples containing HTTP header key/value pairs to send with the connection request. Note that headers used by the WebSocket protocol (e.g. ``Sec-WebSocket-Accept``) will be overwritten. :param int message_queue_size: The maximum number of messages that will be buffered in the library's internal message queue. :param int max_message_size: The maximum message size as measured by ``len()``. If a message is received that is larger than this size, then the connection is closed with code 1009 (Message Too Big). :param float connect_timeout: The number of seconds to wait for the connection before timing out. :param float disconnect_timeout: The number of seconds to wait when closing the connection before timing out. :raises HandshakeError: for any networking error, client-side timeout (:exc:`ConnectionTimeout`, :exc:`DisconnectionTimeout`), or server rejection (:exc:`ConnectionRejected`) during handshakes. )rWrOrPrQrRrSrT) _url_to_hostrg) urlrkrOrPrQrRrSrTrarbrcs r&open_websocket_urlrs3D)5S(F%D $h!-)'  PPr(c T# [X5upxp[XXX#XEUS9 IShvN $N7f)a Return an open WebSocket client connection to a URL. This function is used to specify a custom nursery to run connection background tasks in. The caller is responsible for closing the connection. If you don't need a custom nursery, you should probably use :func:`open_websocket_url` instead. :param nursery: A nursery to run background tasks in. :param str url: A WebSocket URL. :param ssl_context: Optional SSL context used for ``wss:`` URLs. :type ssl_context: ssl.SSLContext or None :param subprotocols: An iterable of strings representing preferred subprotocols. :param list[tuple[bytes,bytes]] extra_headers: A list of 2-tuples containing HTTP header key/value pairs to send with the connection request. Note that headers used by the WebSocket protocol (e.g. ``Sec-WebSocket-Accept``) will be overwritten. :param int message_queue_size: The maximum number of messages that will be buffered in the library's internal message queue. :param int max_message_size: The maximum message size as measured by ``len()``. If a message is received that is larger than this size, then the connection is closed with code 1009 (Message Too Big). :rtype: WebSocketConnection rVN)rrZ) rrrkrOrPrQrRrarbrcs r&connect_websocket_urlrs::)5S(F%D"7$#)+ ++ +s (&(c[U5n[RRU5nURS;a [ S5eUcURS:HnOURS:Xa [ S5eUR nURb URnO U(aSOSnURnU(dSnS U;aUS UR-- nX4XQ4$) at Convert a WebSocket URL to a (host,port,resource) tuple. The returned ``ssl_context`` is either the same object that was passed in, or if ``ssl_context`` is None, then a bool indicating if a default SSL context needs to be created. :param str url: A WebSocket URL. :type ssl_context: ssl.SSLContext or None :returns: A tuple of ``(host, port, resource, ssl_context)``. )wswssz,WebSocket URL scheme must be "ws:" or "wss:"rrz+SSL context must be None for ws: URL schemernrm/?) strurllibparseurlsplitscheme ValueErrorhostnamerbrqquery)rrkpartsrarbpath_qss r&rrs c(C LL ! !# &E ||=(GHHlle+  FGG >>D zzzz!srjjG  cz3$$ w ++r(c # [U[[R5X#XEUUS9nUR UR 5 UR R5IShvN U$N7f)a Wrap an arbitrary stream in a WebSocket connection. This is a low-level function only needed in rare cases. In most cases, you should use :func:`open_websocket` or :func:`open_websocket_url`. :param nursery: A Trio nursery to run background tasks in. :param stream: A Trio stream to be wrapped. :type stream: trio.abc.Stream :param str host: A host string that will be sent in the ``Host:`` header. :param str resource: A resource string, i.e. the path component to be accessed on the server. :param subprotocols: An iterable of strings representing preferred subprotocols. :param list[tuple[bytes,bytes]] extra_headers: A list of 2-tuples containing HTTP header key/value pairs to send with the connection request. Note that headers used by the WebSocket protocol (e.g. ``Sec-WebSocket-Accept``) will be overwritten. :param int message_queue_size: The maximum number of messages that will be buffered in the library's internal message queue. :param int max_message_size: The maximum message size as measured by ``len()``. If a message is received that is larger than this size, then the connection is closed with code 1009 (Message Too Big). :rtype: WebSocketConnection rpN)r|r r r}r~rrr) rrrarcrOrPrQrRres r&wrap_client_streamr=sf8%V^**+ (-) +J  z../  $ $ ) ) +++ ,sAA) A'!A)c# [U[[R5UUS9nUR UR 5 UR 5IShvN nU$N7f)a Wrap an arbitrary stream in a server-side WebSocket. This is a low-level function only needed in rare cases. In most cases, you should use :func:`serve_websocket`. :param nursery: A nursery to run background tasks in. :param stream: A stream to be wrapped. :param int message_queue_size: The maximum number of messages that will be buffered in the library's internal message queue. :param int max_message_size: The maximum message size as measured by ``len()``. If a message is received that is larger than this size, then the connection is closed with code 1009 (Message Too Big). :type stream: trio.abc.Stream :rtype: WebSocketRequest rQrRN)r|r r SERVERr~r _get_request)rrrQrRrerequests r&wrap_server_streamrdsX$%V^**+-)+J z../++--G N.sAAAA)handler_nurseryrQrRrSrT task_statusc # Uc[[RX!S9n O[[RUX1SS9n U "5IShvN n [ X XEXgUS9n U R U S9IShvN gN(N7f)u" Serve a WebSocket over TCP. This function supports the Trio nursery start protocol: ``server = await nursery.start(serve_websocket, …)``. It will block until the server is accepting connections and then return a :class:`WebSocketServer` object. Note that if ``host`` is ``None`` and ``port`` is zero, then you may get multiple listeners that have *different port numbers!* :param handler: An async function that is invoked with a request for each new connection. :param host: The host interface to bind. This can be an address of an interface, a name that resolves to an interface address (e.g. ``localhost``), or a wildcard address like ``0.0.0.0`` for IPv4 or ``::`` for IPv6. If ``None``, then all local interfaces are bound. :type host: str, bytes, or None :param int port: The port to bind to. :param ssl_context: The SSL context to use for encrypted connections, or ``None`` for unencrypted connection. :type ssl_context: ssl.SSLContext or None :param handler_nursery: An optional nursery to spawn handlers and background tasks in. If not specified, a new nursery will be created internally. :param int message_queue_size: The maximum number of messages that will be buffered in the library's internal message queue. :param int max_message_size: The maximum message size as measured by ``len()``. If a message is received that is larger than this size, then the connection is closed with code 1009 (Message Too Big). :param float connect_timeout: The number of seconds to wait for a client to finish connection handshake before timing out. :param float disconnect_timeout: The number of seconds to wait for a client to finish the closing handshake before timing out. :param task_status: Part of Trio nursery start protocol. :returns: This function runs until cancelled. N)raT)rarlrrQrRrSrTr)rr"open_tcp_listenersopen_ssl_over_tcp_listenersWebSocketServerrun) handlerrarbrkrrQrRrSrTrr listenersservers r&serve_websocketrs{N$T%<%[TU]5 Xlgz8 Constructor. :param reason: :type reason: CloseReason N)superr2reason)r1r __class__s r&r2ConnectionClosed.__init__s  r(cNURRSURS3$)Return representation. <>)rrGrr0s r&__repr__ConnectionClosed.__repr__s$..))*!DKK=::r()r rGrHrIrJrKr2rrM __classcell__rs@r&rrs;;r(rc2^\rSrSrSrU4SjrSrSrU=r$)ConnectionRejectedize A WebSocket connection could not be established because the server rejected the connection attempt. cF>[TU]5 XlX lX0lgr)rr2 status_codeheadersbody)r1rrrrs r&r2ConnectionRejected.__init__s  &  r(cNURRSURS3$)rz Ar)rGrHrIrJrKr2rrrqrrr rrrMrNr(r&rr2s ))""//&&''+/d :>DIIr(rcfSup#[U[R5(a URnO7[U[R5(aUR RnSnU(a7U(aUR 5OUR5tpEn[XEU5nU$[U5nU$)a Construct an endpoint from a stream. :param trio.Stream stream: :param bool local: If true, return local endpoint. Otherwise return remote. :returns: An endpoint instance or ``repr()`` for streams that cannot be represented as an endpoint. :rtype: Endpoint or str r/T) r!r" SocketStreamsocket SSLStreamtransport_stream getsockname getpeernameEndpointrepr)rrris_ssladdrrb_endpoints r&_get_stream_endpointr#s!NF&$++,, FDNN + +((// 16++-F"5Ul [ R>"5Ul![ R>"5Ul"g)a Constructor. Generally speaking, users are discouraged from directly instantiating a ``WebSocketConnection`` and should instead use one of the convenience functions in this module, e.g. ``open_websocket()`` or ``serve_websocket()``. This class has some tricky internal logic and timing that depends on whether it is an instance of a client connection or a server connection. The convenience functions handle this complexity for you. :param SocketStream stream: :param ws_connection wsproto.WSConnection: :param str host: The hostname to send in the HTTP request headers. Only used for client connections. :param str path: The URL path for this connection. :param list client_subprotocols: A list of desired subprotocols. Only used for client connections. :param list[tuple[bytes,bytes]] client_extra_headers: Extra headers to send with the connection request. Only used for client connections. :param int message_queue_size: The maximum number of messages that will be buffered in the library's internal message queue. :param int max_message_size: The maximum message size as measured by ``len()``. If a message is received that is larger than this size, then the connection is closed with code 1009 (Message Too Big). NrT)rarrOrPr()# _close_reasonnextr CONNECTION_ID_id_streamr"StrictFIFOLock _stream_lock_wsproto _message_size_message_parts_max_message_size_reader_runningclientr_initial_request_path _subprotocolr_handshake_headers_reject_status_reject_headers _reject_bodyopen_memory_channel _send_channel _recv_channelr_pingsr_connection_proposalrr_close_handshake#_for_testing_peer_closed_connection) r1r ws_connectionrarqrrrsrQrRs r&r2WebSocketConnection.__init__sB59445  //1% 79!1#   7>D028b8:D !%)D ! +/"''$w151I1I 2 .D.!m %+H! $zz|!% 48::<0r(cUR$)zq (Read-only) The reason why the connection was or is being closed, else ``None``. :rtype: Optional[CloseReason] )r&r0s r&closedWebSocketConnection.closeds!!!r(c.URR$)z'(Read-only) Is this a client instance? r-r2r0s r& is_clientWebSocketConnection.is_clients}}###r(c8URR(+$)z'(Read-only) Is this a server instance? rGr0s r& is_serverWebSocketConnection.is_servers==''''r(c*[URSS9$)z@ The local endpoint of the connection. :rtype: Endpoint or str Trr#r*r0s r&rWebSocketConnection.local s$DLL==r(c*[URSS9$)zA The remote endpoint of the connection. :rtype: Endpoint or str FrNrOr0s r&r WebSocketConnection.remotes$DLL>>r(cUR$)z The requested URL path. For clients, this is set when the connection is instantiated. For servers, it is set after the handshake completes. :rtype: str )r4r0s r&rqWebSocketConnection.pathszzr(cUR$)z (Read-only) The negotiated subprotocol, or ``None`` if there is no subprotocol. This is only valid after the opening handshake is complete. :rtype: str or None )r5r0s r&r WebSocketConnection.subprotocol%s   r(cUR$)z The HTTP headers that were sent by the remote during the handshake, stored as 2-tuples containing key/value pairs. Header keys are always lower case. :rtype: tuple[tuple[str,str]] )r6r0s r&handshake_headers%WebSocketConnection.handshake_headers1s&&&r(c# [5 URX5IShvN SSS5 gN !,(df  g=f7f)a Close the WebSocket connection. This sends a closing frame and suspends until the connection is closed. After calling this method, any further I/O on this WebSocket (such as ``get_message()`` or ``send_message()``) will raise ``ConnectionClosed``. This method is idempotent: it may be called multiple times on the same connection without any errors. :param int code: A 4-digit code number indicating the type of closure. :param str reason: An optional string describing the closure. N)r*_aclosers r&r_WebSocketConnection.aclose<s2) *,,t, , ,+ * ,+ *s$ A202 A2 AAc# UR(agURR[R:Xa2[ SS5UlUR [XS95IShvN ORURR[R[R4;aURR5 URR5IShvN URR5IShvN UR!5IShvN gNNAN!![a N+f=fN!UR!5IShvN f=f7f)Nrrr)r&r-stater OPENr_sendr CONNECTING REJECTINGr?rr<r_rr _close_streamrs r&r[WebSocketConnection._acloseNs     '}}""o&:&::&1t%<"jjd!JKKK$$)C)C#--)//%%))+$$++- - -'',,. . .$$& & &L . .    '$$$& & &sEAD%*D+A4D%D! !D%D#D%ED5ED%!D%#D%% D2/D71D22D75E7E E EEc# URR5IShvN nU$N![R[R4a [ UR 5Sef=f7f)aC Receive the next WebSocket message. If no message is available immediately, then this function blocks until a message is ready. If the remote endpoint closes the connection, then the caller can still get messages sent prior to closing. Once all pending messages have been retrieved, additional calls to this method will raise ``ConnectionClosed``. If the local endpoint closes the connection, then pending messages are discarded and calls to this method will immediately raise ``ConnectionClosed``. :rtype: str or bytes :raises ConnectionClosed: if the connection is closed. N)r<receiver"ClosedResourceError EndOfChannelrr&)r1messages r& get_messageWebSocketConnection.get_messagehsb" A ..6688G9(($*;*;< A"4#5#56D @ As%A(*(*A(*;A%%A(c# UR(a[UR5eXR;a[SUS35eUc+[R "S[ R"S55n[R"5nX RU'UR[US95IShvN UR5IShvN gNN7f)a Send WebSocket ping to remote endpoint and wait for a correspoding pong. Each in-flight ping must include a unique payload. This function sends the ping and then waits for a corresponding pong from the remote endpoint. *Note: If the remote endpoint recieves multiple pings, it is allowed to send a single pong. Therefore, the order of calls to ``ping()`` is tracked, and a pong will wake up its corresponding ping as well as all previous in-flight pings.* :param payload: The payload to send. If ``None`` then a random 32-bit payload is created. :type payload: bytes or None :raises ConnectionClosed: if connection is closed. :raises ValueError: if ``payload`` is identical to another in-flight ping. zPayload value z is already in flight.Nz!I payload) r&rr=rstructpackrandom getrandbitsr"rrarr)r1rprs r&pingWebSocketConnection.pings(   "4#5#56 6 kk !~gY6LMN N ?kk$(:(:2(>?G $ Gjjg.///jjl 0s$B1C3C4C C CCc# UR(a[UR5eUR[US95IShvN gN7f)z Send an unsolicted pong. :param payload: The pong's payload. If ``None``, then no payload is sent. :type payload: bytes or None :raises ConnectionClosed: if connection is closed roN)r&rrar)r1rps r&pongWebSocketConnection.pongs8   "4#5#56 6jjg.///sAA A A c # UR(a[UR5e[U[5(a [ US9nO*[U[ 5(a [ US9nO [S5eURU5IShvN gN7f)z Send a WebSocket message. :param message: The message to send. :type message: str or bytes :raises ConnectionClosed: if connection is closed, or being closed datazmessage must be str or bytesN) r&rr!rrbytesrrra)r1rjrs r& send_message WebSocketConnection.send_messagesm   "4#5#56 6 gs # #W-E  ' ' g.E;< <jjsBBB BcNUR(aSOSnUSUR3$)zConnection ID and type. r2r-)rHr))r1type_s r&__str__WebSocketConnection.__str__s$ NN$(($$r(c# X lURUlUR[ URUS95IShvN UR R 5 gN7f)a( Accept the handshake. This method is only applicable to server-side connections. :param wsproto.events.Request request: :param subprotocol: :type subprotocol: str or None :param list[tuple[bytes,bytes]] extra_headers: A list of 2-tuples containing key/value pairs to send as HTTP headers. r N)r5rr4rar rr)r1rr rPs r&rWebSocketConnection._acceptsX(^^ jj)d6G6G')* * *   " *s>A"A  A"c# U(a4URS[[U55RS545 [ X[ U5S9nUR U5IShvN U(a"[US9nUR U5IShvN [SS5Ul URR5 gNYN27f)ad Reject the handshake. :param int status_code: The 3 digit HTTP status code. In order to be RFC-compliant, this must not be 101, and should be an appropriate code in the range 300-599. :param list[tuple[bytes,bytes]] headers: A list of 2-tuples containing key/value pairs to send as HTTP headers. :param bytes body: An optional response body. zContent-lengthascii)rrhas_bodyNr{izRejected WebSocket handshake) appendrlenencoderboolrarrr&r?r)r1rrr reject_conn reject_bodys r&rWebSocketConnection._rejects  NN,c#d)n.C.CG.LM N&;$Z! jj%%% $$/K**[) ) )(/MN !!# & *s$A#C%B?&(CC1CCcz# [RRnURR[ R :Xa,URR[URS95 URcURU5IShvN SUl URR5 gN&7f)z If a stream is closed outside of this class, e.g. due to network conditions or because some other code closed our stream object, then we cannot perform the close handshake. We just need to clean up internal state. )rNF)rrABNORMAL_CLOSUREr-r_r r`sendrrBr&_close_web_socketr1r?r)r1 close_reasons r&_abort_web_socket%WebSocketConnection._abort_web_sockets$//@@ ==  /"6"6 6 MM  L4F4FG H    %((6 6 6$ !!# 7sBB;B9'B;c# SUl[5 URR5IShvN SSS5 gN !,(df  g=f![R a gf=f7f)zClose the TCP connection. FN)r1r*r*r_r"BrokenResourceErrorr0s r&rd!WebSocketConnection._close_streamsX$ ,.ll))+++/.+/.''   sZA. AAAAAA.A A AA.AA+(A.*A++A.c# [X5Ul[UR5n[R SX5 UR R 5IShvN gN7f)z Mark the WebSocket as closed. Close the message channel so that if any tasks are suspended in get_message(), they will wake up with a ConnectionClosed exception. z%s websocket closed %rN)rr&rrxryr;r_)r1rrr%s r&r%WebSocketConnection._close_web_socketsK )6t112 -t9  '')))sAA#A!A#c# UR(d [S5eURc [S5eURR5IShvN nSUlU$N 7f)z Return a proposal for a WebSocket handshake. This method can only be called on server connections and it may only be called one time. :rtype: WebSocketRequest z1This method is only valid for server connections.NzTNo proposal available. Did you call this method multiple times or at the wrong time?)rK RuntimeErrorr>r)r1proposals r&r WebSocketConnection._get_requestsb~~RS S  $ $ , 89 922==??$(!@sAA$A"A$cX# [X5nURRU5 g7f)z Handle a connection request. This method is async even though it never awaits, because the event dispatch requires an async function. :param event: N)rr>r)r1rrs r&_handle_request_event)WebSocketConnection._handle_request_event"s%$D0 !!++H5s(*c# URUl[UR5UlUR R 5 g7f)zQ Handle an AcceptConnection event. :param wsproto.eventsAcceptConnection event: N)r r5rrPr6rrr1rs r&_handle_accept_connection_event3WebSocketConnection._handle_accept_connection_event.s: "--"'(;(;"<   "sAA c# URUl[UR5UlUR (d[ URURSS9eg7f)z1 Handle a RejectConnection event. :param event: Nr)rr7rrr8rrrs r&_handle_reject_connection_event3WebSocketConnection._handle_reject_connection_event8sR $//$U]]3~~$T%8%8$:N:N sAAc# U=RUR- slUR(a)[URUR URS9eg7f)z+ Handle a RejectData event. :param event: rN)r9r| body_finishedrr7r8rs r&_handle_reject_data_event-WebSocketConnection._handle_reject_data_eventDsP UZZ'   $T%8%8$:N:N&&( ( sAAc<# URR[R:Xao[ UR UR =(d S5UlURR5 URUR55IShvN URUR UR =(d S5IShvN URR5 UR(aUR5IShvN ggNNKN 7f)zE Handle a close event. :param wsproto.events.CloseConnection event: N)r-r_r REMOTE_CLOSINGrrrr&r@rraresponserr?rKrdrs r&_handle_close_connection_event2WebSocketConnection._handle_close_connection_eventOs ==  /"@"@ @"-UZZ9M!ND   4 4 8 8 :**U^^-. . .$$UZZ1EFFF !!# >>$$& & &  /F 's7BDD6D D ADDDDDc# U=R[UR5- slURR UR5 URUR :azSUR S3nSUl/Ul[ SU5UlUR[SUS95IShvN URR5IShvN SUl gUR(ae[U[5(aSOS R!UR5nSUl/UlUR"R%U5IShvN ggNNN ![&R([&R*4a gf=f7f) zo Handle a message event. :param event: :type event: wsproto.events.BytesMessage or wsproto.events.TextMessage zExceeded maximum message size: z bytesrir^NFr(ri)r.rr|r/rr0rr&rarr<r_r1message_finishedr!rjoinr;rr"rhr)r1rerrmsgs r&_handle_message_event)WebSocketConnection._handle_message_eventdsN c%**o- ""5::.    6 6 63D4J4J3K6RC!"D "$D !,T3!7D **_$sCD D D$$++- - -#(D  # #$UL993rd))* !"D "$D  ((--c222 $ E -3,,d.F.FG   s[B3F 5E6!F EAF 6E!EE!F F E!!$FF FF c# [RSXR5 URUR 55IShvN gN7f)z Handle a PingReceived event. Wsproto queues a pong frame automatically, so this handler just needs to send it. :param wsproto.events.Ping event: z %s ping %rN)rxryrprarrs r&_handle_ping_event&WebSocketConnection._handle_ping_events2  \47jj)***sAA A A cf# [UR5nURUnUR(agURR S5up1X#:waSOSn[ R SXU5 UR5 X#:XagUR(aMfgg![a gf=f7f)a Handle a PongReceived event. When a pong is received, check if we have any ping requests waiting for this pong response. If the remote endpoint skipped any earlier pings, then we wake up those skipped pings, too. This function is async even though it never awaits, because the other event handlers are async, too, and event dispatch would be more complicated if some handlers were sync. :param event: Nrz [skipped]  z %s pong%s%r)r}rpr=KeyErrorpopitemrxryr)r1rrpkeyskippeds r&_handle_pong_event&WebSocketConnection._handle_pong_events & KK(E kk,,Q/JC'.~m3G LLs ; IIK~ kkk    s.B1B!A5B1B1! B.+B1-B..B1c# [UR[UR[UR [ UR[UR[UR[UR[UR[ UR0 nUR"(a$UR%UR"5IShvN UR*IShvN UR((Ga^UR,R/5H:n[1U5nXn[2R5SUU5 U"U5IShvN M< UR:R=[>5IShvN n[IU5S:XaW[2R5SU5 UR,RJ[LRN:waURG5IShvN Ox[2R5SU[IU55 UR,RJ[LRN:waUR,RQU5 UR((aGM^SSS5IShvN [2R5S U5 gGN![&a SUlGNf=fGNGNT![6a [2R9SUU5 GM[&a SUl GMf=fGNi![@RB[@RD4a URG5IShvN Mf=fGNK![RRTRVaon[2R5SX5 URX(a$UR%URX5IShvN UR[5IShvN SnAGNlSnAff=fGNU!,IShvN (df  GNk=f7f) z@A background task that reads network data and generates events. NFz%s received event: %sz$%s received unknown event type: "%s"rz*%s received zero bytes (connection closed)z%s received %d bytesz%s remote protocol error: %sz%s reader task finished).r rrrrrrrrrrrrrrrrr3rarr1r;r-eventstyperxryrwarningr* receive_some RECEIVE_BYTESr"rrhrrr_r CLOSED receive_datawsproto utilitiesRemoteProtocolError event_hintrd)r1handlersr event_typerr|rs r&r WebSocketConnection._reader_tasks dBB $44 T@@ $)) $)) dBB 66 T// 33     -jj!6!6777%%%&&&!]]113E!%eJ "*"6 %LL!M}}**o.D.DD"44666 3T3t9E==&&/*@*@@3 2248C&&&&%R  .5[8# -',$ -&-#('Mt&((+/4, J00$2J2JK002227 #,,@@3 %CTO>>"&**S^^"<<<"00222 3G&%%%sSB$O 'I9I6I9 O JO ;N2&JJJN2 "K,K-K1A N2LA N2 L;N2 O N/O 6I99J O  JO J!K8N2<K N2KN2K7LLLN2LN2N,=AN'NN'NN'!N2'N,,N2/O 2O 8N; 9 O O c# URRU5nURIShvN [R SU[ U55 UR RU5IShvN SSS5IShvN gNYN![R[R4a0 UR5IShvN [UR5Sef=fN`!,IShvN (df  g=f7f)z Send an event to the remote WebSocket. The reader task and one or more writers might try to send messages at the same time, so this method uses an internal lock to serialize requests to send data. :param wsproto.events.Event event: Nz%s sending %d bytes)r-rr,rxryrr*send_allr"rrhrrr&)r1rr|s r&raWebSocketConnection._sends}}!!%($$$ LL.c$i @ Ell++D111%$$2,,d.F.FG E,,...&t'9'9:D E %$$$st,C?BC?!C%B 2B 3B 7 C?C#C? B  7C CC  C%#C?%C<+C. , C<8C?)r?r&r>r@r6r)r3r0r/r.rr4r=r1r<r9r8r7r;r*r,r5r-)rNr),rGrHrIrJrK itertoolscountr(MESSAGE_QUEUE_SIZEMAX_MESSAGE_SIZEr2rrDrHrKrr rqr rXr_r[rkrurxr~rrrrrdrrrrrrrrrrrrarMrNr(r&r|r|s>#OO%M6: t-)D@L""$$((>>?? ! !''-$'4.> 0 $% #$$,$" *$ 6#  ('*< +:>6@Er(r|c4\rSrSrSrSr\S5rSrSr g)riz"Represents a connection endpoint. c<[U5UlX lX0lgr)raddressrbr)r1rrbrs r&r2Endpoint.__init__s!'*   r(chUR(aSOSnURS:XaUR(a!URS:XaUR(aSnOS[UR5-nURRS:XaUSURU3$US URS U3$) zKReturn a URL representation of a TCP endpoint, e.g. ``ws://127.0.0.1:80``. rrrmrnriroz://z://[])rrbrrversion)r1rport_strs r&r Endpoint.url s++4 IIODKK II HS^+H <<  1 $XSxj9 9dll^1XJ77r(cVSURSURSURS3$)z Return endpoint info as string. zEndpoint(address="z", port=z , is_ssl=))rrbrr0s r&rEndpoint.__repr__s*#DLL>$))Idkk]Z[\\r()rrrbN) rGrHrIrJrKr2rrrrMrNr(r&rrs$- 8 8]r(rcv\rSrSrSrS\\\\S.Sjr\ S5r \ S5r \ RS.S jrS rS rg) riz WebSocket server. The server class handles incoming connections on one or more ``Listener`` objects. For each incoming connection, it creates a ``WebSocketConnection`` instance and starts some background tasks, Nrc[U5S:Xa [S5eXlX0lX lX@lXPlX`lXplg)a Constructor. Note that if ``host`` is ``None`` and ``port`` is zero, then you may get multiple listeners that have _different port numbers!_ See the ``listeners`` property. :param handler: the async function called with a :class:`WebSocketRequest` on each new connection. The call will be made once the HTTP handshake completes, which notably implies that the connection's `path` property will be valid. :param listeners: The WebSocket will be served on each of the listeners. :param handler_nursery: An optional nursery to spawn connection tasks inside of. If ``None``, then a new nursery will be created internally. :param float connect_timeout: The number of seconds to wait for a client to finish connection handshake before timing out. :param float disconnect_timeout: The number of seconds to wait for a client to finish the closing handshake before timing out. rz)Listeners must contain at least one item.N) rr_handler_handler_nursery _listeners_message_queue_sizer0_connect_timeout_disconnect_timeout)r1rrrrQrRrSrTs r&r2WebSocketServer.__init__%sD0 y>Q HI I /##5 !1 /#5 r(c[UR5S:a [S5eURSnUR$![ a [S[ U535Sef=f)aoReturns the requested or kernel-assigned port number. In the case of kernel-assigned port (requested with port=0 in the constructor), the assigned port will be reflected after calling starting the `listen` task. (Technically, once listen reaches the "started" state.) This property only works if you have a single listener, and that listener must be socket-based. rz>Cannot get port because this server has more than 1 listeners.rz"This socket does not have a port: N)rrrrrbAttributeErrorr)r1listeners r&rbWebSocketServer.portGsq t ! # *+ +>>!$ `==  `!CDNCSTU[_ _ `s A#A$c/nURHnSup4[U[R5(a URnO7[U[R 5(aUR RnSnU(a4UR5nUR[USUSU55 MUR[U55 M U$)z Return a list of listener metadata. Each TCP listener is represented as an ``Endpoint`` instance. Other listener types are represented by their ``repr()``. :returns: Listeners :rtype list[Endpoint or str]: r/Trr) rr!r"SocketListenerr SSLListenertransport_listenerrrrr)r1rrrrsocknames r&rWebSocketServer.listeners\s H(NF(D$7$788!Hd&6&677!44;;!--/  (1+x{F!KL  h0(r(rc D# [R"5IShvN n[[RURUR UR S9nURU5IShvN [RSSRURVs/sHn[U5PM sn55 URU5 [R"5IShvN SSS5IShvN gNNs snfNN!,IShvN (df  g=f7f)uw Start serving incoming connections requests. This method supports the Trio nursery start protocol: ``server = await nursery.start(server.run, …)``. It will block until the server is accepting connections and then return a :class:`WebSocketServer` object. :param task_status: Part of the Trio nursery start protocol. :returns: This method never returns unless cancelled. N)rzListening on %s,)r"rXrserve_listeners_handle_connectionrrstartrxryrrrstarted sleep_forever)r1rrrls r&rWebSocketServer.runus$$&&'%d&:&:'' $ 5 57O--0 0 0 LL*$..9.Q#a&.9: <    %$$& & &'&& 19 &'&&&suD C9D A D-C;.-DC=/4D#D$D( D 3D4D ;D=DD D D DD c 4# [R"5IShvN n[U[[R 5UR URS9nURUR5 [R"UR5nUR5IShvN nSSS5 WR(aDURR5 UR!5IShvN SSS5IShvN gUR#W5IShvN [R"UR$5 UR!5IShvN SSS5 SSS5IShvN gGNYN!,(df  N=fNNNpN9!,(df  N==f![R"UR$5 UR!5IShvN SSS5 f!,(df  f=f=fN!,IShvN (df  g=f7f)z Handle an incoming connection by spawning a connection background task and a handler task inside a new nursery. :param stream: :type stream: trio.abc.Stream Nr)r"rXr|r r rrr0r~r move_on_afterrrcancelled_caught cancel_scopecancelr_rr)r1rrre connect_scopers r&r"WebSocketServer._handle_connections|$$&&',V^223#'#;#;!%!7!79J   z66 7##D$9$9:m * 7 7 99;--$$++-mmo%%'&& .mmG,,,''(@(@A%++---B'&&:;:&'- .BAT''(@(@A%++---BAA'&&&s HE5HA3G>E:'E8(E:,AG>2F 3G>8 HF H F$FF$# G>FFFG>$ H/G<0H8E:: F G> HF$F F! G>$!G9G( G G(  G9( G6 2G99G><H>HH  HH)rrrrrr0r)rGrHrIrJrKrr CONN_TIMEOUTr2rrbrr"TASK_STATUS_IGNOREDrrrMrNr(r&rrs]?C-)<' 6D``(0(,'?'?'*.r(rr)Rr5 collectionsr contextlibr functoolsr ipaddressrrloggingrsrtrq urllib.parsertypingrrr r"trio.abcrr r wsproto.connectionr wsproto.frame_protocolframe_protocolrwsproto.eventsr rrrrrrrrwsproto.utilities version_infoexceptiongrouprrmapint __version__splitr=r rrr getLoggerrxr'r*rgrZrrrrrrr Exceptionr^r\r`rrrrrr#abc AsyncResourcer|rrrNr(r&r&s #*  (( 0.-   g1#c4#3#3#9#9##>r#BCDwN    + ,<**>HL)L;y;(LL2)M)MX4]I]I@0R E$((00R Ej]]:H.H.r(