vKgSSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSKJ r J r J r J r SSK Jr SSKJrJrJr SSKJr SSKJr SS KJr SS KJr SS KJrJrJr SS KJ r J!r!J"r" SS K#J$r$J%r%J&r& SSK'J(r( SSKJ)r)J*r*J+r+J,r, SSK-J.r. SSK/J0r0J1r1 /SQr2"SS\05r3"SS5r4"SS5r5SSSjjr6SSjr7S S!Sjjr8g)") annotationsN) Awaitable GeneratorIterableSequence) TracebackType)AnyCallablecast) InvalidHeader)ServerExtensionFactory) enable_server_permessage_deflate) CloseCode)build_www_authenticate_basicparse_authorization_basicvalidate_subprotocols)SERVERRequestResponse) CONNECTINGOPENEvent)ServerProtocol) LoggerLikeOrigin StatusLike Subprotocol)asyncio_timeout) Connection broadcast)r"serve unix_serveServerConnectionServer basic_authc^\rSrSrSrSSSSSS.SU4SjjjrSS jrS S \4SS jjrSU4S jjr SU4S jjr Sr U=r $)r%(a :mod:`asyncio` implementation of a WebSocket server connection. :class:`ServerConnection` provides :meth:`recv` and :meth:`send` methods for receiving and sending messages. It supports asynchronous iteration to receive messages:: async for message in websocket: await process(message) The iterator exits normally when the connection is closed with close code 1000 (OK) or 1001 (going away) or without a close code. It raises a :exc:`~websockets.exceptions.ConnectionClosedError` when the connection is closed with any other code. The ``ping_interval``, ``ping_timeout``, ``close_timeout``, ``max_queue``, and ``write_limit`` arguments have the same meaning as in :func:`serve`. Args: protocol: Sans-I/O connection. server: Server that manages this connection.   ping_interval ping_timeout close_timeout max_queue write_limitc |>U [TU]UUUUUUS9 X lURR 5UlU g)Nr.)super__init__serverloop create_future request_rcvd) selfprotocolr7r/r0r1r2r3 __class__s Y/var/www/highfloat_scraper/venv/lib/python3.13/site-packages/websockets/asyncio/server.pyr6ServerConnection.__init__BsK   '%'#   26))2I2I2K c8URRX5$)a Create a plain text HTTP response. ``process_request`` and ``process_response`` may call this method to return an HTTP response instead of performing the WebSocket opening handshake. You can modify the response before returning it, for example by changing HTTP headers. Args: status: HTTP status code. text: HTTP response body; it will be encoded to UTF-8. Returns: HTTP response to send to the client. )r<reject)r;statustexts r>respondServerConnection.respondZs&}}##F11r@Nc# [R"URUR/[RS9IShvN UR GbUR [S9IShvN SnUb2U"XR 5n[U[5(a UIShvN nUcUR"R%5(a+URR'UR 5UlOWURR[RR*S5UlO[U[,5(deX@lU(aX0R(R.S'SnUb=U"XR UR(5n[U[5(a UIShvN nUb[U[,5(deX@lURR1UR(5 SSS5IShvN URRbURRegGNGNGN![aOnXPRl URR[RR S5nSnAGNSnAff=fN![aOnXPRl URR[RR S5nSnAGN>SnAff=fN!,IShvN (df  GN =f7f)z! Perform the opening handshake. ) return_whenN)expected_statezLFailed to open a WebSocket connection. See server log for more information. zServer is shutting down. r&)asynciowaitr:connection_lost_waiterFIRST_COMPLETEDrequest send_contextr isinstancer Exceptionr< handshake_excrBhttp HTTPStatusINTERNAL_SERVER_ERRORr7 is_servingacceptresponseSERVICE_UNAVAILABLErheaders send_response)r;process_requestprocess_response server_headerrXexcs r> handshakeServerConnection.handshakeos^,ll    ; ; <//   << #(( (CC". #24#F%h ::-5~H#{{--//(, (<((6$69 3#'==#7#7 OOAA!I$QDCCCs=L H-)L )H0*L -K24,H6 H3!H6%CK2.7J%J&J*AK2/ L :K0;3L 0L 3H66 JAJ K2 JK2J K-AK("K2(K--K20L 2L 8K; 9 L L c>URc9[U[5(deXlURR S5 g[ TU]U5 g)z Process one incoming event. N)rNrPrr: set_resultr5 process_event)r;eventr=s r>rdServerConnection.process_eventsJ << eW-- -- L    ( ( . G !% (r@cZ>[TU]U5 URRU5 gN)r5connection_mader7start_connection_handler)r; transportr=s r>ri ServerConnection.connection_mades"  * ,,T2r@)rNr:rXr7)r<rr7r&r/ float | Noner0rmr1rmr2*int | None | tuple[int | None, int | None]r3int | tuple[int, int | None]returnNone)rCrrDstrrpr)r\ZCallable[[ServerConnection, Request], Awaitable[Response | None] | Response | None] | Noner]dCallable[[ServerConnection, Request, Response], Awaitable[Response | None] | Response | None] | Noner^ str | Nonerprq)rerrprq)rkzasyncio.BaseTransportrprq) __name__ __module__ __qualname____firstlineno____doc__r6rErr`rdri__static_attributes__ __classcell__)r=s@r>r%r%(s<')%'&(@B49  $  # $>2 02:  $*!]. ]. ]. "!]." #].~ )33r@r%c\rSrSrSrSS\SSS.SSjjr\SSj5rSSjr SS jr SS jr SSS jjr SS jr SS jrSSjrSSjrSSjrSSjr\SSj5rS SjrS!SjrSrg)"r&a WebSocket server returned by :func:`serve`. This class mirrors the API of :class:`asyncio.Server`. It keeps track of WebSocket connections in order to close them properly when shutting down. Args: handler: Connection handler. It receives the WebSocket connection, which is a :class:`ServerConnection`, in argument. process_request: Intercept the request during the opening handshake. Return an HTTP response to force the response. Return :obj:`None` to continue normally. When you force an HTTP 101 Continue response, the handshake is successful. Else, the connection is aborted. ``process_request`` may be a function or a coroutine. process_response: Intercept the response during the opening handshake. Modify the response or return a new HTTP response to force the response. Return :obj:`None` to continue normally. When you force an HTTP 101 Continue response, the handshake is successful. Else, the connection is aborted. ``process_response`` may be a function or a coroutine. server_header: Value of the ``Server`` response header. It defaults to ``"Python/x.y.z websockets/X.Y"``. Setting it to :obj:`None` removes the header. open_timeout: Timeout for opening connections in seconds. :obj:`None` disables the timeout. logger: Logger for this server. It defaults to ``logging.getLogger("websockets.server")``. See the :doc:`logging guide <../../topics/logging>` for details. Nr+r\r]r^ open_timeoutloggerc [R"5UlXlX lX0lX@lXPlUc[R"S5nX`l 0Ul SUl URR5Ulg)Nzwebsockets.server)rJget_running_loopr8handlerr\r]r^rlogging getLoggerrhandlers close_taskr9 closed_waiter)r;rr\r]r^rrs r>r6Server.__init__sw,,,.  . 0*( >&&':;F EG 6:48993J3J3Lr@clURVs1sHoR[LdMUiM sn$s snf)z Set of active connections. This property contains all connections that completed the opening handshake successfully and didn't start the closing handshake yet. It can be useful in combination with :func:`~broadcast`. )rstaterr; connections r> connectionsServer.connections,s,.2]]W]z>N>NRV>V ]WWWs11cXlURHnUR[R:XaSUR 5-nO}UR[R :XaSUR 5SS-nOHUR[R:XaUR 5nO[UR 55nURRSU5 M g)a Attach to a given :class:`asyncio.Server`. Since :meth:`~asyncio.loop.create_server` doesn't support injecting a custom ``Server`` class, the easiest solution that doesn't rely on private :mod:`asyncio` APIs is to: - instantiate a :class:`Server` - give the protocol factory a reference to that instance - call :meth:`~asyncio.loop.create_server` with the factory - attach the resulting :class:`asyncio.Server` with this method z%s:%dz[%s]:%dNr zserver listening on %s) r7socketsfamilysocketAF_INET getsocknameAF_INET6AF_UNIXrrrinfo)r;r7socknames r>wrap Server.wrap8s NND{{fnn,!1!1!33/ 4#3#3#5bq#99.'')4++-. KK  5t <#r@cn# [UR5IShvN URURURUR 5IShvN SSS5IShvN URR[LaUR5 URU gUR!5 UR#U5IShvN UR%5IShvN URU gNN![ Ra UR5 e[aK URRSSS9 UR5 SSS5IShvN URU gf=fGN!,IShvN (df  GN'=fNN![aE URRSSS9 UR%[&R(5IShvN Nf=f![*a GN[a UR,R/5 GN5f=f!URU f=f7f)z Handle the lifecycle of a WebSocket connection. Since this method doesn't have a caller that can handle exceptions, it attempts to log relevant ones. It guarantees that the TCP connection is closed before exiting. Nzopening handshake failedT)exc_infozconnection handler failed)r rr`r\r]r^rJCancelledErrorclose_transportrQrerrorrr<rrstart_keepalivercloserINTERNAL_ERROR TimeoutErrorrkabortrs r> conn_handlerServer.conn_handlerTs* *&t'8'899 $..,,--**:9""((4**,. j)+ )**,ll:... !&&((( j)S: --..0 %%++,FQU+V..0:99R j)?:999,/ )  A!!''(Cd'S &&y'?'?@@@ A    )  & & ( ) j)s.H5G,C8G,E;4C<C:C< G,'E8(1G,H5)$F FFG,%F&G,*H58G,:C<rjServer.start_connection_handlers,%)II$9$9$:K:KJ:W$X j!r@cURc4UR5RURU55Ulgg)a Close the server. * Close the underlying :class:`asyncio.Server`. * When ``close_connections`` is :obj:`True`, which is the default, close existing connections. Specifically: * Reject opening WebSocket connections with an HTTP 503 (service unavailable) error. This happens when the server accepted the TCP connection but didn't complete the opening handshake before closing. * Close open WebSocket connections with close code 1001 (going away). * Wait until all connection handlers terminate. :meth:`close` is idempotent. N)rget_loopr_close)r;close_connectionss r>r Server.closes8$ ?? ""mmo99 -.DO #r@c# URRS5 URR5 [R "S5IShvN U(aUR Vs/sHGnURR[LdM"[R"URS55PMI nnU(a[R"U5IShvN URR5IShvN UR (a6[R"UR R55IShvN URRS5 URRS5 gGN.s snfNNNG7f)z Implementation of :meth:`close`. This calls :meth:`~asyncio.Server.close` on the underlying :class:`asyncio.Server` object to stop accepting new connections and then closes open connections with close code 1001. zserver closingrNiz server closed)rrr7rrJsleeprr<rrrrK wait_closedvaluesrrc)r;rr close_taskss r>r Server._closes- )*  mmA  #'--"/J&&,,J><##J$4$4T$:;"/  ll;///kk%%''' ==,,t}}3356 6 6 %%d+ )3  0 ( 7s[AF E?F + F)F8"F F!F <F =AF F rServer.wait_closeds&nnT//000 $.,.c6URR5$)z' See :meth:`asyncio.Server.get_loop`. )r7rrs r>rServer.get_loops {{##%%r@c6URR5$)z) See :meth:`asyncio.Server.is_serving`. )r7rVrs r>rVServer.is_servings {{%%''r@cT# URR5IShvN gN7f)z See :meth:`asyncio.Server.start_serving`. Typical use:: server = await serve(..., start_serving=False) # perform additional setup here... # ... then start the server await server.start_serving() N)r7 start_servingrs r>rServer.start_servingskk''))) (&(cT# URR5IShvN gN7f)a{ See :meth:`asyncio.Server.serve_forever`. Typical use:: server = await serve(...) # this coroutine doesn't return # canceling it stops the server await server.serve_forever() This is an alternative to using :func:`serve` as an asynchronous context manager. Shutdown is triggered by canceling :meth:`serve_forever` instead of exiting a :func:`serve` context. N)r7 serve_foreverrs r>rServer.serve_forever s kk'')))rc.URR$)z& See :attr:`asyncio.Server.sockets`. )r7rrs r>rServer.socketss {{"""r@c# U$7frhrs r> __aenter__Server.__aenter__#s  sc`# UR5 UR5IShvN gN7frh)rrr;exc_type exc_value tracebacks r> __aexit__Server.__aexit__&s"    r) rrrrrr8rr\r]r7r^)r-Callable[[ServerConnection], Awaitable[None]]r\rsr]rtr^rurrmrLoggerLike | Nonerprq)rpzset[ServerConnection])r7zasyncio.Serverrprq)rr%rprq)T)rboolrprq)rprq)rpzasyncio.AbstractEventLoop)rpr)rpzIterable[socket.socket]rpr&rztype[BaseException] | NonerzBaseException | NonerzTracebackType | Nonerprq)rvrwrxryrzrr6propertyrrrrjrrrrrVrrrrrr{rr@r>r&r&sV  $*%'$()'M>'M   'M 'M$"%'M&#''M(")'M* +'MR X X=84*l Y.**X1*&( **$##!,!(!( !  !r@r&c\rSrSrSrSSSSSSS\SSSSSSSS SSS .SS jjjrSS jrSS jrSSjr SSjr \ r Sr g)r#i1uo Create a WebSocket server listening on ``host`` and ``port``. Whenever a client connects, the server creates a :class:`ServerConnection`, performs the opening handshake, and delegates to the ``handler`` coroutine. The handler receives the :class:`ServerConnection` instance, which you can use to send and receive messages. Once the handler completes, either normally or with an exception, the server performs the closing handshake and closes the connection. This coroutine returns a :class:`Server` whose API mirrors :class:`asyncio.Server`. Treat it as an asynchronous context manager to ensure that the server will be closed:: from websockets.asyncio.server import serve def handler(websocket): ... # set this future to exit the server stop = asyncio.get_running_loop().create_future() async with serve(handler, host, port): await stop Alternatively, call :meth:`~Server.serve_forever` to serve requests and cancel it to stop the server:: server = await serve(handler, host, port) await server.serve_forever() Args: handler: Connection handler. It receives the WebSocket connection, which is a :class:`ServerConnection`, in argument. host: Network interfaces the server binds to. See :meth:`~asyncio.loop.create_server` for details. port: TCP port the server listens on. See :meth:`~asyncio.loop.create_server` for details. origins: Acceptable values of the ``Origin`` header, for defending against Cross-Site WebSocket Hijacking attacks. Include :obj:`None` in the list if the lack of an origin is acceptable. extensions: List of supported extensions, in order in which they should be negotiated and run. subprotocols: List of supported subprotocols, in order of decreasing preference. select_subprotocol: Callback for selecting a subprotocol among those supported by the client and the server. It receives a :class:`ServerConnection` (not a :class:`~websockets.server.ServerProtocol`!) instance and a list of subprotocols offered by the client. Other than the first argument, it has the same behavior as the :meth:`ServerProtocol.select_subprotocol ` method. process_request: Intercept the request during the opening handshake. Return an HTTP response to force the response or :obj:`None` to continue normally. When you force an HTTP 101 Continue response, the handshake is successful. Else, the connection is aborted. ``process_request`` may be a function or a coroutine. process_response: Intercept the response during the opening handshake. Return an HTTP response to force the response or :obj:`None` to continue normally. When you force an HTTP 101 Continue response, the handshake is successful. Else, the connection is aborted. ``process_response`` may be a function or a coroutine. server_header: Value of the ``Server`` response header. It defaults to ``"Python/x.y.z websockets/X.Y"``. Setting it to :obj:`None` removes the header. compression: The "permessage-deflate" extension is enabled by default. Set ``compression`` to :obj:`None` to disable it. See the :doc:`compression guide <../../topics/compression>` for details. open_timeout: Timeout for opening connections in seconds. :obj:`None` disables the timeout. ping_interval: Interval between keepalive pings in seconds. :obj:`None` disables keepalive. ping_timeout: Timeout for keepalive pings in seconds. :obj:`None` disables timeouts. close_timeout: Timeout for closing connections in seconds. :obj:`None` disables the timeout. max_size: Maximum size of incoming messages in bytes. :obj:`None` disables the limit. max_queue: High-water mark of the buffer where frames are received. It defaults to 16 frames. The low-water mark defaults to ``max_queue // 4``. You may pass a ``(high, low)`` tuple to set the high-water and low-water marks. If you want to disable flow control entirely, you may set it to ``None``, although that's a bad idea. write_limit: High-water mark of write buffer in bytes. It is passed to :meth:`~asyncio.WriteTransport.set_write_buffer_limits`. It defaults to 32 KiB. You may pass a ``(high, low)`` tuple to set the high-water and low-water marks. logger: Logger for this server. It defaults to ``logging.getLogger("websockets.server")``. See the :doc:`logging guide <../../topics/logging>` for details. create_connection: Factory for the :class:`ServerConnection` managing the connection. Set it to a wrapper or a subclass to customize connection handling. Any other keyword arguments are passed to the event loop's :meth:`~asyncio.loop.create_server` method. For example: * You can set ``ssl`` to a :class:`~ssl.SSLContext` to enable TLS. * You can set ``sock`` to provide a preexisting TCP socket. You may call :func:`socket.create_server` (not to be confused with the event loop's :meth:`~asyncio.loop.create_server` method) to create a suitable server socket and customize it. * You can set ``start_serving`` to ``False`` to start accepting connections only after you call :meth:`~Server.start_serving()` or :meth:`~Server.serve_forever()`. Ndeflater+r*ir,r-)origins extensions subprotocolsselect_subprotocolr\r]r^ compressionrr/r0r1max_sizer2r3rcreate_connectionc 6^^^^^^ ^^^^^^^Tb [T5 U S:Xa [T5mOU b[SU 35eTc[m[ UUU U U TS9TlUR S5b;URSU 5 [RSSS:aURST5 S UUUUUUUU UUUUU4 S jjn[R"5nURS S 5(aUR"U40UD6TlgUR"UX#40UD6Tlg) Nrzunsupported compression: rsslssl_handshake_timeoutr ) ssl_shutdown_timeoutc z> ^SnT bSUU 4Sjjn[T TTUTTS9nT"UT RT T TTTS9mT$)zB Create an asyncio protocol for managing a WebSocket connection. NcB>TceUTRLdeT"TU5$rh)r<)r<rrrs r>protocol_select_subprotocolDserve.__init__..factory..protocol_select_subprotocols2 .999#z':'::::-j,GGr@)rrrrrrr.)r<rrzSequence[Subprotocol]rpzSubprotocol | None)rr7)rr<rr1rrrr2rrr/r0rr;rr3s @r>factoryserve.__init__..factorys ("-H,H"7H(HH&%)#>! H+ +)+#'J r@unixF)rpr%)rr ValueErrorr%r&r7get setdefaultsys version_inforJrpopcreate_unix_server create_server)r;rhostportrrrrr\r]r^rrr/r0r1rr2r3rrkwargsrr8s` ```` ```````` r>r6serve.__init__sb  # !, / ) #9*EJ  $8 FG G  $ 0  +-'%    ::e  (   5| D#w.!!"8-H, , , \'') ::fe $ $!%!8!8!KF!KD "&!3!3GT!R6!RD r@c"# UIShvN $N7frhrrs r>rserve.__aenter__&szzs  c# URR5 URR5IShvN gN7frh)r7rrrs r>rserve.__aexit__)s- kk%%'''s8AAAc>UR5R5$rh)__await_impl__ __await__rs r>rserve.__await__4s""$..00r@c# URIShvN nURRU5 UR$N+7frh)rr7r)r;r7s r>rserve.__await_impl__8s4)))  {{*sA>,A)rr7)NN),rrrrur int | NonerzSequence[Origin | None] | Nonerz'Sequence[ServerExtensionFactory] | NonerzSequence[Subprotocol] | NonerzNCallable[[ServerConnection, Sequence[Subprotocol]], Subprotocol | None] | Noner\rsr]rtr^rurrurrmr/rmr0rmr1rmrrr2rnr3rorrrztype[ServerConnection] | Nonerr rprqrr)rpzGenerator[Any, None, Server]) rvrwrxryrzrr6rrrr__iter__r{rr@r>r#r#1sql  }S37>B59   $*"+%'&(%'&($@B49$(;?[}S>}S}S }S0}S<}S3}S }S$ %}S2 3}S>"?}S@ A}SD#E}SF$G}SH#I}SJ$K}SNO}SP>Q}SR2S}SV"W}SZ9[}S^_}S` a}SB(,(((( (  (1Hr@r#c  [U4SUS.UD6$)a Create a WebSocket server listening on a Unix socket. This function is identical to :func:`serve`, except the ``host`` and ``port`` arguments are replaced by ``path``. It's only available on Unix. It's useful for deploying a server behind a reverse proxy such as nginx. Args: handler: Connection handler. It receives the WebSocket connection, which is a :class:`ServerConnection`, in argument. path: File system path to the Unix socket. T)rpath)r#)rr rs r>r$r$Bs&  9t$ 9& 99r@cUup[U[5=(a [U[5$![[4a gf=fNF)rPrr TypeErrorr) credentialsusernamepasswords r>is_credentialsrXsDG((C(FZ#-FF z "s-AAc^^^USLTSL:Xa [S5eUb[U5(a[[[[4U5/nOv[ U[ 5(aS[[[ [[[4U55n[SU55(d[SU35eO[SU35e[U5mSU4SjjmTceSUU4SjjnU$) a Factory for ``process_request`` to enforce HTTP Basic Authentication. :func:`basic_auth` is designed to integrate with :func:`serve` as follows:: from websockets.asyncio.server import basic_auth, serve async with serve( ..., process_request=basic_auth( realm="my dev server", credentials=("hello", "iloveyou"), ), ): If authentication succeeds, the connection's ``username`` attribute is set. If it fails, the server responds with an HTTP 401 Unauthorized status. One of ``credentials`` or ``check_credentials`` must be provided; not both. Args: realm: Scope of protection. It should contain only ASCII characters because the encoding of non-ASCII characters is undefined. Refer to section 2.2 of :rfc:`7235` for details. credentials: Hard coded authorized credentials. It can be a ``(username, password)`` pair or a list of such pairs. check_credentials: Function or coroutine that verifies credentials. It receives ``username`` and ``password`` arguments and returns whether they're valid. Raises: TypeError: If ``credentials`` or ``check_credentials`` is wrong. ValueError: If ``credentials`` and ``check_credentials`` are both provided or both not provided. Nz/provide either credentials or check_credentialsc36# UHn[U5v M g7frh)r).0items r> basic_auth..sI8H~d++8Hszinvalid credentials argument: c\>TUn[R"X!5$![a gf=fr )KeyErrorhmaccompare_digest)rrexpected_passwordcredentials_dicts r>check_credentials%basic_auth..check_credentialss; $4X$>!&&'8C C  s  ++c># URSn[U5upET"XE5n[U[5(a UIShvN nU(dDUR[RR S5n[ T5URS'U$X@l g![aG UR[RR S5n[ T5URS'Us$f=f![aG UR[RR S5n[ T5URS'Us$f=fN7f)z Perform HTTP Basic Authentication. If it succeeds, set the connection's ``username`` attribute and return :obj:`None`. If it fails, return an HTTP 401 Unauthorized responss. AuthorizationzMissing credentials zWWW-AuthenticatezUnsupported credentials NzInvalid credentials ) rZrrErSrT UNAUTHORIZEDrrr rPrr) rrN authorizationrXrrvalid_credentialsrrealms r>r\#basic_auth..process_requests> #OOOr'r'asP t!2d!:;JKK + & & $U38_k BC   X . .#D%S/)BK$PQ I8HIII"@ NOOJ<[MJK K 01 D  (( (,$,, ,,\ r@rh)rrr rurr rpzAwaitable[Server])rr rpr)NN)r%rrrz2tuple[str, str] | Iterable[tuple[str, str]] | Nonerz3Callable[[str, str], Awaitable[bool] | bool] | NonerpzACallable[[ServerConnection, Request], Awaitable[Response | None]])9 __future__rrJrrSrrrcollections.abcrrrrtypesrtypingr r r exceptionsr extensions.baserextensions.permessage_deflaterframesrrZrrrhttp11rrrr<rrrr7rrrrr compatibilityr rr!r"__all__r%r&r#r$rr'rr@r>r8s"  DD&&&4L /...#@@*- v3zv3rL!L!` NNf: :: :: :,GFJMQn nCnKnG nr@