vKgRgHSSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSKr SSK r SSK r SSK r SSK JrJr SSKJr SSKJrJrJr SSKJr SSKJr SS KJr SS KJr SS KJrJ r J!r! SS K"J#r#J$r$J%r% SS K&J'r'J(r(J)r) SSK*J+r+ SSKJ,r,J-r-J.r.J/r/ SSK0J1r1 SSK2J3r3 /SQr4"SS\15r5"SS5r6S"Sjr7S#SSSSSSSS\#SSSSSSSS.S$Sjjjr8S%S&Sjjr9S'S jr:S(S)S!jjr;g)*) annotationsN)IterableSequence) TracebackType)AnyCallablecast) InvalidHeader)ServerExtensionFactory) enable_server_permessage_deflate) CloseCode)build_www_authenticate_basicparse_authorization_basicvalidate_subprotocols)SERVERRequestResponse) CONNECTINGOPENEvent)ServerProtocol) LoggerLikeOrigin StatusLike Subprotocol) Connection)Deadline)serve unix_serveServerConnectionServer basic_authc^\rSrSrSrSSS.S U4SjjjrSSjrSS\S4SS jjrSU4S jjr SU4S jjr S r U=r $)r"%a :mod:`threading` implementation of a WebSocket server connection. :class:`ServerConnection` provides :meth:`recv` and :meth:`send` methods for receiving and sending messages. It supports iteration to receive messages:: for message in websocket: 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 ``close_timeout`` and ``max_queue`` arguments have the same meaning as in :func:`serve`. Args: socket: Socket connected to a WebSocket client. protocol: Sans-I/O connection.  close_timeout max_queuecb>U [R"5Ul[TU]UUUUS9 U g)Nr)) threadingr request_rcvdsuper__init__)selfsocketprotocolr*r+ __class__s V/var/www/highfloat_scraper/venv/lib/python3.13/site-packages/websockets/sync/server.pyr0ServerConnection.__init__?s: %OO-   '  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. )r3reject)r1statustexts r5respondServerConnection.respondQs&}}##F11r7NcURRU5(d [S5eURbUR [ S9 SnUbU"XR5nUc+URRUR5UlOXPlU(aX0RRS'SnUb'U"XRUR5nUbXPlURR!UR5 SSS5 URRbURReg![ aOnX`RlURR[RRS5nSnAGN.SnAff=f![ aOnX`RlURR[RRS5nSnAGNSnAff=f!,(df  N=f)z! Perform the opening handshake. ztimed out during handshakeN)expected_statezLFailed to open a WebSocket connection. See server log for more information. r#)r.wait TimeoutErrorrequest send_contextr Exceptionr3 handshake_excr9http HTTPStatusINTERNAL_SERVER_ERRORacceptresponseheaders send_response)r1process_requestprocess_response server_headertimeoutrJexcs r5 handshakeServerConnection.handshakefs.  %%g..;< < << #""*"=". #24#F#$(MM$8$8$FDM$,M 6CMM))(3#/ #3D,, #V +(0  ++DMM:U>h == & & 2---- - 3]%69 3#'==#7#7 OOAA!I$.%69 3#'==#7#7 OOAA!I$;>=sc G7D?%AG7>F.G7? F AF G7FG7 G4%AG/)G7/G44G77 Hc>URc8[U[5(deXlURR 5 g[ TU]U5 g)z Process one incoming event. N)rB isinstancerr.setr/ process_event)r1eventr4s r5rWServerConnection.process_eventsH << eW-- -- L    ! ! # G !% (r7c>[TU]5 URR5 g!URR5 f=f)z9 Read incoming data from the socket and process events. N)r/ recv_eventsr.rV)r1r4s r5r[ServerConnection.recv_eventss:  $ G  !    ! ! #D   ! ! #s ,A)rBr.rJ) r2 socket.socketr3rr* float | Noner+*int | None | tuple[int | None, int | None]returnNone)r:rr;strr`r) rM=Callable[[ServerConnection, Request], Response | None] | NonerNGCallable[[ServerConnection, Request, Response], Response | None] | NonerO str | NonerPr^r`ra)rXrr`rar`ra) __name__ __module__ __qualname____firstlineno____doc__r0r<rrRrWr[__static_attributes__ __classcell__)r4s@r5r"r"%s<')@B ! $  >  $2:  $* $#P. P. P. "!P."#P.$ %P.d ) $ $r7r"cx\rSrSrSrS S SjjrS SjrS SjrSSjrSSjr SS jr S r g)r#aw WebSocket server returned by :func:`serve`. This class mirrors the API of :class:`~socketserver.BaseServer`, notably the :meth:`~socketserver.BaseServer.serve_forever` and :meth:`~socketserver.BaseServer.shutdown` methods, as well as the context manager protocol. Args: socket: Server socket listening for new connections. handler: Handler for one connection. Receives the socket and address returned by :meth:`~socket.socket.accept`. logger: Logger for this server. It defaults to ``logging.getLogger("websockets.server")``. See the :doc:`logging guide <../../topics/logging>` for details. NcXlX lUc[R"S5nX0l[ R S:wa#[R"5uUl Ul gg)Nzwebsockets.serverwin32) r2handlerlogging getLoggerloggersysplatformospipeshutdown_watchershutdown_notifier)r1r2rrrus r5r0Server.__init__sP   >&&':;F <<7 "<>GGI 9D !4#9 #r7c[R"5nURUR[R5 [ RS:wa*URUR[R5 UR5 URR5up#[R"URX#4S9nUR5 M_![ a gf=f![a gf=f)z See :meth:`socketserver.BaseServer.serve_forever`. This method doesn't return. Calling :meth:`shutdown` from another thread stops the server. Typical use:: with serve(...) as server: server.serve_forever() Nrq)targetargs) selectorsDefaultSelectorregisterr2 EVENT_READ ValueErrorrvrwrzselectrIOSErrorr-Threadrrstart)r1pollersockaddrthreads r5 serve_foreverServer.serve_forevers**,  OODKK)=)= > <<7 " OOD1193G3G H MMO "[[//1  %%T\\ MF LLN      s#*CC/ C,+C,/ C<;C<cURR5 [RS:wa"[R "UR S5 gg)z0 See :meth:`socketserver.BaseServer.shutdown`. rqxN)r2closervrwrxwriter{r1s r5shutdownServer.shutdowns9  <<7 " HHT++T 2 #r7c6URR5$)z. See :meth:`socketserver.BaseServer.fileno`. )r2filenors r5r Server.fileno"s {{!!##r7cU$Nrs r5 __enter__Server.__enter__)s r7c$UR5 gr)r)r1exc_type exc_value tracebacks r5__exit__Server.__exit__,s r7)rrrur{rzr2r)r2r]rrz$Callable[[socket.socket, Any], None]ruLoggerLike | Noner`rarf)r`int)r`r#)rztype[BaseException] | NonerzBaseException | NonerzTracebackType | Noner`ra) rgrhrirjrkr0rrrrrrlrr7r5r#r#s|,%) F F6 F" F  F$L3$,((   r7r#c~US:Xa![R"S[5 [$[ S[ <SU<35e)NWebSocketServerz%WebSocketServer was renamed to Serverzmodule z has no attribute )warningswarnDeprecationWarningr#AttributeErrorrg)names r5 __getattr__r5s=    3   78,.@I JJr7deflater'ir()rsslorigins extensions subprotocolsselect_subprotocolrMrNrO compression open_timeoutr*max_sizer+rucreate_connectionc ^^^^^^^ ^ ^ ^ ^^^^^^Tc2SU;a,URS5m[R"S[5 Tb [ T5 U S:Xa [ T5mOU b[ SU 35eTc[mURSS5mURSS5nUcfT(aFUc [ S 5eURS [R5 [R"U40UD6nO'[R"X440UD6nOUb [ S 5eTbTRUS SS 9nSUUUUUUUU UU U UU UUU4Sjjn[UUT5$)a% 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``. 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 function returns a :class:`Server` whose API mirrors :class:`~socketserver.BaseServer`. Treat it as a context manager to ensure that it will be closed and call :meth:`~Server.serve_forever` to serve requests:: from websockets.sync.server import serve def handler(websocket): ... with serve(handler, ...) as server: 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 :func:`~socket.create_server` for details. port: TCP port the server listens on. See :func:`~socket.create_server` for details. sock: Preexisting TCP socket. ``sock`` replaces ``host`` and ``port``. You may call :func:`socket.create_server` to create a suitable TCP socket. ssl: Configuration for enabling TLS on the connection. 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. 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: 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. 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. 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. 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 :func:`~socket.create_server`. N ssl_contextzssl_context was renamed to sslrzunsupported compression: unixFpathzmissing path argumentfamilyz(path and sock arguments are incompatibleT) server_sidedo_handshake_on_connectc >^[T 5nT(d/UR[R[RS5 TbaUR UR 55 [U[R5(deUR5 UR S5 SnTbSUU4Sjjn[TTTUT T S9nTceT"UUTT S9mTRTTTUR 55 TR*R,[.LdeT "T5 TR5 g![a UR5 gf=f![a- TR!5 TR"R%5 g[aG TR&R)SSS9 TR!5 TR"R%5 gf=f![a< TR&R)SSS9 TR25 gf=f![a UR5 gf=f) NTcB>TceUTRLdeT"TU5$r)r3)r3r connectionrs r5protocol_select_subprotocol@serve..conn_handler..protocol_select_subprotocols2 .999#z':'::::-j,GGr7)rrrrrrur)zopening handshake failed)exc_infozconnection handler failed)r3rrzSequence[Subprotocol]r`zSubprotocol | None)r setsockoptr2 IPPROTO_TCP TCP_NODELAY settimeoutrPrU ssl_module SSLSocket do_handshakerrDrrRrA close_socketrecv_events_threadjoinruerrorr3staterrINTERNAL_ERROR)rrdeadlinerr3rr*rrrrrur+rrrrMrNrrOrrrs @r5 conn_handlerserve..conn_handlersKL)9  2 2F4F4FM 0 0 23!$ (<(<====!!#% ("-H,H"7H(HH&%)#>! H%0 00*+# J  $$#$!$$&  &&,,4 44 # #   ";  JJL    '')--224 !!''(BT'R'')--224   ;!!''(Cd'S  !9!9: ;   JJL stC D6"E=H(G%H(6EE4G H( A GH(GH(AH%"H($H%%H((II)rr]rrr`ra)poprrrrr rr" setdefaultr2AF_UNIX create_server wrap_socketr#)rrhostportrrrrrrrMrNrOrrr*rr+rurkwargsrrrs` ```````` `````` @r5r r ?sNT {}.jj' ,  l+i5jA  4[MBCC , FE*Dzz&$/D | | !899   h 7''77D'' ??D  GH H  $)  ^^^D $ f --r7c  [U4SUS.UD6$)a Create a WebSocket server listening on a Unix socket. This function accepts the same keyword arguments as :func:`serve`. 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)rr)r )rrrrs r5r!r!^s(  9t$ 9& 99r7cUup[U[5=(a [U[5$![[4a gf=fNF)rUrb TypeErrorr) credentialsusernamepasswords r5is_credentialsrusDG((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.sync.server import basic_auth, serve 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 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 g7fr)r).0items r5 basic_auth..sI8H~d++8Hszinvalid credentials argument: c\>TUn[R"X!5$![a gf=fr)KeyErrorhmaccompare_digest)rrexpected_passwordcredentials_dicts r5check_credentials%basic_auth..check_credentialss; $4X$>!&&'8C C  s  ++c@>URSn[U5upET"XE5(dDUR[RR S5n[ T5URS'U$X@l g![aG UR[RR S5n[ T5URS'Us$f=f![aG UR[RR S5n[ T5URS'Us$f=f)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 zInvalid credentials N) rKrr<rFrG UNAUTHORIZEDrrr r)rrB authorizationrJrrrrealms r5rM#basic_auth..process_requests #OOOrsA"    .&&&4L /...#@@" Nj$zj$Z``FK\. "&(,.2:>15   &'!#"$ <> $7;Y\. /\. \. \.  \. &\.,\.8\./\. \.( )\.6 7\.BC\.DE\.HI\.J K\.NO\.P:Q\.T U\.X5Y\.Z[\.\ ]\.B : /: :: :.GFJ;?j jCj9j< jr7