A>qj?,ddlmZddlZddlZddlZddlZddlZddlZddlm Z m Z m Z m Z m Z ddlmZddlmZmZmZmZmZddlmZddlmZdd lmZdd lmZdd lmZm Z m!Z!dd l"m#Z#m$Z$m%Z%dd l&m'Z'm(Z(m)Z)ddl*m+Z+ddlm,Z,m-Z-m.Z.m/Z/ddl0m1Z1ddl2m3Z3m4Z4gdZ5Gdde3Z6GddZ7 d#ddddddde#dddddddddd d$dZ8 d% d&d Z9d'd!Z: d( d)d"Z;y)*) annotationsN) Awaitable Coroutine GeneratorIterableSequence) TracebackType)AnyCallableMappingSelfcast) InvalidHeader)ServerExtensionFactory) enable_server_permessage_deflate) CloseCode)build_www_authenticate_basicparse_authorization_basicvalidate_subprotocols)SERVERRequestResponse) CONNECTINGOPENEventServerProtocol) LoggerLikeOrigin StatusLike Subprotocol)get_socket_name) Connection broadcast)r&serve unix_serveServerConnectionServer basic_authceZdZdZdddddd d fdZddZd d ef dd Zdfd Zdfd Z xZ S)r)aN :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 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|t|||||||||_|jj |_|||y)Nr1)super__init__serverloop create_future request_rcvd) selfprotocolr:r2r3r4r5r6 __class__s X/opt/rentech/trading_bot/.venv/lib/python3.12/site-packages/websockets/asyncio/server.pyr9zServerConnection.__init__BsS   '%'#   26))2I2I2K   c:|jj||S)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 rArespondzServerConnection.respond\s&}}##FD11rBNcKtj|j|jgtjd{|j d}|. |||j }t |tr |d{}|+|jj#|j |_nt |t&sJ||_|||j$j(d<d}|9 |||j |j$}t |tr |d{}|t |t&sJ||_|j$j*tjj,k(rS|j.j1s9|jjtjj2d |_|j4t6urU|j9t6 4d{|jj;|j$dddd{yyy77#t$rm}||j_ |jjdd|jjtjj d}Yd}~d}~wwxYw7#t$rm}||j_ |jjdd|jjtjj d}Yd}~d}~wwxYw787#1d{7swYyxYww) z1 Perform the opening handshake. ) return_whenNzprocess_request failedTexc_infozLFailed to open a WebSocket connection. See server log for more information. r*zprocess_response failedzServer is shutting down. )expected_state)asynciowaitr=connection_lost_waiterFIRST_COMPLETEDrequest isinstancer Exceptionr? handshake_excloggererrorrDhttp HTTPStatusINTERNAL_SERVER_ERRORacceptresponserheaders status_codeSWITCHING_PROTOCOLSr: is_servingSERVICE_UNAVAILABLEstater send_context send_response)r>process_requestprocess_response server_headerr[excs rA handshakezServerConnection.handshakeqs,ll    ; ; <//   << #H* .tT\\BH!(I6)1> $ 4 4T\\ B !(H555 ( (2? %%h/H+ /dllDMMRH!(I6)1>#!(H555 (  ))T__-P-PP ..0 $ 4 4OO770! zzZ',,J,G??MM// >???( $  $2 25DMM/KK%%&>%N#}}33==E H 4$2 25DMM/KK%%&?$%O#}}33==E H :?????s?MH+M(H1H.H1A%M+3J-J*J-#C M.L&/M2&L, M#L)$M.H11 J':A"J"M"J''M*J-- L#6A"LML##M)M,L>2L5 3L>:Mc|j5t|tsJ||_|jj dyt ||y)z. Process one incoming event. N)rQrRrr= set_resultr8 process_event)r>eventr@s rArkzServerConnection.process_eventsI << eW- -- DL    ( ( . G !% (rBct|||jj|jj |}|jj j|yN)r8connection_mader; create_taskr:handler handler_tasksadd)r> transport handler_taskr@s rAroz ServerConnection.connection_madesM  *yy,,T[[-@-@-FG  !!%%l3rB)r?rr:r*r2 float | Noner3rvr4rvr5*int | None | tuple[int | None, int | None]r6int | tuple[int, int | None]returnNone)rEr!rFstrryr)rdZCallable[[ServerConnection, Request], Awaitable[Response | None] | Response | None] | NoneredCallable[[ServerConnection, Request, Response], Awaitable[Response | None] | Response | None] | Nonerf str | Noneryrz)rlrryrz)rtzasyncio.BaseTransportryrz) __name__ __module__ __qualname____doc__r9rGrrhrkro __classcell__)r@s@rAr)r)(s<')%'&(@B49/ // $ / # /$/>/2/ /42:  $*!\? \? \? "!\?" #\?| )44rBr)c eZdZdZ d ddZeddZdejdf ddZ dejdf ddZ dd Z dd Z dd Z dd Zdd ZeddZddZddZddZ ddZy)r*a WebSocket server returned by :func:`serve`. This class mirrors most of the API of :class:`asyncio.Server`, with the following differences: * You can invoke :func:`serve` as ``async with serve(...) as server: ...`` in addition to ``server = await serve(...)`` to start the server. * It doesn't provide ``close_clients`` or ``abort_clients``; by default, :meth:`close` closes existing connections with code 1001 (going away). Args: handler: Handler for one connection. It receives an asyncio protocol. logger: Logger for this server. It defaults to ``logging.getLogger("websockets.server")``. See the :doc:`logging guide <../../topics/logging>` for details. Nc||_||_|tjd}||_t |_t |_d|_tj}|j|_ y)Nzwebsockets.server) create_serverrqlogging getLoggerrUsetall_connectionsrr close_taskrMget_running_loopr<handlers_waiter)r>rrqrUr;s rAr9zServer.__init__sp + >&&':;F 7:e69e6:'')595G5G5IrBcx|jDchc] }|jjtur|"c}Scc}w)a 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`. )rr?rar)r> connections rA connectionszServer.connectionss>#22 ""((D0    s%7Tc|j6|jj|j||||_yy)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 code 1001 (going away). ``code`` and ``reason`` can be customized, for example to use code 1012 (service restart). * Wait until all connection handlers have returned. :meth:`close` is idempotent. N)rget_looprp_close)r>close_connectionscodereasons rAclosez Server.close"s<2 ?? ""mmo99 -tV<DO #rBc K|jjd|jj|rw|jDcgc]C}|j j tur%tj|j||E}}|rtj|d{|jjd{|jr'tj|jd{|jjd|jjdycc}w77u7Dw)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. zserver closingNz server closed)rUinfor:rrr?rarrMrprN wait_closedrrrrj)r>rrrr close_taskss rArz Server._close@s )*  #'"6"6&&,,4##J$4$4T6$BCK ll;///kk%%'''   ,,t112 2 2 ''- ))0 ( 3sDAEAD=E,E-!EE2EEAEEEc6|jjS)z7 See :meth:`asyncio.Server.get_loop`. )r:rr>s rArzServer.get_loopls {{##%%rBcTK|jjd{y7w)a 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)r: start_servingrs rArzServer.start_servingsskk'')))s (&(c$K |js|jd{|jd{y77#tj$r1 |j |jd{7#xYwwxYww)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` or by calling :meth:`~Server.close` from another task. N)r_rrrMCancelledErrorrrs rA serve_foreverzServer.serve_forevers} ??$((***""$ $ $+ $%%   &&(((  saB#A AA AA BA A B #BBBB B  B  Bc6|jjS)z9 See :meth:`asyncio.Server.is_serving`. )r:r_rs rAr_zServer.is_servings {{%%''rBc^Ktj|jd{y7w)a Wait until the server is closed. When :meth:`wait_closed` returns, all TCP connections are closed and all connection handlers have returned. To ensure a fast shutdown, a connection handler should always be awaiting at least one of: * :meth:`~ServerConnection.recv`: when the connection is closed, it raises :exc:`~websockets.exceptions.ConnectionClosedOK`; * :meth:`~ServerConnection.wait_closed`: when the connection is closed, it returns. Then the connection handler is immediately notified of the shutdown; it can clean up and exit. N)rMshieldrrs rArzServer.wait_closeds &nnT11222s #-+-c.|jjS)z6 See :attr:`asyncio.Server.sockets`. )r:socketsrs rArzServer.socketss {{"""rBcKt|dsw|jd{|_|jjr@|jjD]'}|j j dt|)|S7ew)Nr:zserver listening on %s)hasattrrr:r_rrUrr#)r>socks rA_awaitz Server._awaitsrtX& $ 2 2 44DK{{%%' KK//VDKK$$%=t?TUV 5s B BA&B c>|jjSrn)r __await__rs rArzServer.__await__s{{}&&((rBc"K|d{S7wrnrs rA __aenter__zServer.__aenter__szzs  c`K|j|jd{y7wrn)rr)r>exc_type exc_value tracebacks rA __aexit__zServer.__aexit__s#    s $.,.rn)rz1Callable[[], Coroutine[Any, Any, asyncio.Server]]rqz7Callable[[ServerConnection], Coroutine[Any, Any, None]]rULoggerLike | Noneryrz)ryzset[ServerConnection])rboolrzCloseCode | intrr{ryrz)ryzasyncio.AbstractEventLoop)ryrz)ryr)ryztuple[socket.socket, ...])ryr )ryzGenerator[Any, None, Self])rztype[BaseException] | NonerzBaseException | NonerzTracebackType | Noneryrz)rrrrr9propertyrr GOING_AWAYrrrrrr_rrrrrrrrBrAr*r*s20%) JHJIJ" J  J.    "#' ) 4 4    @#' ) 4 4 ****** **  **X& *8(3*##)!,!(!( !  !rBr*deflater.r-ir/r0)origins extensions subprotocolsselect_subprotocol compressionrdrerf open_timeoutr2r3r4max_sizer5r6rUcreate_connectionc n  t|dk(r tn|td|tj d$j d j dd fd }d  f d d   fd }t ||S) u 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 function returns a :class:`Server` object whose API mirrors :class:`asyncio.Server`. Treat it as an asynchronous context manager to serve requests and ensure that the server will be closed gracefully:: from websockets.asyncio.server import serve async def handler(websocket): ... # set this event to exit the server stop = asyncio.Event() async with serve(handler, host, port): await stop.wait() Alternatively, await it and call :meth:`~Server.serve_forever` to serve requests, then cancel it or call :meth:`~Server.close` to stop the server:: server = await serve(handler, host, port) await server.serve_forever() The following pattern is functional but redundant: by the time the context manager exits, :meth:`~Server.serve_forever` has already closed the server:: async with serve(handler, host, port) as server: 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. Values can be :class:`str` to test for an exact match or regular expressions compiled by :func:`re.compile` to test against a pattern. 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. 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. 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. 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. You may pass a ``(max_message_size, max_fragment_size)`` tuple to set different limits for messages and fragments when you expect long messages sent in short fragments. 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()`. rzunsupported compression: sslssl_handshake_timeoutssl_shutdown_timeoutcKtj}jddr|jfid{S|jfid{S7!7w)NunixF)rMrpopcreate_unix_serverr)r;hostkwargsportprotocol_factorys rArzserve..create_serversn'') ::fe $0001ALVLL L,++,J|jusJ|Srn)r?)r?rrrs rAprotocol_select_subprotocolzDserve..protocol_factory..protocol_select_subprotocols2 *555:#6#6666)*lCCrB)rrrrrrUr1)r?rrzSequence[Subprotocol]ryzSubprotocol | Noner)rr?rr4rrrUr5rrr2r3rr:rr6s @rArzserve..protocol_factorys  $  ) D( D3 D$ D"!%:  '  '%'# rBcK tj4d{|jd{dddd{|jjt urI|j j jjtjyjj||j |d{|jd{jj| jjtjy7377#1d{7swYxYw77o#t$rH|j j#dd|jt$j&d{7YwxYw#jj|wxYw#t$r|j jYwxYw#jjtjwxYww)a Handle the lifecycle of a WebSocket connection. Since this coroutine 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. Nzconnection handler failedTrJ)rMtimeoutrhr?rarrtabortrrdiscard current_taskrrsstart_keepaliverrSrUrVrINTERNAL_ERROR)rrqrrdrer:rfs rAprotocol_handlerzserve..protocol_handlers A|4   **#$!  ""((4$$**,(  ( ()=)=)? @%  " " & &z 2  & & ( ;j))) !&&(((&&..z:  ( ()=)=)? @;     * )  A!!''(Cd'S &&y'?'?@@@ A &&..z: )  & & ( )  ( ()=)=)? @sIG(EG(EEE G( E :G(.I3+G( E4*E0+E4/GE2GG("H#.IG(EG(E- E# !E-(G(0E42G4AG<F?=GGGGG%%G((#H H HH/II)ryzasyncio.Server)ryr))rr)ryrz)rr ValueErrorr)get setdefaultr*)rqrrrrrrrrdrerfrr2r3r4rr5r6rUrrrrrr:s``````` ````````````` @@rAr'r'sZl+i5jA  4[MBCC , zz%$1<@0-@TT,,,\*A*A\M#3V zbasic_auth..QsI~d+Iszinvalid credentials argument: cZ |}tj||S#t$rYywxYwr)KeyErrorhmaccompare_digest)rrexpected_passwordcredentials_dicts rAcheck_credentialsz%basic_auth..check_credentialsXs= $4X$>!&&'8(C C  s  **c|K |jd} t|\}}||}t|tr |d{}|sD|jtjj d}t |jd<|S||_ y#t$rG|jtjj d}t |jd<|cYSwxYw#t$rG|jtjj d}t |jd<|cYSwxYw7w)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 ) r\rrGrWrX UNAUTHORIZEDrrrrRrr) rrQ authorizationr[rrvalid_credentialsrrealms rArdz#basic_auth..process_requestasB #OOOr sG"  OO55&4L /...#@@#- {4z{4|q!q!ta AE:>15 '  &!#"$!#"$;@<>05 $7;[a :a a a > a8a/a a !a& 'a4 5a@AaDEaF GaHIaJ KaN9OaP:QaR.SaV WaZ5[a^_a` aaL : :: :: :,GFJMQn nCnKnG nrB