o êi@sddlZddlZddlZddlZddlZddlZddlZddlZddl m Z ddl Z ddl Z ddl Z ddlZddlZddlmZmZddl mZmZddlmZddlmZmZmZmZmZddlmZmZdd l m!Z!ej"d Z#e$d Z%e$d Z&ej$d ddZ'ej$dddZ(dZ)dZ*dZ+dZ,Gddde-Z.Gddde-Z/GdddZ0GdddZ1de2e3dBde4e3ej5ffddZ6Gdd d ej7e'Z8ej9 d0e)e*e+e,de0d!d"e3d#e j:dBd$e;d%e;d&ee'ddffd*d+Z?Gd,d-d-ej7e(Z@ejA d0e)e*e+e,de1d!d"e3d#e jBdBd$e;d%e;d&ed?Z.dS)Fra+ Sync context manager representing an opened WebSocket session. Attributes: subprotocol (typing.Optional[str]): Optional protocol that has been accepted by the server. response (typing.Optional[httpx.Response]): The webSocket handshake response. N subprotocolresponsemax_message_size_bytes queue_sizekeepalive_ping_interval_secondskeepalive_ping_timeout_secondsr&streamr(r)r*r+returncCs||_tjtjj|_||_|jdur|jjd|_ nd|_ t ||_ t |_t|_t|_d|_d|_||_||_||_||_dSNsec-websocket-protocol)r,wsproto connection ConnectionConnectionTypeCLIENTr&headersgetr%queueQueue_eventsr _ping_manager threadingEvent _should_closeLock _write_lock_should_close_task _executor_max_message_size_bytes _queue_size _keepalive_ping_interval_seconds_keepalive_ping_timeout_secondsselfr,r(r)r*r+r&r!r!r"__init__@s"     zWebSocketSession.__init__zconcurrent.futures.Future[bool]cCsB|jdurtj|_|j|jj|_|jdusJ|j|jfSN)r@ concurrentfuturesThreadPoolExecutorrAsubmitr=waitrGr!r!r"_get_executor_should_close_taskcs   z0WebSocketSession._get_executor_should_close_taskcCsXtj|j|jfd|_|jd|_|jdur*tj|j|j|j fd|_|j|S)N)targetargs) r;Thread_background_receiverB_background_receive_taskstart_background_keepalive_ping_taskrD_background_keepalive_pingrErOr!r!r" __enter__ns    zWebSocketSession.__enter__cCs.||j|jdur|jdSdSrI)closerUjoinrWrGexc_typeexctbr!r!r"__exit__s   zWebSocketSession.__exit__payloadcCs*|j|\}}tj|}|||S)a? Send a Ping message. Args: payload: Payload to attach to the Ping event. Internally, it's used to track this specific event. If left empty, a random one will be generated. Returns: An event that can be used to wait for the corresponding Pong response. Examples: Send a Ping and wait for the Pong pong_callback = ws.ping() # Will block until the corresponding Pong is received. pong_callback.wait() r:creater0eventsPingsendrGrbping_idcallbackeventr!r!r"pings  zWebSocketSession.pingrkc Cszz$|j|}|j|j|WdWdS1swYWdStjy<}z |tj dt |d}~ww)a Send an Event message. Mainly useful to send events that are not supported by the library. Most of the time, [ping()][httpx_ws.WebSocketSession.ping], [send_text()][httpx_ws.WebSocketSession.send_text], [send_bytes()][httpx_ws.WebSocketSession.send_bytes] and [send_json()][httpx_ws.WebSocketSession.send_json] are preferred. Args: event: The event to send. Raises: WebSocketNetworkError: A network error occured. Examples: Send an event. event = wsproto.events.Message(b"Hello!") ws.send(event) NStream write error r1rgr?r,writehttpcore WriteErrorrZrINTERNAL_ERRORr rGrkdataer!r!r"rgs &zWebSocketSession.sendrtcCtjj|d}||dS)a Send a text message. Args: data: The text to send. Raises: WebSocketNetworkError: A network error occured. Examples: Send a text message. ws.send_text("Hello!") rtNr0re TextMessagergrGrtrkr!r!r" send_textzWebSocketSession.send_textcCrv)a Send a bytes message. Args: data: The data to send. Raises: WebSocketNetworkError: A network error occured. Examples: Send a bytes message. ws.send_bytes(b"Hello!") rwNr0re BytesMessagergrzr!r!r" send_bytesr|zWebSocketSession.send_bytesrmodecCs@|dvsJt|}|dkr||dS||ddS)a Send JSON data. Args: data: The data to send. Must be serializable by [json.dumps][json.dumps]. mode: The sending mode. Should either be `'text'` or `'bytes'`. Raises: WebSocketNetworkError: A network error occured. Examples: Send JSON data. data = {"message": "Hello!"} ws.send_json(data) rrutf-8Njsondumpsr{rencoderGrtrserialized_datar!r!r" send_jsons  zWebSocketSession.send_jsontimeoutcCs>|jjd|d}t|tr|t|tjjrt|j|j |S)aE Receive an event from the server. Mainly useful to receive raw [wsproto.events.Event][wsproto.events.Event]. Most of the time, [receive_text()][httpx_ws.WebSocketSession.receive_text], [receive_bytes()][httpx_ws.WebSocketSession.receive_bytes], and [receive_json()][httpx_ws.WebSocketSession.receive_json] are preferred. Args: timeout: Number of seconds to wait for an event. If `None`, will block until an event is available. Returns: A raw [wsproto.events.Event][wsproto.events.Event]. Raises: queue.Empty: No event was received before the timeout delay. WebSocketDisconnect: The server closed the websocket. WebSocketNetworkError: A network error occured. Examples: Wait for an event until one is available. try: event = ws.receive() except WebSocketDisconnect: print("Connection closed") Wait for an event for 2 seconds. try: event = ws.receive(timeout=2.) except queue.Empty: print("No event received.") except WebSocketDisconnect: print("Connection closed") T)blockr) r9r6 isinstancer r0reCloseConnectionr codereasonrGrrkr!r!r"receives ' zWebSocketSession.receivecC&||}t|tjjr|jSt|)a& Receive text from the server. Args: timeout: Number of seconds to wait for an event. If `None`, will block until an event is available. Returns: Text data. Raises: queue.Empty: No event was received before the timeout delay. WebSocketDisconnect: The server closed the websocket. WebSocketNetworkError: A network error occured. WebSocketInvalidTypeReceived: The received event was not a text message. Examples: Wait for text until available. try: text = ws.receive_text() except WebSocketDisconnect: print("Connection closed") Wait for text for 2 seconds. try: event = ws.receive_text(timeout=2.) except queue.Empty: print("No text received.") except WebSocketDisconnect: print("Connection closed") rrr0reryrtr rr!r!r" receive_text* #zWebSocketSession.receive_textcCr)a, Receive bytes from the server. Args: timeout: Number of seconds to wait for an event. If `None`, will block until an event is available. Returns: Bytes data. Raises: queue.Empty: No event was received before the timeout delay. WebSocketDisconnect: The server closed the websocket. WebSocketNetworkError: A network error occured. WebSocketInvalidTypeReceived: The received event was not a bytes message. Examples: Wait for bytes until available. try: data = ws.receive_bytes() except WebSocketDisconnect: print("Connection closed") Wait for bytes for 2 seconds. try: data = ws.receive_bytes(timeout=2.) except queue.Empty: print("No data received.") except WebSocketDisconnect: print("Connection closed") rrr0rer~rtr rr!r!r" receive_bytesRrzWebSocketSession.receive_bytescCs<|dvsJ|dkr||}n |dkr||}t|S)a Receive JSON data from the server. The received data should be parseable by [json.loads][json.loads]. Args: timeout: Number of seconds to wait for an event. If `None`, will block until an event is available. mode: Receive mode. Should either be `'text'` or `'bytes'`. Returns: Parsed JSON data. Raises: queue.Empty: No event was received before the timeout delay. WebSocketDisconnect: The server closed the websocket. WebSocketNetworkError: A network error occured. WebSocketInvalidTypeReceived: The received event didn't correspond to the specified mode. Examples: Wait for data until available. try: data = ws.receive_json() except WebSocketDisconnect: print("Connection closed") Wait for data for 2 seconds. try: data = ws.receive_json(timeout=2.) except queue.Empty: print("No data received.") except WebSocketDisconnect: print("Connection closed") rrrrrrloadsrGrrrtr!r!r" receive_jsonzs *   zWebSocketSession.receive_jsonrrcCs|j|jdur|jd|jjtjjjtjjj hvrQtj ||}|j |}z|j |j|Wdn1s@wYWn tjyPYnw|jdS)a  Close the WebSocket session. Internally, it'll send the [CloseConnection][wsproto.events.CloseConnection] event. *This method is automatically called when exiting the context manager.* Args: code: The integer close code to indicate why the connection has closed. reason: Additional reasoning for why the connection has closed. Examples: Close the WebSocket session. ws.close() NF)r=setrAshutdownr1stater0ConnectionState LOCAL_CLOSINGCLOSEDrerrgr?r,rorprqrZrGrrrkrtr!r!r"rZs$    zWebSocketSession.close max_bytesc Csd}z|js||j|}|j||jD]}t|tjj rE|j | }|j |j |Wdn1s?wYqt|tjjrT|j|jqt|tjjr`|jt|tjjr|jsx|durr|j}n$||j7}n|dur|j|nt|}|||j}d}|j|q|j|q|jrWdSWdStjtjtfy|t j!d|jt"YdSt#yYdSw)ao Background thread listening for data from the server. Internally, it'll: * Answer to Ping events. * Acknowledge Pong events. * Put other events in the [_events][_events] queue that'll eventually be consumed by the user. Args: max_bytes: The maximum chunk size to read at each iteration. N Stream error)$r=is_set_wait_until_closed _read_streamr1 receive_datarerr0rfrgr&r?r,roPongr:ackrbrrMessagemessage_finishedrtr9puttyperp ReadErrorrqr$rZrrrr rrGrpartial_message_bufferrtrk event_typefull_message_eventr!r!r"rTsN     " z$WebSocketSession._background_receiveinterval_secondstimeout_secondscCsz<|js:||jj|}|rt|}|dur2||j|}|s2|tjd|j t |jrWdSWdStyFYdSwNzKeepalive ping timeout) r=rrrNrrlrZrrrr9rr )rGrr should_close pong_callback acknowledgedr!r!r"rXs&  z+WebSocketSession._background_keepalive_pingcallable.c Osz|\}}|j|g|Ri|}Wnty$}zt|d}~wwtjj||ftjjd\}} ||vr:t||vs@J|} | S)N) return_when) rPrM RuntimeErrorrrJrKrNFIRST_COMPLETEDresult) rGrrRkwargsexecutorshould_close_task todo_taskrudone_rr!r!r"rs    z#WebSocketSession._wait_until_closedcCs|j|}|dkr t|SNrar,readr$rGrrtr!r!r"r0s zWebSocketSession._read_stream)r-rrarrINrrN)/rrr __doc__str__annotations__httpxResponseDEFAULT_MAX_MESSAGE_SIZE_BYTESDEFAULT_QUEUE_SIZE'DEFAULT_KEEPALIVE_PING_INTERVAL_SECONDS&DEFAULT_KEEPALIVE_PING_TIMEOUT_SECONDSrintfloatrHtuplerJrKrLrPrYr`bytesr;r<rlr0rergr{rtypingAnyJSONModerrrrrrZrTrXCallablerrrr!r!r!r"r2s    #  .() 2$9   c@seZdZUdZedBed<ejdBed<ee j j e Bed<e e j j e Bed<eeeeddded ed ed edBd edBdejdBd dfddZd>ddZdeedBdedBdedBd dfddZd?ded ej fddZde j j d dfddZded dfdd Zded dfd!d"Z d@de!j"d$e#d dfd%d&Z$dAd'edBd e j j fd(d)Z%dAd'edBd efd*d+Z&dAd'edBd efd,d-Z' #dBd'edBd$e#d e!j"fd.d/Z(dCd1ed2edBfd3d4Z)d5ed dfd6d7Z* dAd8ed9edBd dfd:d;Z+d5ed efdr?rBrCrrrDrErFr!r!r"rHGs        zAsyncWebSocketSession.__init__c st4IdH`}tjtjjtB\|_|_ | |j| |j t |_ | |j IdH|j |j|j|jdurK|j |j|j|j||j jj||j||_WdIdH|S1IdHsowY|SrI) contextlibAsyncExitStackrcreate_memory_object_streamr0rer<r rr enter_contextcreate_task_group_background_task_groupenter_async_context start_soonrTrBrDrXrErj cancel_scopecancelpush_async_callbackrZpop_all _exit_stack)rG exit_stackr!r!r" __aenter__js2       z AsyncWebSocketSession.__aenter__r]r^r_cs|jIdHdSrI)racloser\r!r!r" __aexit__szAsyncWebSocketSession.__aexit__rarbcs2|j|\}}tj|}||IdH|S)aK Send a Ping message. Args: payload: Payload to attach to the Ping event. Internally, it's used to track this specific event. If left empty, a random one will be generated. Returns: An event that can be used to wait for the corresponding Pong response. Examples: Send a Ping and wait for the Pong pong_callback = await ws.ping() # Will block until the corresponding Pong is received. await pong_callback.wait() Nrcrhr!r!r"rls  zAsyncWebSocketSession.pingrkc sz1|j|}|j4IdH|j|IdHWdIdHWdS1IdHs+wYWdStjyM}z|tj dIdHt |d}~ww)a Send an Event message. Mainly useful to send events that are not supported by the library. Most of the time, [ping()][httpx_ws.AsyncWebSocketSession.ping], [send_text()][httpx_ws.AsyncWebSocketSession.send_text], [send_bytes()][httpx_ws.AsyncWebSocketSession.send_bytes] and [send_json()][httpx_ws.AsyncWebSocketSession.send_json] are preferred. Args: event: The event to send. Raises: WebSocketNetworkError: A network error occured. Examples: Send an event. event = await wsproto.events.Message(b"Hello!") ws.send(event) Nrmrnrsr!r!r"rgs 2zAsyncWebSocketSession.sendrtc$tjj|d}||IdHdS)a Send a text message. Args: data: The text to send. Raises: WebSocketNetworkError: A network error occured. Examples: Send a text message. await ws.send_text("Hello!") rwNrxrzr!r!r"r{zAsyncWebSocketSession.send_textcr)a  Send a bytes message. Args: data: The data to send. Raises: WebSocketNetworkError: A network error occured. Examples: Send a bytes message. await ws.send_bytes(b"Hello!") rwNr}rzr!r!r"rrz AsyncWebSocketSession.send_bytesrrcsN|dvsJt|}|dkr||IdHdS||dIdHdS)a Send JSON data. Args: data: The data to send. Must be serializable by [json.dumps][json.dumps]. mode: The sending mode. Should either be `'text'` or `'bytes'`. Raises: WebSocketNetworkError: A network error occured. Examples: Send JSON data. data = {"message": "Hello!"} await ws.send_json(data) rrNrrrr!r!r"rs   zAsyncWebSocketSession.send_jsonrcsjt||jIdH}Wdn1swYt|tr%|t|tjjr3t |j |j |S)ab Receive an event from the server. Mainly useful to receive raw [wsproto.events.Event][wsproto.events.Event]. Most of the time, [receive_text()][httpx_ws.AsyncWebSocketSession.receive_text], [receive_bytes()][httpx_ws.AsyncWebSocketSession.receive_bytes], and [receive_json()][httpx_ws.AsyncWebSocketSession.receive_json] are preferred. Args: timeout: Number of seconds to wait for an event. If `None`, will block until an event is available. Returns: A raw [wsproto.events.Event][wsproto.events.Event]. Raises: TimeoutError: No event was received before the timeout delay. WebSocketDisconnect: The server closed the websocket. WebSocketNetworkError: A network error occured. Examples: Wait for an event until one is available. try: event = await ws.receive() except WebSocketDisconnect: print("Connection closed") Wait for an event for 2 seconds. try: event = await ws.receive(timeout=2.) except TimeoutError: print("No event received.") except WebSocketDisconnect: print("Connection closed") N) r fail_afterrrrr r0rerr rrrr!r!r"rs ' zAsyncWebSocketSession.receivec.||IdH}t|tjjr|jSt|)a4 Receive text from the server. Args: timeout: Number of seconds to wait for an event. If `None`, will block until an event is available. Returns: Text data. Raises: TimeoutError: No event was received before the timeout delay. WebSocketDisconnect: The server closed the websocket. WebSocketNetworkError: A network error occured. WebSocketInvalidTypeReceived: The received event was not a text message. Examples: Wait for text until available. try: text = await ws.receive_text() except WebSocketDisconnect: print("Connection closed") Wait for text for 2 seconds. try: event = await ws.receive_text(timeout=2.) except TimeoutError: print("No text received.") except WebSocketDisconnect: print("Connection closed") Nrrr!r!r"r1 #z"AsyncWebSocketSession.receive_textcr)a: Receive bytes from the server. Args: timeout: Number of seconds to wait for an event. If `None`, will block until an event is available. Returns: Bytes data. Raises: TimeoutError: No event was received before the timeout delay. WebSocketDisconnect: The server closed the websocket. WebSocketNetworkError: A network error occured. WebSocketInvalidTypeReceived: The received event was not a bytes message. Examples: Wait for bytes until available. try: data = await ws.receive_bytes() except WebSocketDisconnect: print("Connection closed") Wait for bytes for 2 seconds. try: data = await ws.receive_bytes(timeout=2.) except TimeoutError: print("No data received.") except WebSocketDisconnect: print("Connection closed") Nrrr!r!r"rYrz#AsyncWebSocketSession.receive_bytescsJ|dvsJ|dkr||IdH}n |dkr ||IdH}t|S)a Receive JSON data from the server. The received data should be parseable by [json.loads][json.loads]. Args: timeout: Number of seconds to wait for an event. If `None`, will block until an event is available. mode: Receive mode. Should either be `'text'` or `'bytes'`. Returns: Parsed JSON data. Raises: TimeoutError: No event was received before the timeout delay. WebSocketDisconnect: The server closed the websocket. WebSocketNetworkError: A network error occured. WebSocketInvalidTypeReceived: The received event didn't correspond to the specified mode. Examples: Wait for data until available. try: data = await ws.receive_json() except WebSocketDisconnect: print("Connection closed") Wait for data for 2 seconds. try: data = await ws.receive_json(timeout=2.) except TimeoutError: print("No data received.") except WebSocketDisconnect: print("Connection closed") rrNrrrr!r!r"rs * z"AsyncWebSocketSession.receive_jsonrrrc s|j|jjtjjjtjjjhvrTtj ||}|j |}z(|j 4IdH|j |IdHWdIdHn 1IdHsCwYWn tjySYnw|j IdHdS)a Close the WebSocket session. Internally, it'll send the [CloseConnection][wsproto.events.CloseConnection] event. *This method is automatically called when exiting the context manager.* Args: code: The integer close code to indicate why the connection has closed. reason: Additional reasoning for why the connection has closed. Examples: Close the WebSocket session. await ws.close() N)r=rr1rr0rrrrerrgr?r,rorprqrrr!r!r"rZs"  (zAsyncWebSocketSession.closerc sd}z|js||IdH}|j||jD]}t|tjjrT|j | }|j 4IdH|j |IdHWdIdHn 1IdHsNwYqt|tjjrc|j|jqt|tjjro|jt|tjjr|js|dur|j}n*||j7}n$|dur|j |IdHnt|}|||j}d}|j |IdHq|j |IdHq|jr WdSWdStjtjtfy|tjdIdH|j t IdHYdSw)am Background task listening for data from the server. Internally, it'll: * Answer to Ping events. * Acknowledge Pong events. * Put other events in the [_events][_events] queue that'll eventually be consumed by the user. Args: max_bytes: The maximum chunk size to read at each iteration. Nr)!r=rrr1rrerr0rfrgr&r?r,rorr:rrbrrrrrtrrrprrqr$rZrrrr rr!r!r"rTsL  (  "z)AsyncWebSocketSession._background_receiverrcs|jskt|IdHz |IdH}Wn tjjy#YdSw|durdzt|| IdHWdn1s@wYWnt yc| t j dIdH|jtIdHYnw|jrdSdSr)r=rrsleeprlr0 utilitiesLocalProtocolErrorrrN TimeoutErrorrZrrrrrgr )rGrrrr!r!r"rX s*    z0AsyncWebSocketSession._background_keepalive_pingcs&|j|IdH}|dkrt|Srrrr!r!r"r!s z"AsyncWebSocketSession._read_stream)r-rrrrIrr)-rrr rrrrrrr0rer<r rrrrrrrrrHrr BaseExceptionrrrrrlrgr{rrrrrrrrrrZrTrXrr!r!r!r"r7s    #  /() 2"7  subprotocolsr-cCs:ddttdddd}|durd||d<|S) Nupgrade websocketr13)r1rzsec-websocket-keyzsec-websocket-versionz, r/)base64 b64encodesecrets token_bytesdecoder[)rr5r!r!r" _get_headers(src@seZdZdZeeeeedde j de de de dBde dBd e ed dfd d Zej dd edeedBdejd ejeddffddZdS)WebSocketClienta6 An sync WebSocket client. This class provides an API for connecting to WebSocket. Attributes: client: HTTPX client to use. If not provided, a default one will be initialized. max_message_size_bytes: Message size in bytes to receive from the server. Defaults to 65 KiB. queue_size: Size of the queue where the received messages will be held until they are consumed. If the queue is full, the client will stop receive messages from the server until the queue has room available. Defaults to 512. keepalive_ping_interval_seconds: Interval at which the client will automatically send a Ping event to keep the connection alive. Set it to `None` to disable this mechanism. Defaults to 20 seconds. keepalive_ping_timeout_seconds: Maximum delay the client will wait for an answer to its Ping event. If the delay is exceeded, [WebSocketNetworkError][httpx_ws.WebSocketNetworkError] will be raised and the connection closed. Defaults to 20 seconds. session_class: The session class to use. Defaults to [WebSocketSession][httpx_ws.WebSocketSession]. r(r)r*r+ session_classclientr(r)r*Nr+r r-cC(||_||_||_||_||_||_dSrIr r(r)r*r+r rGr r(r)r*r+r r!r!r"rHX   zWebSocketClient.__init__urlrrc ks|di}|t||jjd|fd|i|A}|jdkr%t||j|jd|j |j |j |j |d}| |VWdn1sGwYWddSWddS1s_wYdS)a' Start a sync WebSocket session. It returns a context manager that'll automatically call [close()][httpx_ws.WebSocketSession.close] when exiting. Args: url: The WebSocket URL. subprotocols: Optional list of subprotocols to negotiate with the server. **kwargs: Additional keyword arguments that will be passed to the [HTTPX stream()](https://www.python-httpx.org/api/#request) method. Returns: A [context manager][contextlib.AbstractContextManager] for [WebSocketSession][httpx_ws.WebSocketSession]. Examples: Initialize the client and connect to a WebSocket. with httpx.Client() as client: ws_client = WebSocketClient(client) with ws_client.connect("http://localhost:8000/ws") as ws: message = ws.receive_text() print(message) ws.send_text("Hello!") r5GETenetwork_streamr'N popupdaterr r, status_coder r  extensionsr(r)r*r+rGrrrr5r&sessionr!r!r"connectks( $  "zWebSocketClient.connectrI)rrr rrrrrrrClientrrrrrHrcontextmanagerrlistrr Generatorrr!r!r!r"r6sJ%   r)r(r)r*r+rr rr r(r)r*r+r rc ks|durLt9}t||||||d} | j|fd|i| } | VWdn1s-wYWddSWddS1sEwYdSt||||||d} | j|fd|i| } | VWddS1spwYdS)a% Start a sync WebSocket session. It returns a context manager that'll automatically call [close()][httpx_ws.WebSocketSession.close] when exiting. Args: url: The WebSocket URL. client: HTTPX client to use. If not provided, a default one will be initialized. max_message_size_bytes: Message size in bytes to receive from the server. Defaults to 65 KiB. queue_size: Size of the queue where the received messages will be held until they are consumed. If the queue is full, the client will stop receive messages from the server until the queue has room available. Defaults to 512. keepalive_ping_interval_seconds: Interval at which the client will automatically send a Ping event to keep the connection alive. Set it to `None` to disable this mechanism. Defaults to 20 seconds. keepalive_ping_timeout_seconds: Maximum delay the client will wait for an answer to its Ping event. If the delay is exceeded, [WebSocketNetworkError][httpx_ws.WebSocketNetworkError] will be raised and the connection closed. Defaults to 20 seconds. subprotocols: Optional list of subprotocols to negotiate with the server. session_class: The session class to use. Defaults to [WebSocketSession][httpx_ws.WebSocketSession]. **kwargs: Additional keyword arguments that will be passed to the [HTTPX stream()](https://www.python-httpx.org/api/#request) method. Returns: A [context manager][contextlib.AbstractContextManager] for [WebSocketSession][httpx_ws.WebSocketSession]. Examples: Without explicit HTTPX client. with connect_ws("http://localhost:8000/ws") as ws: message = ws.receive_text() print(message) ws.send_text("Hello!") With explicit HTTPX client. with httpx.Client() as client: with connect_ws("http://localhost:8000/ws", client) as ws: message = ws.receive_text() print(message) ws.send_text("Hello!") Nr r)rrrr rr r(r)r*r+rr r ws_clientrr!r!r" connect_wssFJ  ""r!c@seZdZdZeeeeedde j de de de dBde dBd e ed dfd d Zej dd edeedBdejd ejedffddZdS)AsyncWebSocketClientaA An async WebSocket client. This class provides an API for connecting to WebSocket. Attributes: client: HTTPX client to use. If not provided, a default one will be initialized. max_message_size_bytes: Message size in bytes to receive from the server. Defaults to 65 KiB. queue_size: Size of the queue where the received messages will be held until they are consumed. If the queue is full, the client will stop receive messages from the server until the queue has room available. Defaults to 512. keepalive_ping_interval_seconds: Interval at which the client will automatically send a Ping event to keep the connection alive. Set it to `None` to disable this mechanism. Defaults to 20 seconds. keepalive_ping_timeout_seconds: Maximum delay the client will wait for an answer to its Ping event. If the delay is exceeded, [WebSocketNetworkError][httpx_ws.WebSocketNetworkError] will be raised and the connection closed. Defaults to 20 seconds. session_class: The session class to use. Defaults to [AsyncWebSocketSession][httpx_ws.AsyncWebSocketSession]. rr r(r)r*Nr+r r-cCr rIr r r!r!r"rH)rzAsyncWebSocketClient.__init__rrrc Ks|di}|t||jjd|fd|i|4IdHF}|jdkr)t||j|jd|j |j |j |j |d}|4IdH|VWdIdHn 1IdHsUwYWdIdHdS1IdHskwYdS)am Start an async WebSocket session. It returns an async context manager that'll automatically call [close()][httpx_ws.AsyncWebSocketSession.close] when exiting. Args: url: The WebSocket URL. subprotocols: Optional list of subprotocols to negotiate with the server. **kwargs: Additional keyword arguments that will be passed to the [HTTPX stream()](https://www.python-httpx.org/api/#request) method. Returns: An [async context manager][contextlib.AbstractAsyncContextManager] for [AsyncWebSocketSession][httpx_ws.AsyncWebSocketSession]. Examples: Initialize the client and connect to a WebSocket. async with httpx.AsyncClient() as client: ws_client = AsyncWebSocketClient(client) async with ws_client.connect("http://localhost:8000/ws") as ws: message = await ws.receive_text() print(message) await ws.send_text("Hello!") r5rNrrr'rrr!r!r"r<s2 # *.zAsyncWebSocketClient.connectrI)rrr rrrrrrr AsyncClientrrrrrHrasynccontextmanagerrrrrAsyncGeneratorrr!r!r!r"r"sJ%    r"c Ks|durXt4IdH>}t||||||d} | j|fd|i|4IdH} | VWdIdHn 1IdHs;wYWdIdHdS1IdHsQwYdSt||||||d} | j|fd|i|4IdH} | VWdIdHdS1IdHswYdS)a Start an async WebSocket session. It returns an async context manager that'll automatically call [close()][httpx_ws.AsyncWebSocketSession.close] when exiting. Args: url: The WebSocket URL. client: HTTPX client to use. If not provided, a default one will be initialized. max_message_size_bytes: Message size in bytes to receive from the server. Defaults to 65 KiB. queue_size: Size of the queue where the received messages will be held until they are consumed. If the queue is full, the client will stop receive messages from the server until the queue has room available. Defaults to 512. keepalive_ping_interval_seconds: Interval at which the client will automatically send a Ping event to keep the connection alive. Set it to `None` to disable this mechanism. Defaults to 20 seconds. keepalive_ping_timeout_seconds: Maximum delay the client will wait for an answer to its Ping event. If the delay is exceeded, [WebSocketNetworkError][httpx_ws.WebSocketNetworkError] will be raised and the connection closed. Defaults to 20 seconds. subprotocols: Optional list of subprotocols to negotiate with the server. session_class: The session class to use. Defaults to [AsyncWebSocketSession][httpx_ws.AsyncWebSocketSession]. **kwargs: Additional keyword arguments that will be passed to the [HTTPX stream()](https://www.python-httpx.org/api/#request) method. Returns: An [async context manager][contextlib.AbstractAsyncContextManager] for [AsyncWebSocketSession][httpx_ws.AsyncWebSocketSession]. Examples: Without explicit HTTPX client. async with aconnect_ws("http://localhost:8000/ws") as ws: message = await ws.receive_text() print(message) await ws.send_text("Hello!") With explicit HTTPX client. async with httpx.AsyncClient() as client: async with aconnect_ws("http://localhost:8000/ws", client) as ws: message = await ws.receive_text() print(message) await ws.send_text("Hello!") Nr r)rr#r"rrr!r!r" aconnect_wstsPJ*..r&rI)Erconcurrent.futuresrJrrr7rr;rtypesrrrprr0wsproto.utilitiesanyio.streams.memoryrrrrwsproto.frame_protocolr _exceptionsr r r r r _pingrr transportrLiteralrTypeVarrrrrrrrr Exceptionrr$rrrrdictrrGenericrrrrrrrr!r"r$r#r%r&r!r!r!r"s       t   l    dm