,h_ UddlmZddlZddlmZddlmZmZddlm Z ddl m Z ddl Z ddl Z ddlZddlZddlZddlZddlmZmZmZmZmZmZmZmZmZddlmZddlZddl Z ddl!Z dd l"m#Z#m$Z$dd l%m&Z&ddl'm(Z)dd l*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3ddl4Z"ejjd krdd l6m7Z7erddl8m9Z9ddl:m;Z;ddlZ>m?Z?m@Z@mAZAmBZBeCeDeEedjddddkZGdeHd<eGr e jZJne7ZJdZKdeHd<dZLdeHd<dZMdeHd<dZNdeHd<e jdZPdeHd <ed!ZQed"eR#ZSGd$d%eTZUdMd&ZVGd'd(ZWeddeLeMeNeKeKd) dNd*ZXddeLeMeNd+ dOd-ZY dPddeLeMeKeKeNd. dQd/ZZ dPddeLeMeNd+ dRd0Z[ dSd1Z\ddeLeMeNd+ dTd2Z]eLeMeNf dUd4Z^deLeMeNeKeKe jd5 dVd6Z`Gd7d8eTZaGd9d:eaZbGd;deTZdGd?d@eaZeGdAdBZfegZhdeHdC<GdDdEeeQZiGdFd3Zj dWdGZkGdHd,e jjZnGdIdJZoGdKdLZpy)X) annotationsN) OrderedDict)asynccontextmanagerAbstractAsyncContextManager)partial) ip_address) AnyListNoReturnOptionalUnionTypeVar TYPE_CHECKINGGenericcast)version)ConnectionType WSConnection)ConnectionState) AcceptConnection BytesMessageCloseConnectionPingPongRejectConnection RejectDataRequest TextMessage) )BaseExceptionGroup) TracebackType)Final)AsyncGenerator AwaitableCallableIterable CoroutineSequencetrio.)rr#_IS_TRIO_MULTI_ERROR< CONN_TIMEOUTMESSAGE_QUEUE_SIZEiMAX_MESSAGE_SIZEi RECEIVE_BYTESztrio-websocketloggerTE)boundceZdZdZy)TrioWebsocketInternalErrorzRaised as a fallback when open_websocket is unable to unwind an exceptiongroup into a single preferred exception. This should never happen, if it does then underlying assumptions about the internal code are incorrect. N__name__ __module__ __qualname____doc__V/var/www/html/Resume-Scraper/venv/lib/python3.12/site-packages/trio_websocket/_impl.pyr:r:>rAr:c>t|tjrdS|SN isinstancer* Cancelledexcs rB_ignore_cancelrKEsc4>>24;;rAc<eZdZdZdZddZddZ ddZy) _preserve_current_exceptionaA 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 _armedcd|_yNFrNselfs rB__init__z$_preserve_current_exception.__init__Us  rAc@tjddu|_y)Nr1)sysexc_inforOrRs rB __enter__z%_preserve_current_exception.__enter__XsllnQ't3 rAc| |jsytr(tjj t |}|duSt |tr|jd}|duSt |}|duS)NFc8t|tj SrErFrIs rBz6_preserve_current_exception.__exit__..gs 3PTP^P^@_<_rA) rOr.r* MultiErrorfilterrKrGr!subgroup)rStyvaluetbfiltered_exceptions rB__exit__z$_preserve_current_exception.__exit__[s{ =  !%!7!7!N  "T)) 1 2!&0_!` "T))"0!6 !T))rANreturnNone)r_ztype[BaseException] | Noner`zBaseException | NonerazTracebackType | Nonerebool)r<r=r>r? __slots__rTrXrcr@rArBrMrMIsCI4* &*$* ! *  *rArM) subprotocols extra_headersmessage_queue_sizemax_message_sizereceive_buffer_sizeconnect_timeoutdisconnect_timeoutc f Kd f d } d fd } dd} d}d}d} tj4d{}tj| |d{}t |tj r5|j } | tj| |d{}dddd{||j  |j yy77#t$r}|}d}~wwxYw7S#tj| |d{7}wxYw7i#1d{7swYyxYw#t$rH}t|jdk(r| |jdd}|jD]#}t |tjr|n-|}%||| || |jd| ||jD]}t |tst|||jDcgc] }||us| ncc}w}}d}|j)|js|j|jd}d |zd z}t!|||_ d |_| |t#d |d}~wwxYw#||j wwxYww)ah 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 Optional[int] receive_buffer_size: The buffer size we use to receive messages internally. None to let trio choose. Defaults to 4 KiB. :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. c  K tj5t|  d{cdddS7 #1swYyxYw#tj$rtdt $r }t |d}~wwxYww)Nuse_sslrirjrkrlrm)r* fail_afterconnect_websocket TooSlowErrorConnectionTimeoutOSErrorHandshakeError) nurseryernrjhostrlrkportrmresourcerirss rB_open_connectionz(open_websocket.._open_connections (1 =.wdgL"/'9%5(; == = == = =   .# - ( a ' (sZBAAAA ABAA A B A"A=1A88A==BcK tj5|jd{dddy7 #1swYyxYw#tj$rtdwxYwwrE)r*rtacloservDisconnectionTimeout) connectionros rB_close_connectionz)open_websocket.._close_connectionsd 1!34 * ''))) * *) * *   1&D 0 1sGA(A ><>A A(>AA A(A A%%A(c@d}|j} |#||_~~wxYw)zIThis helper allows re-raising an exception without __context__ being set.T) __context__)rJ__tracebackhide__contexts rB_raisezopen_websocket.._raises+!// I%COWs Nr1rz' and the context for the user exceptionz\Both internal and user exceptions encountered. This group contains the internal exception(s)r+FzThe trio-websocket API is not expected to raise multiple exceptions. Please report this as a bug to https://github.com/python-trio/trio-websocket)rz trio.NurseryreWebSocketConnection)rrrerf)rJ BaseExceptionrer )r* open_nurseryoutcomeacapturerGValueunwrapr_TRIO_EXC_GROUP_TYPElen exceptionsrHKeyboardInterruptr__suppress_context__appendr!r:)r|r}r~rsrirjrkrlrmrnrorrrr close_result user_error new_nurseryresultr{exception_to_raisesub_excsubexcr eg_substreg_strs``````````` rBopen_websocketrmsR ( (1 *.J/3LJL"$$& Y Y+"++, &8 %KJ ".3J + : ( <   g7t  #    ! $s J1EC/E D/$C1%.D/C3D/3D4D/8 ED-E'J1/E1D/3 D<C??DD D/ D*#D& $D**D/-E/E5D8 6E=E JAJ'AJ8J HHA3JJJJ..J1)rirjrkrlrmrc TK|durtj} n/|durd} n(t|tjr|} n t dt j d| dnd|||| tj||d{} n!tj||| dd{} |d vr|} n|d |} t| ttj| |||||| } |j| j| j j#d{| S77~7 w) aj 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). :param Optional[int] receive_buffer_size: The buffer size we use to receive messages internally. None to let trio choose. Defaults to 4 KiB. :rtype: WebSocketConnection TFNz1`use_ssl` argument must be bool or ssl.SSLContextzConnecting to ws%s://%s:%d%srs) ssl_contexthttps_compatible)P:r|pathclient_subprotocolsclient_extra_headersrkrlrm)sslcreate_default_contextrG SSLContext TypeErrorr5debugr*open_tcp_streamopen_ssl_over_tcp_streamrrrCLIENT start_soon _reader_task_open_handshakewait)rzr|r}r~rsrirjrkrlrmrstream host_headerrs rBruru4s5Z$002 E  GS^^ , KLL LL/!sD$B++D$7744T4#d<< y av& $V^**+  (}-)/1J z../  $ $ ) ) +++ %8<,s7BD(D"!D(%D$&A5D(D&D($D(&D()rirjrkrlrnrormc Pt||\} } } } t| | | | ||||||| S)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 Optional[int] receive_buffer_size: The buffer size we use to receive messages internally. None to let trio choose. Defaults to 4 KiB. :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. )rsrirjrkrlrmrnro) _url_to_hostr) urlrrirjrkrlrnrormr|r}r~return_ssl_contexts rBopen_websocket_urlrsGZ0>D |455 zzzz(sbjjG  cz3$$ w 2 22rAc Kt|ttj||||||| } |j | j | j jd{| S7w)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). :param Optional[int] receive_buffer_size: The buffer size we use to receive messages internally. None to let trio choose. Defaults to 4 KiB. :rtype: WebSocketConnection rN)rrrrrrrr) rzrr|r~rirjrkrlrmrs rBwrap_client_streamrsoP%V^**+ (}-)/ 1J z../  $ $ ) ) +++ ,sA$A/&A-'A/WebSocketRequestcKt|ttj|||}|j |j |j d{}|S7w)aa 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). :param Optional[int] receive_buffer_size: The buffer size we use to receive messages internally. None to let trio choose. Defaults to 4 KiB. :type stream: trio.abc.Stream :rtype: WebSocketRequest rkrlrmN)rrrSERVERrr _get_request)rzrrkrlrmrrequests rBwrap_server_streamrIs]4%^**+-)/ 1J  z../++--G N.sAA!AA!)handler_nurseryrkrlrmrnro task_statusc K|ttj||} nttj|||d} | d{} t || |||||| } | j | d{y727w)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 Optional[int] receive_buffer_size: The buffer size we use to receive messages internally. None to let trio choose. Defaults to 4 KiB. :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)r|T)r|rrrkrlrmrnror)rr*open_tcp_listenersopen_ssl_over_tcp_listenersWebSocketServerrun)handlerr|r}rrrkrlrmrnrorr listenersservers rBserve_websocketrosp$T%<%)rr<rrRs rB__repr__zConnectionClosed.__repr__s$..))*!DKK=::rA)rCloseReason | Nonererfrerr<r=r>r?rTr __classcell__rs@rBrrs;rArc<eZdZdZ dfd ZddZxZS)ConnectionRejectedzq A WebSocket connection could not be established because the server rejected the connection attempt. cRt||||||_||_||_yr)rrT status_codeheadersbody)rSrrrrs rBrTzConnectionRejected.__init__s, gt4&  rAcN|jjd|jdS)rz r?rTpropertyrrrrr@rArBrrsLB*MrArNULLc(eZdZdZddZddZddZy) Futurez: Represents a value that will be available in the future. chttt|_t j |_y)z Constructor. N)rr6r_valuer*Event _value_eventrRs rBrTzFuture.__init__.sa  JJLrAcF||_|jjy)zT Set a value, which will notify any waiters. :param value: N)r#r%set)rSr`s rB set_valuezFuture.set_value5s   rAcK|jjd{|jtusJ|jS7$w)z| Wait for this future to have a value, then return it. :returns: The value set by ``set_value()``. N)r%rr#rrRs rB wait_valuezFuture.wait_value>s> $$&&&{{$&&{{ 'sAA%ANrd)r`r6rerf)rer6)r<r=r>r?rTr(r*r@rArBr!r!,sD) rAr!ceZdZdZ d dZeddZeddZeddZeddZ eddZ ddd  dd Z ddd  dd Z y)rz Represents a handshake presented by a client to a server. The server may modify the handshake or leave it as is. The server should call ``accept()`` to finish the handshake and obtain a connection object. c ||_||_y)zz Constructor. :param WebSocketConnection connection: :type event: wsproto.events.Request N) _connection_event)rSrevents rBrTzWebSocketRequest.__init__Ps& rAc.|jjS)zi HTTP headers represented as a list of (name, value) pairs. :rtype: list[tuple] )r.rjrRs rBrzWebSocketRequest.headers^s{{(((rAc.|jjS)z> The requested URL path. :rtype: str )r.targetrRs rBrzWebSocketRequest.pathgs{{!!!rAc@t|jjS)zZ A tuple of protocols proposed by the client. :rtype: tuple[str] )tupler.rirRs rBproposed_subprotocolsz&WebSocketRequest.proposed_subprotocolspsT[[--..rAc.|jjS)zS The connection's local endpoint. :rtype: Endpoint or str )r-localrRs rBr7zWebSocketRequest.localys%%%rAc.|jjS)zT The connection's remote endpoint. :rtype: Endpoint or str )r-remoterRs rBr9zWebSocketRequest.remotes&&&rAN subprotocolrjcK|g}|jj|j||d{|jS7w)a Accept the request and return a connection object. :param subprotocol: The selected subprotocol for this connection. :type subprotocol: str or None :param extra_headers: A list of 2-tuples containing key/value pairs to send as HTTP headers. :type extra_headers: list[tuple[bytes,bytes]] or None :rtype: WebSocketConnection N)r-_acceptr.)rSr;rjs rBacceptzWebSocketRequest.acceptsG  M&&t{{KOOO Ps/AAA)rjrcrK|xsg}|xsd}|jj|||d{y7w)a# Reject the handshake. :param int status_code: The 3 digit HTTP status code. In order to be RFC-compliant, this should NOT be 101, and would ideally be an appropriate code in the range 300-599. :param list[tuple[bytes,bytes]] extra_headers: A list of 2-tuples containing key/value pairs to send as HTTP headers. :param body: If provided, this data will be sent in the response body, otherwise no response body will be sent. :type body: bytes or None rAN)r-_reject)rSrrjrs rBrejectzWebSocketRequest.rejects9&&+ {s&&{M4HHHs -757)rrr/wsproto.events.Requestrerf)relist[tuple[bytes, bytes]]r)reztuple[str, ...]reEndpoint | str)r;rrj list[tuple[bytes, bytes]] | Nonerer)rrrjrFrrrerf) r<r=r>r?rTrrrr5r7r9r>rAr@rArBrrIs ' &   ))""//&&''#':>    8    2;?! II8 I  I  IrAcDd\}}t|tjr |j}n2t|tjr|j j}d}|r4|r|j n|j^}}}t|||}|St|}|S)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 rQT) rGr* SocketStreamsocket SSLStreamtransport_stream getsockname getpeernameEndpointrepr)rr7rIis_ssladdrr}_endpoints rB_get_stream_endpointrTs!NFF&$++, FDNN +((// 16++-Frz A WebSocket connection. Nrcd|_t|jj|_||_t j|_||_ d|_ g|_ ||_ | |_ d|_|jr.|J|Jt!||t#|xsd|xsg|_nd|_||_d|_d|_d|_d|_d|_t j2t4t6t8f|\|_|_t?|_ tCtD|_#t jH|_%t jH|_&t jH|_'y)aC 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). :param Optional[int] receive_buffer_size: The buffer size we use to receive messages internally. None to let trio choose. Defaults to 4 KiB. NrTr@)r|r2rirjrA)( _close_reasonnextr CONNECTION_ID_id_streamr*StrictFIFOLock _stream_lock_wsproto _message_size_message_parts_max_message_size_receive_buffer_size_reader_runningclientrlist_initial_request_path _subprotocol_handshake_headers_reject_status_reject_headers _reject_bodyopen_memory_channelr bytesr _send_channel _recv_channelr_pingsr!r_connection_proposalr$r_close_handshake#_for_testing_peer_closed_connection) rSr ws_connectionr|rrrrkrlrms rBrTzWebSocketConnection.__init__sfZ59445  //1% 79!13F!#   # ## #7>DQU!"5";<28b8:D !%)D ! +/CE@B151I1I %* 2 2.D.7Bm FLL\E]E_! $zz|!% 48::<0rAc|jS)z (Read-only) The reason why the connection was or is being closed, else ``None``. :rtype: Optional[CloseReason] )rWrRs rBclosedzWebSocketConnection.closed0s!!!rAc.|jjS)z( (Read-only) Is this a client instance? r^rdrRs rB is_clientzWebSocketConnection.is_client:s}}###rAc0|jj S)z( (Read-only) Is this a server instance? ryrRs rB is_serverzWebSocketConnection.is_server?s==''''rAc0t|jdS)zX The local endpoint of the connection. :rtype: Endpoint or str Tr7rTr[rRs rBr7zWebSocketConnection.localDs$DLL==rAc0t|jdS)zY The remote endpoint of the connection. :rtype: Endpoint or str Fr~rrRs rBr9zWebSocketConnection.remoteMs$DLL>>rAc|jS)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 or None )rgrRs rBrzWebSocketConnection.pathVszzrAc|jS)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 )rhrRs rBr;zWebSocketConnection.subprotocol`s   rAc|jS)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]] )rirRs rBhandshake_headersz%WebSocketConnection.handshake_headersls&&&rAcKt5|j||d{dddy7 #1swYyxYww)a7 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)rM_aclosers rBrzWebSocketConnection.aclosews?) * -,,tV, , , - - , - -s ?313 ?3<?cK|jry |jjtjk(r6t dd|_|j t||d{nP|jjtjtjfvr|jj|jjd{|jjd{|j!d{y77A7!#t$rY*wxYw7#|j!d{7wxYww)Nr rr)rWr^staterOPENr_sendr CONNECTING REJECTINGrsr'rprrr _close_streamrs rBrzWebSocketConnection._acloses     '}}""o&:&::&1t%<"jjd6!JKKK$$)C)C#--)//%%))+$$++- - -'',,. . .$$& & &L . .    '$$$& & &sEAD!(D)A2D!D!D!=D>D!ED0ED!D!D!! D-*D2,D--D20E2E E E  EcK |jjd{}|S7#tjtjf$rt |j dwxYww)a 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)rpreceiver*ClosedResourceError EndOfChannelrrW)rSmessages rB get_messagezWebSocketConnection.get_messagesc" A ..6688G9(($*;*;< A"4#5#56D @ As%A'*(*A'*:A$$A'cK|jrt|j||jvrtd|d|)t j dt jd}tj}||j|<|jt|d{|jd{y77w)aA 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) rWrrqrstructpackrandom getrandbitsr*r$rrr)rSrr/s rBpingzWebSocketConnection.pings(   "4#5#56 6 dkk !~g[8NOP P ?kk$(:(:2(>?G $ Gjjg.///jjl 0s$B+C-C .CC C CcK|jrt|j|jt|xsdd{y7w)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 rArN)rWrrr)rSrs rBpongzWebSocketConnection.pongs=   "4#5#56 6jjgn5666AAA AcK|jrt|jt|tr t |}n(t|t r t |}n td|j|d{y7w)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) rWrrGrrrnrrr)rSrr/s rB send_messagez WebSocketConnection.send_messagesh   "4#5#56 6 gs #W-E  ' g.E;< <jjsA;B=B>BcD|jrdnd}|d|jS)z Connection ID and type. rdr-)rzrZ)rStype_s rB__str__zWebSocketConnection.__str__s$ NN$(($$rAcK||_|j|_|jt |j|d{|j j y7w)ah 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)rhr2rgrrrr')rSrr;rjs rBr=zWebSocketConnection._accepts["(^^ jj)d6G6G')* * *   " *sAA&A$ A&cK|r4|jdtt|jdft ||t |}|j |d{|r%t|}|j |d{tdd|_ |jjy7W72w)a 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. sContent-lengthascii)rrhas_bodyNrizRejected WebSocket handshake) rrrencoderrgrrrrWrsr')rSrrr reject_conn reject_bodys rBr@zWebSocketConnection._rejects  NN-s3t9~/D/DW/MN O&;$Z! jj%%% $$/K**[) ) )(/MN !!# & *s$A"C$B<%&C B> 1C>Cc|Ktjj}|jjt j k(r/|jjt|j|j|j|d{d|_ |jjy7&w)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^rrrsendrr`rW_close_web_socketrcrsr')rS close_reasons rB_abort_web_socketz%WebSocketConnection._abort_web_socket0s$//@@ ==  /"6"6 6 MM  L4F4FG H    %((6 6 6$ !!# 7sBB<B:'B<cKd|_ t5|jjd{dddy7 #1swYyxYw#tj $rYywxYww)z Close the TCP connection. FN)rcrMr[rr*BrokenResourceErrorrRs rBrz!WebSocketConnection._close_streamAsc$ ,. ,ll))+++ , ,+ , ,''   sZA( AAAAAA(AA A A( AA%"A($A%%A(cKt|||_t|j}tj d|||j j d{y7w)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)rrWrr5rror)rSrrrJs rBrz%WebSocketConnection._close_web_socketKsP )v6t112 -tS9  '')))sAA%A#A%cK|js td|j td|jjd{}d|_|S7 w)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?)r| RuntimeErrorrrr*)rSproposals rBrz WebSocketConnection._get_requestVsc~~RS S  $ $ , 89 922==??$(!@sA AAAcvKt||}|jJ|jj|yw)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)rrrr()rSr/rs rB_handle_request_eventz)WebSocketConnection._handle_request_evenths7$D%0((44 !!++H5s79cK|j|_t|j|_|j j yw)zi Handle an AcceptConnection event. :param wsproto.eventsAcceptConnection event: N)r;rhr4rjrirr'rSr/s rB_handle_accept_connection_eventz3WebSocketConnection._handle_accept_connection_eventus; "--"'(;(;"<   "sAA cK|j|_t|j|_|j s"t |j|jdyw)zI Handle a RejectConnection event. :param event: Nr)rrjr4rrkrrrs rB_handle_reject_connection_eventz3WebSocketConnection._handle_reject_connection_eventsS $//$U]]3~~$T%8%8$:N:N sAAcK|xj|jz c_|jr,t|j|j |jyw)zC Handle a RejectData event. :param event: rN)rlr body_finishedrrjrkrs rB_handle_reject_data_eventz-WebSocketConnection._handle_reject_data_eventsQ UZZ'   $T%8%8$:N:N&&( ( sAAcK|jjtjk(rjt |j |j xsd|_|jj|j|jd{|j|j |j xsdd{|jj|jr|jd{yy7v7F7 w)z] Handle a close event. :param wsproto.events.CloseConnection event: N)r^rrREMOTE_CLOSINGrrrrWrtr'rresponserrsr|rrs rB_handle_close_connection_eventz2WebSocketConnection._handle_close_connection_events ==  /"@"@ @"-UZZ9M!ND   4 4 8 8 :**U^^-. . .$$UZZ1EFFF !!# >>$$& & &  /F 's6B D D1D D=D ?D D D  D cdK|xjt|jz c_|jj |j|j|j kDr}d|j d}d|_g|_t d||_|jtd|d{|jjd{d|_ y|jrt|tr&dj!t#d |j}n%d j!t#d |j}d|_g|_ |j$j'|d{yy777 #t(j*t(j,f$rYywxYww) z Handle a message event. :param event: :type event: wsproto.events.BytesMessage or wsproto.events.TextMessage zExceeded maximum message size: z bytesrirNFrAz list[bytes]rz list[str])r_rrr`rrarrWrrrprrcmessage_finishedrGrjoinrrorr*rr)rSr/errmsgs rB_handle_message_eventz)WebSocketConnection._handle_message_eventsm c%**o- ""5::.    6 6 63D4J4J3K6RC!"D "$D !,T3!7D **_$sCD D D$$++- - -#(D  # #%.hhtM43F3FGHggd;0C0CDE!"D "$D  ((--c222$ E -3,,d.F.FG   s[B5F07F8!F0FBF0F:F;F?F0F0F#F-*F0,F--F0cKtjd||j|j|j d{y7w)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)r5rrrrrs rB_handle_ping_eventz&WebSocketConnection._handle_ping_events5  \47jj)***rcRKt|j} |j|}|jrc|jj d\}}||k7rdnd}t j d||||j||k(ry|jrbyy#t$rYywxYww)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: NFz [skipped]  z %s pong%s%r)rnrrqKeyErrorpopitemr5rr')rSr/r ping_eventkeyskippeds rB_handle_pong_eventz&WebSocketConnection._handle_pong_events & W-J kk"kk11%8OC'.#~m3G LLgs ; NN #~ kk    s.B'BA-B'B' B$!B'#B$$B'c`Kt|jt|jt|j t |jt|jt|jt|jt|jt |ji }|j"r$ |j%|j"d{|j*4d{|j(rZ|j,j/D]:}t1|} ||}t2j5d||||d{< |j:j=|j>d{}tI|dk(rVt2j5d||j,jJtLjNk7r|jGd{nqt2j5d|tI||j,jJtLjNk7r |j,jQ||j(rZdddd{t2j5d |y7#t&$r d|_YwxYw77N#t6$rt2j9d||Yt&$r d|_YwxYw7[#t@jBt@jDf$r|jGd{7YwxYw7=#tRjTjV$rk}t2j5d|||jXr$|j%|jXd{7|j[d{7Yd}~Zd}~wwxYw7I#1d{7swYZxYww) zA 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).rrrrrrrrrrrrrrrrrrfrrrcror^eventstyper5rrwarningr[ receive_somerbr*rrrrrrCLOSED receive_datawsproto utilitiesRemoteProtocolError event_hintr)rShandlersr/ event_typerrrs rBrz WebSocketConnection._reader_tasks dBB $44 T@@ $)) $)) dBB 66 T// 33     -jj!6!6777%%* 3* 3&&!]]113E!%eJ "*:"6 %LL!M}}**o.D.DD"44666 3T3t9E==&&/*@*@@3 2248I&&* 3* 3X  .5a8# -',$ -* 3-#('Mt&(+/4, V00$2J2JK002227 #,,@@3 %CT3O>>"&**S^^"<<<"00222 3M* 3* 3* 3* 3sSBN."I+I(I+N.JN.6N'J7J8J<N?(K'K(K,AN L A NL 3 N N. N N.(I++I?;N.>I??N.J J?(N+J?:N>J??NK6L;K><LNLN N'AN (M+)N NN N NNN.N+N! N+&N.cK|jj|}|j4d{tj d|t | |j j|d{dddd{y7Y7#tjtjf$r>|jd{7|jJt|jdwxYw7m#1d{7swYyxYww)a 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]r5rrr[send_allr*rrrrWr)rSr/rs rBrzWebSocketConnection._send<s}}!!%($$ E E LL.c$i @ Ell++D111 E E E2,,d.F.FG E,,...))55&t'9'9:D E  E E E Est,DBD!C2B 2B 3B 7 DC0D B  6C-C*C--C20D2D8C; 9DD)rtrio.abc.Streamruzwsproto.WSConnectionr|rrrrIterable[str] | NonerrFrkrrlrrmUnion[None, int]rerf)rer)rergrDr)rer)r Nr)re str | bytesrE)rrrerf)rrrerfr)rrr;rrjrCrerf)rrrrCrrnrerfrd)rer)r/rBrerf)r/zwsproto.events.AcceptConnectionrerf)r/zwsproto.events.RejectConnectionrerf)r/zwsproto.events.RejectDatarerf)r/zwsproto.events.CloseConnectionrerf)r/z8wsproto.events.BytesMessage | wsproto.events.TextMessagererf)r/zwsproto.events.Pingrerf)r/zwsproto.events.Pongrerf)r/zwsproto.events.Eventrerf)+r<r=r>r? itertoolscountrYr2r3r4rTrrwrzr|r7r9rr;rrrrrrrrr=r@rrrrrrrrrrrrrrr@rArBrrs##IOO%M 48AE"4 00=T@T@,T@  T@  T@2T@?T@ T@T@.T@ T@l""$$((>>?? ! !''-$'4.> 7 &% ## #1 #  #.$$+$ $  $6$" *$ 6#  ('*#G# #J +:A6FErAc2eZdZdZddZeddZddZy)rNz# Represents a connection endpoint. c@t||_||_||_yrE)raddressr}rP)rSrr}rPs rBrTzEndpoint.__init__Ss!'*   rAcD|jrdnd}|jdk(r |jr|jdk(r|jrd}ndt|jz}|jjdk(r|d|j|S|d |jd |S) zT Return a URL representation of a TCP endpoint, e.g. ``ws://127.0.0.1:80``. rrrrrrz://z://[])rPr}rrr)rSrport_strs rBrz Endpoint.url[s++4 IIODKK II HS^+H <<  1 $XSxj9 9dll^1XJ77rAcVd|jd|jd|jdS)z! Return endpoint info as string. zEndpoint(address="z", port=z , is_ssl=))rr}rPrRs rBrzEndpoint.__repr__is*#DLL>$))Idkk]Z[\\rAN)rz str | intr}rrPrgrerfr)r<r=r>r?rTrrrr@rArBrNrNQs$- 8 8]rArNceZdZdZdeeeeed d dZe d dZ e d dZ e jd d dZdd Zy)rz 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, Nrct|dk(r td||_||_||_||_||_||_||_||_ y)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 Optional[int] receive_buffer_size: The buffer size we use to receive messages internally. None to let trio choose. Defaults to 4 KiB. :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_sizerarb_connect_timeout_disconnect_timeout) rSrrrrkrlrmrnros rBrTzWebSocketServer.__init__ws[F y>Q HI I /##5 !1$7! /#5 rAct|jdkDr td|jd} |jS#t $rtdt |dwxYw)aReturns 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. r1z=Cannot get port because this server has more than 1 listener.rz"This socket does not have a port: N)rrrrr}AttributeErrorrO)rSlisteners rBr}zWebSocketServer.portsq t ! # )* *>>!$ `==  `!CDNCSTU[_ _ `s A"A"cg}|jD]}d\}}t|tjr |j}nPt|tj r6|j }t|tjsJ|j}d}|r3|j}|jt|d|d||jt||S)a 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]: rQTrr1) rrGr*SocketListenerrI SSLListenertransport_listenerrLrrNrO)rSrrrIrPinternal_listenersocknames rBrzWebSocketServer.listenerss+-  1H(NFF(D$7$78!Hd&6&67$,$?$?!!"3T5H5HII*11!--/  (1+x{F!KL  h0 1rArc JKtj4d{}ttj|jt |j |j}|j|d{tjddj|jDcgc] }t|c}|j|tjd{dddd{y77cc}w77#1d{7swYyxYww)u 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*rrserve_listeners_handle_connectionrerrstartr5rrrrstarted sleep_forever)rSrrzr ls rBrzWebSocketServer.runs$$& ' ''%d&:&:''doo)> $ 5 57O--0 0 0 LL*$..9Q#a&9: <    %$$& & & ' ' ' 19 & ' ' ' 'suD#DD#AD8D9-D&D83D+D ,D0 D#;D <D#DD D#D D D D#c Ktj4d{}t|ttj |j |j|j}|j|jtj|j5}|jd{}dddjrD|jj!|j#d{ dddd{y |j%d{tj|j&5|j#d{ddddddd{y7`7#1swYxYw777j74#1swY3xYw#tj|j&5|j#d{7dddw#1swYwxYwxYw7|#1d{7swYyxYww)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*rrrrrrrarbrr move_on_afterrrcancelled_caught cancel_scopecancelrrr)rSrrzr connect_scopers rBr z"WebSocketServer._handle_connections$$& . .',V^223#'#;#;!%!7!7$($=$= ?J   z66 7##D$9$9: :m * 7 7 99 :--$$++-mmo%% . . . .mmG,,,''(@(@A.%++---.! . . .: : :& .- ...T''(@(@A.%++---...! . . . .s H E;H BG4F3E>4F8AG49F :G4? H  F H F %F&F *G4 FFF"G4* H 5G26H >FF G4H F FF G4 G/G# G G#  G/#G, (G//G42H 4H:G= ;HH )r-Callable[[WebSocketRequest], Awaitable[None]]rzCSequence[trio.SSLListener[trio.SocketStream] | trio.SocketListener]rtrio.Nursery | Nonerkrrlrrmrrnfloatrorrerfr)rezlist[Endpoint | str])r trio.TaskStatus[WebSocketServer]rer )rrrerf)r<r=r>r?r2r3r4r0rTrr}rr*TASK_STATUS_IGNOREDrr r@rArBrrns04"4 00=!-$0,6>,6W,6 - ,6  ,6,6.,6,6",6 ,6\``(B9=8P8P'6'  '2.rAr)rJr7rezE | None)r|rr}rr~rrszUnion[bool, ssl.SSLContext]rizOptional[Iterable[str]]rjz#Optional[list[tuple[bytes, bytes]]]rkrrlrrmrrnrrorrez)AsyncGenerator[WebSocketConnection, None])rzrr|rr}rr~rrszbool | ssl.SSLContextrirrjrFrkrrlrrmrrerrE)rrrssl.SSLContext | NonerirrjrFrkrrlrrnrrorrmrrez0AbstractAsyncContextManager[WebSocketConnection])rzrrrrrrirrjrFrkrrlrrmrrer)rrrrrez+tuple[str, int, str, ssl.SSLContext | bool])rzrrz5trio.SocketStream | trio.SSLStream[trio.SocketStream]r|rr~rrirrjrFrkrrlrrmrrer) rzrrrrkrrlrrmrrer)rrr|zstr | bytes | Noner}rrrrrrkrrlrrmrrnrrorrrrer )rrr7rgrerE)q __future__rrV collectionsr contextlibrr functoolsr ipaddressrrloggingrrr urllib.parsertypingr r r r r rrrrimportlib.metadatarrr*trio.abcrrrwsproto.connectionrwsproto.frame_protocolframe_protocolrwsproto.eventsrrrrrrrrrwsproto.utilities version_infoexceptiongroupr!typesr"typing_extensionsr#collections.abcr$r%r&r'r(r)r4maprsplitr.__annotations__r\rr0r2r3r4 getLoggerr5r6rr7 Exceptionr:rKrMrrurrrrrrrryrwrrrrobjectrr!rrTabc AsyncResourcerrNrr@rArBr:s" #G  ^^^& 0.-   g1#'bb#CWV_-B-B3-G-K$LMPWWeW??- eE!%!" u"!!!"233 CL C}%<!*!*H-18<0,,9) ,C C CC ) C * C6CCC*CCC/CCZ*.6:0,,9L L L L L # L'L4LLL*LLb*.3P*.6:0,) ,,93P 3P&3P' 3P 4 3P  3P3P3P3P*3P63Pr*.-1 *.6:0,,9-1 -1 -1'-1 ' -1 4 -1-1-1*-1-1`)3 )3&)31)3d*.6:0,,91 1 A1 1 1 ' 14111*11n1,,9 " " "" " * "  "X,00,,9) ,484L4LM. :M. M. M.' M. ) M.M.M.*M.M.M.2M.M.`Y GGL>L;y;(LL<)M)MXheWQZ:lIlI^   :y E$((00y Ex]]:_._.rA