iHddlmZddlZddlZddlZddlZddlZddlZddlZddl Z ddl m Z ddl m Z mZmZmZmZddlmZddlmZddlmZdd lmZdd lmZdd lmZmZdd lmZm Z m!Z!dd l"m#Z#ddl m$Z$m%Z%m&Z&ddl'm(Z(ddl)m*Z*gdZ+Gdde(Z,GddZ- dEddddddddddeddddddddFd@Z. dGdHdDZ/dS)I) annotationsN) TracebackType)AnyCallableOptionalSequenceType) CloseCode)ServerExtensionFactory) enable_server_permessage_deflate)validate_subprotocols) USER_AGENT)RequestResponse) CONNECTINGOPENEvent)ServerProtocol) LoggerLikeOrigin Subprotocol) Connection)Deadline)serve unix_serveServerConnectionWebSocketServercTeZdZdZdddfd Zd d ed fddZdfd Zdfd ZxZ S)ra Threaded 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. Args: socket: Socket connected to a WebSocket client. protocol: Sans-I/O connection. close_timeout: Timeout for closing the connection in seconds.  close_timeoutsocket socket.socketprotocolrr#Optional[float]returnNonec|tj|_t|||dS)Nr") threadingr request_rcvdsuper__init__)selfr$r&r# __class__s \/var/www/html/crypto-bot/backend/venv/lib/python3.11/site-packages/websockets/sync/server.pyr.zServerConnection.__init__7sO %%O--   '      Nprocess_requestCOptional[Callable[[ServerConnection, Request], Optional[Response]]]process_responseMOptional[Callable[[ServerConnection, Request, Response], Optional[Response]]] server_header Optional[str]timeoutc|j|s<||jt d|j<||jtd|t5d|_ | |||j|_ nn#t$ra}||j _ |jdd|j t"jjd|_ Yd}~nd}~wwxYw|j $|j |j|_ |||j jd <| |||j|j }|||_ nn#t$ra}||j _ |jdd|j t"jjd|_ Yd}~nd}~wwxYw|j |j dddn #1swxYwY|j jt0urL|j|j||j|j j |j j dS) z1 Perform the opening handshake. ztimed out during handshakeNz"connection closed during handshake)expected_statezopening handshake failedTexc_infozLFailed to open a WebSocket connection. See server log for more information. Server)r,wait close_socketrecv_events_threadjoin TimeoutErrorrequestConnectionError send_contextrresponse Exceptionr& handshake_excloggererrorrejecthttp HTTPStatusINTERNAL_SERVER_ERRORacceptheaders send_responsestaterr#)r/r3r5r7r9excrGs r1 handshakezServerConnection.handshakeFs * %%g.. =        # ( ( * * *;<< < <         # ( ( * * *!"FGG G   j  9 9( 7( 7 DM* $3OD$,$G$GDMM   25DM/K%%&@4%PPP$(M$8$8=E%%DMMMMMM }$ $ 4 4T\ B B (2? %h/+1//dlDMRRH +(0 !   25DM/K%%&@4%PPP$(M$8$8=E%%DMMMMMM  M ' ' 6 6 6Q( 7( 7( 7( 7( 7( 7( 7( 7( 7( 7( 7( 7( 7( 7( 7T = d * *  # ( (); < < <        # ( ( * * * = & 2-- - 3 2si5 H>CH> E!AD=8H>=EAH>F% H>% H/AH H> H"H>>IIeventrc|j9t|tsJ||_|jdSt |dS)z. Process one incoming event. N)rD isinstancerr,setr- process_event)r/rVr0s r1rZzServerConnection.process_eventse < eW-- - -- DL   ! ! # # # # # GG ! !% ( ( ( ( (r2c t|jdS#|jwxYw)zI Read incoming data from the socket and process events. N)r- recv_eventsr,rY)r/r0s r1r\zServerConnection.recv_eventssV  $ GG   ! ! !   ! ! # # # # #D  ! ! # # # #s >A)r$r%r&rr#r'r(r)) r3r4r5r6r7r8r9r'r(r))rVrr(r)r(r)) __name__ __module__ __qualname____doc__r.rrUrZr\ __classcell__)r0s@r1rrs8*,         ,  '1#'O.O.O.O.O.b ) ) ) ) ) ) $ $ $ $ $ $ $ $ $ $r2rcFeZdZdZ ddd Zdd Zdd ZddZddZddZ dS)ra 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. Nr$r%handler$Callable[[socket.socket, Any], None]rJOptional[LoggerLike]c||_||_|tjd}||_t jdkr"tj\|_ |_ dSdS)Nzwebsockets.serverwin32) r$rdlogging getLoggerrJsysplatformospipeshutdown_watchershutdown_notifier)r/r$rdrJs r1r.zWebSocketServer.__init__s`   >&':;;F <7 " "<>GII 9D !4#9#9#9 # "r2r(r)ctj}||jtjt jdkr%||jtj | |j \}}n#t$rYdSwxYwtj |j ||f}|u)a 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() rhT)targetargsN) selectorsDefaultSelectorregisterr$ EVENT_READrkrlroselectrPOSErrorr+Threadrdstart)r/pollersockaddrthreads r1 serve_foreverzWebSocketServer.serve_forevers*,, Y%9::: <7 " " OOD193G H H H  MMOOO "[//11 dd    %T\t MMMF LLNNN sB!! B/.B/c|jtjdkrt j|jddSdS)z@ See :meth:`socketserver.BaseServer.shutdown`. rhxN)r$closerkrlrmwriterpr/s r1shutdownzWebSocketServer.shutdownsH  <7 " " HT+T 2 2 2 2 2 # "r2intc4|jS)z> See :meth:`socketserver.BaseServer.fileno`. )r$filenors r1rzWebSocketServer.filenos {!!###r2c|SNrs r1 __enter__zWebSocketServer.__enter__s r2exc_typeOptional[Type[BaseException]] exc_valueOptional[BaseException] tracebackOptional[TracebackType]c.|dSr)r)r/rrrs r1__exit__zWebSocketServer.__exit__s r2r)r$r%rdrerJrfr])r(r)r(r)rrrrrrr(r)) r^r_r`rar.rrrrrrr2r1rrs((, F F F F F:3333$$$$r2rFdeflater!i)r} ssl_contextunixpathorigins extensions subprotocolsselect_subprotocolr3r5r7 compression open_timeoutr#max_sizerJcreate_connectionrd"Callable[[ServerConnection], None]hostr8port Optional[int]r}Optional[socket.socket]rOptional[ssl.SSLContext]rboolrr$Optional[Sequence[Optional[Origin]]]r*Optional[Sequence[ServerExtensionFactory]]rOptional[Sequence[Subprotocol]]rTOptional[Callable[[ServerConnection, Sequence[Subprotocol]], Optional[Subprotocol]]]r3r4r5r6r7rrr'r#rrJrfr Optional[Type[ServerConnection]]r(c  t |dkrtn|td|t|Kr2|t dt j|t j}n(t j||f}n|t d|dd }d  fd }t||S)aH 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 a :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. :class:`WebSocketServer` mirrors the API of :class:`~socketserver.BaseServer`. Treat it as a context manager to ensure that it will be closed and call the :meth:`~WebSocketServer.serve_forever` method to serve requests:: def handler(websocket): ... with websockets.sync.server.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_context: 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 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: 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. 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. 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. Nrzunsupported compression: zmissing path argument)familyz(path and sock arguments are incompatibleTF) server_sidedo_handshake_on_connectr}r%r~rr(r)c Ht } s+|tjtjdl||t|tj sJ| |dd}d fd }t |t }J||  |n%#t$r|YdSwxYw  dS#t$r?|jd d t$jYdSwxYw)NTr&rrSequence[Subprotocol]r(Optional[Subprotocol]c:J|jusJ|Sr)r&)r&r connectionrs r1protocol_select_subprotocolz@serve..conn_handler..protocol_select_subprotocols8 .999#z':::::--j,GGGr2)rrrrrSrrJr"zconnection handler failedr<)r&rrrr(r)r setsockoptr$ IPPROTO_TCP TCP_NODELAY settimeoutr9rXssl SSLSocket do_handshakerrrUrHrrJrKr INTERNAL_ERROR)r}r~deadlinerr&rr#rrrdrJrrrr3r5rr7rrrs @r1 conn_handlerzserve..conn_handlers'L))B  N 2F4FMMM& 0 0 2 2333!$ 66666!!###%%% ("-HHHHHHH&%)#> !H%000**+J     ""         JJLLL FF   GJ             7 7 7 O ! !"= ! M M M   Y5 6 6 6 6 6 6 7s%C=DD32D37 EAF! F!)r}r%r~rr(r)) rr ValueErrorr TypeErrorr$ create_serverAF_UNIX wrap_socketr)rdrrr}rrrrrrrr3r5r7rrr#rrJrrs` `` ``````` ````` r1rr svl+++i5jAA  B[BBCCC , |  6| 7888'V^DDDDD't 55DD  FGG G&& $) '  PPPPPPPPPPPPPPPPPPPPh 4v 6 66r2!Callable[[ServerConnection], Any]kwargsrc "t|f|dd|S)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)rr)r)rdrrs r1rrs!&  9t$ 9 9& 9 99r2)NN)*rdrrr8rrr}rrrrrrr8rrrrrrrrr3r4r5r6r7r8rr8rr'r#r'rrrJrfrrr(rr)rdrrr8rrr(r)0 __future__rrMrirmrtr$rrkr+typesrtypingrrrrr websockets.framesr extensions.baser extensions.permessage_deflater rQrrhttp11rrr&rrrserverrrrrrrutilsr__all__rrrrrr2r1rs""""""   ::::::::::::::''''''444444LLLLLL++++++&&&&&&&&..........######4444444444"""""" I H HO$O$O$O$O$zO$O$O$dUUUUUUUUts7 %),048=A48 #-!*$&%'##':>Us7s7s7s7s7s7p:::::::r2